From 1a482dcae703452d9752418417ab2175a000ea67 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 03:22:02 +0200 Subject: [PATCH 01/11] Initial upload --- .github/CODEOWNERS | 1 + .github/workflows/ci.yaml | 117 ++++ .gitignore | 11 + LICENSE | 661 ++++++++++++++++++ benchmarks/bench_array.py | 71 ++ benchmarks/bench_common.py | 179 +++++ benchmarks/bench_iop.py | 132 ++++ benchmarks/profile_hotpath.py | 111 +++ decent_array/__init__.py | 153 ++++ decent_array/array.py | 242 +++++++ decent_array/interoperability/__init__.py | 0 .../interoperability/_jax/__init__.py | 5 + .../interoperability/_jax/jax_backend.py | 272 +++++++ .../interoperability/_numpy/__init__.py | 5 + .../interoperability/_numpy/numpy_backend.py | 267 +++++++ .../interoperability/_pytorch/__init__.py | 5 + .../_pytorch/pytorch_backend.py | 312 +++++++++ .../interoperability/_tensorflow/__init__.py | 5 + .../_tensorflow/tensorflow_backend.py | 315 +++++++++ .../interoperability/abstracts/__init__.py | 3 + .../interoperability/abstracts/backend.py | 289 ++++++++ .../interoperability/backend_manager.py | 184 +++++ decent_array/interoperability/decorators.py | 56 ++ decent_array/interoperability/iop/__init__.py | 0 .../interoperability/iop/functions.py | 418 +++++++++++ decent_array/interoperability/iop/rng.py | 205 ++++++ decent_array/types.py | 49 ++ docs/Makefile | 20 + docs/make.bat | 35 + docs/source/_static/custom.css | 6 + docs/source/_static/logo.png | Bin 0 -> 1440708 bytes docs/source/_templates/module.rst.jinja | 8 + docs/source/_templates/package.rst.jinja | 49 ++ docs/source/author.rst | 7 + docs/source/background.rst | 3 + docs/source/conf.py | 158 +++++ docs/source/developer.rst | 203 ++++++ docs/source/index.rst | 15 + docs/source/user.rst | 12 + docs/sphinx_theme.txt | 2 + pyproject.toml | 190 +++++ readthedocs.yaml | 27 + tests/conftest.py | 121 ++++ tests/test_array.py | 274 ++++++++ tests/test_backend_manager.py | 189 +++++ tests/test_decorators.py | 107 +++ tests/test_iop_functions.py | 448 ++++++++++++ tests/test_iop_rng.py | 196 ++++++ 48 files changed, 6138 insertions(+) create mode 100644 .github/CODEOWNERS create mode 100644 .github/workflows/ci.yaml create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 benchmarks/bench_array.py create mode 100644 benchmarks/bench_common.py create mode 100644 benchmarks/bench_iop.py create mode 100644 benchmarks/profile_hotpath.py create mode 100644 decent_array/__init__.py create mode 100644 decent_array/array.py create mode 100644 decent_array/interoperability/__init__.py create mode 100644 decent_array/interoperability/_jax/__init__.py create mode 100644 decent_array/interoperability/_jax/jax_backend.py create mode 100644 decent_array/interoperability/_numpy/__init__.py create mode 100644 decent_array/interoperability/_numpy/numpy_backend.py create mode 100644 decent_array/interoperability/_pytorch/__init__.py create mode 100644 decent_array/interoperability/_pytorch/pytorch_backend.py create mode 100644 decent_array/interoperability/_tensorflow/__init__.py create mode 100644 decent_array/interoperability/_tensorflow/tensorflow_backend.py create mode 100644 decent_array/interoperability/abstracts/__init__.py create mode 100644 decent_array/interoperability/abstracts/backend.py create mode 100644 decent_array/interoperability/backend_manager.py create mode 100644 decent_array/interoperability/decorators.py create mode 100644 decent_array/interoperability/iop/__init__.py create mode 100644 decent_array/interoperability/iop/functions.py create mode 100644 decent_array/interoperability/iop/rng.py create mode 100644 decent_array/types.py create mode 100644 docs/Makefile create mode 100644 docs/make.bat create mode 100644 docs/source/_static/custom.css create mode 100644 docs/source/_static/logo.png create mode 100644 docs/source/_templates/module.rst.jinja create mode 100644 docs/source/_templates/package.rst.jinja create mode 100644 docs/source/author.rst create mode 100644 docs/source/background.rst create mode 100644 docs/source/conf.py create mode 100644 docs/source/developer.rst create mode 100644 docs/source/index.rst create mode 100644 docs/source/user.rst create mode 100644 docs/sphinx_theme.txt create mode 100644 pyproject.toml create mode 100644 readthedocs.yaml create mode 100644 tests/conftest.py create mode 100644 tests/test_array.py create mode 100644 tests/test_backend_manager.py create mode 100644 tests/test_decorators.py create mode 100644 tests/test_iop_functions.py create mode 100644 tests/test_iop_rng.py diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..083ec3c --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @Simpag @nicola-bastianello diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml new file mode 100644 index 0000000..44b5982 --- /dev/null +++ b/.github/workflows/ci.yaml @@ -0,0 +1,117 @@ +name: ci + +on: + pull_request: + branches: [ main ] + +jobs: + mypy: + runs-on: ubuntu-latest + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run mypy + run: tox -e mypy + + pytest-macos-latest: + runs-on: "macos-latest" + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run pytest + run: tox -e pytest + + pytest-ubuntu-latest: + runs-on: "ubuntu-latest" + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run pytest + run: tox -e pytest + + pytest-windows-latest: + runs-on: "windows-latest" + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run pytest + run: tox -e pytest + + ruff: + runs-on: ubuntu-latest + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run ruff + run: tox -e ruff + + sphinx: + runs-on: ubuntu-latest + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run sphinx + run: tox -e sphinx + + - name: Check git diff + run: git diff --exit-code || { echo 'Error - Docs are stale, please regenerate with `tox -e sphinx`.'; exit 1; } diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..db3da45 --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +**/__pycache__ +**/build +*.egg-info +*.so +.DS_Store +.mypy_cache +.tox +.vscode +dist +pyrightconfig.json +.claude \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0ad25db --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are 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. + + 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. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + 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 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 work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero 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 Affero 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 Affero 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 Affero 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. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + 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 AGPL, see +. diff --git a/benchmarks/bench_array.py b/benchmarks/bench_array.py new file mode 100644 index 0000000..4ae8d8f --- /dev/null +++ b/benchmarks/bench_array.py @@ -0,0 +1,71 @@ +""" +Microbenchmark: ``decent_array.Array`` operator overhead vs native frameworks. + +Measures the wrapper cost added by routing operators through ``Array.__add__``, +``Array.__neg__`` etc. against calling the framework's native operators +directly. Iterates over every framework whose package is importable; missing +optional dependencies are skipped silently. + +The overhead column is ``wrapped / native`` runtime — values close to 1.0x mean +the wrapper is essentially free. Large values at small sizes are expected +(operator dispatch dominates) and should converge toward 1.0x as elementwise +work grows. + +Run with:: + + python benchmarks/bench_array.py +""" + +from __future__ import annotations + +from bench_common import ( + SIZES, + BackendCase, + activate_backend, + discover_backends, + fmt_row, + parse_backends_arg, + print_preamble, + print_size_header, + time_us_safe, +) + +from decent_array import Array + + +def _bench_case(case: BackendCase) -> None: + activate_backend(case.name) + print(f"## {case.name}\n") + for n in SIZES: + a = case.make(n) + b = case.make(n) + d_a, d_b = Array(a), Array(b) + + print_size_header(n) + rows = ( + ("add", lambda a=a, b=b: a + b, lambda d_a=d_a, d_b=d_b: d_a + d_b), + ("sub", lambda a=a, b=b: a - b, lambda d_a=d_a, d_b=d_b: d_a - d_b), + ("mul", lambda a=a, b=b: a * b, lambda d_a=d_a, d_b=d_b: d_a * d_b), + ("div", lambda a=a, b=b: a / b, lambda d_a=d_a, d_b=d_b: d_a / d_b), + ("neg", lambda a=a: -a, lambda d_a=d_a: -d_a), + ("abs", lambda a=a: abs(a), lambda d_a=d_a: abs(d_a)), + ("pow", lambda a=a: a ** 2.0, lambda d_a=d_a: d_a ** 2.0), + ) + for op, native_fn, wrapped_fn in rows: + n_us = time_us_safe(case, native_fn) + w_us = time_us_safe(case, wrapped_fn) + print(fmt_row(op, n_us, w_us)) + print() + print() + + +def main() -> None: + print_preamble("Array operator overhead vs native frameworks") + cases = discover_backends(only=parse_backends_arg()) + print(f"available backends: {', '.join(c.name for c in cases)}\n") + for case in cases: + _bench_case(case) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/bench_common.py b/benchmarks/bench_common.py new file mode 100644 index 0000000..ebe1659 --- /dev/null +++ b/benchmarks/bench_common.py @@ -0,0 +1,179 @@ +""" +Shared helpers for ``bench_array.py`` and ``bench_iop.py``. + +Three concerns live here so the benchmarks stay focused on the comparison logic: + +* :func:`discover_backends` returns the subset of frameworks whose package is + importable; backends with a missing optional dependency are skipped silently. +* :func:`is_compiled` / :func:`print_preamble` report whether the user is + running against a mypyc-compiled build of ``decent_array`` or the pure-Python + source — this materially changes overhead numbers, so the result is printed + at the top of every run. +* :func:`time_us` / :func:`time_us_safe` wrap :mod:`timeit` to take the + ``min`` of several auto-ranged repeats. ``min`` is the canonical choice: it + reports the lower bound of the machine's per-call cost and is the metric + least sensitive to background activity. A warmup call precedes timing so + JIT-style backends (JAX) don't skew the first iteration. +""" + +from __future__ import annotations + +import importlib +import timeit +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any + +SIZES: tuple[int, ...] = (10, 100, 1_000, 10_000) +REPEATS: int = 7 + + +def _no_sync(_value: Any) -> None: # noqa: ANN401 + """No-op sync used for synchronous backends (numpy, torch CPU, tf eager CPU).""" + + +def _sync_jax(value: Any) -> None: # noqa: ANN401 + """Block until a JAX DeviceArray is materialized, unwrapping ``Array`` if needed.""" + # Imported lazily so the module can load even when decent_array isn't yet importable. + from decent_array import Array # noqa: PLC0415 + + raw = value.value if isinstance(value, Array) else value + raw.block_until_ready() + + +@dataclass(slots=True) +class BackendCase: + """A discovered backend plus the helpers needed to drive it in a benchmark.""" + + name: str + make: Callable[[int], Any] + sync: Callable[[Any], None] + + +def activate_backend(name: str) -> None: + """Activate ``name`` as the live backend, resetting any previously active one. + + ``decent_array`` enforces a single-active-backend invariant per execution context; + swapping between frameworks within one process requires resetting first. + """ + from decent_array.interoperability.backend_manager import reset_backends, set_backend # noqa: PLC0415 + + reset_backends() + set_backend(name) + + +def discover_backends(only: list[str] | None = None) -> list[BackendCase]: + """Return one :class:`BackendCase` per importable framework, in a stable order. + + Args: + only: Optional allowlist of backend names. When provided, frameworks not in the + list are skipped entirely (their packages aren't even imported), and any + requested name that isn't a known backend raises :class:`ValueError`. + + """ + import numpy as np # always available — hard dependency # noqa: PLC0415 + + known = {"numpy", "pytorch", "jax", "tensorflow"} + if only is not None: + unknown = set(only) - known + if unknown: + raise ValueError(f"unknown backend(s): {sorted(unknown)}; known: {sorted(known)}") + wanted = set(only) + else: + wanted = known + + cases: list[BackendCase] = [] + + if "numpy" in wanted: + cases.append(BackendCase("numpy", lambda n: np.random.rand(n), _no_sync)) + + if "pytorch" in wanted: + try: + import torch # noqa: PLC0415 + except ImportError: + pass + else: + cases.append(BackendCase("pytorch", lambda n: torch.from_numpy(np.random.rand(n)), _no_sync)) + + if "jax" in wanted: + try: + import jax.numpy as jnp # noqa: PLC0415 + except ImportError: + pass + else: + cases.append(BackendCase("jax", lambda n: jnp.asarray(np.random.rand(n)), _sync_jax)) + + if "tensorflow" in wanted: + try: + import tensorflow as tf # noqa: PLC0415 + except ImportError: + pass + else: + cases.append(BackendCase("tensorflow", lambda n: tf.constant(np.random.rand(n)), _no_sync)) + + return cases + + +def parse_backends_arg() -> list[str] | None: + """Parse the shared ``--backends`` CLI flag; returns ``None`` if not given.""" + import argparse # noqa: PLC0415 + + parser = argparse.ArgumentParser(add_help=True) + parser.add_argument( + "--backends", + type=str, + default=None, + help="comma-separated allowlist of backends (numpy,pytorch,jax,tensorflow); default = all available", + ) + args = parser.parse_args() + if args.backends is None: + return None + return [b.strip() for b in args.backends.split(",") if b.strip()] + + +def is_compiled() -> tuple[bool, str]: + """Return ``(True, path)`` if the Array module loaded from a ``.so``/``.pyd``, else ``(False, .py path)``.""" + module = importlib.import_module("decent_array.array.array") + path = module.__file__ or "" + return path.endswith((".so", ".pyd")), path + + +def print_preamble(title: str) -> None: + compiled, path = is_compiled() + print(f"# {title}\n") + print(f"decent_array compiled: {'yes' if compiled else 'no'}") + print(f" Array loaded from: {path}") + print(f" timing: min over {REPEATS} repeats, iterations per repeat auto-tuned to ~0.2s\n") + + +def time_us(case: BackendCase, fn: Callable[[], Any]) -> float: + """Per-call runtime in µs; min over :data:`REPEATS` measurements with autoranged N.""" + + def runner() -> None: + case.sync(fn()) + + runner() # warmup — material for JAX's first-call compilation + timer = timeit.Timer(runner) + n, _ = timer.autorange() + times = timer.repeat(repeat=REPEATS, number=n) + return (min(times) / n) * 1e6 + + +def time_us_safe(case: BackendCase, fn: Callable[[], Any]) -> float | None: + """Like :func:`time_us` but returns ``None`` if ``fn`` raises (e.g. TF 1D matmul).""" + try: + return time_us(case, fn) + except Exception: # noqa: BLE001 + return None + + +def fmt_row(op: str, native_us: float | None, wrapped_us: float | None) -> str: + if native_us is None or wrapped_us is None: + return f" {op:<8} {'n/a':>13} {'n/a':>13} {'n/a':>8}" + ratio = wrapped_us / native_us if native_us > 0 else float("inf") + return f" {op:<8} {native_us:>10.3f} µs {wrapped_us:>10.3f} µs {ratio:>6.2f}x" + + +def print_size_header(n: int) -> None: + print(f"size = {n:_}") + print(f" {'op':<8} {'native':>13} {'wrapped':>13} {'overhead':>8}") diff --git a/benchmarks/bench_iop.py b/benchmarks/bench_iop.py new file mode 100644 index 0000000..5991f2c --- /dev/null +++ b/benchmarks/bench_iop.py @@ -0,0 +1,132 @@ +""" +Microbenchmark: ``iop.`` dispatch overhead vs native frameworks. + +Measures the cost of calling top-level interoperability functions (which look +up the active backend on each call and dispatch to it) against calling each +framework's native equivalents directly. Same shape and intent as +``bench_array.py`` but for the function-style API surface rather than the +operator-style ``Array`` API. Iterates over every framework whose package is +importable; missing optional dependencies are skipped silently. + +Where the two benchmarks share an op (``add``, ``mul``), differences in the +overhead column reflect dunder-method dispatch vs. module-level function +dispatch; the remaining ops (``sum``, ``dot``, ``norm``, ``mean``, ``sqrt``, +``sign``) only exist on this surface. + +Run with:: + + python benchmarks/bench_iop.py +""" + +from __future__ import annotations + +from collections.abc import Callable +from typing import Any + +from bench_common import ( + SIZES, + BackendCase, + activate_backend, + discover_backends, + fmt_row, + parse_backends_arg, + print_preamble, + print_size_header, + time_us_safe, +) + +import decent_array as iop +from decent_array import Array + + +def _native_ops(backend: str) -> dict[str, Callable[..., Any]]: + """Return the native-framework equivalents of each ``iop.`` for ``backend``.""" + if backend == "numpy": + import numpy as np # noqa: PLC0415 + return { + "add": np.add, + "mul": np.multiply, + "dot": np.dot, + "sum": np.sum, + "mean": np.mean, + "norm": np.linalg.norm, + "sqrt": np.sqrt, + "sign": np.sign, + } + if backend == "pytorch": + import torch # noqa: PLC0415 + return { + "add": torch.add, + "mul": torch.mul, + "dot": torch.dot, + "sum": torch.sum, + "mean": torch.mean, + "norm": torch.linalg.norm, + "sqrt": torch.sqrt, + "sign": torch.sign, + } + if backend == "jax": + import jax.numpy as jnp # noqa: PLC0415 + return { + "add": jnp.add, + "mul": jnp.multiply, + "dot": jnp.dot, + "sum": jnp.sum, + "mean": jnp.mean, + "norm": jnp.linalg.norm, + "sqrt": jnp.sqrt, + "sign": jnp.sign, + } + if backend == "tensorflow": + import tensorflow as tf # noqa: PLC0415 + return { + "add": tf.add, + "mul": tf.multiply, + "dot": lambda a, b: tf.tensordot(a, b, axes=1), + "sum": tf.reduce_sum, + "mean": tf.reduce_mean, + "norm": tf.norm, + "sqrt": tf.sqrt, + "sign": tf.sign, + } + raise ValueError(f"unknown backend: {backend}") + + +def _bench_case(case: BackendCase) -> None: + activate_backend(case.name) + native = _native_ops(case.name) + print(f"## {case.name}\n") + for n in SIZES: + a = case.make(n) + b = case.make(n) + d_a, d_b = Array(a), Array(b) + + print_size_header(n) + rows = ( + ("add", lambda a=a, b=b: native["add"](a, b), lambda d_a=d_a, d_b=d_b: iop.add(d_a, d_b)), + ("mul", lambda a=a, b=b: native["mul"](a, b), lambda d_a=d_a, d_b=d_b: iop.mul(d_a, d_b)), + ("dot", lambda a=a, b=b: native["dot"](a, b), lambda d_a=d_a, d_b=d_b: iop.dot(d_a, d_b)), + ("sum", lambda a=a: native["sum"](a), lambda d_a=d_a: iop.sum(d_a)), + ("mean", lambda a=a: native["mean"](a), lambda d_a=d_a: iop.mean(d_a)), + ("norm", lambda a=a: native["norm"](a), lambda d_a=d_a: iop.norm(d_a)), + ("sqrt", lambda a=a: native["sqrt"](a), lambda d_a=d_a: iop.sqrt(d_a)), + ("sign", lambda a=a: native["sign"](a), lambda d_a=d_a: iop.sign(d_a)), + ) + for op, native_fn, wrapped_fn in rows: + n_us = time_us_safe(case, native_fn) + w_us = time_us_safe(case, wrapped_fn) + print(fmt_row(op, n_us, w_us)) + print() + print() + + +def main() -> None: + print_preamble("iop function-call overhead vs native frameworks") + cases = discover_backends(only=parse_backends_arg()) + print(f"available backends: {', '.join(c.name for c in cases)}\n") + for case in cases: + _bench_case(case) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/profile_hotpath.py b/benchmarks/profile_hotpath.py new file mode 100644 index 0000000..eee9451 --- /dev/null +++ b/benchmarks/profile_hotpath.py @@ -0,0 +1,111 @@ +""" +Profile ``decent_array`` hot paths to find where wrapper overhead actually lives. + +Runs a tight loop of representative operations (mix of ``Array`` operators and +``iop`` function calls) under :mod:`cProfile`, then prints the highest-impact +callees by cumulative time. The output answers "of the wrapper overhead we see +in ``bench_array.py`` / ``bench_iop.py``, where is the time actually spent?" — +turning a vague ratio number into specific functions to optimize. + +Notes: +* cProfile adds per-call overhead of ~1 µs, which dominates anything sub-µs. The + *relative* shape of the profile is still informative (which functions are + called most often, and which take the largest share of cumulative time); + don't read the absolute µs values. +* Repeats are deliberately on the small side so that pure-Python and mypyc- + compiled runs both finish quickly. For mypyc-compiled modules cProfile only + records entry/exit (compiled internals are opaque), so the profile is most + informative against the pure-Python source. + +Run with:: + + python benchmarks/profile_hotpath.py + python benchmarks/profile_hotpath.py --backend pytorch + python benchmarks/profile_hotpath.py --topn 50 +""" + +from __future__ import annotations + +import argparse +import cProfile +import importlib +import pstats +from io import StringIO + +import numpy as np + +import decent_array as iop +from decent_array import Array + + +def _is_compiled() -> tuple[bool, str]: + module = importlib.import_module("decent_array.array") + path = module.__file__ or "" + return path.endswith((".so", ".pyd")), path + + +def hot_loop(a: Array, b: Array, iterations: int) -> None: + """A representative mix of operator-style and function-style calls.""" + for _ in range(iterations): + # Operator surface (Array dunders) + _ = a + b + _ = a - b + _ = a * b + _ = a / b + _ = a + 2.0 + _ = -a + _ = abs(a) + _ = a**2.0 + # Function surface (iop dispatch) + _ = iop.add(a, b) + _ = iop.mul(a, b) + _ = iop.sum(a) + _ = iop.norm(a) + _ = iop.dot(a, b) + _ = iop.sqrt(a) + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--backend", default="numpy", choices=["numpy", "pytorch", "jax", "tensorflow"]) + parser.add_argument("--iterations", type=int, default=20_000) + parser.add_argument("--topn", type=int, default=30) + parser.add_argument("--size", type=int, default=100, help="size of the arrays to operate on") + args = parser.parse_args() + + iop.set_backend(args.backend) + + # Modest fixed-size array — small enough that wrapper overhead is the + # dominant cost, large enough that the underlying ops aren't degenerate. + a = iop.uniform(0.0, 1.0, shape=(args.size,)) + b = iop.uniform(0.0, 1.0, shape=(args.size,)) + + # Warmup so first-call jit / cache effects don't pollute the profile. + hot_loop(a, b, iterations=10) + + profiler = cProfile.Profile() + profiler.enable() + hot_loop(a, b, iterations=args.iterations) + profiler.disable() + + compiled, path = _is_compiled() + print(f"backend: {args.backend} compiled: {'yes' if compiled else 'no'}") + print(f"Array module: {path}") + print(f"iterations: {args.iterations:_}\n") + + buf = StringIO() + stats = pstats.Stats(profiler, stream=buf) + stats.sort_stats("cumulative") + stats.print_stats(args.topn) + print(buf.getvalue()) + + print("\n--- top callees by total (self) time ---\n") + buf2 = StringIO() + stats2 = pstats.Stats(profiler, stream=buf2) + stats2.sort_stats("tottime") + stats2.print_stats(args.topn) + print(buf2.getvalue()) + + +if __name__ == "__main__": + main() diff --git a/decent_array/__init__.py b/decent_array/__init__.py new file mode 100644 index 0000000..9694575 --- /dev/null +++ b/decent_array/__init__.py @@ -0,0 +1,153 @@ +""" +Interoperability layer (v2). + +Single-active-backend variant of the original interoperability package. Each framework +implements :class:`_Backend` and registers itself via :func:`register_backend`. Users +(or the cost-function machinery) bind a backend once with :func:`set_backend`; from +that point on every call in this package routes to that backend without isinstance +dispatch. + +Typical usage:: + + import decent_bench.utils.interoperability_2 as iop + + iop.set_backend("numpy") + a = iop.zeros((3, 3)) + iop.set_seed(42) + s = iop.normal(shape=(2,)) + +""" + +from decent_array import types +from decent_array.array import Array +from decent_array.interoperability.backend_manager import set_backend +from decent_array.interoperability.decorators import autodecorate_cost_method +from decent_array.interoperability.iop.functions import ( + absolute, + add, + all, # noqa: A004 + any, # noqa: A004 + argmax, + argmin, + astype, + copy, + device_of, + device_to_native, + diag, + div, + dot, + eye, + eye_like, + from_numpy, + get_item, + iadd, + idiv, + imul, + isub, + matmul, + max, # noqa: A004 + maximum, + mean, + min, # noqa: A004 + mul, + ndim, + negative, + norm, + ones, + ones_like, + pow, # noqa: A004 + reshape, + set_item, + shape, + sign, + size, + sqrt, + squeeze, + stack, + sub, + sum, # noqa: A004 + to_array, + to_numpy, + transpose, + unsqueeze, + zeros, + zeros_like, +) +from decent_array.interoperability.iop.rng import ( + choice, + derive_seed, + get_rng_state, + get_seed, + normal, + normal_like, + set_rng_state, + set_seed, + uniform, + uniform_like, +) + +__all__ = [ + "Array", + "absolute", + "add", + "all", + "any", + "argmax", + "argmin", + "astype", + "autodecorate_cost_method", + "choice", + "copy", + "derive_seed", + "device_of", + "device_to_native", + "diag", + "div", + "dot", + "eye", + "eye_like", + "from_numpy", + "get_item", + "get_rng_state", + "get_seed", + "iadd", + "idiv", + "imul", + "isub", + "matmul", + "max", + "maximum", + "mean", + "min", + "mul", + "ndim", + "negative", + "norm", + "normal", + "normal_like", + "ones", + "ones_like", + "pow", + "reshape", + "set_backend", + "set_item", + "set_rng_state", + "set_seed", + "shape", + "sign", + "size", + "sqrt", + "squeeze", + "stack", + "sub", + "sum", + "to_array", + "to_numpy", + "transpose", + "types", + "uniform", + "uniform_like", + "unsqueeze", + "zeros", + "zeros_like", +] diff --git a/decent_array/array.py b/decent_array/array.py new file mode 100644 index 0000000..142a82d --- /dev/null +++ b/decent_array/array.py @@ -0,0 +1,242 @@ +""" +Lightweight wrapper around backend-native arrays. + +The :class:`Array` class wraps a single value of the active backend's framework type. +Under the single-active-backend invariant maintained by +:mod:`decent_array.interoperability.backend_manager`, every :class:`Array` at runtime +holds a value from the same framework, so operators dispatch directly to the active +backend without per-call isinstance dispatch. + +Operator contract is *strict*: binary arithmetic and indexing accept either another +:class:`Array` or a Python scalar (``int``/``float``). Pass other framework-native +arrays through :func:`decent_array.iop.get_item` and friends, not through the +operator path. + +Hot-path notes: + +* ``__add__``/``__sub__``/``__mul__``/``__truediv__``/``__matmul__`` and the unary + ``__neg__``/``__abs__``/``__pow__`` are inlined: every supported framework's tensor + implements the equivalent operator natively with numpy-equivalent semantics, so + routing through the backend saves nothing. +* Operators that *do* go through the backend (in-place math, indexing, properties + like ``shape``/``transpose``) read the cached ``_backend`` slot. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Self + +from decent_array.interoperability.backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array.interoperability.abstracts import _Backend + from decent_array.types import ArrayKey + + +_BACKEND_INSTANCE: _Backend | None = None + + +def _update_backend(backend: _Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +class Array: # noqa: PLR0904 + """ + Wrapper around a single backend-native array. + + Storage is two slots (``value``, ``_backend``) declared via ``__slots__``; + instances have no ``__dict__``. Every operator that delegates to the backend + reads the cached slot, so dispatch is one slot load plus the backend method call. + """ + + __slots__ = ("_backend", "value") + + def __init__(self, value: Any) -> None: # noqa: ANN401 + """ + Wrap ``value`` in an :class:`Array`. + + Args: + value: A backend-native array (or scalar) to wrap. The attribute is typed + as :class:`typing.Any` because the wrapper is intentionally type-erased + — backend code accesses :attr:`value` knowing the framework type, and + typing it more strictly forces a ``cast`` at every call site without + runtime benefit. + + Raises: + RuntimeError: If no backend is registered yet. An :class:`Array` cannot be + constructed until a backend is set; call :func:`set_backend` to initialize + the interoperability layer. + + """ + if _BACKEND_INSTANCE is None: + raise RuntimeError( + "No backend registered yet. An Array cannot be constructed until a backend is set. " + "Call set_backend() to initialize the interoperability layer." + ) + + self.value: Any = value + self._backend: _Backend = _BACKEND_INSTANCE + + # Binary arithmetic ---------------------------------------------------- + + def __add__(self, other: Array | float) -> Array: + """Return the sum of the array and another array or a scalar.""" + return Array(self.value + (other.value if type(other) is Array else other)) + + def __radd__(self, other: float) -> Array: + """Return the sum of the array and a scalar.""" + return Array(other + self.value) + + def __sub__(self, other: Array | float) -> Array: + """Return the subtraction of another array or a scalar from the array.""" + return Array(self.value - (other.value if type(other) is Array else other)) + + def __rsub__(self, other: float) -> Array: + """Return the subtraction of the array from a scalar.""" + return Array(other - self.value) + + def __mul__(self, other: Array | float) -> Array: + """Return the product of the array and another array or a scalar.""" + return Array(self.value * (other.value if type(other) is Array else other)) + + def __rmul__(self, other: float) -> Array: + """Return the product of the array and a scalar.""" + return Array(other * self.value) + + def __truediv__(self, other: Array | float) -> Array: + """Return the true division of the array by ``other``.""" + return Array(self.value / (other.value if type(other) is Array else other)) + + def __rtruediv__(self, other: float) -> Array: + """Return the true division of ``other`` by the array.""" + return Array(other / self.value) + + def __matmul__(self, other: Array) -> Array: + """Return the matrix multiplication of the array with ``other``.""" + return Array(self.value @ other.value) + + def __rmatmul__(self, other: Array) -> Array: + """Return the matrix multiplication of ``other`` with the array.""" + return Array(other.value @ self.value) + + def __pow__(self, other: float) -> Array: + """Exponentiate the array by a scalar power.""" + # numpy/torch/jax/tf all implement ``tensor ** p`` with semantics matching the + # backend's ``pow``; routing through the backend would cost an extra method + # call for no behavioral difference. + return Array(self.value**other) + + # In-place arithmetic -------------------------------------------------- + # + # The backend handles the framework's mutability semantics: numpy/pytorch mutate + # `value` in place, jax/tensorflow rebind it. In every case the returned object is + # the same wrapper instance, so we just discard the return and yield ``self``. + + def __iadd__(self, other: Array | float) -> Self: + """In-place addition.""" + self._backend.iadd(self, other) + return self + + def __isub__(self, other: Array | float) -> Self: + """In-place subtraction.""" + self._backend.isub(self, other) + return self + + def __imul__(self, other: Array | float) -> Self: + """In-place multiplication.""" + self._backend.imul(self, other) + return self + + def __itruediv__(self, other: Array | float) -> Self: + """In-place true division.""" + self._backend.idiv(self, other) + return self + + # Unary ---------------------------------------------------------------- + + def __neg__(self) -> Array: + """Return the negation of the array.""" + # Native ``-tensor`` matches the backend's ``negative`` wrapper across all + # supported frameworks, so the indirection is not needed. + return Array(-self.value) + + def __abs__(self) -> Array: + """Return the absolute value of the array.""" + # Same rationale as ``__neg__`` — native ``abs(tensor)`` matches each + # backend's ``absolute`` implementation. + return Array(abs(self.value)) + + # Indexing ------------------------------------------------------------- + + def __getitem__(self, key: ArrayKey) -> Array: + """Return the item at ``key``.""" + return self._backend.get_item(self, key) + + def __setitem__(self, key: ArrayKey, value: Array | float) -> None: + """Set the item at ``key`` to ``value``.""" + if type(value) is not Array: + value = Array(value) + self._backend.set_item(self, key, value) + + # Containers / iteration ---------------------------------------------- + + def __len__(self) -> int: + """Return the size of the first dimension of the array.""" + return len(self.value) + + # Coercion ------------------------------------------------------------- + + def __float__(self) -> float: + """Coerce a scalar array to a Python float.""" + return float(self._backend.astype(self, float)) + + # Repr ----------------------------------------------------------------- + + def __repr__(self) -> str: + """Show the wrapper and the wrapped value.""" + return f"Array({self.value!r})" + + def __str__(self) -> str: + """Stringify the wrapped value, not the wrapper.""" + return str(self.value) + + # Properties ----------------------------------------------------------- + + @property + def shape(self) -> tuple[int, ...]: + """Return the shape of the array.""" + return self._backend.shape(self) + + @property + def size(self) -> int: + """Return the total number of elements in the array.""" + return self._backend.size(self) + + @property + def ndim(self) -> int: + """Return the number of dimensions of the array.""" + return self._backend.ndim(self) + + @property + def transpose(self) -> Array: + """Return a transposed view of the array.""" + return self._backend.transpose(self) + + @property + def T(self) -> Array: # noqa: N802 + """Return a transposed view of the array.""" + return self.transpose + + @property + def any(self) -> bool: + """Return True if any element of the array is truthy.""" + return self._backend.any(self) + + @property + def all(self) -> bool: + """Return True if all elements of the array are truthy.""" + return self._backend.all(self) diff --git a/decent_array/interoperability/__init__.py b/decent_array/interoperability/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/decent_array/interoperability/_jax/__init__.py b/decent_array/interoperability/_jax/__init__.py new file mode 100644 index 0000000..23baa9c --- /dev/null +++ b/decent_array/interoperability/_jax/__init__.py @@ -0,0 +1,5 @@ +"""JAX backend package; importing it triggers backend registration.""" + +from .jax_backend import JaxBackend + +__all__ = ["JaxBackend"] diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py new file mode 100644 index 0000000..b5eceba --- /dev/null +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -0,0 +1,272 @@ +""" +JAX backend for interoperability_2. + +Importing this module registers the backend via :func:`register_backend`, so the +package can be auto-loaded on the first ``set_backend("jax")`` call. + +JAX arrays are immutable, so :meth:`set_item` rebinds the wrapper's underlying value +rather than mutating it. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from time import time_ns +from typing import Any, cast + +import jax +import jax.numpy as jnp +import numpy as np +from numpy.typing import NDArray + +from decent_array.array import Array +from decent_array.interoperability.abstracts import _Backend +from decent_array.interoperability.backend_manager import register_backend +from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks + + +def _unwrap(array: Any) -> Any: # noqa: ANN401 + """Return the underlying value of an :class:`Array`, or pass ``array`` through.""" + return array.value if type(array) is Array else array + + +class JaxBackend(_Backend): # noqa: PLR0904 + """JAX implementation of :class:`_Backend`.""" + + def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: + super().__init__(device) + self._native_device: jax.Device = self.device_to_native(device) + self._key: jax.Array = jax.random.key(time_ns()) + + # Array creation + + def zeros(self, shape: tuple[int, ...]) -> Array: + return Array(jnp.zeros(shape, device=self._native_device)) + + def zeros_like(self, array: Array) -> Array: + return Array(jnp.zeros_like(array.value)) + + def ones(self, shape: tuple[int, ...]) -> Array: + return Array(jnp.ones(shape, device=self._native_device)) + + def ones_like(self, array: Array) -> Array: + return Array(jnp.ones_like(array.value)) + + def eye(self, n: int) -> Array: + return Array(jnp.eye(n, device=self._native_device)) + + def eye_like(self, array: Array) -> Array: + v = array.value + rows, cols = v.shape[-2:] + return Array(jnp.eye(rows, cols, dtype=v.dtype, device=v.device)) + + def device_to_native(self, device: SupportedDevices) -> jax.Device: + if device == SupportedDevices.CPU: + return jax.devices("cpu")[0] + if device == SupportedDevices.GPU: + return jax.devices("gpu")[0] + raise ValueError(f"Unsupported device for JAX: {device}") + + def device_of(self, array: Array) -> SupportedDevices: + platform = array.value.device.platform + if platform == "gpu": + return SupportedDevices.GPU + if platform == "cpu": + return SupportedDevices.CPU + raise TypeError(f"Unsupported JAX platform: {platform}") + + # Array manipulation + + def copy(self, array: Array) -> Array: + return Array(jnp.array(array.value, copy=True)) + + def to_numpy(self, array: Array) -> NDArray[Any]: + return np.array(array.value) + + def from_numpy(self, array: NDArray[Any]) -> Array: + return Array(jnp.array(array, device=self._native_device)) + + def to_array(self, array: float | bool) -> Array: + return Array(jnp.array(array, device=self._native_device)) + + def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + if len(arrays) == 0: + raise ValueError("Cannot stack an empty sequence of arrays.") + return Array(jnp.stack([a.value for a in arrays], axis=dim)) + + def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: + return Array(jnp.reshape(array.value, shape)) + + def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + return Array(jnp.transpose(array.value, axes=dim)) + + def shape(self, array: Array) -> tuple[int, ...]: + return tuple(array.value.shape) + + def size(self, array: Array) -> int: + return int(array.value.size) + + def ndim(self, array: Array) -> int: + return int(array.value.ndim) + + def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + return Array(jnp.squeeze(array.value, axis=dim)) + + def unsqueeze(self, array: Array, dim: int) -> Array: + return Array(jnp.expand_dims(array.value, axis=dim)) + + def diag(self, array: Array) -> Array: + return Array(jnp.diag(array.value)) + + def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: + return dtype(array.value.item()) + + # Linalg + + def dot(self, array1: Array, array2: Array) -> Array: + return Array(jnp.dot(array1.value, array2.value)) + + def matmul(self, array1: Array, array2: Array) -> Array: + return Array(array1.value @ array2.value) + + def norm( + self, + array: Array, + p: float = 2, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ) -> Array: + return Array(jnp.linalg.norm(array.value, ord=p, axis=dim, keepdims=keepdims)) + + # Math reductions + + def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.sum(array.value, axis=dim, keepdims=keepdims)) + + def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.mean(array.value, axis=dim, keepdims=keepdims)) + + def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.min(array.value, axis=dim, keepdims=keepdims)) + + def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.max(array.value, axis=dim, keepdims=keepdims)) + + def any(self, array: Array) -> bool: + return bool(jnp.any(array.value)) + + def all(self, array: Array) -> bool: + return bool(jnp.all(array.value)) + + # Math elementwise — JAX arrays are immutable; "in-place" ops rebind the wrapper. + # Operands may be Array or scalar (operator dunders pass either); ``Array | float`` + # covers both because PEP 484's numeric tower implicitly admits ``int``. + + def add(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.add(_unwrap(array1), _unwrap(array2))) + + def iadd[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = jnp.add(array1.value, _unwrap(array2)) + return array1 + + def sub(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.subtract(_unwrap(array1), _unwrap(array2))) + + def isub[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = jnp.subtract(array1.value, _unwrap(array2)) + return array1 + + def mul(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.multiply(_unwrap(array1), _unwrap(array2))) + + def imul[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = jnp.multiply(array1.value, _unwrap(array2)) + return array1 + + def div(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.divide(_unwrap(array1), _unwrap(array2))) + + def idiv[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = jnp.divide(array1.value, _unwrap(array2)) + return array1 + + def pow(self, array: Array, p: float) -> Array: + return Array(jnp.power(array.value, p)) + + def negative(self, array: Array) -> Array: + return Array(jnp.negative(array.value)) + + def absolute(self, array: Array) -> Array: + return Array(jnp.abs(array.value)) + + def sqrt(self, array: Array) -> Array: + return Array(jnp.sqrt(array.value)) + + # Operators + + def sign(self, array: Array) -> Array: + return Array(jnp.sign(array.value)) + + def maximum(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.maximum(_unwrap(array1), _unwrap(array2))) + + def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + return Array(jnp.argmax(array.value, axis=dim, keepdims=keepdims)) + + def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + return Array(jnp.argmin(array.value, axis=dim, keepdims=keepdims)) + + def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + # JAX arrays are immutable; rebind the wrapper to a new array with `key` updated. + array.value = array.value.at[key].set(value.value) + + def get_item(self, array: Array, key: ArrayKey) -> Array: + return Array(array.value[key]) + + # RNG + + def set_seed(self, seed: int) -> None: + self._key = jax.random.key(seed) + + def get_rng_state(self) -> dict[str, Any]: + return {"jax_key": jax.random.key_data(self._key)} + + def set_rng_state(self, state: dict[str, Any]) -> None: + if "jax_key" in state: + self._key = jax.random.wrap_key_data(state["jax_key"]) + + def normal(self, mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + sub = self._next_key() + sample = jax.random.normal(sub, shape=shape).to_device(self._native_device) + return Array(mean + std * sample) + + def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + sub = self._next_key() + return Array(jax.random.uniform(sub, shape=shape, minval=low, maxval=high).to_device(self._native_device)) + + def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: + v = array.value + sub = self._next_key() + sample = jax.random.normal(sub, shape=v.shape, dtype=v.dtype) + return Array(mean + std * sample) + + def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: + v = array.value + sub = self._next_key() + return Array(jax.random.uniform(sub, shape=v.shape, dtype=v.dtype, minval=low, maxval=high)) + + def choice(self, array: Array, size: int, replace: bool = True) -> Array: + v = array.value + sub = self._next_key() + indices = jax.random.choice(sub, a=v.shape[0], shape=(size,), replace=replace) + return Array(v[indices]) + + # internals + + def _next_key(self) -> jax.Array: + """Split the stored key, advance state, return a sub-key for one draw.""" + self._key, sub = jax.random.split(self._key) + return cast("jax.Array", sub) + + +register_backend(SupportedFrameworks.JAX, JaxBackend) diff --git a/decent_array/interoperability/_numpy/__init__.py b/decent_array/interoperability/_numpy/__init__.py new file mode 100644 index 0000000..7d2136e --- /dev/null +++ b/decent_array/interoperability/_numpy/__init__.py @@ -0,0 +1,5 @@ +"""NumPy backend package; importing it triggers backend registration.""" + +from .numpy_backend import NumpyBackend + +__all__ = ["NumpyBackend"] diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py new file mode 100644 index 0000000..5555192 --- /dev/null +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -0,0 +1,267 @@ +""" +NumPy backend for interoperability_2. + +Importing this module registers the backend via :func:`register_backend`, so the +package can be auto-loaded on the first ``set_backend("numpy")`` call. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from copy import deepcopy +from typing import Any + +import numpy as np +from numpy.typing import NDArray + +from decent_array.array import Array +from decent_array.interoperability.abstracts import _Backend +from decent_array.interoperability.backend_manager import register_backend +from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks + + +def _unwrap(array: Any) -> Any: # noqa: ANN401 + """ + Return the underlying value of an :class:`Array`, or pass ``array`` through. + + Typed as ``Any`` because operator dunders may pass either an :class:`Array` or a + Python scalar; the strict abstract signature would force a ``cast`` at every call + site without runtime benefit. + """ + return array.value if type(array) is Array else array + + +class NumpyBackend(_Backend): # noqa: PLR0904 + """NumPy implementation of :class:`_Backend`.""" + + def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: + if device != SupportedDevices.CPU: + raise ValueError(f"NumPy backend only supports CPU, got '{device.value}'.") + super().__init__(device) + self._rng: np.random.Generator = np.random.default_rng() + + # Array creation + + def zeros(self, shape: tuple[int, ...]) -> Array: + return Array(np.zeros(shape)) + + def zeros_like(self, array: Array) -> Array: + return Array(np.zeros_like(array.value)) + + def ones(self, shape: tuple[int, ...]) -> Array: + return Array(np.ones(shape)) + + def ones_like(self, array: Array) -> Array: + return Array(np.ones_like(array.value)) + + def eye(self, n: int) -> Array: + return Array(np.eye(n)) + + def eye_like(self, array: Array) -> Array: + v = array.value + return Array(np.eye(*v.shape[-2:], dtype=v.dtype)) + + def device_to_native(self, device: SupportedDevices) -> Any: # noqa: ANN401 + # NumPy has no explicit device management; surface the request unchanged. + return device + + def device_of(self, array: Array) -> SupportedDevices: # noqa: ARG002 + return SupportedDevices.CPU + + # Array manipulation + + def copy(self, array: Array) -> Array: + v = array.value + if isinstance(v, np.ndarray | np.generic): + return Array(np.copy(v)) + return Array(deepcopy(v)) + + def to_numpy(self, array: Array) -> NDArray[Any]: + """Return the value of an :class:`Array` as a NumPy array.""" + v = array.value + if isinstance(v, np.ndarray): + return v + return np.asarray(v) + + def from_numpy(self, array: NDArray[Any]) -> Array: + return Array(array) + + def to_array(self, array: float | bool) -> Array: + return Array(np.array(array)) + + def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + if len(arrays) == 0: + raise ValueError("Cannot stack an empty sequence of arrays.") + return Array(np.stack([a.value for a in arrays], axis=dim)) + + def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: + return Array(np.reshape(array.value, shape)) + + def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + return Array(np.transpose(array.value, axes=dim)) + + def shape(self, array: Array) -> tuple[int, ...]: + return tuple(array.value.shape) + + def size(self, array: Array) -> int: + return int(array.value.size) + + def ndim(self, array: Array) -> int: + return int(array.value.ndim) + + def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + return Array(np.squeeze(array.value, axis=dim)) + + def unsqueeze(self, array: Array, dim: int) -> Array: + return Array(np.expand_dims(array.value, axis=dim)) + + def diag(self, array: Array) -> Array: + return Array(np.diag(array.value)) + + def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: + v = array.value + scalar = v.item() if hasattr(v, "item") else v + return dtype(scalar) + + # Linalg + + def dot(self, array1: Array, array2: Array) -> Array: + return Array(np.dot(array1.value, array2.value)) + + def matmul(self, array1: Array, array2: Array) -> Array: + return Array(array1.value @ array2.value) + + def norm( + self, + array: Array, + p: float = 2, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ) -> Array: + return Array(np.linalg.norm(array.value, ord=p, axis=dim, keepdims=keepdims)) + + # Math reductions + + def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.sum(array.value, axis=dim, keepdims=keepdims)) + + def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.mean(array.value, axis=dim, keepdims=keepdims)) + + def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.min(array.value, axis=dim, keepdims=keepdims)) + + def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.max(array.value, axis=dim, keepdims=keepdims)) + + def any(self, array: Array) -> bool: + return bool(np.any(array.value)) + + def all(self, array: Array) -> bool: + return bool(np.all(array.value)) + + # Math elementwise — operands may be Array or scalar (operator dunders pass either). + # ``Array | float`` covers both: PEP 484's numeric tower implicitly admits ``int``. + + def add(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.add(_unwrap(array1), _unwrap(array2))) + + def iadd[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value += _unwrap(array2) + return array1 + + def sub(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.subtract(_unwrap(array1), _unwrap(array2))) + + def isub[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value -= _unwrap(array2) + return array1 + + def mul(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.multiply(_unwrap(array1), _unwrap(array2))) + + def imul[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value *= _unwrap(array2) + return array1 + + def div(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.divide(_unwrap(array1), _unwrap(array2))) + + def idiv[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value /= _unwrap(array2) + return array1 + + def pow(self, array: Array, p: float) -> Array: + return Array(np.power(array.value, p)) + + def negative(self, array: Array) -> Array: + return Array(np.negative(array.value)) + + def absolute(self, array: Array) -> Array: + return Array(np.abs(array.value)) + + def sqrt(self, array: Array) -> Array: + return Array(np.sqrt(array.value)) + + # Operators + + def sign(self, array: Array) -> Array: + return Array(np.sign(array.value)) + + def maximum(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.maximum(_unwrap(array1), _unwrap(array2))) + + def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + return Array(np.argmax(array.value, axis=dim, keepdims=keepdims)) + + def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + return Array(np.argmin(array.value, axis=dim, keepdims=keepdims)) + + def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + array.value[key] = value.value + + def get_item(self, array: Array, key: ArrayKey) -> Array: + return Array(array.value[key]) + + # RNG + + def set_seed(self, seed: int) -> None: + # Seed both the legacy global state and our owned Generator. The legacy state is + # important because some downstream libraries (sklearn, pandas) consult it. + np.random.seed(seed) # noqa: NPY002 + self._rng = np.random.default_rng(seed) + + def get_rng_state(self) -> dict[str, Any]: + # ``np.random.get_state()`` returns a tuple by default; ``legacy=False`` returns + # the equivalent dict form, which both matches the surrounding ``dict[str, Any]`` + # value type (so mypyc's strict union narrowing is satisfied) and round-trips + # cleanly through ``np.random.set_state``. + return { + "numpy_bit_generator_state": deepcopy(self._rng.bit_generator.state), + "numpy_legacy_state": np.random.get_state(legacy=False), # noqa: NPY002 + } + + def set_rng_state(self, state: dict[str, Any]) -> None: + if "numpy_bit_generator_state" in state: + self._rng = np.random.default_rng() + self._rng.bit_generator.state = state["numpy_bit_generator_state"] + if "numpy_legacy_state" in state: + np.random.set_state(state["numpy_legacy_state"]) # noqa: NPY002 + + def normal(self, mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + return Array(self._rng.normal(loc=mean, scale=std, size=shape)) + + def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + return Array(self._rng.uniform(low=low, high=high, size=shape)) + + def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: + return Array(self._rng.normal(loc=mean, scale=std, size=array.value.shape)) + + def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: + return Array(self._rng.uniform(low=low, high=high, size=array.value.shape)) + + def choice(self, array: Array, size: int, replace: bool = True) -> Array: + return Array(self._rng.choice(array.value, size=size, replace=replace)) + + +register_backend(SupportedFrameworks.NUMPY, NumpyBackend) diff --git a/decent_array/interoperability/_pytorch/__init__.py b/decent_array/interoperability/_pytorch/__init__.py new file mode 100644 index 0000000..7e28c44 --- /dev/null +++ b/decent_array/interoperability/_pytorch/__init__.py @@ -0,0 +1,5 @@ +"""PyTorch backend package; importing it triggers backend registration.""" + +from .pytorch_backend import PyTorchBackend + +__all__ = ["PyTorchBackend"] diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py new file mode 100644 index 0000000..f3a8730 --- /dev/null +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -0,0 +1,312 @@ +""" +PyTorch backend for interoperability_2. + +Importing this module registers the backend via :func:`register_backend`, so the +package can be auto-loaded on the first ``set_backend("pytorch")`` call. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import Any + +import numpy as np +import torch +from numpy.typing import NDArray + +from decent_array.array import Array +from decent_array.interoperability.abstracts import _Backend +from decent_array.interoperability.backend_manager import register_backend +from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks + + +def _unwrap(array: Any) -> Any: # noqa: ANN401 + """Return the underlying value of an :class:`Array`, or pass ``array`` through.""" + return array.value if type(array) is Array else array + + +class PyTorchBackend(_Backend): # noqa: PLR0904 + """PyTorch implementation of :class:`_Backend`.""" + + def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: + super().__init__(device) + self._native_device: str = self.device_to_native(device) + self._generator: torch.Generator = torch.Generator(device=self._native_device) + + # Array creation + + def zeros(self, shape: tuple[int, ...]) -> Array: + return Array(torch.zeros(shape, device=self._native_device)) + + def zeros_like(self, array: Array) -> Array: + return Array(torch.zeros_like(array.value)) + + def ones(self, shape: tuple[int, ...]) -> Array: + return Array(torch.ones(shape, device=self._native_device)) + + def ones_like(self, array: Array) -> Array: + return Array(torch.ones_like(array.value)) + + def eye(self, n: int) -> Array: + return Array(torch.eye(n, device=self._native_device)) + + def eye_like(self, array: Array) -> Array: + v = array.value + return Array(torch.eye(*v.shape[-2:], dtype=v.dtype, device=v.device)) + + def device_to_native(self, device: SupportedDevices) -> str: + if device == SupportedDevices.CPU: + return "cpu" + if device == SupportedDevices.GPU: + return "cuda" + if device == SupportedDevices.MPS: + return "mps" + raise ValueError(f"Unsupported device: {device}") + + def device_of(self, array: Array) -> SupportedDevices: + kind = array.value.device.type + if kind == "cpu": + return SupportedDevices.CPU + if kind == "cuda": + return SupportedDevices.GPU + if kind == "mps": + return SupportedDevices.MPS + raise TypeError(f"Unsupported PyTorch device type: {kind}") + + # Array manipulation + + def copy(self, array: Array) -> Array: + return Array(array.value.detach().clone()) + + def to_numpy(self, array: Array) -> NDArray[Any]: + """Return the value of an :class:`Array` as a NumPy array.""" + v = array.value + if isinstance(v, torch.Tensor): + ret: NDArray[Any] = v.cpu().numpy() + else: + ret = np.asarray(v) + return ret + + def from_numpy(self, array: NDArray[Any]) -> Array: + return Array(torch.from_numpy(array).to(device=self._native_device)) + + def to_array(self, array: float | bool) -> Array: + return Array(torch.tensor(array, device=self._native_device)) + + def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + if len(arrays) == 0: + raise ValueError("Cannot stack an empty sequence of arrays.") + return Array(torch.stack([a.value for a in arrays], dim=dim)) + + def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: + return Array(torch.reshape(array.value, shape)) + + def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + v = array.value + dims = dim if dim is not None else tuple(reversed(range(v.ndim))) + return Array(torch.permute(v, dims=dims)) + + def shape(self, array: Array) -> tuple[int, ...]: + return tuple(array.value.shape) + + def size(self, array: Array) -> int: + return int(array.value.numel()) + + def ndim(self, array: Array) -> int: + return int(array.value.ndim) + + def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + v = array.value + if dim is None: + return Array(torch.squeeze(v)) + return Array(torch.squeeze(v, dim=dim)) + + def unsqueeze(self, array: Array, dim: int) -> Array: + return Array(torch.unsqueeze(array.value, dim=dim)) + + def diag(self, array: Array) -> Array: + return Array(torch.diag(array.value)) + + def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: + return dtype(array.value.item()) + + # Linalg + + def dot(self, array1: Array, array2: Array) -> Array: + return Array(torch.dot(array1.value, array2.value)) + + def matmul(self, array1: Array, array2: Array) -> Array: + return Array(array1.value @ array2.value) + + def norm( + self, + array: Array, + p: float = 2, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ) -> Array: + return Array(torch.linalg.norm(array.value, ord=p, dim=dim, keepdim=keepdims)) + + # Math reductions + + def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = array.value + if dim is None: + return Array(torch.sum(v)) + return Array(torch.sum(v, dim=dim, keepdim=keepdims)) + + def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = array.value + if dim is None: + return Array(torch.mean(v)) + return Array(torch.mean(v, dim=dim, keepdim=keepdims)) + + def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = array.value + if dim is None: + return Array(torch.min(v)) + return Array(torch.amin(v, dim=dim, keepdim=keepdims)) + + def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = array.value + if dim is None: + return Array(torch.max(v)) + return Array(torch.amax(v, dim=dim, keepdim=keepdims)) + + def any(self, array: Array) -> bool: + return bool(torch.any(array.value).item()) + + def all(self, array: Array) -> bool: + return bool(torch.all(array.value).item()) + + # Math elementwise — operands may be Array or scalar (operator dunders pass either). + # ``Array | float`` covers both: PEP 484's numeric tower implicitly admits ``int``. + + def add(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.add(_unwrap(array1), _unwrap(array2))) + + def iadd[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value.add_(_unwrap(array2)) + return array1 + + def sub(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.sub(_unwrap(array1), _unwrap(array2))) + + def isub[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value.sub_(_unwrap(array2)) + return array1 + + def mul(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.mul(_unwrap(array1), _unwrap(array2))) + + def imul[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value.mul_(_unwrap(array2)) + return array1 + + def div(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.div(_unwrap(array1), _unwrap(array2))) + + def idiv[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value.div_(_unwrap(array2)) + return array1 + + def pow(self, array: Array, p: float) -> Array: + return Array(torch.pow(array.value, p)) + + def negative(self, array: Array) -> Array: + return Array(torch.neg(array.value)) + + def absolute(self, array: Array) -> Array: + return Array(torch.abs(array.value)) + + def sqrt(self, array: Array) -> Array: + return Array(torch.sqrt(array.value)) + + # Operators + + def sign(self, array: Array) -> Array: + return Array(torch.sign(array.value)) + + def maximum(self, array1: Array | float, array2: Array | float) -> Array: + a, b = _unwrap(array1), _unwrap(array2) + # torch.maximum requires both operands to be Tensors; lift Python scalars to + # match the dtype/device of the tensor operand so the contract matches numpy. + if not isinstance(a, torch.Tensor): + ref = b if isinstance(b, torch.Tensor) else None + a = torch.tensor(a, dtype=ref.dtype if ref is not None else None, device=self._native_device) + if not isinstance(b, torch.Tensor): + b = torch.tensor(b, dtype=a.dtype, device=a.device) + return Array(torch.maximum(a, b)) + + def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + return Array(torch.argmax(array.value, dim=dim, keepdim=keepdims)) + + def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + return Array(torch.argmin(array.value, dim=dim, keepdim=keepdims)) + + def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + array.value[key] = value.value + + def get_item(self, array: Array, key: ArrayKey) -> Array: + return Array(array.value[key]) + + # RNG + + def set_seed(self, seed: int) -> None: + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(seed) + self._generator.manual_seed(seed) + + def get_rng_state(self) -> dict[str, Any]: + state: dict[str, Any] = { + "torch_cpu_state": torch.random.get_rng_state(), + "torch_generator_state": self._generator.get_state(), + } + if torch.cuda.is_available(): + state["torch_cuda_states"] = torch.cuda.get_rng_state_all() + return state + + def set_rng_state(self, state: dict[str, Any]) -> None: + if "torch_cpu_state" in state: + torch.random.set_rng_state(state["torch_cpu_state"]) + if "torch_cuda_states" in state and torch.cuda.is_available(): + torch.cuda.set_rng_state_all(state["torch_cuda_states"]) + if "torch_generator_state" in state: + self._generator.set_state(state["torch_generator_state"]) + + def normal(self, mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + return Array( + torch.normal(mean=mean, std=std, size=shape, device=self._native_device, generator=self._generator) + ) + + def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + rand = torch.rand(size=shape, device=self._native_device, generator=self._generator) + return Array((high - low) * rand + low) + + def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: + v = array.value + return Array( + torch.normal( + mean=mean, + std=std, + size=tuple(v.shape), + dtype=v.dtype, + device=v.device, + generator=self._generator, + ) + ) + + def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: + v = array.value + rand = torch.rand(size=tuple(v.shape), dtype=v.dtype, device=v.device, generator=self._generator) + return Array((high - low) * rand + low) + + def choice(self, array: Array, size: int, replace: bool = True) -> Array: + v = array.value + weights = torch.ones(v.shape[0], device=v.device) + indices = weights.multinomial(num_samples=size, replacement=replace, generator=self._generator) + return Array(v[indices]) + + +register_backend(SupportedFrameworks.PYTORCH, PyTorchBackend) diff --git a/decent_array/interoperability/_tensorflow/__init__.py b/decent_array/interoperability/_tensorflow/__init__.py new file mode 100644 index 0000000..dae3831 --- /dev/null +++ b/decent_array/interoperability/_tensorflow/__init__.py @@ -0,0 +1,5 @@ +"""TensorFlow backend package; importing it triggers backend registration.""" + +from .tensorflow_backend import TensorflowBackend + +__all__ = ["TensorflowBackend"] diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py new file mode 100644 index 0000000..f153ed3 --- /dev/null +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -0,0 +1,315 @@ +""" +TensorFlow backend for interoperability_2. + +Importing this module registers the backend via :func:`register_backend`, so the +package can be auto-loaded on the first ``set_backend("tensorflow")`` call. + +TF eager Tensors are immutable, so :meth:`set_item` round-trips through numpy and the +in-place math operations rebind the wrapper's underlying value. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import Any, cast + +import numpy as np +import tensorflow as tf +from numpy.typing import NDArray + +from decent_array.array import Array +from decent_array.interoperability.abstracts import _Backend +from decent_array.interoperability.backend_manager import register_backend +from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks + + +def _unwrap(array: Any) -> Any: # noqa: ANN401 + """Return the underlying value of an :class:`Array`, or pass ``array`` through.""" + return array.value if type(array) is Array else array + + +class TensorflowBackend(_Backend): # noqa: PLR0904 + """TensorFlow implementation of :class:`_Backend`.""" + + def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: + super().__init__(device) + self._native_device: str = self.device_to_native(device) + self._generator: tf.random.Generator = tf.random.Generator.from_non_deterministic_state(alg="philox") + + # Array creation + + def zeros(self, shape: tuple[int, ...]) -> Array: + with tf.device(self._native_device): + return Array(tf.zeros(shape)) + + def zeros_like(self, array: Array) -> Array: + return Array(tf.zeros_like(array.value)) + + def ones(self, shape: tuple[int, ...]) -> Array: + with tf.device(self._native_device): + return Array(tf.ones(shape)) + + def ones_like(self, array: Array) -> Array: + return Array(tf.ones_like(array.value)) + + def eye(self, n: int) -> Array: + with tf.device(self._native_device): + return Array(tf.eye(n)) + + def eye_like(self, array: Array) -> Array: + v = array.value + rows, cols = v.shape[-2:] + return Array(tf.eye(rows, cols, dtype=v.dtype)) + + def device_to_native(self, device: SupportedDevices) -> str: + if device in {SupportedDevices.CPU, SupportedDevices.GPU}: + return f"/{device.value}:0" + raise ValueError(f"Unsupported device for TensorFlow: {device}") + + def device_of(self, array: Array) -> SupportedDevices: + device_str = array.value.device.lower() + if "gpu" in device_str or "cuda" in device_str: + return SupportedDevices.GPU + return SupportedDevices.CPU + + # Array manipulation + + def copy(self, array: Array) -> Array: + return Array(tf.identity(array.value)) + + def to_numpy(self, array: Array) -> NDArray[Any]: + """Return the value of an :class:`Array` as a NumPy array.""" + v = array.value + if isinstance(v, tf.Tensor): + ret: NDArray[Any] = v.numpy() + else: + ret = np.asarray(v) + return ret + + def from_numpy(self, array: NDArray[Any]) -> Array: + """Create an :class:`Array` from a NumPy array.""" + with tf.device(self._native_device): + return Array(tf.convert_to_tensor(array)) + + def to_array(self, array: float | bool) -> Array: + """Convert a Python scalar to an :class:`Array` on this backend.""" + with tf.device(self._native_device): + return Array(tf.convert_to_tensor(array)) + + def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + if len(arrays) == 0: + raise ValueError("Cannot stack an empty sequence of arrays.") + return Array(tf.stack([a.value for a in arrays], axis=dim)) + + def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: + return Array(tf.reshape(array.value, shape)) + + def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + return Array(tf.transpose(array.value, perm=dim)) + + def shape(self, array: Array) -> tuple[int, ...]: + return cast("tuple[int, ...]", tuple(array.value.shape)) + + def size(self, array: Array) -> int: + return int(tf.size(array.value).numpy()) + + def ndim(self, array: Array) -> int: + return len(array.value.shape) + + def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + return Array(tf.squeeze(array.value, axis=dim)) + + def unsqueeze(self, array: Array, dim: int) -> Array: + return Array(tf.expand_dims(array.value, axis=dim)) + + def diag(self, array: Array) -> Array: + v = array.value + rank = v.shape.ndims + if rank == 1: + return Array(tf.linalg.diag(v)) + if rank == 2: + return Array(tf.linalg.diag_part(v)) + raise ValueError(f"diag requires a 1- or 2-D tensor, got rank {rank}") + + def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: + return dtype(array.value.numpy().item()) + + # Linalg + + def dot(self, array1: Array, array2: Array) -> Array: + return Array(tf.tensordot(array1.value, array2.value, axes=1)) + + def matmul(self, array1: Array, array2: Array) -> Array: + # tf.matmul requires both operands to have ndim >= 2; fall back to tensordot + # for the vector cases so semantics match numpy / torch / jax matmul. + a, b = array1.value, array2.value + if a.shape.ndims is None or b.shape.ndims is None or a.shape.ndims < 2 or b.shape.ndims < 2: + return Array(tf.tensordot(a, b, axes=1)) + return Array(a @ b) + + def norm( + self, + array: Array, + p: float = 2, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ) -> Array: + v = array.value + # tf.norm defaults differ from np.linalg.norm on 2-D inputs (operator vs. + # Frobenius); match numpy's flat default by reducing over both trailing axes. + axis = dim if dim is not None else (-2, -1) if v.ndim == 2 else None + return Array(tf.norm(v, ord=p, axis=axis, keepdims=keepdims)) + + # Math reductions + + def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_sum(array.value, axis=dim, keepdims=keepdims)) + + def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_mean(array.value, axis=dim, keepdims=keepdims)) + + def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_min(array.value, axis=dim, keepdims=keepdims)) + + def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_max(array.value, axis=dim, keepdims=keepdims)) + + def any(self, array: Array) -> bool: + return bool(tf.reduce_any(tf.cast(array.value, tf.bool)).numpy()) + + def all(self, array: Array) -> bool: + return bool(tf.reduce_all(tf.cast(array.value, tf.bool)).numpy()) + + # Math elementwise — TF Tensors are immutable; "in-place" ops rebind the wrapper. + # Operands may be Array or scalar (operator dunders pass either); ``Array | float`` + # covers both because PEP 484's numeric tower implicitly admits ``int``. + + def add(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.add(_unwrap(array1), _unwrap(array2))) + + def iadd[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = tf.add(array1.value, _unwrap(array2)) + return array1 + + def sub(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.subtract(_unwrap(array1), _unwrap(array2))) + + def isub[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = tf.subtract(array1.value, _unwrap(array2)) + return array1 + + def mul(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.multiply(_unwrap(array1), _unwrap(array2))) + + def imul[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = tf.multiply(array1.value, _unwrap(array2)) + return array1 + + def div(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.divide(_unwrap(array1), _unwrap(array2))) + + def idiv[T: Array](self, array1: T, array2: Array | float) -> T: + array1.value = tf.divide(array1.value, _unwrap(array2)) + return array1 + + def pow(self, array: Array, p: float) -> Array: + return Array(tf.pow(array.value, p)) + + def negative(self, array: Array) -> Array: + return Array(tf.negative(array.value)) + + def absolute(self, array: Array) -> Array: + return Array(tf.abs(array.value)) + + def sqrt(self, array: Array) -> Array: + return Array(tf.sqrt(array.value)) + + # Operators + + def sign(self, array: Array) -> Array: + return Array(tf.sign(array.value)) + + def maximum(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.maximum(_unwrap(array1), _unwrap(array2))) + + def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + v = array.value + if dim is None: + flat = tf.argmax(tf.reshape(v, [-1]), axis=0) + if keepdims: + ndim = v.shape.ndims or 0 + return Array(tf.reshape(flat, [1] * ndim)) + return Array(flat) + out = tf.argmax(v, axis=dim) + if keepdims: + out = tf.expand_dims(out, axis=dim) + return Array(out) + + def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + v = array.value + if dim is None: + flat = tf.argmin(tf.reshape(v, [-1]), axis=0) + if keepdims: + ndim = v.shape.ndims or 0 + return Array(tf.reshape(flat, [1] * ndim)) + return Array(flat) + out = tf.argmin(v, axis=dim) + if keepdims: + out = tf.expand_dims(out, axis=dim) + return Array(out) + + def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + # TF eager tensors are immutable; round-trip through numpy so arbitrary indexing + # patterns (slices, fancy indexing) Just Work. The wrapper is rebound to a fresh + # tensor on the configured device. This is correct but allocates — algorithms + # that hammer set_item in tight loops should consider numpy or pytorch. + original = array.value + np_array = original.numpy().copy() + np_array[key] = np.asarray(value.value) + with tf.device(self._native_device): + array.value = tf.convert_to_tensor(np_array, dtype=original.dtype) + + def get_item(self, array: Array, key: ArrayKey) -> Array: + return Array(array.value[key]) + + # RNG + + def set_seed(self, seed: int) -> None: + tf.random.set_seed(seed) + self._generator = tf.random.Generator.from_seed(seed, alg="philox") + + def get_rng_state(self) -> dict[str, Any]: + return {"tf_generator_state": self._generator.state.numpy()} + + def set_rng_state(self, state: dict[str, Any]) -> None: + if "tf_generator_state" in state: + self._generator = tf.random.Generator.from_state(state["tf_generator_state"], alg="philox") + + def normal(self, mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + with tf.device(self._native_device): + return Array(self._generator.normal(shape=shape, mean=mean, stddev=std)) + + def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + with tf.device(self._native_device): + return Array(self._generator.uniform(shape=shape, minval=low, maxval=high)) + + def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: + v = array.value + return Array(self._generator.normal(shape=tf.shape(v), mean=mean, stddev=std, dtype=v.dtype)) + + def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: + v = array.value + return Array(self._generator.uniform(shape=tf.shape(v), minval=low, maxval=high, dtype=v.dtype)) + + def choice(self, array: Array, size: int, replace: bool = True) -> Array: + v = array.value + n = v.shape[0] + if replace: + indices = self._generator.uniform(shape=(size,), minval=0, maxval=n, dtype=tf.int32) + else: + scores = self._generator.uniform(shape=(n,), dtype=tf.float32) + indices = tf.cast(tf.math.top_k(scores, k=size).indices, tf.int32) + return Array(tf.gather(v, indices)) + + +register_backend(SupportedFrameworks.TENSORFLOW, TensorflowBackend) diff --git a/decent_array/interoperability/abstracts/__init__.py b/decent_array/interoperability/abstracts/__init__.py new file mode 100644 index 0000000..d8b79e9 --- /dev/null +++ b/decent_array/interoperability/abstracts/__init__.py @@ -0,0 +1,3 @@ +from .backend import _Backend + +__all__ = ["_Backend"] diff --git a/decent_array/interoperability/abstracts/backend.py b/decent_array/interoperability/abstracts/backend.py new file mode 100644 index 0000000..99d3ecc --- /dev/null +++ b/decent_array/interoperability/abstracts/backend.py @@ -0,0 +1,289 @@ +""" +Abstract :class:`_Backend` contract. + +All abstract methods live in this single class rather than across six mixin ABCs. The +flat layout is mypyc-compatible: when this module is included in the same compilation +group as the concrete backends, ``_BACKEND.add(self, other)`` becomes a native +compiled-to-compiled call (no Python attribute lookup, no bound-method allocation), +which removes the need for a ``raw_ops`` escape hatch on the hot path. + +Section dividers in this file group related operations the way the legacy split files +did (creation, manipulation, linalg, math, operators, RNG); the only thing that +changed is that they all live on one class. +""" + +from __future__ import annotations + +from abc import ABC, abstractmethod +from collections.abc import Sequence +from typing import TYPE_CHECKING, Any + +from decent_array.types import SupportedDevices + +if TYPE_CHECKING: + from numpy.typing import NDArray + + from decent_array.array import Array + from decent_array.types import ArrayKey + + +class _Backend(ABC): # noqa: PLR0904 + """ + Abstract base class for a backend. + + Concrete backends are bound to a single :class:`SupportedDevices` at construction + time; that device is the default for all new arrays produced by this backend. + """ + + def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: + self.device: SupportedDevices = device + + # Array creation ------------------------------------------------------ + + @abstractmethod + def zeros(self, shape: tuple[int, ...]) -> Array: + """Create an array of zeros with the given shape.""" + + @abstractmethod + def zeros_like(self, array: Array) -> Array: + """Create an array of zeros matching the shape and type of ``array``.""" + + @abstractmethod + def ones(self, shape: tuple[int, ...]) -> Array: + """Create an array of ones with the given shape.""" + + @abstractmethod + def ones_like(self, array: Array) -> Array: + """Create an array of ones matching the shape and type of ``array``.""" + + @abstractmethod + def eye(self, n: int) -> Array: + """Create an ``n x n`` identity matrix.""" + + @abstractmethod + def eye_like(self, array: Array) -> Array: + """Create an identity matrix matching the trailing two dims of ``array``.""" + + @abstractmethod + def device_to_native(self, device: SupportedDevices) -> Any: # noqa: ANN401 + """Convert :class:`SupportedDevices` to the backend's native device representation.""" + + @abstractmethod + def device_of(self, array: Array) -> SupportedDevices: + """Return the :class:`SupportedDevices` of the given array.""" + + # Array manipulation -------------------------------------------------- + + @abstractmethod + def copy(self, array: Array) -> Array: + """Return a copy of ``array``.""" + + @abstractmethod + def to_numpy(self, array: Array) -> NDArray[Any]: + """Convert ``array`` to a NumPy array on the CPU.""" + + @abstractmethod + def from_numpy(self, array: NDArray[Any]) -> Array: + """Convert a NumPy array on the CPU to an :class:`Array` on this backend.""" + + @abstractmethod + def to_array(self, array: float | bool) -> Array: + """Convert a Python scalar to an :class:`Array` on this backend.""" + + @abstractmethod + def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + """Stack a sequence of arrays along a new dimension.""" + + @abstractmethod + def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: + """Reshape ``array`` to ``shape``.""" + + @abstractmethod + def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + """Transpose ``array``; ``None`` reverses the dimensions.""" + + @abstractmethod + def shape(self, array: Array) -> tuple[int, ...]: + """Return the shape of ``array``.""" + + @abstractmethod + def size(self, array: Array) -> int: + """Return the total number of elements in ``array``.""" + + @abstractmethod + def ndim(self, array: Array) -> int: + """Return the number of dimensions of ``array``.""" + + @abstractmethod + def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + """Remove single-dimensional entries from ``array``.""" + + @abstractmethod + def unsqueeze(self, array: Array, dim: int) -> Array: + """Insert a singleton dimension at ``dim``.""" + + @abstractmethod + def diag(self, array: Array) -> Array: + """Diagonal: build from a vector or extract from a matrix.""" + + @abstractmethod + def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: + """Cast a single-element ``array`` to a Python scalar of ``dtype``.""" + + # Linalg -------------------------------------------------------------- + + @abstractmethod + def dot(self, array1: Array, array2: Array) -> Array: + """Dot product of two arrays.""" + + @abstractmethod + def matmul(self, array1: Array, array2: Array) -> Array: + """Matrix multiplication of two arrays.""" + + @abstractmethod + def norm( + self, + array: Array, + p: float = 2, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ) -> Array: + """Compute the norm of ``array``.""" + + # Math reductions ----------------------------------------------------- + + @abstractmethod + def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Sum elements of ``array`` along ``dim``.""" + + @abstractmethod + def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Mean of ``array`` along ``dim``.""" + + @abstractmethod + def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Minimum of ``array`` along ``dim``.""" + + @abstractmethod + def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Maximum of ``array`` along ``dim``.""" + + @abstractmethod + def any(self, array: Array) -> bool: + """Return True if any element of ``array`` is truthy.""" + + @abstractmethod + def all(self, array: Array) -> bool: + """Return True if all elements of ``array`` are truthy.""" + + # Math elementwise — both operands may be Array or scalar (operator dunders pass + # either). ``Array | float`` covers both because PEP 484's numeric tower implicitly + # admits ``int``. + + @abstractmethod + def add(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise addition.""" + + @abstractmethod + def iadd[T: Array](self, array1: T, array2: Array | float) -> T: + """In-place element-wise addition.""" + + @abstractmethod + def sub(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise subtraction.""" + + @abstractmethod + def isub[T: Array](self, array1: T, array2: Array | float) -> T: + """In-place element-wise subtraction.""" + + @abstractmethod + def mul(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise multiplication.""" + + @abstractmethod + def imul[T: Array](self, array1: T, array2: Array | float) -> T: + """In-place element-wise multiplication.""" + + @abstractmethod + def div(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise division.""" + + @abstractmethod + def idiv[T: Array](self, array1: T, array2: Array | float) -> T: + """In-place element-wise division.""" + + @abstractmethod + def pow(self, array: Array, p: float) -> Array: + """Raise ``array`` to power ``p``.""" + + @abstractmethod + def negative(self, array: Array) -> Array: + """Element-wise negation.""" + + @abstractmethod + def absolute(self, array: Array) -> Array: + """Element-wise absolute value.""" + + @abstractmethod + def sqrt(self, array: Array) -> Array: + """Element-wise square root.""" + + # Operators ----------------------------------------------------------- + + @abstractmethod + def sign(self, array: Array) -> Array: + """Element-wise sign.""" + + @abstractmethod + def maximum(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise maximum.""" + + @abstractmethod + def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + """Index of maximum value along ``dim``.""" + + @abstractmethod + def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + """Index of minimum value along ``dim``.""" + + @abstractmethod + def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + """Set ``array[key] = value``.""" + + @abstractmethod + def get_item(self, array: Array, key: ArrayKey) -> Array: + """Return ``array[key]``.""" + + # RNG ----------------------------------------------------------------- + + @abstractmethod + def set_seed(self, seed: int) -> None: + """Seed the backend's RNG with ``seed``.""" + + @abstractmethod + def get_rng_state(self) -> dict[str, Any]: + """Return a snapshot of the backend's RNG state.""" + + @abstractmethod + def set_rng_state(self, state: dict[str, Any]) -> None: + """Restore an RNG snapshot produced by :meth:`get_rng_state`.""" + + @abstractmethod + def normal(self, mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + """Draw normally distributed samples.""" + + @abstractmethod + def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + """Draw uniformly distributed samples from ``[low, high)``.""" + + @abstractmethod + def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: + """Draw normally distributed samples shaped like ``array``.""" + + @abstractmethod + def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: + """Draw uniformly distributed samples shaped like ``array``.""" + + @abstractmethod + def choice(self, array: Array, size: int, replace: bool = True) -> Array: + """Sample ``size`` elements from ``array``.""" diff --git a/decent_array/interoperability/backend_manager.py b/decent_array/interoperability/backend_manager.py new file mode 100644 index 0000000..7a743d3 --- /dev/null +++ b/decent_array/interoperability/backend_manager.py @@ -0,0 +1,184 @@ +from __future__ import annotations + +import importlib +from collections.abc import Callable +from contextvars import ContextVar + +from decent_array.types import SupportedDevices, SupportedFrameworks + +from .abstracts import _Backend + +_BACKEND_REGISTRY: dict[SupportedFrameworks, type[_Backend]] = {} +_BACKEND_INSTANCES: dict[SupportedFrameworks, _Backend] = {} +_ACTIVE_BACKEND: ContextVar[SupportedFrameworks | None] = ContextVar("decent_bench.iop2.active_backend", default=None) +_BACKEND_LISTENERS: list[Callable[[_Backend | None], None]] = [] +_BACKEND_INSTANCE: _Backend | None = None + + +def set_backend( + backend: SupportedFrameworks | str, + device: SupportedDevices | str = SupportedDevices.CPU, +) -> None: + """ + Set the active backend (and target device) for the current execution context. + + The first call binds both the backend and the device; subsequent calls must use the + same backend *and* the same device or a :class:`RuntimeError` is raised. This + single-backend, single-device invariant lets the rest of the interoperability layer + skip framework dispatch and isinstance checks, and lets backends construct array + creation routines bound to a specific accelerator. + + Backend modules are auto-imported on demand: the first call to ``set_backend("pytorch")`` + triggers import of ``decent_bench.utils.interoperability_2._pytorch``, whose ``__init__`` + is expected to register the backend via :func:`register_backend`. + + Args: + backend: A :class:`SupportedFrameworks` value, its canonical string (e.g. + ``"numpy"``, ``"pytorch"``), or any alias declared by the backend at + registration time. Aliases are only resolvable after the backend module has + been loaded; pass the canonical name on the first call to trigger autoload. + device: Target accelerator. Accepts a :class:`SupportedDevices` value or its + string equivalent (``"cpu"``, ``"gpu"``, ``"mps"``). Defaults to CPU. The + backend's array-creation methods produce arrays on this device by default. + + Note: + Raises :class:`ImportError` if the backend module cannot be imported (e.g. due to + a missing optional dependency); the failure originates from :func:`_auto_import`. + + Raises: + RuntimeError: If a different backend (or the same backend with a different device) + is already active in this context. + + """ + requested = _normalize(backend) + requested_device = device if isinstance(device, SupportedDevices) else SupportedDevices(device) + + current = _ACTIVE_BACKEND.get() + if current is not None and current != requested: + raise RuntimeError( + f"Backend already set to '{current.value}', cannot set to '{requested.value}'. " + "A single execution context may only use one backend." + ) + + cached = _instantiate(requested, requested_device) + if cached.device != requested_device: + raise RuntimeError( + f"Backend '{requested.value}' already configured with device " + f"'{cached.device.value}', cannot reconfigure to '{requested_device.value}'." + ) + + if current is None: + _ACTIVE_BACKEND.set(requested) + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = cached + for listener in _BACKEND_LISTENERS: + listener(_BACKEND_INSTANCE) + + +def register_backend_listener(listener: Callable[[_Backend | None], None]) -> None: + """ + Register a callback to be invoked on backend activation. + + The callback receives the active backend instance as its only argument. If a backend + is already active, the callback is invoked immediately with the current backend. + + Args: + listener: A callable that accepts a single :class:`_Backend` instance argument. + + """ + _BACKEND_LISTENERS.append(listener) + if _BACKEND_INSTANCE is not None: + listener(_BACKEND_INSTANCE) + + +def register_backend( + backend: SupportedFrameworks, + cls: type[_Backend], +) -> None: + """ + Register a backend class under a :class:`SupportedFrameworks` value. + + Called once per backend module *after* the class definition (rather than as a + class decorator). Decorator-based registration would mark the decorated class as + non-extension under mypyc, blocking native compiled-to-compiled dispatch on + ``_BACKEND.add(...)`` and friends — the call-form keeps concrete backends as + extension classes. + + Backends are instantiated lazily on first use. Re-registering replaces the + previous class and discards any cached instance, but keeps existing aliases + (which still point to the same canonical name). + + Args: + backend: Canonical backend identifier. + cls: A concrete subclass of :class:`_Backend`. + + Raises: + TypeError: If ``cls`` is not a subclass of :class:`_Backend`. + + """ + if not issubclass(cls, _Backend): + raise TypeError(f"Registered backend must be a subclass of _Backend, got {cls}") + _BACKEND_REGISTRY[backend] = cls + _BACKEND_INSTANCES.pop(backend, None) + + +def reset_backends() -> None: + """ + Clear the active backend and all cached instances for the current context. + + Intended for tests or tightly scoped execution; not part of normal use. Registry + entries (classes and aliases) are preserved. + """ + global _BACKEND_INSTANCE # noqa: PLW0603 + _ACTIVE_BACKEND.set(None) + _BACKEND_INSTANCES.clear() + _BACKEND_INSTANCE = None + for listener in _BACKEND_LISTENERS: + listener(None) + + +def _normalize(backend: SupportedFrameworks | str) -> SupportedFrameworks: + if isinstance(backend, SupportedFrameworks): + return backend + try: + return SupportedFrameworks(backend) + except ValueError as exc: + valid = ", ".join(f.value for f in SupportedFrameworks) + raise KeyError(f"Unknown backend '{backend}'. Valid backends: {valid}.") from exc + + +def _instantiate(backend: SupportedFrameworks, device: SupportedDevices) -> _Backend: + if backend in _BACKEND_INSTANCES: + return _BACKEND_INSTANCES[backend] + + if backend not in _BACKEND_REGISTRY: + _auto_import(backend) + + cls = _BACKEND_REGISTRY.get(backend) + if cls is None: + raise KeyError( + f"Backend '{backend.value}' is not registered. Ensure the corresponding backend module is importable." + ) + + instance = cls(device=device) + _BACKEND_INSTANCES[backend] = instance + return instance + + +def _auto_import(backend: SupportedFrameworks) -> None: + """ + Import the backend's package so its registration side-effect runs. + + Raises: + ImportError: If the backend module cannot be imported. + + """ + current_module = __name__.rsplit(".", 1)[0] + module_name = current_module + f"._{backend.value}" + try: + importlib.import_module(module_name) + except ImportError as exc: + raise ImportError( + f"Failed to import the backend module for '{backend.value}'. Ensure the " + "corresponding backend package is installed and importable." + ) from exc diff --git a/decent_array/interoperability/decorators.py b/decent_array/interoperability/decorators.py new file mode 100644 index 0000000..97a6ec5 --- /dev/null +++ b/decent_array/interoperability/decorators.py @@ -0,0 +1,56 @@ +""" +Decorator that bridges :class:`Cost` superclass signatures with framework-native subclass implementations. + +Single-backend semantics make this decorator dramatically simpler than the v1 version: no +framework dispatch, no cross-framework conversion, no ``to_array_like`` magic — just +unwrap input :class:`Array` values to their native form, call the subclass method, and +re-wrap the return if the superclass declared ``-> Array``. +""" + +from __future__ import annotations + +from collections.abc import Callable +from functools import wraps +from typing import Any, cast + + +def autodecorate_cost_method[T: Callable[..., Any]](superclass_method: T) -> Callable[[Callable[..., Any]], T]: + """ + Decorate a Cost method override so its body can use raw framework arrays. + + Each :class:`Array` argument is unwrapped to its underlying value before the call. + If the *superclass* method's return annotation is :class:`Array`, the return value + is re-wrapped in :class:`Array` (unless already wrapped). All other arguments and + return values pass through unchanged. + + Args: + superclass_method: The base-class method being overridden (e.g. ``Cost.function``). + Used solely to look up the declared return type at decoration time. + + Example: + class LinearRegressionCost(EmpiricalRiskCost): + @autodecorate_cost_method(EmpiricalRiskCost.gradient) + def gradient(self, x: NDArray[float64], indices: ...) -> NDArray[float64]: + # ``x`` arrives as a numpy ndarray; the wrapper unwraps the caller's Array. + return self.A.T @ (self.A @ x - self.b) / self.n_samples + # Return value is wrapped back into Array because EmpiricalRiskCost.gradient + # is annotated ``-> Array``. + + """ + from decent_array.array import Array # noqa: PLC0415 + + return_is_array = superclass_method.__annotations__.get("return") is Array + + def decorator(func: Callable[..., Any]) -> T: + @wraps(func) + def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any: # noqa: ANN401 + new_args = [a.value if isinstance(a, Array) else a for a in args] + new_kwargs = {k: (v.value if isinstance(v, Array) else v) for k, v in kwargs.items()} + result = func(self, *new_args, **new_kwargs) + if return_is_array and not isinstance(result, Array): + return Array(result) + return result + + return cast("T", wrapper) + + return decorator diff --git a/decent_array/interoperability/iop/__init__.py b/decent_array/interoperability/iop/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/decent_array/interoperability/iop/functions.py b/decent_array/interoperability/iop/functions.py new file mode 100644 index 0000000..efb637e --- /dev/null +++ b/decent_array/interoperability/iop/functions.py @@ -0,0 +1,418 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND`` +slot. The slot is rebound by :func:`decent_bench.utils.interoperability_2.set_backend` +via :func:`_set_active_backend`. Calling any of these before ``set_backend`` raises +:class:`RuntimeError` via the sentinel's ``__getattr__``. + +When this module and ``_Backend`` are mypyc-compiled in the same group, +``_BACKEND.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import TYPE_CHECKING, Any + +from decent_array.interoperability.backend_manager import register_backend_listener + +if TYPE_CHECKING: + from numpy.typing import NDArray + + from decent_array.array import Array + from decent_array.interoperability.abstracts import _Backend + from decent_array.types import ArrayKey, SupportedDevices + +_BACKEND_INSTANCE: _Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: _Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + +# Array creation + + +def zeros(shape: tuple[int, ...]) -> Array: + """Create an array of zeros with the given shape.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.zeros(shape) + + +def zeros_like(array: Array) -> Array: + """Create an array of zeros matching the shape and type of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.zeros_like(array) + + +def ones(shape: tuple[int, ...]) -> Array: + """Create an array of ones with the given shape.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ones(shape) + + +def ones_like(array: Array) -> Array: + """Create an array of ones matching the shape and type of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ones_like(array) + + +def eye(n: int) -> Array: + """Create an ``n x n`` identity matrix.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.eye(n) + + +def eye_like(array: Array) -> Array: + """Create an identity matrix matching the trailing 2 dims of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.eye_like(array) + + +def device_to_native(device: SupportedDevices) -> Any: # noqa: ANN401 + """Convert :class:`SupportedDevices` to the active backend's native device.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.device_to_native(device) + + +def device_of(array: Array) -> SupportedDevices: + """Return the :class:`SupportedDevices` of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.device_of(array) + + +# Array manipulation + + +def copy(array: Array) -> Array: + """Return a copy of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.copy(array) + + +def to_numpy(array: Array) -> NDArray[Any]: + """Convert ``array`` to a NumPy array on CPU.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.to_numpy(array) + + +def from_numpy(array: NDArray[Any]) -> Array: + """Convert a NumPy array on CPU to an :class:`Array` on the active backend.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.from_numpy(array) + + +def to_array(array: float | bool) -> Array: + """Convert a Python scalar to an :class:`Array` on the active backend.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.to_array(array) + + +def stack(arrays: Sequence[Array], dim: int = 0) -> Array: + """Stack a sequence of arrays along a new dimension.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.stack(arrays, dim) + + +def reshape(array: Array, shape: tuple[int, ...]) -> Array: + """Reshape ``array`` to ``shape``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.reshape(array, shape) + + +def transpose(array: Array, dim: tuple[int, ...] | None = None) -> Array: + """Transpose ``array``; ``None`` reverses dimensions.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.transpose(array, dim) + + +def shape(array: Array) -> tuple[int, ...]: + """Return the shape of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.shape(array) + + +def size(array: Array) -> int: + """Return the total number of elements in ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.size(array) + + +def ndim(array: Array) -> int: + """Return the number of dimensions of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ndim(array) + + +def squeeze(array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + """Remove single-dimensional entries from ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.squeeze(array, dim) + + +def unsqueeze(array: Array, dim: int) -> Array: + """Insert a singleton dimension at ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.unsqueeze(array, dim) + + +def diag(array: Array) -> Array: + """Diagonal: build from a vector or extract from a matrix.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.diag(array) + + +def astype(array: Array, dtype: type[float | int | bool]) -> float | int | bool: + """Cast a single-element ``array`` to a Python scalar of ``dtype``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.astype(array, dtype) + + +# Linalg + + +def dot(array1: Array, array2: Array) -> Array: + """Dot product of two arrays.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.dot(array1, array2) + + +def matmul(array1: Array, array2: Array) -> Array: + """Matrix multiplication of two arrays.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.matmul(array1, array2) + + +def norm( + array: Array, + p: float = 2, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Norm of ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.norm(array, p, dim, keepdims) + + +# Math reductions + + +def sum( # noqa: A001 + array: Array, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Sum elements of ``array`` along ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sum(array, dim, keepdims) + + +def mean( + array: Array, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Mean of ``array`` along ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.mean(array, dim, keepdims) + + +def min( # noqa: A001 + array: Array, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Minimum of ``array`` along ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.min(array, dim, keepdims) + + +def max( # noqa: A001 + array: Array, + dim: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Maximum of ``array`` along ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.max(array, dim, keepdims) + + +def any(array: Array) -> bool: # noqa: A001 + """Return True if any element of ``array`` is truthy.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.any(array) + + +def all(array: Array) -> bool: # noqa: A001 + """Return True if all elements of ``array`` are truthy.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.all(array) + + +# Math elementwise + + +def add(array1: Array | float, array2: Array | float) -> Array: + """Element-wise addition.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.add(array1, array2) + + +def iadd[T: Array](array1: T, array2: Array | float) -> T: + """In-place element-wise addition.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.iadd(array1, array2) + + +def sub(array1: Array | float, array2: Array | float) -> Array: + """Element-wise subtraction.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sub(array1, array2) + + +def isub[T: Array](array1: T, array2: Array | float) -> T: + """In-place element-wise subtraction.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.isub(array1, array2) + + +def mul(array1: Array | float, array2: Array | float) -> Array: + """Element-wise multiplication.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.mul(array1, array2) + + +def imul[T: Array](array1: T, array2: Array | float) -> T: + """In-place element-wise multiplication.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.imul(array1, array2) + + +def div(array1: Array | float, array2: Array | float) -> Array: + """Element-wise division.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.div(array1, array2) + + +def idiv[T: Array](array1: T, array2: Array | float) -> T: + """In-place element-wise division.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.idiv(array1, array2) + + +def pow(array: Array, p: float) -> Array: # noqa: A001 + """Raise ``array`` to power ``p``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.pow(array, p) + + +def negative(array: Array) -> Array: + """Element-wise negation.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.negative(array) + + +def absolute(array: Array) -> Array: + """Element-wise absolute value.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.absolute(array) + + +def sqrt(array: Array) -> Array: + """Element-wise square root.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sqrt(array) + + +# Operators + + +def sign(array: Array) -> Array: + """Element-wise sign.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sign(array) + + +def maximum(array1: Array | float, array2: Array | float) -> Array: + """Element-wise maximum.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.maximum(array1, array2) + + +def argmax(array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + """Index of maximum value along ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.argmax(array, dim, keepdims) + + +def argmin(array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + """Index of minimum value along ``dim``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.argmin(array, dim, keepdims) + + +def set_item(array: Array, key: ArrayKey, value: Array) -> None: + """Set ``array[key] = value`` in place.""" + if _BACKEND_INSTANCE is None: + raise _error + _BACKEND_INSTANCE.set_item(array, key, value) + + +def get_item(array: Array, key: ArrayKey) -> Array: + """Return ``array[key]``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.get_item(array, key) diff --git a/decent_array/interoperability/iop/rng.py b/decent_array/interoperability/iop/rng.py new file mode 100644 index 0000000..a472bad --- /dev/null +++ b/decent_array/interoperability/iop/rng.py @@ -0,0 +1,205 @@ +""" +Random-number coordination across backends. + +The active backend handles its own RNG, but two extra concerns sit above it: + +1. Python's :mod:`random` is often used incidentally and must also be seeded. +2. NumPy's RNG is frequently consulted by other frameworks (e.g. dataset shuffling + helpers, scikit-learn pre-processing) regardless of the active backend, so its state + must be tracked and restored alongside the active backend's state. + +:class:`_RngCoordinator` owns both concerns. RNG functions exposed by ``_iop`` route +through a process-singleton coordinator. + +When the active backend *is* numpy, the coordinator avoids double-seeding to keep the +RNG-state snapshot self-consistent. +""" + +from __future__ import annotations + +import random +from typing import TYPE_CHECKING, Any + +from decent_array.interoperability.backend_manager import _instantiate, register_backend_listener +from decent_array.types import SupportedDevices, SupportedFrameworks + +if TYPE_CHECKING: + from decent_array.array import Array + from decent_array.interoperability.abstracts import _Backend + + +_NUMPY_STATE_KEY = "__numpy_rng_state__" +_PYTHON_RANDOM_KEY = "__python_random_state__" +_BACKEND_INSTANCE: _Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: _Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +class _RngCoordinator: + """Coordinate RNG seeding/state across the active backend, NumPy, and Python's random.""" + + def __init__(self) -> None: + self._global_seed: int | None = None + + def set_seed(self, seed: int, *, set_global_seed: bool = True) -> None: + """ + Seed Python's ``random``, NumPy's RNG, and the active backend's RNG. + + Args: + seed: Base seed. + set_global_seed: If False, leaves :func:`get_seed` untouched. Use this for + trial-local reseeding where the externally observable base seed must be + preserved. + + """ + if _BACKEND_INSTANCE is None: + raise _error + + random.seed(seed) + active = _BACKEND_INSTANCE + active.set_seed(seed) + numpy_backend = self._numpy_backend() + if numpy_backend is not active: + numpy_backend.set_seed(seed) + if set_global_seed: + self._global_seed = seed + + def get_seed(self) -> int | None: + """Return the seed last passed to :meth:`set_seed` (with ``set_global_seed=True``).""" + return self._global_seed + + def get_rng_state(self) -> dict[str, Any]: + """ + Snapshot the RNG state of the active backend, NumPy (if auxiliary), and Python's random. + + The active backend's state is returned as-is. If the active backend is not NumPy, + NumPy's state is embedded under the reserved key ``"__numpy_rng_state__"``. The + Python ``random`` state is always embedded under ``"__python_random_state__"`` so + that incidental ``random.random()`` calls survive a snapshot/restore round-trip. + + """ + if _BACKEND_INSTANCE is None: + raise _error + + active = _BACKEND_INSTANCE + state = active.get_rng_state() + state[_PYTHON_RANDOM_KEY] = random.getstate() + numpy_backend = self._numpy_backend() + if numpy_backend is not active: + state[_NUMPY_STATE_KEY] = numpy_backend.get_rng_state() + return state + + def set_rng_state(self, state: dict[str, Any]) -> None: + """Restore a snapshot produced by :meth:`get_rng_state`.""" + if _BACKEND_INSTANCE is None: + raise _error + + # Copy so we can mutate without surprising the caller. + state = dict(state) + python_state = state.pop(_PYTHON_RANDOM_KEY, None) + if python_state is not None: + random.setstate(python_state) + active = _BACKEND_INSTANCE + numpy_backend = self._numpy_backend() + if numpy_backend is not active: + numpy_state = state.pop(_NUMPY_STATE_KEY, None) + if numpy_state is not None: + numpy_backend.set_rng_state(numpy_state) + active.set_rng_state(state) + + def _numpy_backend(self) -> _Backend: + return _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU) + + +_COORDINATOR = _RngCoordinator() + + +def set_seed(seed: int) -> None: + """Seed Python ``random``, NumPy, and the active backend's RNG with ``seed``.""" + _COORDINATOR.set_seed(seed) + + +def _set_seed_without_global(seed: int) -> None: + """ + Seed without changing the value returned by :func:`get_seed`. + + Used for trial-local reseeding where the externally observable base seed must be preserved. + """ + _COORDINATOR.set_seed(seed, set_global_seed=False) + + +def get_seed() -> int | None: + """Return the most recently set global seed, or ``None`` if unset.""" + return _COORDINATOR.get_seed() + + +def get_rng_state() -> dict[str, Any]: + """Return a snapshot of the active backend's RNG state.""" + return _COORDINATOR.get_rng_state() + + +def set_rng_state(state: dict[str, Any]) -> None: + """Restore an RNG snapshot produced by :func:`get_rng_state`.""" + _COORDINATOR.set_rng_state(state) + + +def derive_seed() -> int: + """ + Derive a new seed from the current state. + + This is useful when you want to create a new generator that is independent but reproducible from the current one. + For example, you might use this to seed a data loader's RNG based on the main RNG to ensure that data shuffling is + reproducible across runs, but different from the main RNG used for model initialization. + + Returns: + An integer seed derived from the current RNG state. + + """ + current_seed = get_seed() + if current_seed is None: + return random.randint(0, 2**32 - 1) + # Derive a new seed by hashing the current seed with some random data. + random_data = random.getrandbits(256) + return (current_seed + random_data) % (2**32) + + +def normal(mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + """Draw normally distributed samples on the active backend.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.normal(mean, std, shape) + + +def uniform(low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: + """Draw uniformly distributed samples on the active backend.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.uniform(low, high, shape) + + +def normal_like(array: Array, mean: float = 0.0, std: float = 1.0) -> Array: + """Draw normally distributed samples shaped like ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.normal_like(array, mean, std) + + +def uniform_like(array: Array, low: float = 0.0, high: float = 1.0) -> Array: + """Draw uniformly distributed samples shaped like ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.uniform_like(array, low, high) + + +def choice(array: Array, size: int, replace: bool = True) -> Array: + """Sample ``size`` elements from ``array``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.choice(array, size, replace) diff --git a/decent_array/types.py b/decent_array/types.py new file mode 100644 index 0000000..3e359aa --- /dev/null +++ b/decent_array/types.py @@ -0,0 +1,49 @@ +"""Type definitions for optimization variables.""" + +from __future__ import annotations + +from enum import Enum +from typing import TYPE_CHECKING, SupportsIndex, TypeAlias, Union + +if TYPE_CHECKING: + import jax + import numpy + import tensorflow as tf + import torch + +ArrayLike: TypeAlias = Union["numpy.ndarray", "torch.Tensor", "tf.Tensor", "jax.Array"] # noqa: UP040 +""" +Type alias for array-like types supported in decent-bench, including NumPy arrays, +PyTorch tensors, TensorFlow tensors, and JAX arrays. +""" + +SupportedArrayTypes: TypeAlias = ArrayLike | float | int # noqa: UP040 +""" +Type alias for supported types for optimization variables in decent-bench, +including array-like types and scalars. +""" + +ArrayKey: TypeAlias = SupportsIndex | slice | tuple[SupportsIndex | slice, ...] # noqa: UP040 +""" +Type alias for valid keys used to index into supported array types. +Includes single indices, tuples of indices, slices, and tuples of slices. +""" + + +# Its important that the enum values correspond to the folder names of the backends, +# since those are used for dynamic imports in _backend_manager.py +class SupportedFrameworks(Enum): + """Enum for supported frameworks in decent-bench.""" + + NUMPY = "numpy" + PYTORCH = "pytorch" + TENSORFLOW = "tensorflow" + JAX = "jax" + + +class SupportedDevices(Enum): + """Enum for supported devices in decent-bench.""" + + CPU = "cpu" + GPU = "gpu" + MPS = "mps" diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d0c3cbf --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..747ffb7 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/source/_static/custom.css b/docs/source/_static/custom.css new file mode 100644 index 0000000..4378c6a --- /dev/null +++ b/docs/source/_static/custom.css @@ -0,0 +1,6 @@ +/* Make the logo bigger */ +.navbar-brand img { + max-height: 65px; + height: auto; + width: auto; +} diff --git a/docs/source/_static/logo.png b/docs/source/_static/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..963c4977ab84693299ffa26d7d175ddca50725f8 GIT binary patch literal 1440708 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�>igkFt)UqIbiHp1#$|EeOGKg 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

uiPg)0h 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 z zMw|3#n>J>j3V&1};|#|2t)Lv%37 z1f)r#KR2BdAOZJcji+e_fuHW0#Y=X+>Cp^UgLq_1rZXPUX4q%UpE3=H9QXos(^dN} zM=oD&D?-NtL*F;y$zm4bwA>{DNUaERH}d1t7}D9D)bO$=lG#ZcYO55*Bqqw|tXnJH zp2W%|RoovScRh}}^Q05>H;0g%`x6pYn4G~Y*{=jD@mIr^x!j9cf`Iareax6H_JK}% z^TjTNq74}wqBXD2u@wlhI)0N=<~KHwQTDxxF&n;47MrKe$N&KV07*naR1<^FW13wW zWGqqRz49ZCY0Ok){2P-fOJ5dEM$qJ|w=}&dCP)ggKG(vwu+WbU%$C3~KhT_lbDzEK zS=H!~c8~oUI}Ey1F_(c^E0MtMzZVEt1?7J=+vllb|A9f86S&8}rcQY3vQ||!xPBN- zuW7IEhkZ2k&3#h#tKB$LL(I!kC8gZS1^aV)q7;*-4#Go=tmqM%5s-Ikn=}wclPgT` z87C_W&DoE=1Q@yoQW{5ACp4JcSAz5;xCjsr_T2L#`>E@zobqJgen7b;Yt@!H?*s}U z#Q9{(gOfQx)8|}uO;jPo&L#rgM{8=#k-xoW%rpl9na=l3R<5hIE)I z0&Z%~B`Uc$&U>IDR*^Dyc9N(t$-0dW&s!7%uVWqN0QtKT%mok+j$1Z2$IH^9fIH5FfP}qq#_JT7;64Y` zo-ex>a5pUSHq{F=T``DLJF7+v+Hrk+oY-s>@L&M9A3ZRt!o

(G*Vv=GYl!3?L!Q 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 T!oSwFGEQs=wb27iNUbqB{%%>No2aVW@Waxg# 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 z zV%}+Tb0Lfc8Y3xhw#@jTGER+BYCEpp8Ou5a^?FU#dHz(g3z*Ds;=yKUpObVtjD3(S zKMHC??s5nJ%;M{V!_bgvk!<81%&z$Eq^5&sBM29!qNVplo|X+H`Y+vLfcX(Tog(tM zq>`urbWGTGmO{UUWq6qYQ{C6E&(ldDnX|Obj=$${l@$bVJ`VJAi4)?su__iL6EzY` zyw^%xGySR8&YYMbi(&ZS_juTMYSDk|V^>t#ItWz+GL_O_mJbX*JUTCaF(OPH2`l*g zS`TXz>g)E|?34Ci6u;$XD(u+!tTEAapWd$L*RJtPF-Rs`+TRFhb%J#!8Xv#bU$1=E zG(X4S*14) z6$@)S0GW(a*D43Frb#__?#wB54`k@89u5r_$?qg92M*@KnI^jdw3pBmA^5C*gdc5~ z|J2C^aQgq6V)JFX7pns z9TbRgH~Gfw4e;d?Z%dn%4{`v0wG!wY4PI|#E*bSs`OC`p@V)FB^q8dz$>mt1N=s9Z zpF|c0Sh-9IDhn5u@R0(4fMzo~s(^*w{q@emH3@FHcbbQ(T>0b6RN!JsyK!9akv&L}4E+abA5n5@8-=Rz z>|-hU>l|=rSFymWPz7->sH<;4hFcmJ&53WtmtGQM@WwdiA}-vkXCj3UZ2BJX^^qci zJD}jHT6)ePxXI@sv%IeoEN9`Q(N*Ll+vpm$mn*A#`!*#}lKTV@5gEEpTLU}Eyrc={ z62K7z8m~%_ho_AK80<0%x&6)Qtr}gdxEEet!EwoIpv#x-b+O0?B(GLgP5Zx`9Uc4| z=Z|lz0p#-P*dqp+sX;33_~I?|`ab~oT9%T5o7j!vV*m6KGr#BT_0NuJ(>px_%)zb8 z)~3BS&vx9YGAp!9t$LbO_VrOLkaS5d1L)dIr<|*O!9)TF0{G?xHf<9^s^qZ$m68dI zO>gB;venP#3$I-awY%|4h`n{0ogxaB6}jqr?Dx7UOK{R1Us1cN=ER@=I`0m>PInc` zIUS%@$MbVTpc{7liwj5`5!$u1ML$naDq36)G&`lua&?xRU zo!U$heQkB@5ZM0xLwv);)V`MZo8wUZs(KMZg^vmvtt{TGzg~u8oMm?gGdDaO2c$7TZz;_e)KbS6}b>_WN?CbSS#0og6itG%y=PX^xL} zx^~=HzNf8oRvx%Bsl#IWIt7G8H)yrwxUSGHja)*!d16Y24fV3-h6LlCSDB2S0%17V zKWiVO;nS!1++YqQX`+DoII$#~^t_FTXox62wx78vh4uck_JqJgmnDso^I)@c?^%$_ zOWXbAVUx6}e^j2aB-29Ym!+!9hulhK68vB>vXQQwhHC{zbm#cK3^u_WB8N$U>iQ;X zI<~JA4hI=Cubjug9xSM_J~fV_;pFob@V8+BC|CZS_-wync8w61DS#r0S)9SmH8k!q z{?4KC8aE;0e=xSqrFQ$C{msbb#_r}!;)?{D(M4Od#qut!e0UzhtVzecy0| zO{Zp2Xv{kZ;==jo=J5;D7B1GWHJL)+H$vrJd;aWWR$sx+db`nBY*2Ez+E;oN~@W`mMX)w3&SihF?2h2H7vCrT;<#%4d=^^Fn`1q8;jDcc~zb2bb2jPzEQxQxr z{3J^`hnSmb#QbEOMDE(uNQTu$vKtezl-f lN~%HnvSZmlrBizEjpM83%l_u({{Q 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

O)+EK`i|&V)wF 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 >Y#9zPw$w@zBkHIeE44WI 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≀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�%B`rFWXahLp~$8~ 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 z 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�R-3q z6AWWmLmZQZH%fsqjbn?^kd0{q-mvmHSb;rViXVe;nHWtoOCgHK0I(y2?ygS={Jw$K_QVeIGF`hrh?Q)5s{qMlBtrZ+i*6t+ zWllrSpTX(D4w=!AM!QBYj%#63G2HVc6CNvDK0;jhv;Jv6Bkc<~zRUoTLNwDCd87~nM|aq&;+FtqXGZ;S zkAY(l5Vqq6CZ)r0sK_@T_h>&W1V!#FveFe|sB}WcpKD9g1A3?QVN%LR4g6 z+C#ccE)kPFWb88AAtP8tkLrtlNOGw#z$9dTGlRw?O>a4?8MJY5QGoC&?OG-R=i5u_ z_eugHvyvQqe}r#x7BbLQ&J+v+LAfw55eI)iI4P3@uEob}$=T7{(ipBIZCOEY&A_Uh z_>As)U&>jlb2iwTG{Dx!WKWEm@Ug9AG93hwrGqJ37di6Jl3jBK9^cr}ZGLdEogK4- z1S!_=Zv7cK_=;&5)llmRiQ+2=HU!UAh9i>2n^+iRux~OafcuPR{5Z&Gwg*AL%-j;> z7rlT$vV7fFTf(`eoi!C;+hphiih>5)AUhohRa8JU_mtpMNz|0m$`U-BxKjeiH%g@TiP(^ zzFynkyE<^Fj`2Gkkpw`(p@MVjcC#e3cW~Fpm4QFUG;`(?N0;iq|Leci53G(-YE7m` zQc9PcnLIF&vl4AE8&7%h1Wu6tGtzS|YpZ0g0+h6erlF)#YjgSePf06<4i?g5 zi;4ng2!(a?WNM8J9YOju~0$0blthF+!X_$>M1 zeqFyw;`FQpk{}}~Hn8<=exP4e3dDC@{sTgq7d|NS;B=Vm# zWywhICV-XJ;c-j`R8rjlrz(aMLF8o+;Qe)i78#r#$u@JL4In7}y5~{Pt8@O8(#B-< z9eZF))-71ROnhC3rq7@CX7T-2%^7e0ITN1NF52K$DslL{Zm&^v8$s-KeF9;h@B6so zAeA8nYDu~Ae1iGtd&+Z5Km*M_oMxsw5)u4-4l3BY$$h@Z8_=8`wkivdRP^C4dB%c zv=rI!cTN8QW%>Nv7tu$v%X@Ww2`|GuL-5BQ1a)6pYu3;2&r zY9zb&B9hKR%_UtJdbNGMEs6FAmlMy2j4VB5M_<_wPCmH6P(2VZ#$zU191wrWZf`gM zr-%dxKj#*zmaAucW|<0K+b2+JHqL=mGw~36l+_we6gg=0xp?ZmIJa{#G#Fv#^*~M0P=Yy2 z`x_`D?%ZeI{q#xbqj0Nk9 zDbtE*yJJJXgI~2`V#2XpF>^3X!#jD*=TAF;k3hTMHFkR!AxISr=08-b{Y0kS8VHW5^%P^Nt*WJ z%a8qK9>ic|OQmYt@5F#bYJDaFeg7klb24SZ*{^-bjJOhno9eQ(N}O{bN@i!6WoY70 zO?)M#oPJa+5`I`m2;TnK@EPf^9=-K*B6W!|$oy1mJdqn@zJk|;Y~oDAaCHvpMj%se z0h&giPFY_P|L78W+a??=DXn~kJUjKLkRds}I*yrs(mf9dsSI?S#U@f(d7L16+`hYO zCOQwM{i4C}Xfi~jRF5CrYmMxKFp8+>2<+b7~mX7wN!5mv^3S%=!){C z`CO*lPZB+NzGs{)G*@fExTo+YU<-@Jq=)hU`8a>%a>%L?wJyM1kO){(sZQ@x)sa#< zYr%1sUuFO#1Dx3dvrkCe90yD0FgY^K(Chs=$O3rQz)+7=r}Z}g3<8^1B4dwY#-(CIqT2=xThvy2HlRfI0 z0r89j9%mWQQCU8^Toyd&g|h(u&aC_in6H6E>QTm2&c1i1C-XGZmeFDLROeh%Hcq+t zo6kf)8hIb#+#Z9rh9DmCZ1PMJOij*yCuC1X_GRdh)a(%-_I#$IYFE(J%NYxBkSQdw z--^S$1T%q)y48KxLe-2*d>enrx#!shnK?t?!=H)gFaG@i`lesM%d~Ak56|c4?{^3e zt^59x*TH<-hClK>oOb|w3mUpnzGyRk8{VRX}>p;aH1)yuWgqLUB>_4BkEm$)y z)t_OpOqu8(XPZakGIuiaE^}|azk%$qSRXRp1K~$~rn9^q8;w1kQT-wlBZt^hy_UNn z(a>!f-O|?4Rx@hk%C6@4-hu9Ru;8SeWn=eUSAt!aE9X1(;0pkWr`?*Mx2b}>Kih90 zLhQBiPqNRh3@P=PsP(LtRvvk?jqSi?);Zw+sK%oT*_qe3r1v$s0-|@Rx^?PszCkS^ zHP6T-%*g&%mmElN7)!2Fm%oa;8}q=67z0m65wl9+EBC+1G&!gE}C`?B}K+ znm4%bZ4b0=Hu^bw9O?TBI(Hb~OsKoQ#zaGvd(#t$J)m=)g|@vm00961NklX`>|EcXO^&`v|oS^Y!<;JYN=k6d9ho_MR1p@xEq{Vd^TsQc?tf(Jt0>l zWxhwn;Et4GKdE}_e%)$m2c^um>3j##@=SSS**G~#A)tz*#lg>A&vDuFp~@JxHgM>V8UunK3yQ=MegVpHUweMoo)N1O$X6*sxt6exMn zC0+AO_`?ylIjs9vNCp@uV&KDWo<#!G-M3)|5=SiHZCRUPH6HW+x-s$~f za2Ns-D2jfmjMb-9opvC8PE?M_WKE){VRlU7&kajZ9oun}N_cbh+2@v~q6~}8*O`#P z2Gh?xN6a`dIZl1X%@DcI3PyY|??pED+yKM+?1O8Jjh+b6%?x{m&gVNK7;`ViK$9Q` zVL_}QR_bOOi&E5-XmhOh`MvT?hbjmH*T-WIbx?UM!%nA+z#sXrzFB?ud=NzP96HW4 zZ9Qa4wQKZKKvPj3lkBQK?~6=GUOf`SKnYQlH3r|ADlS${Mk^W9aaJ>$&&1sd7`?== zS;tf9-0*u%ChPjUU*6Maad4zCd|~G$GI21aMRpET;Ven--AnFgR+kbJ?eHr8Ur4m( zUY~Jb>{2$&G?Oid`!!KnH^A-)qOBDCKl;sveIw4Ro3-Y8FWtO9i)Y!Qo24jQ>{_I z<(Xi-Mj|otD&$crWIEW{1+jsoFZSbY{>Zu^C%HSG2 zWm`5M;v>$iTQjfi7~tvUGv=7InIgVC(nEXA1PBrU45Z%bl>m?vjs2~>+Mb)ZkZ{^* zA?l*trf3TuWZHqLIj%^ngKqDi_Sv@VxGmET{s&+xN--UDQT-8x;r>Ss;640@XYZdB zQ!BTP)QtLdaCAnL;1%(8=`{8-K}h$KKRYj{=h_e>Q|ZUERyx|}en!9ncDR)Lx4iTO zm{~60@;e_s+JSdT^JZ)qy}kZj0S2ZUV*|K;U;QAlCi*i3E(xN4fQ}z>3cN?Jp zhEN-kb@zMqYvFlw2QmSz*L~~;AqmEr%Td%rwWq-cWX%h)OBPFQ`F7R?TmH@x2w96{ z41@pfS)x9Hwlz&F^Nr!CmfkT?+97pw11=xd5EavRTLppR&q?<1mb;p4YQV$~A6HWV zJpO@nD}K)WsI%ODltwm6>y(N%x@m$B^sfTu=MoMtw(hn4t!94A_r%i29^ZYC)BI{e%U#||wZ|V4~k>BF8 zyULq}%6_L1{Q>+9)ljFs!fo368Nx&}I&TPn2dFKQOVvt6R1p-p4G0qW1e*?bZQU7& zv-4V3rmlR5>a}TSB7c(G?cN8>NMN4tA^o0KA|K=YLq|P8@xituUd%=4l`(Acgi3Gi zAjKNFHKW$1nNWW1%j(7gchIPA_82>yz{Z%un5!Gv#b-1m_Io}Fym9qi=CbV2V9r0j zr>b22K;~L4aQyY_r*h5?m|VGN%cPV0t9x(3U`=WXd*DQfd)iCZy_t7${${li=gi;K z*rv2RTjtJ?imY%>WBKfp_5^|RwZ7Z4H-_^2Bk6BrwgD{O5_dl@#Vt!dg@>u5ZFvxZ z_@NvO%Fq~jv_0fI-%PV{jg^MgiR)?eRw6qX^CTUDi(mo*`Co_cneQ8P0I`B@_ky6R*3gyv}vi)VG*_%BO>PL57 zd@1dghj_XUiA`*VTO*IoW1M`<-Z|z?>z)HmCFb@J#bTqRlyGn>;De14RzzAl#clr-P0PQ@YrFZdu6IffTH`9sT^B?W@(eRPG@4 zP05E)_(}Qf4CP|8W!l54F*`U*@GLblTf^uqB822RZa_t<$evg=-Y@MC2x1_-RG;27 zzvD~-J$lmq>N6d+G@qUB!thzZAHHhh*2bDisvxtD^)C><)`); zQxe!yI~=Rt(Qcs>K)*ScN`?^#e9i(|2lnpIntee75>@RU;eV`P6o$V>(xWrYz!TJc z#)|o2nG=*9!<>Xy*U zEbZ?-ti>}xdP-aUFtp51NRRvEjhB2(NCJ+9?v zus-}L>mvips@>{y22~ER832APm47AuUay&I$jpTmb*q5xg%;eFNkG59Nlc-qbC_|^ z4AMCdGJvgkZe~EtyeQ3`Ln6!D%ln&1`SUK|vx0l=l}*C}nnHfw6QV7K)IKk56Y+eR zzFxE*EM2dlORB!Or*x2Xx6Ts~_36*A1Aw9BLeihmYhg1|<#t4%m#;DqNvUE%VomI1 z%Y#6zl-Lv#W*Pn_WYWH!|T#OMg;_5it5y?b= zG0$8*4=x$$@0heJN!esGf(Sa!*mbvu?LF~p0Romq{iM#2N`kUXL3ew6bo!H#g4DUB zFWJ4Z%`NPgy~NSe?SSH!L=IRc7NJB|9NVs8_~|Us7HhqD>Ln0RFrfbh8f)R!CK-I2 zQhS!mj|_A7SLRCTCtpK2=yi*%PS|N4qvhE(jmI2U!0n1P&ZQF+s2o65sucWg+2G^{ z@%ei7F+jB=ci0gs^b#;`3kUvw77ORV{QiSoj+`f`k2CNZW$bi~GN`o%f&(Ao?FPXX zkpKWwK&-#+0RqJ2gh|t6{&o;DK*bn4_|fOx3KpPx?k%@x^yw+Oaa{ zWrsZ@XhV=>Q}`p+sKp(&S)~bXd;j_SsTej!@5LcI7bQ-0EGsuN@1uCRmd2*-7KZUl z-{F~@NVV;8CWe>opJ!U&&!>0r^kAnIoygT!nWQ{C(}?*_;GJqJuQDqEA0T9)Wx&1jd>-O?X#GN~<4pQ>u9&bFd zk#CU*LFR&Y8oSgQ{f$Y%Q+|rf;k05gslWa&?Tio99iEtHI@qAWexwb!qS$1Dvr_z2 zT8KuOLw4g5TAlF+llY$GcKz3X{|^Cp9H(D$-s3@Xln~O*a1F}Z<^U!uOPvIM*Z8mO zOJ*#XbSMtE0;oC}&zC?<_ppwq-EOPCH$`b#;gZhV`lW;&Ba+X^bV?6m3v1jcmVYdJ zt9>}>g<+*yzp8%rk#IX?I|Cri_7>>)ytk8eiQwqLa)NcmLheFdtH7_gQCpP@IGNbDYikbA}@TTLf%{ z0h=1l@33cn_B{py31!1DaCV~Fq!LgXnB|>UjD=Hu#ijt=`35|9#Xtub#Nb312l+Y9 zVY%FjVU|-19_vW+8`YD6Q>F6+1o=FgPuO5;5{wYc2&XT%-TdUrn)H#XdV9PqSF^z~ zQ_n7`h855;0n?w1WyLK*Qk7qqR8!+tT_LION8HcmqVtt5=Ad3ovY~}QTD$b3- zvv`I$6OF5dv@2*KZDzvuamUP#m`BfPR$FE4TPji>?1dPhWJ)w!CBmX3pxwTiUHRfI1!j zd=$}xFMYS3Gla2)aA`inl|Gj7Qy%gbDJy_PpOrX3QwUN}bs>vF_kw$c-^6ZMlP^ta z&<2>I2R;Erj(z6|0Hg!qf*~?-ITw<0<-+Tgi5Mb zd^Mb%BOkrLaf_7*RtvcUgxvn|=%)|pm3H2PTLO&~`X9kIemiY1$yR4_{3~ala@q`R z3r8_jcr20jO7$G|ygT&mD1>)fNJNFzP#t19%cSzrkzRaF5HZ9~0_(5aUWG}#h3P+z&(?5M&{9%L#2oZ-7Yj+yc{3*zK|*aE_mxJFTPDRx?dlX zCxG6-Q6D`?cri-k-pr&KLEaK9408=!c}x;Sx4kR#SwiaBHk5Ngn@u}PCTh zBvJ>sE#W?IzKi=9t*n~>@udI>*Os?gRc&jvklmIN0H-pcM)JG>aOZRQo{+4TxpQ9W z^$diN(|4t+pCM$1bk_nRl~? z`9n)v59|iPc9?JnvjVUWgiI;>fdlNX>%vKt1GqX~H^c+@f75TsOYUH)A<$3)9)x5l zBRtZ1i;@pl8O*`ZOBO;DqGT;A)};lU$7n`vKOx~|<6xES^kLoS&+L%2Ydg|3}n_oEQI(EW3H&f7~ z75LbKJY3-v*9o0CGiP%SOm)gvkqS%Xak{uPHjX&eGX#Q9nNY}B_%$v}0#yjVFlZ+i zwt&~i;(pkk;(Txv4}c@0){c>yXZ8@x!!&-u(0bs}4(32M)=1~n%Dq53E{i^ocMqoz zZi;=Qn{I*Ye9Zjy*NDr;K_do$4(}RghLI-7_!@-0XEQzvf^V+rAdK?oTv77GX=UgUvZfF! zF3Ei;5AL~y(otaolTAv{{OE*Ig*1B>5cqu``94>BmWelEv~3G3|EN=vZti;x+2Et_^u<8gU+31 zzF%sY+=Z3|J&(?v%Wm%ztg)@_34kPSrs(_|V@IY;3OGI^E;m)$Y0p4l>*RSw1uNwR8jO zd8rzK@Ej`GX5^VT|3Q*3ST3P62@u5slNLd~haS6J{N0S>N#a4X*)vBA9dFAgq*oGpR;NNw) z_=dpiD^LGOp7f9hq`&|8xif^&v9o=Eb=qb7(5?Q&83la?u-$cap+=Go#$NI$4W>4^ zX(w^pkhRgQ{5VSI&ZA?ITGJWf!-MK^%`n5yNT40fq z*EJe{zHRJV=%42+jk2I8@Wz>HfkCldF25neO3-es-l6=pTWW}w#9A(?Y`e}wa zpEJzQA^2kmu7@YySmHop+<%M}pHsWpVv_;yNqhYNb#B2wGFf--EVXQlaeQ<(NpQ}q zyIxVslz5XW3%``s1HIC&Z&X2qEgHFc7z~VtW?q@w1kT3T5BMWQ%sLIo)Ff7JrHS}N z)@z3zp8lt9#LvmY$I~f%0LiJsR?${jH^+a<6(>DisTDZr_LoP`<8y8?P+ zzZG4YadNbSpWn4XJ8Oi8?M*WJGrw)z#h=x`|L1>vfWmOb4vvAwJM9VHjl--s>)N1E zOmDX#!`aTQmPs;yr;4_rlFo-6o>>qEp4VS_kEP~Soj--)eJTunF=OSW%puP<>+r)y z7pz=_@QtIYfT1AgfRzYV06nZX46R^R;^HzLSFc>&;p^)i5G$TI%JCkAM9 z4+g7N0Qbp2)L@wO99Z2KX8w{CYR^V^aqKB8e&yiSI&jwUZrSnZV{F4dCI=;Ld9F4bJQxcNRX_^dM?j1;LA4CO7Y4FR~|rVKh(pA`ErE{Ar* zrwBy>1^WM+l7Hl%UrE-Bgodx9Y zlsv4zHjtu`#XraS*iPK=V>fO{49>6_FNz!)>%!6{emP$}|vKBbta&?(qIfr!)Z9Tp`0?9!Im(d8Ir3(kss*MuNRLw|UO3T2aZhBbKekr^ z;E)Sja@(nXp=1;yLA@c7o>MOU<=#C=;bs`m`myw55|l`vK-uB4+QWH!dNhztu9>J2A4 zebG*tUv%2DGiac{mF$(Xjq{Ip+bjZ@Ev4d`1POl5(M#ZVOXOo$)4~_^53%Zxf0to) z0CYBJ^mEP*_;d!>tpe|g+U$M$*es-rCxbcoIrBZqEKmtNMoka0 zT|g5=1MX9b&bxhkzKvgJgZ(wITzR%gsWUBId)6UhjALhQ;;C0J!L)t$ulE5|gKn#^^pVW6Af#0p;;FOh+RKe=$b-$qC0)Gi4b9LLp1tcwXI7Z=~d<-?I2Ulik^R>_nu6M@Ji+R8@_G- z?^B)^Q(bq6-m<>;b2WiJAEHvFEK3UL%KhxYO^g#*?m%FC$O$RLeXxV=g`UHPh-A{E zU;dp}qrZaBiWwYa_8^~i=>4&8xE0X&a{TW}^67|mctLWnNs4OCC-zHNPP$Ero$}EM z#1#=3?fY+Qi-K8iLfeD`0e(oO^U@L@0t=5C{agR&N-(K54of&jgRIZGjWd41#Ut%3 zhse=LO?yZE*Z=|1_-h1nhG8>IN} zmLcZghO+2Gc3@fi05ZUSlxFvM|3m4_xO(U9{rzNSo|#m=*m!GpxA$tvjWK2RvAIBb zpibTIA>yR!;xY0XWl&eC^y|@iu0i*) zIoK#Mbm;i0&RZMErgvv5fnw{HFk3-OkKbEGX$io}41|AX{*Z>@P%Ol8gjxA!_P5r^ zt#SoLuwt*t4(T|E@cKeNvm~0AB^}Mvnx<-n`wMvyz?u@u;d@*ive4f>N6+YeOV5+< zj}bo$s&25THG~<4x8j0cy(gJ)2b@nb(`BM1vFG_4bta8w7b{GanMebKLSM4tBw$?u zUmwTm{kRD=&N`Zu>bceeX^EjxsvGRgduuu+orghk7_&*RG#&^!8B@g_&eezD%?Ags zdt7|B<;AaZ9m_f?0xr6R3HUj*@LIsp6l=M4V`}*15Zs5&8U^TUk`+4ta}XNNZ1V$MHGR zC4T_5A=msF*q_2vBs;?ICoAlKFD9K=UJEU)K=vi-EN`{)krpZk?E?Yc_p|m~{63K` zXj1%m{ADR+&ELJ!RX209AZCv3qei>-PXOO!Y4S{+_eeHW1S!6+DQDlTqa+!Q^w+k# zeVP~w`S)R8OYcLCE7*suXGuq&R=aSu}*}$%pISldl4ryna6UYsh$gjXO**`<)}LTZmD1^u7DHP>{QI^9kB9*{-`ENKZ)FQi&CV-I0!6WXnc}YTdfp6j zJojv!V==&sohk64N&eZhOZ!a76w$sITM^>a)f`|w5gabQnLOcEUZkx=efC-N{;H&Y zwAeNV>eBFFsQ~z)x>oPOK)4^4dne+u86+% z$0>o22uM`MMaLFLL?2?47y?d)<`P1>Rp2cpxGe|`1>b}O$97)7b=z8fE&O@fQk(WF zG9qajH9_?G`H(rHvZtgUKX*x{d~>bNoO5Mh%kkqARMbz;`ohcyPze08ZYFa1Y(}SQ zQ4sQx?<5qogxZpvYY4P*oDN2@_Vz2db6r<2*8Z;6Ofkx_Btr zUZ(?ob0&Al81=zVjvB(OMmp2<*N0%^nPMLS8wTOdvRt4;FEP539?Y6#7zhxa-mH;_ zxLgMtThnixGqzE=V+R}QKQzeodczD_tmKg`P^9Ow6wU zI#~3w%_ur9!b@fhkKN>ZG)l}Na02o_J?ODD4`FrL&EN((3_-0;gRdu^+sps0< zu??9XolM;y$kVkSkxLO{aw0v-%pB`t@B3{q`XZw_^ZsP|#`mPo)_}HtLX1B%%Eb8U zatq$vpfzA+@O#p0u>Tv?Pj}k39DsDEU({#v9m;3j5kR+DA87v`(C^9Z{=8yBzg_}I zn=dTqyP#`&^hfWn)J*nALOR0e7Q0M$zsWfW<=5|*ee44s8QH(3L>Ayc5B=y&HWuLL zhm~|gqtOVP`&m6}H=+%S0su7p%t-IZlgF`rZ!d7yq|LzZ;ePVhSZkPI&&ThoxqbGz z@}t3jP?-YA?U`Fx@O&!dY}6FTQS|}hvQ0b_nH`Ru?|Wx`L$ZK@z!@U=K=vEUK)xR1 z!;4#PMoS8@`f9*dv4e{3Bmi@aQy&HMYXmR$F*vtL<&F;h+DUG_*UwHX7nxAbzNi%Fdddgc}ieZ8^Bt_(^C6Xc05#Lvuy&&(vk2S#}1cSBG zZ~rb{}7tG()UT0vTV`Lx15q{$o7?Kv5 zYI1PC)0Tgxx>Wz?fB#1sms~8{GASko{w8x8x*erW=01+pE6n@?8OBxgIvoH`c=7aJ z42L25jOLM^c?>v`jnW4|D<$<|snf4_%-|H0TwxxUEmL%2RFq@elD_VBEVIqY-Wasd z6FH^+3?_2*LT>;R9}ZPwK`R@v41f~fo4zhBpb)JO6uXtQ8446YN?`c-c{aO}9$_=$ zn=JQqFn$x~Qln>%-t+1($!#a+tL|NvjUK-YxWm}%tiehESoJF0pi53io0SjIV%<)) zxKu8(`QfOJ$TCw#|3@!m?_`uPS1@cLBx09RFDQd1=Bs_)DIoRWuya$B6Wq`8pCsb8 zq4VsylGKh5hpE5so!vx;7wQdUcP|LflcXuR8;rg?;COtz6s&OjPvN3uTI zNHfiu=4x`zOEVZqc#huJEeyBq+$U+45&}a-20AAZKq1X@Frvs$A&Z6mDCzW{L>A&H z`EKXf=*&nAH@tfJksr-wzqiUj+-+%xw}kl)*iD6lk)%@xbsl;Kv85A3>pw_MNs1{m z6XHDX`P?Cp6}`aX?vpa45hIw4txMHP0ZdD*h|>BwTc&P1nta4rK%VmdfCB@T6S3s1 z(<7Ox4(;&N%>>rfgPNm0wi;&tsU}!?hLjU^E>k8R1A8O;N7`Qg$N?GL`8#$js738? zzkEj8g>3IalI^EOe}wSn+{Ogd`;=TfPz%Zu2v1RM@dmGuh0xKQ%vb@$@Gd&sahxhL z*CpCiVu2;4ZH?I}F30y!GvD`7KkivPMf*pVrejz8)Au<5f;C@lo%Pok0M_&QezMd> zDZfcmOk{{YHj_NvdY|=rO0}H}0uJ9>^h?jJ?m*^Hxhp$X;RSn6xF*2h{2>*LS>0os z^IP`4X;rFAVD37<9l|Fv)(6d;TN&8#n~gthbdP`&S*mWm^zs^>0MK~OssM;lmox1f zH!8TnxWKv-haBQBGaB5(>TF_cWnOpO|Gb$*F*whl-RDP8tebH&*1{f;h^UlKk9&ek zR{I0dlxJU4OrOPxswJ* zp9(xX)U5an0`$K1WW;N2;sKkcKRkkYlp# zbBCVH=o!nAXBcHWk!`lKv1Hq64M+lF(v}mz9sjLlCZiXvuZ3y6k*KuV_8zvIxCP}| zI6^jsy?ts`p%OD_5061@X1!s;MY@4^p4A;GfW?#p#*^H9@hN>rIn@RM6ZF23^jpEK&$xXi6yV9Y}`gIaIPZKCv&pH$5C=q*=` ze%yhH$IM<~gG4K2M$=jWR#9{>vnuon?g#Q6$N{Ek@W_zTVn?>?%TwSud}xB<8s)ezPAES|YX^Kl$SwGBjD#~z{Cbx08FlFPBF5NWgeCCglSazD5D=v)IYGV6fX`7lT?bmoHfh)=%1 z_6n^k7zG{Q-5bUX(kK~|XQY=QC;9)5hy@DeJ*=*aA;VZ}id~&@f8iA15m0=zSprEa zPwOHer&m^&QVNq+C^y(nVfGyS^4{nAFReixiGhG7v&eP?{L))$meZg8%wZ0P-`w_* zhm_e>m&XP)!~n5pwJ1oX#Knv-NjN{o7OPrqBAva3H!5+SL!Cz1emf5pL7&wbUe1jC zYx3eW*$lEQz28*}_TEWBWGW$Svn_ID@&zy+m**v5eqIO6tue5{4vq{)&a1V5Gna5q zwq4_FSd+!v3S1>veHm|*U<5msAg=suFM(B)5$YjmX$NyXO^_FT2xH&6`@0)J&(9U* zk!?_WX553{0Oac{N1D#=a{Z`IlFLoFoDA83K;HU8%1-lD=vZKlvt^wmP z@8A#=to^QGL?hK2?F_8>j{`v%AI^PaIu2xI#}0$~4@BIYwAJM~N~snIDKH@ey1mkH zMxr%t%0Xt4UGvSOe|#pE)#MO%Y35%W$cc9vN&h*l_^aB^lVAB6PLHR40|1IPgm-R+ za7ixwt99D=CqY1*O^}rF9e+MW<kTnnQl|Dr4(B}%{3m+ZBqFhA&hWbaE0I{{sl;b? zrR^wo&F!N{r8m`mNT=H;!7oMoM^TMfx8>91Cb3JI;CPc%flNONJ{LaqX!)X}#nmd3 zbr48;4>wihm7}8+Bbvm9FSaMN+ifg0x9+(V3OxkF`PYZ-kiUS*h$<3H#Gj>c(SZ zpk7aUVg%ct?1#ahhZ&LqfI-3@>h_Ez(||x!%8Hg0rQE1sF%eR^;vs!N>9egEZJ4KZ z8m!;2y>mA21fzV0GDeWqFG2b}b4}6XiPL$S)rt@T$m(m#BnzmBJOB*K1~F9x0d^WYgo0UBN~~W3 zGFVIqdp*Yh&50PZeTv-FmDw10scazf+*7{0^2FIcn9qrvXP!ccn6ms0Xv_KoTN*>8 z>nwymdMIS>r&74#cWb#kiVT>i&Z8HTd-F>lWbEZflBJ%`9ZKi#eA6fdl8EC(#!oz{ zQidP-Pbr+``XML~YgVM^Fjuu8oRYfCImNT&axsc%?{#Kt=P<_D3-_h__cPe?glVkM zRsPEJN=-{ncTuW~quBR0ne^*%WzHXLGdHaO ztAx7*f@Wrcy69izJ(vmdj=@{XB{yT=(qV{R_3?Vv8nUm^Uz3h{Lg>xP*Nm$Sk^!Uy z%(6k2AuC%mtz$GUB4KTh&PuNMSiN<(l2kovjaLoMy`R{T=K%B`Kxu57Vn{1)U}ZHj ziC9c0g*r<^< zi^Dtir%41GxbK*A;)!;cS&hz5>PI^drfT%kYMA_BN?9#dAqRTxD8?%$!$f0zd@8mQ zX>)#F&zO+w=y|1=lHO3IsS35BpT$O^1!nPHEM5Cjm6pDNz|Gf4 zb=wh-RP-npZCt9sK3&o(I#E6*evCh;(!5{+T9Vu?k&=`c z5is;i*0^E-R!1VgCZGa;JTTG)AP~XK{n^!{i}^PWT>_z!l`I~prL5hwU}4|ReGd_+ zCht^KGZ^nLkfP;Kn(`j@R08t1*1Oj`+aJwc5;?9+@Mjm3&27DXOh!IAzhi$euYF)h zi$A#%cXSEA;GWFjF#bukv}i;52<_skA_M;FsiXJx%hv(>bN7{P4UlSg6|MC?E3H=+ z&;2U9i95{Ij~F|DJV2hZ`c~UFr}Y>#u`|I&ON2G^6pCc%JWcF-b+9=XiOK}*nb-F= zG3MFI6A7G*3$DI;T50FaY_J(@MMw#Ve&#MkJu(2dLQ;;91)rfec#IC)(_Hml8y}oG zs{j5!|1X)ah*T};HG{_LuN^o>mXyP-?{BsNqsziE9CcPn6(FyyFpD|xzdM6r1?zLM zS5Hdadk;k^y;hvQKdQGrhRacQGyB>)1EG{(AFY<o$F%ei)9ebb6*QRL{8<8_9a&EH zHHLBP^wNWmQ1<7A%b(jPiX~QIHNcxSYZ#EO1Pha^wtO8yk0ymfprZ&V7mGpj>PO+E zp$863Ia6Bgj9|4+G=M){QsEl0 z>$ujy#)zb5x&N5`00EJ69C@%K6HLP(<(=bR?u7DL4G^E>fCxacex-IOO0qctq~ab- z>e*owY*Cs%O1ZBL_Id&_0KP?lR;{c%S zaKiYjE{2Kjb(c=ocb3m(H%62+$pnN|s<8Ly=+w%PRN56j=-q0IO#8Wl~=+9Z9B|SfPYoRLs09!+lWnp#z@~D*H$=x8IvkEZBfLB1> zsSmlS%sQf!FbaWu8d+|yuUoG8yhj9VpWCP1!meRfsb&Pr0cj~RnCNHjBVr{~KnZ%{ z^tu;d>Xdqp{>}^7Phem8@&vDtJAkiLE-c84nH&r#B!$ndcOH*P0RR2eryNw$0u$_f zN@BIrX)KeWnEiRtwRYuF*(1lbA@o(_Z5W){H;LhXUw?fo!$zy{C zU+I}K4H4-B@Xwrkwny%_PD>4E_ma@D`}cd5-X*v!76h%>kJw1>WgkyFUs85RG|UCX z`uIPdJpn|(etz4}PQbi>)Jq)2pKL3rq?C4-jDsKD1WYKMec;SK84_B^z5`b7TVO4P zNOfhV+cqwim~o(LSQL_M_8tR?Gr-T9VSTGAPv{pFZ&f^#Uwm4wh&Yd{ag2U@{9!V>uapI zhB!(hQ;GpUZ>b+!9fSW7s0mkyvXYoKv*qMGw=q z8S7Om$00ccR;l|}N;v2rd@Oeh6Tw)lQ_rjdfe*|bb3`J9MnJ05^V{p>jf;}aObr%JCuSS zd6mnQ)RX|ZYzopPPJKl61p()n5)4G{)=5jV9O~%wEuY+<1Dv1X+)69|Etj?4Ef*=i6KV9B5R(tMo7O-*bU#KvznJ?y4n>WVe3&+*Gq}Q`%sy+%0NDXbV37 zAe9^djHG%^&b-}HXK>Q1u2-3(l_t&5<2i6R5~-o@6* zyvg@XiF)R(v@RfBP6RtS@3ph9Y%jeQllzwSxV!b6*LvNpYM1)vxeOHUOpOFhu6nY~ zXsTE;5N|4@xC}}*>#}RLpn)id9({-;*$(HuK8*+X5;C|W2O|K;uDNCRLnX{_C^@{K z{Ln_@`*BG#6J*pc<;Ab{XDf95TGmGZn1|HmB=WrmpVi~D9#4trA^SLYpq1l}SD#~$ zv4(FgS@pEl44L7a|C}a^j{W=u!*zZhsE1sp<;{0v$5>1~cHrx_0sUIl?+(Iy0U3kr z*R(u{HSHM&ATO)%j4^EAjDzi0yx#73co+BkC^}}eksO`vr)Sdm{oD($l}CarfYfYh zDABZJ`Io$Qu1jm~4#DO-^!MNQiVS!NUqDL7bvyVk;jj5~&hGu)JYA8^t}*<16<~_cHZvHai;NbHTAYxS!aX;Edk|k#nRvkSed7WNP(kiMAg5mG-bb z-Jn}D9-Ih>P5Z@E@AnNYC;l1q{~cwBX~zx}b_s%Zl1aqIzc~7t*8H%?Z|m2!!y(Ua zHklKmb>^sgYxnM8tg&KQ1VU|23m{2{qm-)sk=61=z8sFEfpjXvS*mT>cygpmeYOD8kP{kL<|8%#03Ah1EP2e~Lla`0s;Bra$ zvAj1a&qvZ9`d(-B8{0^4mYP+S1mem1yQn#Kc&j`C3$g9vB{Np44F8ttl4%!Ij#x0;JLmdrRt`12jj)H6K`zmBkN-=Lg2O} zXJVVnH+^18`uptn8_+nKe|M%@t;`*&(^R9LKd=qfr*36W{7VsS0m8slmtz6T+vbe_y7DanE=38%5Gqy9CX_l)oH-8 zS*BgD1kZS%hJIbjK%NsY$N?W4oyx!}%^i#YYn)*wQnDokaqoCA)mzIPE~8O6X$+8X z;#06~-(a6XPIjEKFcQyI)vl{ZrQl}r)?p<2x6l@o=N!)cDJyw;mJ6x~)~yR>`yZv>BD)^N zDzax*yp)Z3VvEu`p#a3nuoN3kl}Vq?7KWHQrJh$0GUXq@nDFy!pqGD{mY>TGqwgBpti*c4*vwwrnWDx+O=|O5 zuE?+qYs#$xl+^jI3kqL86V@vF_loEA1@=hKQwu6WtfX3~lX;$-Nk5VOG69w98_$HO z{ayPqgD=-)IQVa3Z!_=OZt=S?Bnd zN79@JLIZXvSB{LiH#sngZv8sTbj)vSp>NBN?*1~)|3k8;ZA91rJNK9@GjfZ z6=pP*8TIjj=L(m5B_S2|vn;WMq#TyZM~&M3Z0c919uJKg^6TTXJm+<({WQUQGLh2R z$)6|+q8ht-qTWs4aPpd-T$;7$f_9n*iJS1J&os0 z{*CterQYn&A-&a(tgJ?T$lS~h*?dKxbNrmz8v^pOEp7RGN$+?&K=r7e@_+X~Mm$62 z8iTp{IywdUr#t^OE4ly|B3a596Orxs$W_o*YNeq zV%6v;Dbu-y2C=%BCY%Leifl`%5ulS>`{%wZ_3O?xV<@Z%)D79Vi_yOwYwp`Y`@%Sx1n)9=ky zGQiHtv8C}fdIqxM3`H&0wtVjBwtvO$hG_XE;Sjme_nzV;<{zrkv{pVf9_p^S=ZYfL z$3N3MvDE>AS;6q7-T-O(`pQGO$V~JLQc#D=Wh`Hd3hc&rW8W(=VKZ;whrK+Mp5^AZ}bdb7-%bfY8-gASydzba0XA5ZuF0xzap@e1D2+2bXg-N*{57PASqU9N;|GJ zZq*4xj6NsinFFKu3E*44RCSKtxAYv~1&BB1qH$tJ(tALaLskfI{nov)OnVK}_0$%J z0jT|M%K??Y<7BLMX{#KZWjp))^I#Noorbt8i{=D7LXZK1(7{8%v!uZqx$}?Gu&{(9 zNTeBwGHic$f}$8k>r7^5h^hC}FY_BjS*+IKCKKoY7?!*e*N~Cd+zF)%Uu?}vZTV=a zkB4EtJLHBhp+{QGK-jW8jQU`xI|f~L9y^hwMB9b*?XN#%Q{N4=31oKFL)wgVOa37d z49KJ~4{lB3f0?8nhcMMT=hKs(X zM=RxW<;=u0$ldIn94Z{X37DOS5Zha^jI-tam7o=H+A*YG9v3()L?X!G#cgp`LC8r^WqOb`TzkYrHCHCXULkDAr z6YS^J$tLGhJoQ>1j*|~QK zrF_1bJ(4iV0!rd}gGpL(3LDVmGsgGV$g_P2K(PsmOS-K%+IvyS*rUYy&YUzhzEcZf zc}XVKMAzthO*v0xb5N>^c)lsA>(P0e(qRHv)UWB4eP}6d*}tqF#Hx&F6`*a$h60_K z?ea22YkVel%7=msbTUGesMq4rNKP-lNZaHmvC;QT3VZ!d^vW|&8hr^kjZGY~I!EuC z#G%c@gM{1fhpbj`A9zrwTs@`eJb_QkEe3zDd(2e~>IF}|u`5Y9ph9PybldOieRu1R z|7`=rC>KCvG)@@3wD>{%2LmQ~kv;W3;#*a8$ZCeZ4Q4k+Kt`%OivYRT5p99dX+8@) zVDLyF2?m|^3gVra$N`?ZZ3$^HrMOzoF#kuHsuN1;AGQfwndInw#}MpN>|$_w>~9hj zQD`6a$kX8?N3-~6!x;3<*up|&JY>9KKc|(wB|+Z!dhqT(`^N?ozXgZ7U>U2w_%khx z*o7yDQ+m!UHn}rlV#lO9#~W(mDs-PyJ0}9{K)jZAx<~iif?q4c?GjUbFmT$keE;K^ zw+jF8a96X5>w|#Ulnu$EJj?62?U5c@4r8GO9!%mUqqOu*Fy(B`I@5A#KjOJNo&#j) zS6jgvOg@qmx9dN(pM5b`#9?&$HnO_y2XK9+)PI*PRoyIaacK#Fa6TQ$6$O#D9idQ|k`0p;mfk6tXq{}ejzfU7 z0L+^OMX_@{I76aZD)k-c zli+>N@19pPS#((@nZ(&?y5h4GoF1U%dz;Nxm!xFPIe~BR516pYc30&H`#Z<=Pf8fUqULM~0DfY*03Qr3QC5Tw+s+9HUe zEI0;w!6I;WIIPCNcyc%2A8@;6)LPk&C!Uu8T>)^EU{`DA#icY(pm0Jj<;RiVe=4=7 zq@qWZ_s%-sHd9F8T8csoiOI)u@>l;PcTV&68DUE?HKzt^g~Q!F#fk>#)it zJrHJn$*K&TvW-SZp9?~Z)jm~ZNX}0wI9ot5{QUq9CL}2V+URBnG1e)^Ms(0~WKuYX zu<*RU_e8t&(%B-Pg)74-Jq8pNC94(3iEdVX0+$*oC8Lr{(knJ02%7t)br9W9J?r{ z*2h7MY4T)A8b`)`nHvH)pVyd+^GTm|QNq?0kRZ#fM6xxqPeJh8(qw`&&%pD!oyN7~ zC)tM~D=?fxk2LS?eZ@belF1PjWJ(PE(1ImwUcFmFdzwCQ#lyRW;?&Rg+oSUm80fv= z)eXyT8FMZl7wcYJ8&mS0D?Jml-lk9x_|=>Zn!qGPiS7 zdMU~74XU@V9evuwz@%Md^ll^QPj2I|4upMuEBF%oGQQ{Nq%YiZn%~<&gINEOJlw6N z^L| zqKhl3)4#D{k$d)tKN&hIUVuYZ^>0!B`@hA7@mi=oGNwyC(92n zVWyEPw1B^JG6XGla*nDT@GjwjfzG`T$)z1Ex0NUH;fMpjS1NtiBJY}EBL-O;u(Ms4 zSW`rIZnBElq)%P^Q@QIw28C?_+izL-*&zQ&kY(8XkSj_eWmqlk4f3g!*nff%(x>0Q z>r>`#)1tH*4gmZ|ERdL@G%GI*9q`Z1u&Uj%e_H&VgJ>P&_0vTQbeaH3K(@cF;-|5( zRT+@5(o{U(i0Zr#$vB*G9!KTx$?4o=N~@kr%)9atLO6GIi{Q3WuRqVR6$#jwjkEgQ z{~mNNEy?bj;=Srev;wY2Sd;8&h7&sGcubNU6Wepz>mrpGPOHICAqzoJjtA!1YbCapJr3Qa^4yXsL9$zHh@eG^EcrSiG$xJ`G?drohw1)uxZw8tA zkEdaOSYH-q;mBoiWRR^i1cIhqr35@1_||?oHI2GV)}5?5Rg@n27*3h}cn`u%s(wE7 zmIr8@RT#uriMq4l+Z?I;iAyqznQSLU;f*BQa+xTY-X5T#j8w_8lw5{O;8pF6dj*9Y zveo=>sv2TE{&GB;WgyovKIMJYlOV|#x4k=c`@#o6o9WCZC77lg1)UHVqJ*bZhm{;9 zgxNtagd(Ng7y_Pq>TG4evtk+}QTH64+F)y$^-AD#2-uvpbl(k5DVbGWLG_;ZS9Si} zQ>{|gS!KWXnfCo@GB8~V^C4*IQQ9N^rd8)( zl<7$SDVGV>V+Qt_BkA?$=b1_hl^;XsfDOF>@R@i9_&;|5+HB^pl#h#QB#W|{L#KM- zPz-8czIO*wwstq{KyaBEA7vV8dfd+(2Q|#c*nvJOc9sVaXz94jhB#^Gq57bQRX`)n zxiS^K>y{4hZL)9HpgAL*jJWnJ2EDzj90R?RWfhFN+kR3)FUl)N!}F2tH~VFPPSsK} z58@2hsE#PpWEjsm%5a_AhVqC-+6KmljS1(_vP1Yx_PSE4%IuEKX242^%nC7^^Qam- zvawy(bENv|ntUy6ae1f%>}au0?d1GBAkM6H=c}r2kD+Q={{>>@RXpyAW02kZ;?;eY z=Nzx_1001wIFWBs%sU7Z$2&*PS{<$5&#Q_S$8qJYew zw(TwEGCG+wOWIoa9;zlv1{La`Qhl()DzTXc=zyHI19$70vkuyd3xLm`$N-wCdzo-; zp%19eoE&~HZVg{xfS!J9vLZUF^NKhJKT`M*yePUNd`FeMf1IrF0hlBcVf{tE)&aFL z7bdy=BPOgz1_P!>N}ArUh`lM_Z|p<9H&djwazv0@StTgG^O7R=BMy3ofFpLW#?|n5 ztZ&|FjSKRgVCAK4Aohnqq&=JC0b8r6=^z*~6f%%B0Tzigzz_a%Ajs?jSqI+`j-0J0 zx+bx52`(`dY9yVvOn4(U>G5CuG&ZOliwwjKx>a&(2xqx7c+i8`JlAGow?6lh?{K9i z0al2s`DWyb%>9Q{jJcmYB-#B+dnwNiMhXeJ7`A=p4(6~aVCD4D?m7zoKvWJ=!tSGFnlNBtdoYZ8r22tqH0zkG*hkJ}ujcubNiBVBN`=DM`Ii zZF_cV&2pk{H(&rfpQlP|Fumqu`EW~kFzHYZFJ;od%@=J-McsriP>;Nl+T=l6$&IHo zz}s@+FRk;{JG5XUtItCv(VQh|Yl*G=HyFF`D$d-Dovn+JX?C@ zot}p}-JX)`hYw|xa_}#)FS2y>tOK7gacjztgR(B2ze2AIg)&?#d7z640gT(oEM~}y z;b#f1L{@ePlB#&V@mdr+0y2jso#SlwucI&k9F5!_aP+))C`rmO8v|9v`L4UTOz6q) zybneXzO?eLkB94=63tX7jE!NO_fyPOcra)sd15R^9zh*?en2Qb%d$gC_Q`|($Ou)k zCjf%(?XBw=MwR}~;l6R6tT;R8U_e?KJX1L3a~xE-R}^I>;P8MRsp`*?&{r+NR8V!5DbHPK6*CavQIg^vH#D=RMF6oia7wedHecu)iXMmu6I$2JLf_Iep z0)0IH!P@jvnr(xB2!0=>uM}AjNTcnP9sq1-xTDI(Y7PMinTZgSahzKwK6)Q{{ayiX zph^zs{+0pK?qEgcst01w6#?g*-Jb9OLh5*;u*zU<*X^WK>$5-owop*<67Zx8*d83Y zMAgeMh!4)6 zkq2me0ras#ON_uoy)rNsAYgPf{YX?^z0I8f`g@{>!nWg_`(1#e(GILkwp$Yi z>uLw7eO^-@;w62C-?%zRdAB9CB@M$O(aDzqZ5Ftawv6{(UGig7=Fi=@Jo#>&33)u@ z-Qj&gNc-mokZs8BpscZv!{9;vn&EC#jL6wwR|wees>Wn#>mQ(hGrPL~YrxZPFM820 zm3|%YmO!b+#8&D3srmn&X@(JwUVvLFPnO7Si1Hhy{o}v;H7>0-s3|FP`xKPda*yNT z4yRv@epI2!{)`A9fy)d-EPFngO@GF#_hxek`Qt8bbxPmhswb`d3r2^tPh{Yrmdq+X z&SMTBD`tOLzd4)zLNu0?w2WNRu^StZz`zgWcWAH?_n+6;lH!Rzfx%j;(|TX@vOjjP z{hlTiW^K<1l5~#V_vjDF3Ar4f9E#l`8&ee?RY2 z)J^zK1M@=K)U-KIz52%h;x5&B!5)4m>ncQIGRkB7@>1z&5lN(lf5D^N7Ds}wLtuss zT6e|95Pj~>&wYX^KeC~m8Ns1y?!EeQ9gLGHZ)}R}GL}r$VgcK~8cTm^cCfY)*XU`> zU#c>LeVsfw=;M=vRIj?(4oy?ZG4kqL^=8jy(*xEWRlRD?z?sq6vUFoo-kH*nt}*_I zoXdCl;-^x@TXH3C&g4z(Le;sjON;)d7V@RGG7a_Ze_J zmE}U;96J#O5w|`hr&dNzv=N>CB)0Bx1^g?)u<@lhSTD36929 z*3bafxxVX@Otr^mv zzq_n&FQv_=YFw&tdM|C=+L4NE(3Z}~J#JDN^mc~nAt)H*1CXv67N^ACkfub1UiHDX_&k{KE<2lt zm*^TYV0JvV;w9DNfH2w6BH*6eBjyz>&EL(Ew?5yI>SuX6+TL5q)72kX!$an<#`5gV z3O2(1VtM)k@9D|TD1yQO^8jJXc|AK-L8aZ^2C%JYyQUqI9iFqBY}FZQ3|?N?`Kp&d zQ%)}}NQ!PLB)EeA)*$9^n(RlN?cMK5-?~4)Be{xC}TphE+mhqB@ffvs~qFdk>w z0GlA2Ork~7e5RcTr{qom+ozQ6A+G+#a|{^)`x6(lj~vMJQ4UZ5g1T8^KXb~2aZJSE zh1`4ky}#;}F4@+A$hpqd)3qUf^a3EX%=Oeb5Iwd+P@_>@c0<$E~TxWdLIAoKI#Lq>pT z3(d$CAx+?u!BRFEZL7;LtOP8!r)8bkOoZ)Adi#bzJ(V)`_5yd+xWY;SmX^u%>^+pY zkKP^j=8O?DE+Uxz1ZCp;9PUe__w;oYl=E6;ZND_gBLq~>&spp-349JjaDv=^)txpi z+r8#{HIn)lPDG-QcHY-#6q^G+Z9NSTicZb-ryA)^1~_dE;JU+7i%cEB%~zr7ys@cbuO0ST@z%dBt977og2W}{*$#A1VJ#@{73yl zTy3d;NHVvW%%(|$j#@Rl%gFv0VrK9KJqc1sJQ9dckzGp3eEfI7k>Voa%wL^q{YTQF zMWkD+H#VI3*tQqjm4;KwP_&mSEoaIf4>8UAlq)GU4WVJbGxdj=~nLGsfX0Zn7<7NUjNT+HH?iD^U{j5{$Kq#6uJ4#kL>m zZCX^p-^b;%&i|CMCK&G8_>)5pNgMqg%EM31#bC`a;`7_z6Em{h7Gd1<5=%TGijo0R z>?mc^GLe6xboDqnlr;*&Q1e2+xsy&M4>B9l$5nFtw?=c$&QiLWVcXtR0VGy6lp&jr zy#NesoRtjoCA9qW4uttL{9}@Ae$Wb_)@tyKe!O2GT)(9`TZ{gWsCBtPsY;brI1%JP1Vsmp3f9pD2U=i+lzj+=Q}xnKI>>y|MP$T z4@RXaC1A+L0CH;fhbN9>wB;>=xp)(F^1G4sN)|)N>yXsN@!ZlYf}t>Df3vNQ#sA6l z(aiP?JFP8QDjV#e`4cCMgY#rCGh?DGYZVHn5(8+X;`hs;dqWfkM7qv$K?0wZ7=vIa zlY}$nIL6^r`s@-MoqI?~O90{}CHRWt5+P&v*3sj&R>d&bJ$ zt%K#>Ph=jz4#6Z{Yhkbn(>Sr^msIPD3|W5iHz`ANNpAp{`@l>XwdR!0>%3#iM_mn+ zfqHR%Cc6l?Oete(9#PO8-s1)0x{DV9We-AlE%iGPmL^R47j+At( zuKM{1VV{tNLC!-!nKW~Zy3>s%%Yk0Cr*3BcAGIa&5NVSIXc($SxuU9H0ju zKGirI1HFS?yazt2k8BK#{NVUS^}{^pUd}mdp{{J7)sJLPLS__Xpr%#N;pc}(;Bzx* zQV`V0W7)Yh=G$MbgZt=$vl%vxvSs8 z6-aaMDE~|LUumC^ZQxz4bU|a3+46&2Kq!^`e#zk2P6DI_ux#4@(xTH^oeJUPwW%Yu z=c=gE$`M=rDD95+|JL<`yuNFL-Lh7!*^GHkIrf~Rp@Pb%YX9cUtMB3);5tA_W{AP5 zvTf+C4Eza7lqw>r>h(KqkXBNY$IN|!ZNF96a_wl}0j?6}BupUH4B zFj1AW_>uFDBn5D%Ts#=$;wwHtZtjWCz}M$TO0Fv3py}wzOp~(goR{*~Oimx{u#LOU zkGUd}GOxw}$a0;&@;84!Zn+Zn{ZL+;VV@ZoXu|oEe9?8)3;RZSv&F7w1hL`A80K%p z&PLTk+Qdgr0$th()nb@)@R#h@k!w5}XVqJk;wqHhY&K|P%YZAS5caHwzjIH@4nEB1 zn;;i5J^TB;<%#~T>x9v1p?9&vCmPL?MA~$*sdB&g&!Qv5G2r+ttx0F@#^-DR42*JYUiN zFpg!CkV+*{Y^39w!~B6-f;ckwwG+F^1zYdGO)GNk46A8ohAB8FZ9QPL;EF}i1i4&! z5{H%xN>u0pxir&gJe=KE{pXPbNHQ}$~I+u#;z0QXO@YH%@`cgP>Nl1qQiN76rCW3->kj3*qlHAeqV-bjhLDq z16i3*T7awgYLbqIRujOKSVJBiIs ze$Pi4;&Duaw8)_GgeR=@AsbMdr?wO}%3ROC3?iy*|8{`iW$?m=<#dB3-(yCy>V?j- zq}l-4KsZPXcs*;>3;^#`)i}nD@^Wqj2%0c)z@<1#;-o=&<`Mf94fwbGP&d#}m`UK( zQ}U`36v7jG#d~`acRNMq*$DI?tKKCmsscd5`ia4Fhry>8zz5Xbc@B=m0(Rnn5>X}= z3nN|AW(3vx^>MXKJs2ts9R>?gkk`$$3Z^nn-m8K9y|8RcW=)I-4#2(5XPsQirw&6+ z9K6(m-^!hzYv@b@%myJQHKd(#jbk+?vyplt9wW_jH1E4T+VdPlWbRr`fWxk2<4hK0 z$u{fdxvHp8T7P0|-TXrFxt;Uj431vC=OM7eN>?0)GjETMbZ#(k4zoGPQf&zxWe01= z#vrH9pR&et!Y&hNCo`75FXi)EmXB%A<5<&_V48q|VE-IS{c}z@sX=}v08q7qxtKuy z-r2Lq&!gwge<>;1bpMC{yGK43$dwb7uhG!to*u!8es==y00yi$FCU`8m1Lz17p?L; zx?Hi9Rf1;Ev7)70jg?;6iYy&a>ixbYK#`?vUXi3?x>4F6T*gV(vPwJTHtQyl{|Kjn z)ypgt{{C4mMk}OsEpm1$ALgor@Q9@kV3;uRT%b#FA9_HYt$i}h*v`|*w?8SR*={Rg z7DxPUMLA=9qQ~AF{x^Wh4fwIXUof@(ncU|{u9LA|9Z?FOpg{5IXUPeD1DlWpwtOT! z3->}mU+K-STg6Zz#r@91tc|T~spBj?_SJ)J2`XP^%ye&H+953hnIR~W5nP@}pLl8P z3!I(5<)z9qVteO(9Y!ZxTFp7>_SIJ@`>Ip@qs=0t4@%$>GGNFmG6PAslF2OxtPSqh z@~yd<@4TNR50`x)L9QP4ytFaeUryQpYL+w3D!M$sI{wUd>FJ{4MR9n_MwMxXSub0o zZJQCm+Mdf*BCb~2Nh3>!4ZXKJYbE$LWL7L2|Cu1GD>&dKdo22at$UA}6|DJwWObxn z7iNd)-tXW6$nf;X4F2~iKYwKS1b4m!Xawk;s67VyduQbe$5Yx$hdT=>_!8ZpRP2#( z5D6m2yaXQgcwNXTso!nF)2qzBR8s`p< zTCXw;bshum^VX6XD2oy#hahPMPxv`X?@cVBdpChptJ_%zTM#staU&smbiaR$MKfdS zt)u5SK6xRyJ#OIMm(4+(5!iN0rB`qLOQ&9)^XPqFoiTYe^_Y}85LQbT8_Q;>W}m~D zt;noC0`jr@``*$eOZ;!oQ`*7pX;UKTnJUk7c|+n{*3C8yyNmzLcdCiePniIS@Hxxh z5`FTUK}2}Dr9HExmLinK|1ngso|V`Fpl#&tNu*H+>`K9kku$z13Q#cnI3zFO{%8owb@a{X-O6H*L8J_`F5#Qz(yAZ=AFsZ(EP($EjA$A1@CH z65Zz)sz=QVxiy<%$6?dGuC4CxYvP)hO^+I8$k0w8#nEI%+Q^Do1c?PIg87!xp~d^G0UPXCXR7R$ z2onIKo3T4n34%wddU>8dX94T#F_s^q!nUsnd^NQoHnuzS0~(o2zzt3g`dp>gL6)?@Q(}*Sq7z~%}-$9S2uv%`#{I%X%7bDonHv1 z!LGf}->&nj+oUTxPTVPd)1S zEz!~ES3zN8{iZ2440(i-)DBK zO9td^#K-KNenuHk6+J$OU{Oc)x9KQt`&B*zAVYe=VD+@BpF509zMss@r~#CZtPi^7 zw62Wt`q`20;J<+45OoAIu9TuGV7AuG&qNSc1W)$wkk0iA|qYLETS{UT3-83 zmA8M7**+R&96{L$Ysn*8BnF?}O%2=PCi^bxWqfWD0hxd2&O`t{g2i0DfSmr0_fx&s z7YBHb9S3#>5_gi#?BrH1P~Y~Vx`~1iza%6q+mpll1W=K8d7zeAe5In{CQitzNxX-H zy6qva*8GC6ENdEf-=0RJKKRVld`Is{e|q%`uH<}{v{|eW!A!*(fhMQ?4(poBxVH6U z$XH|`0o~2S&Rd#4ZE$QX!#Rf~TYTxYV!v|b#eB|^T)4}9;~X`#Px!reDDSH+b5APA zB-WMB&14P1L6UgIxt!9BM`MaMm{brD?<@J~9(JaanZ8@0>Ly6qM9E6R8LBReVQK!n zlQ{uhnnN|{;`ux^iUCb^Jb3GgLSZB%_bn>`ls5w04=88@c1jeh!-U1ils?O034Q~dB5!wa zj(d$QjLDEyK+d$XJF-^i3+C4>ZpwaC^svu8yJhy0bk|iVJww?}eSl&q$>+wJ9@r-j z6nQWxHmY{w!EX7#kVf%GZ?daofKYCO?#p)}>42_d!+NBQYAuVh4J85oyM4}|02cpf zr{c2dLT04w(YCQ`-IAw6Mk#Dy<9Gx+4CK`fpgbf_DEANqDQ-DIFUD^;*zk0Ahy?cM za#Y1d&p4AYQ8+HiYwzO{cxRlCPIzAoyQDJ@@7xe0&e~`Oc=-HXa~3Y` zqSRZuzy>`_3yZP0C2A`d+7&^0GOPRSeW-Ad$(BPbO>{oKpl*xFkuHIu{*V!hYZWiQ zRZ11-7~}`$s0u)IJ zmmG{I0E7@Zvwy#!eD3dND?>`~#D$cBKn zfbw`W2k%Fj=h3G(XfZj7Z!LUlU&2VzK4{HRA zmuzszf#J+*MPu!7%xJ#=-;!nne1BGaW#sitY2KlY&u9H2TZK#typgzY+q_2C7!04? zTH+$@U;Z!qXIGLz=7?VAPN3?0J$lp(1@3M_44>Om;Mkt+lF?`byZo7N348aJ-e+`P z`|k;k!=8)a!W9G%p#l%r*&(OtrLD{N*+{?t{v7{Xcr|568#e)r{k#Italc2ikOIo5Z;$xqb zRinY!Pc|(tk-`g8(L)VoA-XCdhcZS zCG>+*u1;&dxMHZDk(QTf$(x4i%3wA|{K;keec!lNQMEb8;G)sE!r%!JO7eylpgkxYBvBB)42W_aqw+{L4t293;Bn&AbIC$n)_$)O zOXOQl5vR{Te9~Hrxprd{8N}4}uYdh(1H%BR^JE2>J{6F6utw*cYINGcaCgcOU8)fS z<^X&aN0dYfSd_7EzwxY^$o%(stF?h_nwB_<%8_f8M%!mkZ-;5Ou zjHlk(X!p((Fmv~o!SuoKS@9^9`#f{W;Io3)d?^1Qz>*36W?)mHv1vj;t7A$BdnxgD zRtn>v?CE-*(N2x+tN1-GC>*^z9QfBBI=mz=`MoO+4%^i01FS$nSm$>dVTW7&MeOn?DwIf$~ynd za|5Tp1TW>DujpQo3rg!@ugP|vB^nN7)j|RsT(<{ct^GRK-E!BUOL&ixy{tfL7;}UF z+W8Ed^@_d~nX9rA9!S5b8}vy>I_|N|o^8#?W}Fz`FCv}=n+73u1NR!QM~p$MPr66g(J zO|f$~6T!=eqf%@1cM@_uT7NNGyPW_r{?u-+`qDQm!PioP)Y181C~M$+jvz=d=ELAo^-E{2>HG zu(#^94Pid2ZaF*=T`CYp>t9RBLPqEZKM+7{8F<_FMzkwb&Nntkx%1f1QpgH%rtw*s zWs;dlQ4CiE68OFj#1mNcQ+i&ApO5~ZDfPi)l2L8-r;;)DtOyo)LO@iF0Q$BAQ?hJ8 zj_!OJNtcj;EhV$wN5h|`zXaj8 zJpAviQDr8_d3TFK$k?sGDc#u+X(vQpx9)}2<-K^%)lR}zXE>cX9qeY4n2g+)GSCHl zYMpyWw3cX-cbZsVU0nCRx)pZdg!gFb=StS}b5SAccI{y(Fc?dQlKajZ;7a)K$aX!EM`3rdH4|u1dUce|K?U*L+-v^XVY9&*VxH51OyUb# zzJC+cK0Etd{9zUCAiVEp<&&ry4K)% z)%MNS`dyZW%4>IWs#5*yzyIX`6v>VuP`{eLNA>FkcfC%L2Pp#>xKT0oL8I0)+OoI= zHCw8ZfS8^p4@kM0taUtrEF544b`?sK%X&@kyW)Os0HEXjhua%5L$Eaj{xR$rO8~o2 zu$yiC80HvpF4UPlf4~NoBQif^J#F#)5426Pg@%Ip4#Mws5&(bz6y3}skFtz$pA1v8 zAU#!f@C;nB6d&zm4GG5I#yUf+{Qhz9$rAbRv!^(?I{;=&%W#w`vvaS`e!oxQED2Mq zA+teDR;qPnI8u=6&D7@{pTo_*KBr}r2~3_Dy(d8_CGZNvTpWj)|5*jJF+KCAOmBCu zs6Qo@5d~4O*;mPH=eW%SVyrn{w9U}S-msbow-WM zZU6$Z9n@U9pp+>M%AVrc^TRG|mQ~7t$pWnS?f#;<3tH>cKgtzLb6bZhjO_hcKMN(< zaT4QTZ=JRVUAlVM{QFj$96z7Sg;N?d;#Kc@b5OC=MK|fynQ9WdG zCINy2wWFfy1-n^AzoebXnr{D1@x5w0u~xD;b89 zl2CM@uBWCr(SUyJs}>tg$?GvQunpsv$DGl7wEdPd$qL_378%OS3p&h(nYA;v%^_DV zm@}F7mgRR|?R~#0GANMo>IIOu8^nR!%_2Ed=6+wO46>vX77l{d*yNSV^&zW+Kk$i4 z&wS72paNnCd#1L`=vDT?yU)0=A2<7?1o3l4W0=|UPD|4eNq+t$CA#G7B42mybtyx^ zY>SYIkezQWW(lDgAS(HL=a-5AW)|(|#iTMsFYFQo#=cL)NZ5|;j3B9P$ZGfp_kz(Q@koO!)(xC#xYq`?~Fww_)N$83ALmObnrk+hK(Mp5e zAq~kpUiq97gYoAk%$Cq$F4o5#6kyIon)Ud$B+L?1HI84reWKTwY3NmlM0v|qwr_*o zO4{lYa7zZL`k0E`DS8)tqmcKIMZ9C5VYst@*F(xJB6-)4Q`Ev(-qI>awe0%Dd^WLr z*6W(g`RP25ZGUUqb5Ha$Zb`O_XLU!~M038U!Tl!^0(pBbj!vv|Xp2i?(8-8L^)lOS z?P9*IcD6?bYI;i((-U{7(K(bwg<~pWfOCC?{1Cpml=iMz^I11*p_H?V3{qK$4w)1u zzMfPXZg5qP|BrhkjurYi(6SRb#`;`RA1+7%*>)NyL(c-{hkm+4W~pNZYzPS9^Qye` ztU{>XRWQ}V!6NJx1C*=}u)EFB&lAOqAlL&2CvOP}%H`~dr+|Bf#j%nfk$uYZ*+?~+ zEa|YOuTq}%wP?tS+L?G zXBH6nWCFJz@-en)Soi9qYEKY$5N27kLxjX|`=z=Z%nVug7^VmpRplGZ8qAPUta4_X zz|||0If%;t_T4$iKYH}1cn{B!XutP^PDJAfR=w6vy0a~g!N(foIApS!2(F9u_}&)I zFaHVY!_-ooUZIPzA3gf)Vdh!Ly1Eazw^T1o`<7F|==PKcAV z4LJSL$+{2D$#T;wsmV(0Ni;pHkP~hBpY%%0b~zcJ;`tr?TDMx|;XAR@yLBadqb>ip z8a4Frp_*ruUVa5E6gSQpt5Qbj3|sSe=?NFlk+`R$|LBYx4)XliJN3P*C1+!UO|IC9 zC-Zo)5d=|fVrpUsj)7=E_B!?cVM}jm`AD2GpoYvPiq3QTGgyjc9RM`?HT-;;?Jzwa zlr~52`)xBm>@L;q)9z3E@oZ3n}A*nUL@+IJb%;*_zC$$~=zw@>pN zp(l5vN2ANBw7A#(5mvCvl2+|L+Zqx><#rAGU*m_PBlqC0$ap-G(o$yIGw;6Kr@br{ zk43VkIa~6cw1VWreT{|8*OJ!rybcB1a_U(d&JU)FGCli~xl!PaTH*=^L0jMq#E+!3 z@1)u)e#43zKY!JBz~%8VS^qZZqt~XM>l1Vn4lh*;FVAuNq@~WBtoVAcOy($6`j@v# zW(Yn)td+7Yqw285>uAfda>fTAKq908$un;#P;fffnETt+udxZJt!6x{VWiz)Q>B{N zbuG~v0<2|1=$w!~t)3(nO@hU58$S^rXlP&dzi%9WpkfYbMwbBEh8V5m5|PUx>ZsDK zN(Dpu;&}%-Nx%s<@kRH=K1ac}wC4^Vu7ZpTdXZ8Y`a&FxU=t;zL96hSlp|UaZ z{nSz7*Hp3%0phJ;7u#CRtJ)$P05A46#L|tM)QmvyHX_FM^ zP+Bu#o<^D%LlOh$-*r%TOMLA^03WYkl;>CarjrFW0~p8jI@^%mpO&YBS2Lgva9HV) z1~{U4ndBNaChM8L?4RY;?D)h;m$P{aSf~I=JJn9#+`Kke6GzZgP0-72AGQX~87tx7 zy`In+jKXnPTDPN_h$1U2vbsY7QZR5e87P90MoCw?wiMQv!8+!m zXOHU*7(}>U?zBd#z7xB7l!i@BPTPSrT!22(fy9VER+IS>hOsEq z#W*V8NG7XK-7@oO7;%1|XPN+A`R)fWX+_uPrEL5kjO>)Ng{OXNM1(PS#wp4;0JOou zQcev}PlnAmZ<+N}U0-$qV0K{jG2`s~7<$R!hr~6cMy^A_0-#zi)0%yEXCN1FuC^WI zS7!V@<8vxSdEToZ0J<2CPL?TIj$srvU_=@{ia+HH&_H3!fwCgJrn_WHr6K9@umU%Blg{8fT7qjuQ%`>*~#nGU3g$8?Y16 zUtuqf|9fHI`|~}|>w&m+bovD>HJLeS+Q{&9D+A+fSIGpEwZ7jukW2ovyOZ6|?<0QK z&WuL-5h_>j@7l(=Z_;(z@1Da<$N}^>b_XJT=0~t${}>R@i>u!z;6V>FTyJa(Ue0W) z)b)crp(lA7{Y;Y4;CDi_B^ASc4Eo_a?vM0wCg`C5H`Qo0WL*7hLMMFw-VN`q0tWo` zv#pvL%TQzUu*voxA6q`9)aQlh9ONU8nCLBQgM)gSaOT8 z#l=Kwsw#)%MLpb`V%rWeOaJ5j)#VoDn5B*I^UT(RnWK4-ZMg;DY^$ha%9e+1XS0YR zj`*opsZve+hOOjI(;|@S$}@jXCjNi^^>2MTsBH{mP}}7MaYX)B1W2_)lAvP)sHV?^ zz<0~HVZ3%SwVb3&rrtwM2=Z~hMSH*~<(EKgto>FdR02T&a!K=2>svcogxD=^fb1`< zV>15Y;I~&AMfT7|SiCm@g}8KQ(h5y`>v+WnndxJ@;mkN}+{8ANHZaJE&OR$=`-^_$kmLz)8$GyT9Vk%yaG(XL;A^J@*vp~x3T4`>dtv*?d zbEvXqm=RwD=2)k-RUB)00s{REuX?}Fx?pEP-eZI0ieSFzoa=9_LzUmH&mcLBJt#4) zI8GqJW&=i@bqE^5*s7Kka%Bgst4Dr&xY^^(M{iY!-``-My=elVS9?!@GFah!^==lC zO;zm#}6bI!iha=Aq>^ zeGrXLZ3(7r3&42;w40fazc4taN(I?c9&5!V!_|;MM6_8UQT=G1SqHwuvH&5XykCFW zp9jc5-zJ#~DhvGMoLRZT>eueSLrM629x%#QO*={KHnRGBoc?jY&%7>`pBQdzOiCk5 zx|LV~U!{MP_s4~n<=bOJ6J zoV6vB`t;FbE#`|`ILG%AbpBD3D!aN@?Xw>DMrRw5Kd-4glkotg;`!jBkkp;~GxFxo zh2=(fx|QK^!#0!cT^|o-J(aAtF7XsQB%kS|j9{*em9jzZ-FG;z`}HR%wvD{v6^S+! z&@$NO5xyfnG?*?2d^k)J5B0X*RHT*mXXd@BD3cYsb|Kjt0%aA%g@Ri`@cOG9bn^lD zu8T}~{xv0$qnBqq`4ImudcVXj@0kFl0uDQv2L*;~9vPIo+OQ>NL*&)-Q)v;^9CeRZ zce1reRc>P}Xu6Qm@gYr;Y_!#vnayB-^}!!t>&|rd=<!q&&mM!3p_ZQP2$;x*0v(dnLWpCn}#TK zWlkxC+h9wsi1~BU&DrQ#Y~_t3q#F~VN00Vi{IgV>48+61cI!{Y+!4#4ZOb|5@+Ew} zTkpJ?;%L0axn*BEQtS9<-W)jZFz@PyP2jA(Sz-s`s0VpC!8csujC4}XKATauUFA$1 z%sB2P?mW@cJWg9XOC8YkO8R z_pCxPPDn2&58t^9mr&HC^E{%_bI%uO6h1x#Wn`V;VCIMVMDC+#`5p(67&FMeu*B7w%=#E;9)?H89PW&OBfWhqhPGVNWkw^W)IYgT zBtGTo%Xm4sef4;SUKcYTjvkocL5_<+UzG})kItRL@1xh;m;VpUDz;^HZ*A^u+riAA zTJ0b%=PBE))3fYt*40$X7VFR(k3BudMm@nsom>?CYW{c2ZH7Qv57eXcNEsTrgb$MQ zVoY}yMDCI2%$elOgoBWJd)^iBfyWrCG0xt{!Crdoi4eIu&bWvLgujWZrD`MzA*Srci+eX`62KbDzB_dnX5t2O4(E$ zN=>JHPQTC9DPWomgw6uK3_TRjIC_`F+zIp$U{784egmVD)a_MH_-7NDJVzx|jE}Hg zct`rH_+CGM%1^bPz;F9P62$H=;D5B_r~M1``Cvzm?V%*i6EKFp_Z@;&+v7~21_SNa zOwcq7qD`RBl?AdLb{_yE2(>ra|5H&R{9nK__tYT|W|I#dTI&G#V8>Ez)=UOJfXlAZ z@sJg=fwpB&h)+Sv&npjkN)Uj3oW_wNm)#4@?ElEd=~cb7i8;fNlh}_L5*-TuihsjV zr~OH!hx?5FG*tP`1_y$ad8_oWS}$#F{%cnTEigvDW~h!y(31=%nx|B`X?(x5L=LuR zTRpfJ+hc#fZP{?Ac|V4js{awZ#sB`gbe{2wHeJ%h!|q!1Fy!&&`7ge~N6M~Y%q`FcstY@z+iCkNL zMZo>Rrv$B$jnVbr)?e`2fR7^Y z5@0bSozb1>d=$^^tjKJDaLQ#{b4q`8`$gmI%mn-U|Hc`W(vXoK*p|{f4qlS^oySg$ zZ&7xQyX0FsO7H_fF85woAt?PkC<-vEa;bj+w_n+ppyLVM2gbFlV30jr@(_eZ+%O=|anRL;fvO=h0LwU~-`Hq)Mu36tgA7%ZjTqnn4>{B* zp1Cb6Lr;8G2swy68+;`I+Q#sBns+=%$G|EMA$Doj;d$mjf0Y^#vULzqP$x!2?JRyAV|qyOFEDp`)+a|eg5uaE`=a3ti!K%j;(zJ#seU&?kMAs`nU+k?M^d#1fSQzpT%jDh=4I$nBmd)oJnc&dU&m+8jPxF_QNpiU zhmR6akF?)&TL$oni9$EaL}eTPSJ;lG<-(mcgxvLA;lJhQ&^sRLm3F&H`L%g z`PuBq&gzJWkNebX_`B_k2Fybq{NZmrp}g1D+K7I9oslu1&FANUidK-^AN{q3-EqJ^ zKJz9V4Np5;2*kR{CTkRdLv(!^5-}a;wrMkWq?IOp!F$LBE{}U=Kt-yx&6{G3fmp(y(aV z)=#RlI_J35@xy`8cYJX+f!xSq@J!zI3{~D5{0q2g(BV360XP`_DVQL7c~y^>cKfmtCQ`y-|Ic}<{{lnT$OZa2{O(%>7$b@ z0Wz=J04tgCo6e|fs3@Pitrux4;q^`e2LUwGc7UA;@SE8-vci6C)_gLV_-0pKby{AX z*cm=cMkW8JZp3)dzhqlWR7#b7oHroY*2W1RK`N-o$nbnr4&`ogj}?7hUvM)Nh0Rc^ zvyxfB{;8Bs0(^t6elZLR+@vkr75d0kq<6aJPtwnN@a)%k@Z{ET)?VZ6)y;xy>hsVG zNY+%JBzO{mXP4^FKa=*6d{>v8ttv^`l!17?@%y~zBfejef5@t)dJKZKkm}R(|A-?5 zk4z-LF|;R>=?h{Z+SOP86q^&-!S3mv-}=144*UqT#?O-S_w1Ffrkpg-qg)iA`LfOH ztEUdxTUP<3YX)9H`uORsT^=df&ul=l8J#Pm3=uq21Yj3H_b~1L_^w2tmllb4oVD|# zkDm9w_sTm2PJMjxAk0~}r#-*;j!&5|Gd#}JR(FMV8Un9|v}Rm}QX9JSWTw4%R5gFjE@|xV=S9a|S?m(maT>hU4wY4!v%NWt^J4N!Wz`wz8qqkk}dGVQ6--356 z4j0>9k4u$a%eWsBwru#dZ3Q_qut75`LXg%2hK$^0M~mu`qEis+MLdB1jsqIiOGPoy zHgNzS-ONTAw^liUmny#pzaDv?nNRgYF8LB;+isbEpZGX^5(kprqxth4oS?1*(KWOo z$-e%S>Sx%K3HEL+76jVIxAFesdksNK#e9hQ6Qpir{hv6+#}j-hD%@=cJP_2r+bYxY z79ji=Ezizn5wSvaOn^?b~jk)`WO>uCLkma8+X#j_CT+(We+A-t<`{8U)80`wNyr9ozCT4YYU@~J#0cae-8s8I^ zt;jWExH2X7m|9)?|IBz_EMUMd^*ywA11wePw3+C0O7%P+16v+mh>>-S*vnp(0y0~- z443!TD9qjISM@|N9%l#+%usC{0V7?@j#dHq3pQxX$_D?XR7^ugA*~O9oQ|`=;CoPn zadwqIR{;9+1gIR%F$+{UyMsf2IKK?USckTZS}AKEBk(GhfeA9Es=QjJKk|+vIV0(* zb*zgtrUACT%S;+}kipuIl($l={51E$on%;ET18x@+k9`b>aekZhiM?yc#w$MEJN34 zjoINWY&eG!xs(^V^sN~dBhnybh!EK3-Qt)~Q|`KC;-hU~(o&GWhlNck?2PXyLvYfz zaGK1NO6Sk-|JKdod!-q@h{%=>KxrBwF3 z7=MN{hb=vneYZ)x%r8v|m4i)yE;35g8O&(Ic7RFKD*eza4{|%nMvagUEL9NHI8!(s zkRaXz^2&_R0_|wMWbhJT-LYpu+t{)hDO1r?vTBUh?#-nCH6Wv~LCs(~A>-*$-5CZL ziISbY`O`#VA+N|@PRnGK-}8)|CFJK0U^BbDb(~4l{N&27#^qT%4FncmspP;dpH(|& zfhjs_Kt$<+HA$l%K-Hk$_WTu*nzD_=S<|sih(05?*&uSuqZ2F+0UiF1wP-sG zv`d+f>5}_Y8YC0%;HO@B?!#u8_KW1|31_VW`cl1g0Oa)os9T!;*{8_Q_8oMH8QgQ; z;I#sZ0Alg;WCRa(_zpW9dXsIxGU*&j%q>|8$U}eiAKUFmnn}^T&+tLNii}MLIc=p2 zHrz7hvuMp$=19)eC$>*;d8SnTk~OB9knCCo%;cXb-5ycjeJaW_crgP3jk-Cn5E1=q ze#3?%d<)O>l^bW5TWd5Ld5M;iOzC9Q)sXW3JP*k8Os3cwR~fu3lL`L(9&eI-@Bqdw zcZgbi=WF5tpN=cEUm7gu>S%+#XDe5f^}uEQY8Z@6YWG$1K7u?7e&82tob60yOU^qL zXN}Q*2xxq0KY!k5&PZh6e#2$y2Xf>rIcM-a`0FJcPb5mtVz*_^SLGIj0@IpsrnIuaWeJ^gSC3)B!JX)(ytbP*2g0s=r>WqLCii9^FBZc`Pf(Lv@;; z9XsX>&wgJBwqPm8OWOD<=Z_Zf9OFs0N27BdXK)VhJ7EoLl}9Qv>4n*~pz0T6d6QKz~yZ4VTVsO!MQ?|-ui1d@eC@;R;281pEX1x0KnO0Wf#U~*}KsicI$`l)D93~ zNspm!=~}YOb!@zI@8a0ilo27SkrVgjQWY>b;4?bsr%d-xIa*fq%<(Sx1&}q$bZ|ZH z%?V(k&3BpAS^(yAyA$dU_hcpW+BpXkC&py7vnt+>gC!%~$f`y&N4r``g3Wec_9`4C z7i#OZBTWTLJ8*spj#Ni!IVp)DKLOtXIHl>=0sF|)!P|_XZ3keNviWKUIT@CsDb2=a*oZvOBN2qIA6G+Je|voIuEq0Z5)5NL5P^4NhX(f^kL!Wsp|e?jeF*7;4wl z-k~p&S3b@VSlAG!dOZD#8;H+rP_m`bDIMn?^9*ym`cX}wJVOaKPKmqoXMAMm&7VPa zC4=-s{>bLJN`z;US?^XuKC+@M>x$Tp;5e&Dbit-45ZV&_VQ9{aI*#hGL(Me!evy?5 z{Q_X!|4qvSNAstm57)N+jXX_gH4NwL?=^b$@2KT7>5#FM7xLW+J8!u?!Hk@#Xi4f9 zvV(h+ftiCLzhfqSZ+@n+=alDlw>hkZy0vUevt`0$ zM*_KlXRzIU=hYwEV4C1T!XA9LJD#Q?mqv$kbrGW;sSDCo_8o0PB4wk~Avo<1 zPlM&6YkdC05UhLl{*D?kC+RgIx9vMc=GMev5B6u?wXvs1^O}&_76*iWhf$84i9<%} zg(#fS=|2dGF%J6$)LSoHt`24Z_#C}UyqzvfYtPL_FUdc8Isxl!i_PGBH6O$?CWfN( zzPx?>y?1kjKN34sDfPI__D8@p4I#+yqDHo}FT_B|HgMw`Mb=g}ZlZ@kBD1GP+CVbB z-6!ugy*O^JxUWC(yLo^~#eYQzNT^8f?EwdSVWFhT>evb&ZQP?tm~hFdar>L)nXuSG zbu0_mx&$$ra@G|wSt7J_v;Kp=mr38uvvCYq*H_P22C>m_Qx0S&B&o@> z4o1w0Cic)c>2!+O1@YU^rNL3)`BYHWqzW??wD*}(5zze1B=TU+iU~aHqr(*N1-O2M zeT<%z)Q>a3t@0eFPP~!Il1HZ>sUPqGN!=cX-&s#4#3FZ@xN4~OR65(r>p zqds9T_kRthRPBEKU|4C~_Ap6_ql1vT6}y7GTJ8!0BJ!ne$1=OvB#xbGcXHhVlX-W_ zOerPOE_8ybT-wn}5L)%`2t zpV8^Z1II)OH9yh~=n88I0G&G5321a4RE2>@J{yBp58iPwvbahAJZopwxqm{0^hc+^ z_A=XbB|4g>f*Wf6&0~Z2+PY0w^N6y!o{^aseXZs?55vrbBJ zgGwJNqM2_oc09MlT9(mzx7_Khkv6MnUyfs`2v-bPZ2;_D&zx&+tlYPJV&D$MPEy}; zO~tbr2uiL9YUX(Jge3jFr8!O6y}vhOc#45N*Je~6VxMpOQ6UI3*ehoqT``oh{FJdP z*@D_u81YX2nlQ>Zn!*)OI=7V^G44~_4e%)WAg`ZH>qascI)nXWXiWTEyNrF;mZs`M zk3r=Ni3)*Ia(U)FxtC(V9Dqb|ZWN0Gs<)(mh60U>=7q&;o>N%abLJyc`n*46BNY(4i2`70!o{-x4t}6Gr1)rj z-Y3q&9<_h&C<48}>5|-lbsPw7rb`lMb(){^W-fhh@7kAoO{}+GJ#C%owr{qqc~d~L zk`502yN#c5+Yeb18MQ&>_e#ZE!*r z(##9g{AAyz6YF9837Y5PD0sGOdxrVffXUGXo6hJpL9iS!9I7oUL2_`K@K2&|wRc^z zCQt9`inqleSnLGt1p&~BD}@IF7MToyfM!Ie-fjjd2fvuysd}XiAbpmH>{;^XYU4o@ z$d9I&AJUITKRKG54K6HMwq-LFe0cAHART zcd_4vzt8M}41pE){76bw@8b6uSpKmIZW6DB3mTHHkR`E=WkOQRkvBUHdl5p$BU~`%kIl~6tq!dO zajccEO5)C@xd z5GHsW0L!wYavz|3x(#@Xs+6M`S}jQC$hN)3!)3^5A1MP{CJq7fT5+0yN42vbCa5jT zRfpCDK&2?>2guHZnGWgovZjxLK$R@BGbuGcRl8iuL0vDSp8d=gNdgxgl92@c^#N>E z`%DWh%2}Hl>HQ%$<%*9Q`8jsHFrPKAGVJSV>2F&7cv86K&wAGrQst)_1|~^*^vV?cZ{1l8IUZp(YdhK`Xu^GGPHb z75!=Cw>kSl?ngZt4row*P<5}=B2Ppn_)Po4oM8>yPxN{Nqt zqv0dl=ayz#FO?b!(cJi-cXOTS6f>0o{HNVp`jR9`<-jipGhVI17mDoxdyF$&y)zps zZ;SuNHu87xxQ(a5k~5xP;P-I=*S|pdUXL(5-ww~6lIqpAo?P@x9%Pi^l{S^vA4&bW z3#wso#GS|Aa&D>X_4B56WZGFz0x!MB#Hm75F|gRLJZIh3m70X$ z+Q7xRp2Hu$%DBVR@z1@Lwc4NvTh^mFx2$~s{)B+DeXjr!{OkeSZ19giKdt_Trz*4D@0D+ z&+p39*^YSrXszE=!rZdg9JW=o+Lci{a?;^`=0ScH;*|%in4naijWl{}K96?BMsItA zu~-smCmGTyZ`|UY(>@a7uz22G{b?bB%$8#!y6Msa7#!(Jr_5Lx6`R!*%p9#oz60Gd zSTv-T!BSuOqEeufB$(HF4sLV7*Tt}-**R8*l;`8O{oc=-AM9s2sCDb&P+eIJ9BgI@ z9=*(ZbDo&Z26JKxY&&2&^A#bBzBBIT3`}v<0X&no2ES`hnX3OY)3(pA1egL?$I(W}UuAq$1sL-0 zsENYJ?lT_jM;+DM4B*0{!J0`o85Qe4=h-2PDko`vvJ9M|ObQ|-=R9)D#Jpq&yQPN- zq&V8A&QAOtEkAQ*M^Rimwe$G%Mi|y))G#`#$AM_YKpg;2{=OLM$T>VYB$l*0 zJ{7Q)b2lsIJ}xGDGH^)exaav9G9|V5+1zI-#CS4Z0G(i>19OV}?W#iy%z~?D&c2PKr##(yXmfwo61G>)eq6r}Yf9mAfRtgC+F zqPwNaj%8b}cLVKbf6cwHfTB7d=fyL}?kq@7AM3f59naj%yG31@@Y+l9n(40v=emFk zf-X~yeNrx~oe-~-Hrt8(X$b)w93C|)`ccWV<@MW7S;^LkEb8I32~6wH=lgsdR4SFw z#pg9Z$wmlYjjKyCBVZ)5CS=e)s|>5Q>4*E`-u5@6AF+?EDfbr^U_%c!g?>F6HdYVp z@KQ_F>Y?%>Ei;9!ip@}n84Ot+dDh2SkTvD!JZ+G5RP+`rES>5&ppCwWvoCy-9+N0f z)8?A4&3R;_A z^yp5E9NqjsL?%i(EoD-(Il7~}WHw;jzPO|k^oe*rT{`SgeZCX@tmc3$%Jlid|$B&hN7}2 z#GPs~xOy|MlMH*&9wVy#0Qw_Izaj8(Rn{n2P)i&v_!h>Iq)z{&`7=lemNWm-AB^Oa zF~-bXBU0y!V_-!R-$N)kLLpn~oCqD}-ZO40qy#5{`>_br{n2lRiqkfYF zInw-e{yZ%9m9`2p!S~gH*dc+lVvc&<^mnND*5JNWj?P018E?HnZYe7JR_ud7zXt<~6q!gd3`8qo9t3HoXjpw;F_dAC(J4@O*n0M$jE6iFvN(`Ibwv~v$$2V0<_R-TA-Xm5MqJ>}lu$bSZq{%8#UQh5#j5Ac`1P=jN z>={0`IApeQHG&0hwr<70O3y>Mm}(|zW5BbOUFb>A`YgYz@8d{RYmT-}hi5mAr}`J1 zZks_FKLa9TP`)})=xywm%B|h=v7%Q7!DdPHRV{{0vR#@x4};kV#!2tuvK=a(bF9x< z>k<%^1WRJbq1yGhI^&g-k7;?fdq0cO>)-$L-`Wa$rF?2uSd|iK8NhkcU`Yg&9@O#3 zD=r?rZ_@*TGRgHn!|bXY{{_av+^69h?ePybw)l-9vDbgTZdA*H!&mt z^({$TM|?p^VT9fp<~H84d%-{_1LdrqS=#=HuCkSvkBb|qm$svHIhmR|bLns1GhwrgNAFy7YE%Ht#whI!H z(U;iK=z7VL6`)ozfR{+yYPP%5u=QSAVo{$=)ltoTG80rL+Og?8N zrRB3%F4Y9R3`TRBKyK|kCM&Gd*)^N8ZEb-14>ECy)le?lRtc9-Ka`)32`2>FLx5&0 z3}R?)kC{kYem;%@dvb8v(1ukza5U$XyS9Em`mgZ-n__~0FjIn%12JNYZ2yspqb`@& z$F7)vD$So%^GdYEh|=i>Bt(s4-@=n-0`pm29usr1YU94-Ll&_WLgA1p0o0wefn8ED zI=!|Bz+UIGe>*luQZf!CE*SheF#!vphV}uM7aygXF9>J%j`xQjSbKGSi#KdMVEOoz z(gC=M`&%G%`m(z`e}b`kumvkWvp{v?<2lojTs4;rS*&e*#VPPfD?@N2J!z*qA;NJ^ zsTz@v_rN!#Z*-l2IPGW|T37^2RkQa|l0L|BZHZS4%DAUZWM-C5bi%&IhqGnX0896* zAN@Vj`{O)LZJ+IM|DJL4#Q@k+xvccrpl*~*uEFtZ`+tsuTG}5fRY#(catM9^)t*C> zKeOj9tSaC5nwn@gG@9C+u9O>HtG* zVs>~gNK0B_Vn;kfuH|y^VBOe7Do$Vg9W;Lg8ukq{?e}1*dPzw^iKKsW_{W`U4k&m2A~y^mUSVII=vfTYEaz{&JB*QtDEB$ ztu80l#Z52L!}p!Vd86kIH(E>9B-43|i)(RdaD2|t?Fl9;s8I&uZNJ-? z5_i=SNO@lgpGUTx6xAkrJeLb|SU1+1oNZb{%lDbKys6fC|7^EMmT{4gT|9woF@I;yd-`H+Ef0pO8(im!T{>(kgy9yb74spxS zKKH30bE5jJU!=H#?>AF0Wo>!UxIV~I26k?i18cB}Rmjzth;njc zG@r=$AsfB)Npf^gmba>?-eT?tA+ zZ6}%F`@=$&DA$`?whVjuqF5WS!z`tT&VY(Ckuh*N^LQX0U`Q(WpHHolOag*D1c%X8 z8}J8K+4?jJn=aBYqx2Cf(zrK6Z`$nz@fn2aNy(?R&be}5(Dr++ATTYLi#p}ub5<%Y zFAg+;+-L=*Fr?Fd@?~syaEFD@tM&XyUfXj4dc*oEL`Db$gue7HTbm3LvAUgG>3yMdBq@YASan?$}fumezUax=PhpmiNdeWhaFBP zv3L)Hhmk13YN;J4JlvP*Wf)w7^|)=7^-H4VVMH%84)HO7F{>%nZ&c6Opub_>{{iUc zLka+bGJMZ7HOyJYVP=+uHM7;nQ*7N+K9?PjwXbV`8vQ&-(YvfXe@d{Oz_0qs%BExK z?NPx9m3_C(Dne_b&cWm;&+AI2^GMnH&@q1m((il{ zCP$tx#rau3VW2v&p&ZLj&F1Yj+MwN2}7-?JfmC9(Rol86dsdey^bEq;9U z4;(efT*&55Yt3`0A|MH{flg`qwM`w#iNvI8AeJ`x;`!4r9)6L)DO{4<5i&U1=bG&$ zYKZGGxoU&>Q&!>%o!nCVI&On{YFiifIx+K4$N}!kRwq^_ncHh`N3FaJQGY$7tj z;KW9aig_1Pt$q(}4we@wKGE5LNs`MJct6iR9>IS}=#XIB#NI(jT0EzRiy9aDXBr<@ z*p(Z5;Ok@Ozz+vv#kh=XC^_ld;NLNsC21=etHhwzJU4omL>G^O2hK?aU(ZKB^1C9o7~`&<-ejU-1c_69ztXo?osXcVp@>5JNIJ1m(P^?Ff3Pp$nU8B{qO&=qEM=(a~TyYRKO+9{*`tj zyXFQQ2+U^xFhI+UmJicx*XL5_I{p(Sf@O*)us{8*`7-Tv86(X)L>_);4x|t94j|(_ zj+ycd~amp7m@97-hvLPAuR~Hc*=(Ms-^$U%G*U zCRw^RgO?)&%w#5D6wXL@D7Z+ce5t&Y7C=P$Dm-r$QjQlm|}A1*|Ng~ zF%gdpC<;;ykR6?6tDT?*fK(JWftla0wshA2B*T`KD9+;XH7CJOhHlhWp{Sf4iE}`$ z>{!mDqn{G_&gTq6g6 z=tr2_C9sw-;+}H;1oJ&vj}ykWuH#{_Ue+2e^Vz8^`sihzYDWFsfGk6QPSFyhE0-x@ zcR)#y8HkQYFLY%8{Bxr_q~|p_9fIVqyzGFst%W={$l)HBxt8{`XUz>YPeLAKoWY}Nyd0r=!P7v3*+S(1vgUx}`34Y7(fC?v$q2DVneaq0- zpo;8QBVqV8!e;~OCAN(qI_qKjpM=nKR5av+2pIe>A;-3@;-fnb*7ue8CxI@yj_fz& zw__jt>b4;E=TgQ&;^Wq@)prF(G+2srOnxSR*8a&QrWHHpb9@QZw{*ItZ1R|bX!FEK zOLjxTw}TaTb%t0^a35GU>H73tzXY%N#iJ_^Q(|UA8Vz#K1%461GPZ46f^>P81iXz9 z5(LBs5_r~;Lac3oC2bjVEylH;ynK!b00%NI^Fvgk#69?l`_KPYY9IX1=~+3tBw74N zh!bpU-Zo@=&&O8l^BI=!16G*Td4sKz^DF1|R;s}DQ=^v_m=oK0g^=Lo($Br@-o zrJxCB=&vT8D*SWhsutwQYod>db&UhbKQN&*nI4($p$`F=JMcR@^M9^B#{W+gqrjA( zin=Cg^hP%a`;4td=W+8SoaCaD2b&U^sn7S!EEe#rjRek?t;&~JDKI;;SUn=J36PQJ zQSD$K^alU^%DyD#(?e+?P-JY_AAf9qzV$$4HLLU%r%>uuiroZL0iOM%<$p&Ob6ts9 zp2MVzHrbyV<;JJ6UdnB%6%SsidvV3>-XA!lLa>ig{kUvzh`b4^iL6DJ@E3J`dd~lQ z_nK5OS(abPWSo-BFJuWEt@@uP5Bnl|#TH z0;knnz-G!iyLt!EeS0m;xN?ywt??TFUI_xsYWIxlfwj*6E#sC32-(L29?Cf zGjy(TuVbk?0Rr9ocRTqWK`rjZ{{bwORP`<}Q&Y}cBNZ8n04@UTnE>WlkY~aneRU#; zsVjgfZwh;wAp7V(yeuCsVfzA=F&n%N_)r@6UVWTZ_3epXhVA%spZ*xDG1#)*$S@dZ z6AlDJcJxXHEr(J@mp30)iov=?!xg&~0R&`bsEJ%n&>YlRV+YZLQ`d_Bm_dFQ)?oq+ zP{p7u=`pyWh$F_{3?i0f#9b%~e#^cThiZrQcI+Z&s+QL@mPVeLkbXqlU_A6BYf{Q@ zX9$n0Phl-PzdL(Z{=QZbELba+2I2R^To0e!`u)wWL(FGuiVW0i)W3!j{X+Qea3i^# zw;0-0UGLlv8DDMi?*JuikhEMQQoQ;3b!_5YBOUVf;W(0xeM9S z5saCEZe>7GGAzk_r7SIaWuP9C%-J}9o(CT8^K1OxIA516W3Q1RwU~3!y3?}9I@MXv zW|FcrO0k&dlC_6?K`?1$nf}!G3zSQ)KlI5?xiNeQ@uj*F43~%KgNzgS>)Sb@fmZ zLxjnS&8wYo&iY2TPzaxhBjgSb`aLzOw^YYIqB>O#bv@P_ndjX3(#l}YbKl8?VEUxz z67Of$UuEUxz)Zy#Z1vn+o$4nfVw52F4PGjU!}_Pcacp;O;SK;-$Un>4t6Rll?lKX} zmG84M#tf7KzsupEhdrll#d49F4a*SrymO<0im|0mNCm^Mo|<@1Y*{YrVip^p!vUbB4n#X83QOpE(b6P5T5PCb86^<( zb`2%?KObERrrgSB-%apersqeeGoioMPJmO7wEYXE8+&2C60e*hzT1lO*>hi?jyyPF z>mc|&ZX-X)VAIwU|B5%@mUEKaX4@|J`+D|JMHh%~H$&$0%)n07SeF)i=7%Kd-B>a> zB$Xp2k$`)^0pHli#9pc;P8B%zEFP(6uAUHcamyhBlX(i9KdXc*!0YUh#I7Z|!hV%T zdK{@fQ~ziy_%h`oWm4Xl08%P4SJHVCN^#*5L<1AICE~VmjMz2`D=iZS#X{PEW-*QZ z3^HE{Vm6XnCR1Yv_b7X@wT3^yMAbTV2nIbh-3?TJ|9o;-Ngb)hhJ?p|Zs&J#tRkpr zw}DkDliQ`*(wG(Y5K#=jsI(ST#`os~RAjB9{=pWTL=#h<2fJHEWDnpjc zKxrcPHXMMALm&Hlf5v1E;1BUPk{J~fKP6Wclnlh`jiGaZkrLQ|q5QpgMYhADW5e3cW~jylO-PXOdATjqHsla|B&%oO zYZOq_qwmiz=sy5#&U=_N58(FcXHb%VCuQgrFh%CGnATfa^_1X-z+VL@q|)akE7`)y z2AI@7lgX|k@Fd8g20dLP)6(Ct=Xp-JL|p?KC!~Km%HanAhFdcH9)jyymU{Fqm`G*V zl2p;*=;zw60QgbS8?VwrQqU3a1O=MrxfFcgEe%?{< zV28>uCjCvjR9-#$rR_r07?ItneqG8Rv)q1$qtW~Ob3l#{GJ#btAJthBMBPiWx!vyr zB)QKmm+z5V)wDK$cait(8KytnA9JTv)58=V`O24Mf;)IiRD$5EEN5f$pZ(!xgQ6k6(t*OQd-=3h^vEtSIdOwO8&>*9JV`r}IjupQTzhprp<4c{z{TU%g~<9o0P2 z>liyj9?vW6q4umCXr?co_bjTwAayeT)e1~yJOUPJ(Kct|A!{^~TsV^S2a)x1uC1*`D0$fUIin{Dy!Ov@ zViY~jv=bLZ%wZidu4gO7(;nw;l-cC(lg(t3QUPAWu=AolH8w`~pJ3i6HXq4;^HUXl z_wSws_4By2m|xi*$FN8BY}WCe@^A~So%=^mzvfW3XaPFo&xxaJE-JeaeaRj$_D9yy z+mrmz0pl5ZF%l)-IN!$x_mod&PT|`OoU0pl=JwFGO7$H55X_@%#Gy{_^GeeBBLIrS zKa_D4gaXf_(tC;$i;4XN*kuwUy~{7g`qXB>4@O~2L~{H9PdkwG;K!~G3>XHq_||IMv{2=}VI+&c475e5`S~L=;y`(!eTb} z<;_I3Gd{+Q5brkoy_Qh}H%&p_SkLFBj=V}K3!1;c2(m1VF7uIdr~t@WRLCZO%)2^^ z9ht{~5lJwQo7n(V^}G%M4;f*lBygxEAR=ds04&JrdtBF8 zlG>>zl}bNkEnql-WBUG`{fpbwR*7t@RdXigwUG((4)0M@`X%#U+j;u`0QalE0q-Mz z==GnzBk2!G?AQt@rE`0FOCcDCe>3Xy!pFIyxpoGd`NlaXh=-&cZ%z?laN?b*f(R0S zDapR&@BA#o;NH2QsP(aPa-iC3_cJSYP7s6F{^$dy^uEp{Dt9J>D$cUzu90#u=j?e1 zf-~+5_2W6<2&mA!^m^CMo7r}%gZ!%?!iPJ9XjmpZk-|_lpzW`n_}PIJFKl;Oh@x~M z=tkH?1HVzQ>$3!mxiibL%dSV7qo#V{C96NLHq%-2hJ}cE_1F+7(2W0$=Xl-z1pzRC(4$W%zV%D(wLm?;NT-nl*mLA1#?! z)3}8C^NuDpAwh@iKV@xBRQ)MSi(B$)F%k5h=n4U{O24cV?AoM2p{sAp_93>dn6p7& z!ArQYrMh$6x;VAnULj}oBr|`IAG}8;@J0`RCYv(AG&V3ev>})^WR4-avVJcZG;^~0 zFD31vxr_s5w5@y@vS%#L946X2GR1xHjg>e6o#{kx3Di&BDfGwRwK_IO+h#TPFK?yI zq4v3Ttkpi1iSd`@*3do=!BFe{3{`bt`zV0?U94$4P|;BCCi7=XQa!U-Z6!Oaw3?7~ zn3A50qq<7J6W^CXeUF3UcHldIKIaUAZseo7jjtbU1@~6Mmlc!I&X2R}t2b4&B_ZWC z%1oy^7u(l-Tbe#`h=@(bKJb-36+&li1Nj^LL{a5*;}>0b*S69Hlm2`6%1io#%sVCiK$%bSR>(Z;>r;#GkEHV);$5GM z_0)599O(P^s>`z_UdIkQ5Sw`?CwEfB)VSi}9FMp!0X2zPTWPy-%zOY+K&`*VbLohD z{QOVrPow(pfB&zl>{JfIk}{%U5K*j20T?GL-`5a1gW4N3IGFI=t?T3uGmNUrB{!Us zk}%ytftdKLjxw0Y=Tdq#qW5`}Y0AsU=kV=v2+~AQd)%u_FGNK6);wSo%Ha9!>_k5+ zJlV5Zl?>uQqVNn&rtpmVrEQnb2Ng=g3a@~y98*~t%vN~|f`^jj7!SC8_Gi^%fEo@| z=rMP;40cQDw4NDd{+F`VssThPROT1P3X765(zVup4{?5J$e{Gsu4P$!`Mu^J^9z6JpMC zpB)C`<1auj&vamiBPZqF{2PRjwi#q*!L84o-^_Q5dwe|`IHQFTdu$v z2ghgJb7iB5BMS)x$u)E3*E{NSwkkq05wsKNe^SzIzSoK`wG*LAArsLfix~vv zVMNc`3t;xOb$+a?Pesod4!VLM2?Xk3hYJ^B@m1z9)Cp3b{ha`*k|>!(j!q&R03P!& zrr4el1RD@F=?$bj`CuBcMOiI+GlZY4YQFnpJL?(EuT-Dvs&mqti1;GI4JZw;OyVw% zYw9=}{quc=+$jk;bxV{E1^BtU(#||-NrwTKdyZ>oEHtMXO7w8uCj`p<`L4NuBQR(T z4ko?%*xau_aZqYN;8JuC7CLoy`^dB3N88tAxKl`048_U??;w1*($8;jenEZ!uHWL6 z^sFST$?r8AUvuzzy@zZiF{CAvf4arltCeDx0s2+Cd6sQ0l zY_=V=?l}xYm)pO0jw_&2sj}IqfNYJ<>p-pd{97|7-H+0)Ah2GPrNJj?#pv1w0*k2T zq#|*o%yT&-pCj)i?A1yb7)rJKnml>{^)L8w=FZnCW}eK^*|q}@N_J&K{B3m2xa(BWu4a3c*0;@| za8os}-<{sx1q8^uX7+r2?K~qsa0Z*XDp}lpN#KS;PXkCY_&b4|5)AZ_DC&ev(3UMP829@Wc(R-q-SpLdGJm(+4!7WWx1K2<2eYYD(>z2 z_}GVW91^^z_=3C>_qeTmU}&#@9*Vb&g)hF)o=@d2_#d+f^W2|_{&zNnX)TRv7<`XT z&z^>MYe~!5`OdKCg$h@{N%C6MvV+VzQ|p9-?Xlte%$dItd9z=74%6%REb%YJTOa~%#(3_XIr=(`8s`nX3x(6 zCQD zY{z0qIcS^LOy*P@Z9eBZ#JmSt7q2ffn5s5V@43OOWpMPqXL}3h9m=C1LedY@Ly1vd zHV?TUvC=Zu`+ z4V&K^I0jT_BK^Z1)i4_&(fTn1YI%-x^6#g-Fuh_!MsCJsnQ@Zo6UwTzCp}`2BW4o; zt$>>yXjnrga=`7qGclSoN;#M6W~CN5H4dw8*4s`cGVBVB$a1ozQM-vZQ!;bGSk|hc zv^cKBB$cZQss%BJ@l&4vC_~sZ?yqi!g-yRZqaj1FZ15UjBJ|w)(T*F|u1POtw*`pt z^Is}3O(ig%DJ=$`drx=H(eqEHUgli*vkpDk^@{#joL7QV?2v)mKt4E&RQ=Mj#Pbe- znE-98M6i#Ao(LJ*_M`SNp`Dx!5bM{0T$uO(I|Hy}LRte0J@JE;-~>M*fMm~h&22v` z>#ocbVc_WI@I8~0!Q^*>&-@^tbue(|B)FMX&* zyNOGtTOrpn!Mz2TQ-~~Qc|uN7d;}3yw%!@$-Ch@rhBX445XwV0c;&+LyZ0Yym=N=XaP9@e-(VY1rx3VPjAK-Wz=JyCJ7+tKTI#3)|M*&Tt>r!QQPr>K6bg z^_y&qb+3|>pp8i#Tx`2I_@Ced%ZKl_+UL?ex)a``%d^;HXn&}FeSWky28hSD&d8bF zwbkwK_fVlL&!QTkkEV;+H4`zu)h-&ulg2`U)(!RNE@2K?d5D zoCyr?Y>{DToxj7+)tgWf2kF|9_A}CqY9UifEkeKifLtY8nrGmgqBN1@Wx? znwWlYS6V!iC3Gcb?++#Gn3@?e!=e9*Y8~i!jxJgBWVuVP1Nyb8u4X8R6yvX25@N>o zEtLh^TmH73Q69~_3_TPjy|JsaF3@(Ffq{cvStNsQHkr|}c)Zx?kV)=SpS3NSzCIEJ zN${am^AO1S9lCPg{tVBFs-1b2VXDu8gljFqV1m{spUTt_S9~fV?z_c`hLNo_&JQhE z2m3Foj#GIjiR~DN@2vGx3EWK;Hyh4sD<|TAO`;UXiQa(`mrS%#+_vaI56_+A4&$=x zg9DH6{-DH7N+d3nPub7QCE6Xd`ea9zV~I*!mH(bp+(fH+k7IdH{J6uPEwM@wo21GqcyUe=Y2uyiH(rTN2f>O=8Y<63*p?oSjSM%`{;8g6uDJCGD+MnrEcngjXWzRriISU^0Bxq;lYFyx=%M`U`%a zKV~C1R%v|usr2?5CblC_aZSDroKK&k%cfB#n|rrMH37J7}>dovj14OI0q-4cg5t#gh6#>r>?t<#=LNn>e)bBxr} z4wS6>W)+$?rj+oY^y&^e^gDW+&K5 zHB9tn6+GQ>Haps~QLnIv7`iU9(#T%^!bHuhuCrO8w>%&(>pXg1GP?vd5!ks|9ZmEY zuzFB>C9pYrpA*wSmh#e>{O`OktZMLL%7{%29UfsQVY!tASuGP5YM6G0_Y zJAGMv!T5#!e6?A<)?6~FZ<~e_j%Tx7QuBWPJnuQS@Six3(5)5H=Vp3+N2R;7-uf2V zwL_1!vHTq96la_<`bt1KJRf#}662$@KzUbbg{)B}QHZc0^a(s6DH9O8df?%>HV8WBzjW7tj9QOQ+2SOV5{KR6Ssd24*o?@-p@hAZ zfleb=dL$b>WVjAa`OHWMy8$2_)^rI%4-txqrP{*&#Dibs3^yl%1f4}j8_08BH?0I5 zjG-?+r|f{8B;vDl(&ATOYB?J73uj67L5H8SW=NK1*;g|+gK7$^2|bUtJ@_oP~|B<$3J8tIeq z5|tm$K&xZ_@_;%2xq)=FdhEC7<^FQhb3Y?{&_e{SUw^GvgH1Y-Dad==vTBTHLVP6m zn##SL?*Q}_K+5mOsaE7S?-kq1-A`=cpv(C^f(VNNXCT}BQzm6pVyCyYRsG#_Zqzbk za%a$sZ1fo-`r=Mrv2Jn-vpyHRL-=y^{x$pVmpky-I({7B*Jyg4Z2 zOt0=wC5Xg^o5l*-;npn79ZyG)=Z(5~2CB%$sDeu;Lpk=(5`@(U?=BXY4}KVBuE*|U zkKyu%+UNDUmnE4BbY3Cxu=hJa(OSEtXXSf4i5v(}aCc#(QY27SyKXO4qrRq)!Uq1; zq52P%x_h(R?w84QXdE8zcLc;U-7jv(ij_+@n$EF^91olX0_3RY*V|^poy@zTs zxX-#iA@d#r<#Kj5tzb$p^@%?ysmANlc0D}XpnIRhMlQ?hgEsoWsgV*uKUTbU@xALG8 z+&88F3Sd#H)S?S&u=M!3cQyHx>fitKKQ{adTbUBBSE^@OK!0#)+QxJMyRjYhF$@{1 zamv}h23RfIi4n~z7i^uf1}Q)ZJG%yB)-!*8ULO#^KVd0VVU)DL=V5Fc>HE(ChgtLB zH7MGfPv2#o<5qyWhN{|tugfg|jHe0w#(~<>%^?0fPk%1l?~t&eu0jJEl*$6UX`F3^ zHC<3mwn6!5NRjF#TC9Br8af{q3SoRZ{cN?Ffs^b!eom?zyo_!iiavnQ{#@`#{`&-z z(LX(^`TIq3 zdJ>gEI1nhb&0N*9WX0Dw#ZH(n!{T8q-CFVBP;cPqt11nPpts+&{QPeh?IO|I8=MvL zbBQOdPHr_pY1vmh8raKv9k?Z!rSifAq7C@h+^TY>0V2?cArlUAkoQ8avN^ydgde%w zv-dMMySGc<&w64mldwR<=yM-fdHS$@EL6Hk8(diVV4u zbm@5l1|kFOcE%TcD{k`aCUPl>elFo0J5Rl=CGOz3%S2hYpdgHpYyMTrJ2!RlNasav zU-kQV@Art7v|1u8gi{Db+v&&hhU|?fMcvc2{jwdJ1vasBt^%UfgdWpEaqhr0z7rBU zb9yd;zFm|n4}P5Mn?&Z(_KT9~9DyvqDb4oJ5$HsuQm)kZEG-a6ySYRrW4i9#@h_n|NdP; zkOQ=XcV?ome%>X*c(+Zj^tDG>ed*1>i)dJ)4qGiUo7AT{@UzK#Bw}MzS(`=Iq$i!59#o8rhGXN zfmV>U8njYA+H&zTNrXsgHyMZ+S14;+N8RGl>(i$WkBhAtDNJF-Cyj_{#QEz!@shV# zTl`Hr;;g@OlLQdzs?vFXj<>2jlcX;G&hupTp1GT}zD1ji_jXnd|0V2Ql7zdLenJAp z5~uz+=9@}D;=1!q_^wS);E$RX$-#K|(*Ao|vc-KL9la3diL@>i^wFsavh@E&a5h^@cYX^qk8#ou%4(FxJ;iSL09^{a0qc6bS~jRO7$5h?&uH190W9?K zL8WhV$j0n2ih%VhiW@3W#Ai<}@#4MoIwlkiJ46tDbbExWrE?CMCxCF2j@LP|a2~}D z)@GJtBkMGu1E9;$p%xj=t4u*}iK(i}WpTyJmL2{M&^fhbAYq)}wqT!Rp2)Z;=Qq;s z^p24WK>$ncVKm&^o5zABZH9+XB39`ao6(m+_qkjLmwmL8&ndT`NOp1=JXd}6%6&(5 zSl<;*LN@5gv(YXue#|uOX+O`b@+JUu#!4Cu!QGtu*>+eA9UR!tvb!=tSUUaCyH}Ja zx{uSp(^v4&?@CWajL;NQi}``a&g;DW*(hMScg0Bq#-*a{Eo2GAxxXi14G2Gttrhb^9-8#FE{>nI0Z|@)<=@ft9oUEAPQTobOvSuMRjpI4 zGY%N~l{C+S>WWgtK}CKZJ6WNR+55VygPNHXonZIf;2&x8=P6FExAZa`nG=S+&{Mib z+qI-#XZWXiA<-RN2@jOL})qk$j4;zJoSZ zMd|Wg?N{_Yx1I%16Cz0v1!Rgc9IxcxaWF$*)Yvq@sZjOETV($LjHeOPCq<^{XXNo~ zq+O3r64}4sZF_mjA2iK*_QBTOEYVKVe;GE%x8%~gUzfVKXK83=%kfmrCXRgOC}mAF zSSWL0vJNl~rm3iNd8!5Hh_ipM1L)VSJbH`rW|x28{en`;xD{KH(kcO-W^~tb$^jhN z`opTV*x;sZsL;itTpX7wxKv7)$5Y>5G7W}jMNcIY5pO=ChJ-SkBCkhCFm{WDoxXpoHx_vn=Slb&g&7Qel^ckgE<5z`{h9dn_mu3{QvvWsm8p;m0p#sY?&NYh(EaDqRh&jnWQS{VrmUA?(aWR-q! z+CxHUdWdHeF!lyIBg)iOCPAk39E0b;cqg@-fhARgUyDByRU`hq3}Flouh@pg5I?;susVc zB)kj!qKT2#65k9Ca|?#=wIBP(l02JcMEmYpJ+VzZYs>Kb*w;ZWA%7%VleBj>Ukn66 z5JJnA*S}cAjMt6Xzu>4%XiOwN$y<|pfyuxxWs3n5rtvo>RYLAbBmMo9;jtC@idpE9 z{?Z3F3hCTWVSJ7&D-oRYx?&@%+r5epc~$(479VWP9VRLE%81@4_e`!pPL^;kaXwc7 zRO6WRO?6xmlU1Y-q7bOy>I~zx<8qg_LZp0lU}T2x;nDIkt;dHoML7iSDModjs3@iO z^}J$81lergZ|{rfcs*Vcu1gxo89?LpFo|L?ryJi`%Z#HZu1ta=L7I0#arj+$ERkZ^MYx~)G z83e(*aUYk5Lp=>c^8TXuQ_}H{^E0(i6D^9vhPP14b~A|Rnj3x2jEU;(9ye>pV$pa8k!Qm_*_Ef3B!^WE#DvffR&j7-d| zdVHUwRnRk|7qZFs$SS6pn|ZX33iXn>>*oCra-Ndk9#6}Utlhg0qmSdO(uAp|bbJY> zPA}r4`n$%}!4ID`7!2+vQ%~I|+I!yHYpM_ie(#ioo@0mdm!Mh!oB>m_Ns(lPy6jl0 z^6o@;Z)4_eXT7V7(T<0HD*k-}Ac|`a@e)8T-^0{TX;*NY1i?lXnequ{^ZOAX)CYK~ zT(z;Kw>pp_Hq`5+>jW2DKQX3WFIU87aejUaja!u@2cGAxJud?hzt4GZNt+2f_lnLL zF-9P#X89dmAWi_&BG706Xw7xD>6eEUF$wiWuzkWnt38awlqND z>D*}oJ@AvRCHpeESS_4C<{kvpQdpsjO!AAyA4&o04QAh-#_n8M^t$F3Ft|x29 zfB1X(HBV$>R>);=O7E^jyo13YB#_a_{s5rt3wi@S->-v_zXbf)$h(%w0n72g1WB!@ zrFnnGJmOFWY*N@si1s+KwRJ@{`?p?`^7mmY59gVzT+@tjA~Tplg6XVXJJ=s>r5u+5 znRRu#yBqM*wjpQ<`3Jd~@$M4u1y3Lb^eueLjEZ4p)zY>-AY*<0 zkZ-?34;WamriY52g75>|=MJ9f6^+2A=(bf9at1QPgNhsc;6FQ2u%-oS@X`<%*QV(X zXg#wsV*8%q-w@SuLZ{h}Asj>6l`WKz1{pZU3Orpe+cc#aGO_otfnh&BkH}Z@}+Vd94MRHOs0U z|L92Xn4L^kSScKdgYiKsJtD~{mYK=HXx15L;pB{=%TjTo0INp;B3LgI9=$?XlAh+M zGO-ONOB~ep@m=KUpry5eq+r!IfIx69Z^;f5c;xvd8_)9rA$_PnI3egFGtMBD}rSl`JItK9@a97C_g#8Xf zAU4@HAg#RZf2Z#qVnf571bCCFTB0GDSAq}$K2ma$o}+VyU*tfGZ?Ctv%%3(NzV+yWd8W5UMG-js_aT%O6L0H-C`s! zMd%>OOtNi6h(-di_M6&SAD#F0JdzCh$!7+zBF|M(y11nnB1zTT&SRw@xElAYS`G`H z8NFlRJjp6?iX{V~RE~I9T`vIi^K&oFH0Eh%NyOo`@6>=_1RU14@}p{Zn=@4M(1!}= zV@6!Fp!SgBu_ytOI{}?c%%BGb-S#J$u%E^>VYNA5M%$jZBz0pk+bvj-_L|- zOxZAmLiZ)VHJde^GtQLanQW+Mbs=MCSGosS3>Hxc9KU*@&Xk}wenX@oahi^^B zS~8F}5zy=BtYh3;!iU^R96R>*OlHs6PAi$wYDgQ~kkhSH$P9KPm75ZoWQlk4`B!8= zW|+IKDfMHb$3Zi{CqGj!dBL-~de-g>(w10aKR}QtAN*d(O9(^( z#W!h?m=NF8#0S-1{}L!q^|wmT@I0xk%IBWZ%-`Ps!i`Fm^61f@&PWfR{}T8HlTGl= ztkm8ro-hTkvHMi%eH{~MvPnWKL#IbIe@@tfq0h12muhW9fpfCes(8PtV6n{J;4YK3 zA9E-@B^6steHNk7NkU=mK(5&>433>=9VemUO z%)v_m@G#O5#*&pkaNwVe!NH2e$cEH-pC}R+Ee9J8&h{#3eSmqKv_Kf#T!-Xy zc`5r!W}qJ!GeA%y*>f-iHDn*;;IE!lf)~(rKIfp8bjA!BigbB)vtMdftNDTrEZ&qW zLs+D5D9;gNS}0L`Hpem;uBXo4X`#=L!WxE|oDJ*^%#i~eWSB3P(jb#ELvQwrQk$6W z)~7%C_S7pu^&eR=zNgRV8O~oe-csb!gw!*_3EiN^&vu8Qxs>zvn`z&@x6FMWGn5M9 z#Y!del`gwFbCJVizPI3{>^6YL z6)x*hYm`2{5GoP|Eg(Im!qKS#P$|HjzM!)@?f~5wzU|VsVUy}^nT7bub+GmBPsI{=2ONtkamT^P40&1 z+y8znw;48+CWZiy%}A1^816KzPG^(w+%}ZhoMfkGL|cxOc^WgVele0S%dA5Zo2pM6i&w`+tWQ1d$Z}#L=0;m!7^&0Jm>%k_El~Qj=5bWFf*qp=o zbZd@0%$MIMv->6^=Dmp~rP_a=$?580#o0*nQo$q>mQ5h0kQJPD?NjTP?^{}$XBOq7 zHRFJMw9g!>qnqlO!j`3-;Ud6mB?J=*oA#~Xk+zqe;) zAel6cG18f>A2jDAspeh6s>)kd8uBJXt&U=!Ly#dq8v8$Nqo#=unrE{;mL3oIonmW* zoiHN-l}u?N$8SMux9!xVf}uqB^+eVcp)3}k57vKGX9R#)Hk1kdqv+?>n=FRoX$lcYaaq#NT#eC3d|tef@Sx-1(U~8szH5 zU-tY_0bp%^KXHc8**rnosLvj=<#*0}s&Q{MSAion_`0ecKNZ-05|1$-Eax`(RlNsd z!GD*k<+Lj&#&M$k&;oz`y4Mo&Y*jm`@%YQlj2=1Ad_E=FHcUq;{nc=>2uAB~!K#v7 z8UtYmwKteA4k{%HUXul*#fVUsw|L_0!1~)>Sh)@c!!Kum=V1p3a@9V@NflT18Cjoe zy*L5DctF(#TE>w|Nux_}6Es6KAo%3xIJ4J7s>*6?<7cbT=@D;H@+6q8fpG&Ibb5vq zBpiF8{@;UfpjV&USB4uVi0gy%jB@YSU!WN+CZ|9Pae2BXS1#U1jmt`~I`8EM>V%u*}$S=5xydiya{UyI$mhnGOI96Cme455{FP zO`#DhCsq>ufjt2fmfr~pGVa%BT&KZDfOeIhlkc5iZUf(vflLu3*43xRLRaVSkCuI< z3~?(qiWOU`4ct1BrRZ}loDSe;^mAEf$ULR!P5`BZ=*e2urwrOgypY*sm|POgdA{xT z>KciX?l)SLQb%F{wQVU)_R4oGsooD@ zN;m&3pxV@lX7#ONpAF)Xz$AKj5}WCgn#yK<&Y9L(I3b8LGP)Ofy0h#7#? z_M4k@w22^a;xL{y$nt&$Yq@>z7w&k_%DXr1kV z*NI)|1<*zCktzg>!Vmv0WiyEf=q5O6)%#Kn!|fy>Q|TQCa#;+TswM}8M;cav_4SSm ziiEx0GxOn_Op4Wx{nPD1pZUkR8`uIED?zMR#)@FTzt(&HtHmTfQljno54b3Nh1+sW z3_CE!KUS&q+xs}^SCL7Ms!J}PH&y%io<_<{5{!eYib@JAcL%)V-)iuGBh?0O;D)Is zcLx9U2Dce3YRe(evyy0$@m;#jiXROgS^a(WlEkpB%^ZN>v$`u+g&&h_OSd%#G&1++ zvU@fIdUuvmzP}>tQKyO&Vdh5(sN%Z=PH%-|?f;`*9qeJ5u~1t-BlcDv#O*WNV=_^F z@iw|q_PFJBjwI;Ar(J&B(@{luEsDRtK(=*!PahBoMJGS|5$9=#z*riDV zEkw+to>ut0$d2_ya`oy9v05uvsp9Q9dj8PkWqBcY3EC{95bq1o;vbXK^33Unc^Xwd}ZT;r_ye=>`pyl;+j})S$ zRxg62otUc-59jk&!GQ7E$C}mWsJisyo>Qgd?ezT**&4~)dU)P^^j4`-(VC&Ff3Z!O zgRuRhzRzbZAa^}{Cl998^pl7UIeI*DoGs=?2m0cVn9lV2f-I{%7B)nmI&qOdE! zLwpe&hT>ROTK(9zH?skHpM4AhHdwd3h(uJ93(|{evBG2(I-Ias@~KBXFG0rK1DY6{ z(M|5T2q;?uQfL$avNi5c!=eJ{6C;)#K`D#}3`iZFdHlT(PBDQ)dbY+VQ!%jhS~+5* zB~3OcJPxS;5bjJgXK_he0Zk`x^Q6t%%0M=3-qJi$R?KC8 zuoDmS!SuDvp(2xcfoVnnAizjVd&C;;577SfF7{0Yhz z0C|;vID<+M5^y2F-Qzp+&m6Khv(3v#0*nz@@eZB90Jma2b$dz5W}~Nl|H&TjR`|VvkWfK0_oNUxBfS;eIgm4l6Zdx=eBn8qoM zdt3uL!hC10NbKR1(yjdP{UVvX{UR@SbpxLM<-kXJ z-~IEQdk}f7R!{41Oi(CQL zZGNZyUdNfc0FO{wli;#O`cYcj_lz%rIJT9OnHAUGPKenZ#)({as>qt`9F+!C@i+?@ zxi1p~d{0`I=KVn`)Sjz3j-SQR@OOQQZP!`S%du>Ll>7P(4t>U{+=%|1=>=FB?ivu} zDhGzFb!wBizZv`sw*Iu{Ej2y78DMDr#W~aC@6RXGDls=K zwZyFb0`l3z5Xxp4;5wCP40`z}&L^eSe*VIq_XdNTHLkvMeaI#c@71aNEBieAk7r|< zdan)c*~3(?-3&+}$q_O(lRhCB(>9j%n9}ivn3~LBw4979t==bn*d(NMb{xbwWykmm zFpO&LQ$c3js2?jZ2a?x+6|)oqX>)zZw#MyE#U1$bp#f*8R!LPU_y0+dX+nIR)t8Ml zbhMo?mG5{{-{cJqU)`;vp5JDnyRVJKbF(psI|xa)%(ZTn4*o{GTjlrX$B&Zec%8NW z&R=@C>qNoVRo-gAP0p#Voggr)zhZ;LyO?WoJ(AM5Y_c=N{3wZ_Ov^W4eepvQ^+LZK zuGw}z2YeL!v;N!Cl>+E`!MS5!By{|okd1z)kgwWdYu`XE$qs^V;?96t&nvV2De!Ea z(ogbS6mY9o{?S`sQlHlR2fXE{xjI*86Pdxz>iApF3lnFsGuHsE6*z^DFU=+W_>&|h ze_%n4-xIZ@!rQ@X+~7>@FhMD#ssmqKIkRS5ZB`HD%oD`ub&0`j20kZaP|$ZRo}UkH z_5Vnl3gk8dQe<^rW-Gw5^i`9-rKu3jN|UzB0_8*8l$B|0%t8(e`90 z=XmwSiy?@8OJZFTtFvG`OEKans%U=r4uh_Wb>~k{BVZF;_&#wC#TVIz4`+G8QBz^nObjB&-yzXbU zY-D%3WhHAqWEYP6(3L!RUB^`hq@I?K-2aBvAFRJLB+*4{mbFulUj3x=Yz9m?wygHZ z8kZ^?WtZQRO^;D37pHz%bd3#nh;`u|Kyx%TJOmO z;Q(6XNOi`p;6ibBprfomJ=%3u&R7CsB)L4QbzZmq%t(Jl=v}sJb*`*VEKb^pPWgA4 zd7-BO-Zv;JNVBYm40~;$l&GFNtXt;Q5U6JKeY00^gLokCj_q649u~m#)o~g35d@qw z3NR?@aZ8Y$y<*@vU&~C&>m#?%JDSJC@p_JjEut6U?bU$54Nzv zdbhOehz@0lN!6jhhwNz9HKvWhvt_IwFNb%qD+VKex~vO2dYoC9_*ptzV~>WiIXqU! z4xLnt2q5QX5TW1M^X>Z%Elz*=xD>nBf5f-!rz^@5T{R|zgd7t+`Fs;c{O_(iNUrR^ zGOx$)3*<)xUKM-jLzn;%DE;U%vD*-UObq5c|0Az5ygEDpQ-i_W590kEKU?%P?*}0o zd$<0-GPx#xRBI>wEmR2xn_*{B3x7X*uBU0a8wh+kV4L^3)698p>-y0gR~cnvLaDLg zG1IJa%3FL0#X1huJWt5Mt+Ps0Dol}m^Nn-})D!!mC4*+lgMH<4fv&ba(|;uWmnxZI zva~gxBVYp9_APA|J7JoDx8xO)9Y36G1NY)pRkvNnvulivoDt_<0IE~clfi7kJtDJ? zy(`urChU0B;4|TCiuIS*Ec))ro{E8sq<#=tK5!`36@j7k3Krj=+~m8 zoiAEPBW1<3Ws=_`L9%C}M`vCw1W16bjwxLkP3sl{EYY^(mcd@!ndDHPSKVGvc1HTy znuDk9Uo${9vtoWj;-#XIw~D~_4_}DCPIceT(ZIIYFcjJ300961NklyC;c&XDHA*`HF#h1kcEZlG4yw<5rHAXy|Hj?}EL#&j15IrF3H9DK6RWi;T$-eknD zhQ$2wdg$=oPeHE#)BXwjT<7TYt7bi~lY5qd6QM=FmROHrj2^MK)3XAKq~1ef=Yz3k z>D2X0)@S4Pzk{z0DUi7h5~PkdmDI`a*}f_(Hs{*AO4Uq0!G~}EN)n(t5yH3%qI><} z2~I8SR~g^vSF}^(L%UQDBuDIvYF}@Y3DI5b&pdY{QtVoAMLuDQt;jR#bM#*${RF(j zkGKki^FC?sa(oz!WO;YBz>;3{9E7NQ=Fu?WZSp+d3XLjh+q;T3T`FA;cI|)v@BiZU z7F&A9<_)HnWvOHYaW-}Pas}&x+0z`%7AphVoH7*aU98O zGrUK>7y_poEBTC{qxbdwcprRiRfC~!KyuV*Hoi#(jq)r4=)c!lR;^A+z`u7|S=r~T z-KgqMS-UgUF6pFtL|I*=0BJHw2eRM?Ktodp;~nx~RuO$W@6hYhBmMb(yN`z_>Kd=L zyQ_FHcAxVPpgYJj{ielw5t9~8`FgEB^G<^tExyNbFFu_kz zU2@+Sjj+KO%0yE|5(iMxe`a9t-4z*G^IV%DSq7CsV#D1$7;b|Ez6Hip_0fkG;BBa= z(SC+z&EHmn+y3O=| zrrKc7ewDJh1-Zy0?Ne5m(!Ay2YX1NOwoQct%!u66LrHNINw*S9qdE@`mKQqQ)+z|{ z$iN&Wi@@`qXWa7`d!0UioKNH}ghF}%BM*OPw&dM2xv<0N>8ZzD@wx7JlTOcNwtHk} z7Nar+QG$Q^4BfHW#%WW9Rg&iKENCgfQwZ5h&tos~Hgnn)DkVcp0_8y$&yuy+_PUO{ zTl)L+V8Q}4WRJaSR(=9R@95MQPL)aUkU`Z90gSCng$qH|-uIRh^Hx3PpglXa%fZ2pz2TTb*?>FK^ijQE)3Uu>Ki##?6r zL1ZIA`alqV<;Qr#x;_dq{PM8cYQ&DsnLxc4e09|GegfIrXBK)rYR^MC30PjtYrfOp z-%TJ~Nox3gJ+wLgBXa8VJ#tHyEB@wwrleF8+zJu7BDUv4vd`k8lI1l68u7+kA*s23 z^zRum&Hn7W4`F;4QMpNi~naA7?9NP4RXue}nu+x{@6?GjaI)e!&pf190*oy8I} zbLOkxsT4tL@Vx+N-Eb?LIux0f`_^NYf_dzQd^7ppRA_Gd1$S8;;@9L(^Rt$Rq{@UH z)ndTlX-}1RhCgkgRob$0DK&r>S0Bw1QgQFeP~QYj^z-aJ9JQ+)9fivsA29< zZ9F&NrH>OeR$3T%R-ZC&3^gW(c+ibgv=De!+xy0BLIkE+tszoVEe#nTs99jd`rrTkKZQ}) zk^>ymsd2B+Dj|VKrL3zk2WI4p433_m4EZ|KS4k}7qItE|a0fQO!9gMn%j}#u+WLn) zR6BSW#YhKWErip&W5~J%=-|RR4v;2I%a` zja+thcBqUE*>ZC$d@bou9zvlyGEJRx13*)nR2@c=j4;3=ghs$q45xy_?&wXkK&Nj{ z7Dl9=C>tcn+zeXbL8>#~Vbppt83Anb53rn_EsY^?$*M~Z=NNRF3^@iy&nq#_diR?X zm>eZTYCyXTTr~jP&hFG%_N-N8E29C<1bBL{gQpBGJKSHsVh=(^z*4ugXr$Di{1vBN zbM2ZQdq68g{Q7fz?|GhFjj+TJf5b7}M=m`}DV_c^xq z$QxOQqHI#NX_=6sB{}#x#gIH4@d4E9wj`yT)9W>3r+MC~dzrFbNC*`|>yo5J=3?lH zL_Z&Z&)6vi(9EG?CKoC)&-3aWoaI~@cmLl=3mEU6(wt$!r?kPjFJ)D0fhh)fljF%O z`v(YQ0<8HnC+z2fyIAem;S;hGJ9c7!weuqC&qSgLC(GC9wR86)DfqN?392*YDiD5X zy+&TLa)Nej6+$BV2QYz?SzDh&zK$EJscuI0W0|g?NT|ByNV{Nb?_T0f@rj#o58wO2=^tir4ZeV1KYT zD^m$pM(cyR8~zg+P=bWmZ{v|O`*g^2?g*&GW}KMqtvY~InKt15H~{PIIrneV} zv1b}=IMQcE1+6$$^oQS`a!nv$?pG#j+CiCHt4j5{Qr2xLzVmwQZ}Yz20;s(&NcJQs zVgLqQ*yo6cZcyb6OI}Bc zcFtjzjrCzGS@DxOWR;A9mB- z2O}l!o{BB1#fph#tHdx^KW}YZW839xc16#5j&^m0KCctyI3i$tM5d%SOSJuyrx&0~ z7P^#{HZ0MJ^Ux^$-J3FneBpNPX9SbU@&U zEN>hIDhrF%r43pOqjxT9(6Yz6pzy>&E9F>rJg2a&+i-`rCcsRfphW}P{!xt%(~wWU zH+ZZBtFJTWhqG)+bF>4+_X}~DfRNT`PBI9iWF_}}B!Z?_MMa95^(%FIoAUWRvl;(n z(lV&g8OdVuH_mMhI>#YNqJLR7b|&^3qig^*oc%id)6yqXlL2Fs#E z(|>2D-=7w%3Bx!`s z%nwMg&?kMW0g0pY(W9WnB7~GkS73y9)eROC&@^{&_HEYT2-#nEY;(8ih z^!8A94{OE-P}@{gxvk2#%vqKPqn&Dd9(sf`pJVT7L=XOp4fNl;SN-q|v)}J^q@(HA zb6f@>7vC|+u14v#dgSle$?yHkwfcG5I^W%v3$=SBUq7eUI*|kTWRaFpB70s5;8rFD zc93?v!(zShy$?1cq|q@x*~y;or4W3t#T}Ud&m?}U2H=YzZDg{1@;$#<`;wUF$oD+x zpH-t*9_=9r7E8Ki$qr+zGYjJpN@E$oh(PaklNsJfSL2 zSjSeT*LwqKtl%SUe=$tc%DUoH`VCigNeE@5OzEzho5h`t{a?(a-qpZUUfFEY9|9(u z6(Jijr@ADj&nXFn3`I^wR)VL6hp=_#MQ6*q{(k=4vprn4{>6wVoNDa_Ixb)`J29K#V27emsRw8 z)JQ)a6TUSNa-+YA-k*TAwSOT}#jwAloA`^J2=U?87%efDR*UBbANc(M#NIB^WM98+ z7r_gE$b>6b{4+bNDdg73#2)xkV9kS#GI>Gy_-6Iy?t14LE6@1+{5zE-!n@nqoCtv^ zqQc^YFt6FT<2;s44RfRhJ>q#pVx^}3L7*m~5c|0`0#&y}_Pv!Ns+e zC&{>A;pW-%Gg?v|4HkJPrQ&NOh>h5Z%2n*ZbnQoN#7N9hRD@msBZ1ZRsCRAqm^kNN zt2`jHIR7vhql~K?rGBJ|w~aaDYd%RVS}uccRhb8fFR8j!!UV(~gzk!*k^Jw9j}(sh z#2IRV+|XZG5|ij_15(?v+6!G47yny4raC4V(s3ABDWB818nqEh4;!uWaaK^

!Xk;@a{oPx%ww@3pW7%(jE(?wQZj0nNV zTeE$`4G=F%@M=WQDU6~O(IQ2^j59I*yrW0c&Xi|1gB4+LD!SDbu`d7^_cfC_+Tc7k zf7JbMAQy?bE67^?GBiX)SxU$`}$lzcL@tmMH|)&Y8p8)vCe?K)2%YO1-4=P1d+16k1M zlZ3q(XVlL5kd|XI?{uqJgL6TU<*n2^6ln+ZOv+LH6IL?^nT5`w`Z)VC@Xw#;EV=29 zzJqrf9WjZ*fr(&qEW>|qAwxW00_}aS+^b2G$#i~R&8t4efI)t?1Ah3=)Sde>t;_(( z#uCY&JJ_jYRC0c$0(`WlJsEpRM~I*uh??MZ#yhDqcW3R=0Ny{cof#*bdC$+F9EXwO zk*-mnqu)R#skePC>!ONR6ux43Hf6?0XUaMr>D?dR@5_ zC#&r?2CZx?ae-|pp6iWWejP+q1B5yN{!hE_I(JVs+D>|Z^9rLA0#PPfx7v+hddVNE zV?>5|XztzjMsB@E4nm$hMkY8nhPblq-qMy{XHYwt=E?ci{{HF1 zXG10t_?7wt(M%AFHGUy#tjCdOS|ob_;kFCa#Yd#-?YF-_EoC)WVM|Z4Ho4;(+w1l_ zcUzB~h4%fP$)H%Ryjt&$I;|{898CzlTK{7L)Ou5FABcSP#O6ije7ELUZqOb4<=aRg zUAEyGHvxl>pko(*oSG$Ni%k~xKe6A)2c%M*+L_8?1Cvun$}9n3z+%65kXtaWVw>u0 zHH7mH`Fw^K#)^$G#!H}^fG#@Muat@N)Wg|cts<1t_q|z4mGnOTYw%wHM{DfkCMsB$ zBj58wrUrjCqu=o?t`I~$p8@G1O0mI96x658Iu{@Fu8>q>*!CsMGQ8TY3nuQCfG>ak zQ(8UI7+?P3TQWc{gI25W+ST~9U~)l{smNN_(V;cCNPMQ!bwOJrsC|$nX*_aJqlf!O zkN?E2LCkLaHXGdYl(v166SG~n3c0Wa&gf#}2(W`=({iOI(MTKt)=L7lYtfPIwWDF< z;RoBq;N?k7AT7>K#N~vJW4x(SKM8h`|Mk*WSGr=0wclT|9F4|-=}5^-tAanIjlbIX zZJ(b6+zubt#VsZAJX+%LYG~qSY*m0u=@O-tc&@01@AVs+8&CM-LpPVeu2`v+C6qyN%* zu)Ink?h!NS98BcgH10Dg8%YnfwetNP|Mt`aqjuIPSZ*x@*;APw%*w&io70r)h(5Y1 zZKl?YA=zPgi;O1=i0@TCi=_L(dHxNykq1c+j8kT^EXB6s%s{M;B8(ZaAq!H^4&%#z zJTxzREYAX~Ou3KRX~^EkpzMdpC1vz=sZETGhPDyQcKYsJeCD9g>&$AE)a)H+TP}5+ z2Ln;>?n2I_V^?B)&eUE*D2z4wU4GsbDxmCnV4cMoVUTtfL>xsOm;4XU2W{=LD>9%* zYmBo-vrp4fW5bwzsR>-(DVN!!3$}0BLyWNH6UL zIOdu=QY%4;v%`bL5El|!Jk_8p^oky7i~a)S0|w`;{5^?2Q|&SavptV=*fWft zYcpg1XXffpqz)<>@b3Qm<~Iv@uʟA!AKrc0>m&43vk{@SXE!RIS$V|)P)y7*2U zWCMyq2v+Q|TKbP&_tfWm@_tE|zEnq{Yv;J5(ZQh%^qb=0X%9E7x;9x^q& zy?QlN9ia{KF zL*)|B3(zej6@w^8Xd95c+8IHru02hO(uZALb!w-2LL2+>>l- z3|4%i3sdHnS;9snb{#;wedIBj3UN>a=*RD+!c!xq^uHr9En^SL{uRK!3>Na!;0q0Q z?0ho4=uZ#WEB2?!N^9k7B-@fuokN*_8(TFb)4Sx86BLea9?fx!+gf#*PW{qE1Q`!b^bimu8J8=Dc|?`d3_j!WA$w@ zEq~tOGED}Mw36FW9!WJ1{wTno>LVeq^B}yzujv8hN#|TFVu3Pwr1rah{PMsK+){Bl z8{BDsO2}ahWtor^?$o8u2%!rg6ZBs>NZrhPs-gPHV28bZ34 z{(S6k+8%cmtE3%AdQ9fl!S@hX)Nw8IIgu%3Mr5a{dXVD6QZa%3cr#AWLlvjwL8wQo zcL&@tl|Lu8DB`eAbtytLrGAY|o+B%y&d#(z$vB6jo}=fre(=(Z?W$rU`FJXOQ^Vrw zAn>Q^+AT2bsRtVotnQC~4=69hPJ88grF{lms>Y6xpq-P?I-lzJ*aUQy7y-}cxje^! zz9#eaN;;38I@TfX4;E%EUd29#@I6Ix`|ERU-=`)cHdO!nfB#>V!h%W9Q<|R@qcoxc z95#(iJ<2D5o7s`ReOiDZ+iE5~#v#{*%>s;ua5}?ajrT^X z7`gzScgkhM2jDR=fRrOu*vOC$0Q0dUd@*AF?v%47OEF15A;eaqF1cj<%w~6r*WcdI zN!37Yr3J_{u7h%%*G^_ZH0Q57#>CDk3Nm1&Y!+6LvmyhHzMYT(32uGQx8;>A^Y*X~#=7#%7@iEGI~C`l zEs+G(<3J%+GOX-nP2s`Ar>ug#5 z<>x~R9e&g;j_7e5LJ2|xXLg(={f+ccMU>$#rvqy8v-LpmFk3O{IsyfZGPn%LmFpDcQv} z#snO_M_U`nMK3l_yw7*00(Ng++cP5Lw(~5oM39B*{9Jhr zR943BG4lH*NtCeaOBM;Nfvvf;`|xB}{gw*Tf1dUy)xj?G>h0RU%6yUp!djBP@!7ZK^U~{1cmpY6@VG@8*uUJ`=^^;>LKwUi_=g@_qDGmx zpUT8KmQ_DG*s7&UWASLWE~Q-|)mo9S;DY#H6%)%d1dj3Ryy2s;=S>nNW@)h|$*+93Z3zMH4#RfA$J5NIl3xESzn|bBg8d64>7H(5=!b93 zT$Eb!<|y$)`~{(?+k1lxIjRD)#evx7z4-X8+VlAqfF$!>1c{yaWPdgwBxep8TJ_4u z>g~xq7m##f7-Va)hZ6X|ceul*_jiLU!7xwj%tI<@7O#!Kp=SZ%;y~Z)M4~pnvOFHG z;i=LBo0`|&DVPFV2PQrVym4q(t#h8O%sXIe#QEMljM$_odaBPelakqw6GvPFn^D8CSgGo$l&a= z`^FFCMMEQoV z-2W_K)y31Dpsg65`W~}oK$$C%yTQp}iyn01U5z+6E#y6pBBT&mkYsdn4kiS{MlSq8 z2S0|4JcT5GymA#XFtM zU*eUULK*IOwxVOzpsvBD#d!nIpw#WfUfT=!*6begtR(B3lG?l3D3P)5p+C3Z?~+=l zakSSCpd&P7APlY?@H7q_6QH5@J?C++i8s&pIGU8W<_;x^-M57wIF!NZ)&_CWWs9bD zSR?k<+uuBZE4N{lKc}rD^YF`U`ANp`R^I(`{#SK=+v;Fh@cB*IzihNHCMSJ}))@~< z?=2(kU#i0>`|e~*Ve&`HHkMYod>h&J8I6<8O8eIA=SN0F0H@%QthGuOm7qjvJxZB% zfcdqQPy7yG#mPrNAa>AMaG$Z7cWZvQO43g?*X8WpZfh9#_Uj0HJ)epN$Rc|F<1o_Z z=hh*Z-Fn}339x>vu;LSIFjT4+;0}Ry{|wH5%pB@|{V3(jhoC8eMNjEBp68<;Pj(-l zNQm1EQR?f!Xt>m zRT>N&s}CVrsApDIz9sm#G9C|}rfjt*`iU%cv8mu~*P6*d=2G@x$Ld=p+$J@$Pv|1U zoWOCve?tO?zhDEmM9h*clb~8JIerxX->+WHh42*fA;>(UTL&NY?s&JaWg>#oGNKus z`5|tv3?yv$4qog!uHxXBLl8Lds}&8eqbsR=_b>66cL;$uOGsAZJ9zI9#l56y5f@}I z$;}Q=3>34=eB~}5vY@(H*YGh(B)s$hMlewP-1wOx_>TO$55af^%1z}}; zWqxS#VO?__hkRqh?XnV99tQS)pcnB@2G*FTQu z#Mp;hmOk7M`c7>9pws`y|MfrCAs;|(KzxkC0@EQyHesB@&J?Q@Dzdl6H?0G=hQ30V zuhzIt`k4UT=o}fT3;~f|B^hsU&V^1rEBtTJ=GtWhOSC>;+DOYvoMH#`5wd8@t%juzMtjc@744 zj?{froR`bw^kz?C>q~7y3WJ}qC>| zDZ6+_ksBNLIqkoTQ#(@j#QOJ~Yb~6#TV&3beiy9Pl9V+t@$uxz(L-*gP(Ygt<$PK@ zJ^LJp&VYkQ&%~YpBVzC+4J{*zT*}FDt{IMct%I78GdQTaMlT5%o0PyqxZpzm#?>@l^)+O$n1~EnmO{p6kqJ~}`3?s3OTsPX{qwe$T;Hc ztatNSF_7vB~L$Cw6v>GRr6IYWsze$+(q=sa0731&OU zRF&r-aLQSW_ET;9!+h|9A2=CJa7sv!rDI<T}9d zvi-Y0lP1G%d9-6p5^MUsKXVkuv92@$6QhX9d~R3&~ZWR|Gc)VLSov#6oF?F%?)&NQwWx!>@H`cKwV*7Ou<D9JpWjn&#T2(x z!MYb)oZFk1`0yaVg5a%{MI{-EuZ?{~kkKnSSr<=`kXYHA1M>#30q55d_ z!B4$D=2ZJjo<*P^r@a<8;O{++qLem*edNC9?M0V+4)YO*O#hh|#66kzTf&jS_{VwS zC0$}Nl0H)?&+$;J31}*pFw3P*VN(vJNL5h`Y0KP>x#D5l!1ll-8>;sVp7ZEYl;;I_ zlkck!fJ&drxZir2#5h|%_u0(bn=vI;l%~EUrLregf4!1?lwmB5vTL(|gTtId=^zF_ z8PLy5yw`kg^igl>l2YDd!+rooep!GA&L~;M;{MOrp;!knas;T`yI!LNt@R8Q5}uBF z?4jNO3*g!%Cd(f_57WEstTgi=KSEB=4$OOM9D^)VMUS}*1ak%tXJoZI8?0Zv*CT`Q zDwiQXHL4;jehBXS&4fS6bZOM{n0P|w4ixcG&ffg-FTg7dLAVc^PG^{0YcB4 z)s7m@Rc2P)io7>K@u#VuZ4JidbU9NLr_uiX?(64QNz+>alTxs%pER_t7zG-DIYnzZ z#}33h7`(fux~En5C@ZQGBzm%aWZwO3E)<8XtYm3%PRX=zp~?E_BcD~J+oSps9B9bD zfayo7@zibSg&OA1IF*{s-OpSKHS04~)A z^?c{_Nl^>t48~pD(Oqd?(k=AvP1ai;%oa=hU1OS3J}030fGdAT$7g7X6_?{v2{I*< zW&Uzcs`fkHp_Q#^PipIY&FHUUKNHkS4TYb?jFMH27r_2txE;85?kB+zu6-!Vo_ZJE@Kl~*bTu0+YSf8W0j*cg$~*w@vjLa4qODn7dH zue;(cN1ES0gC7m~oJ;nj)%{qfQx;It(NC@zV!sP_-T0ExPq!?Sv-jv=p^nd{=h0jf z9#4(Wj!E_ZR43_Ue=a@~qRX0im={8}N!-&6lluKRS8cf}`=<;>b;i(g_|y=0BuhoL z!Ik>bhmM`FIX;q({&v`}<+GOvGQfV4k?!72PBihmOnHV%hg9SAes_SdlP3PVN7|}M zcMkU2G^~xHR2K%z@!o&E1&E;Q)rBL~(VU~danR>qGWqbQx5a5Q^@m05>$^=i zS_V>KU;uKJ3Kdsky#DLxonzp^c<)?_Buo5}Nu&(LiUh+1w;t(Wa&WFO!ZWQ($8@rT zGS zRw^@Wv!qk5cFsV*LLQCPoTguV%X1X^h#3qxb5LvAcdEZ{ZXc>WTt zi7&?RS0}mwU*ZR?e|A)jK4&vgeCkO%7UyHT6Waz!QNSA!pWbrZ6dB(jy*7@hy!tV| zNSf<#IHl1k2FF8^bd_7WL$*{x{Gs*M`aegWYjIi+Gxp}x68wBWf7 zp~xsDJ5XCzwHdCh9*7dmI?$=_W^95!y~^h=t#v|$!zm2OuhKe%B+xIV3NtjDk@-%k zUJx*~y?oAoq>p-D!8@GK5WI)xdd30ew9jzs$|rBm#}8P zas>qPX5VqN8Rfl0D~p|I5&WloZB{XZ#Y0N%sue)*a$dQ!UwPQ$$^gfXQ<%t)(sSrc zz6XY#d>H`L=bO0@Uagt_ua|MR6Eqk)AKBaB0cPB@Itn6cP~}w36alOCFvi^=*IMuh z4*rC3)(bM$E^t1)XZC6fqdFgB)n}ysGq6Bb#NBH!k`OP7&H!A*-^E0aO6Mu{4+Hpg zu&kuR^m#Toi_5U(h221KJAC@A-V9o{ufvzf2 zj_nrEp6An}jpegJOMJpDFpZ&|(-yM@vDOLTNn=hc@{bTb(3WV5Bru!T% zV4IU6R>(pX=UY0uJHKL1k#L^1c_qR0XHb_(H2?Zbo|asxaWe}*_9reekIkzEaju@_ z%u`WQqj^U4BM9ff3V;!Cs4=P62!s9IpS&s(pV|Rb{0zDf&CglQq`#Z9s_6C*nEQTP zqa1X}_R96_R9-%&q28`eF5XNP-pox2I+UzPeuf_OU!x_9$4YhV-%H ze3$T5j0Tv(fH`U%(vuSKLpp4vBz& zt1~5~%I%raFLEyYS?*RBu#E2asQ!%A*2WG#vLzbJKR%jDtlQ`<`o|r(@+Y{-K4=HQ zExz+vc$&K)cp-NtRwM_Y7%BU%V1n|jrBoc)N`f&zxN`P0k4A4b(~O6MB`cSHb3Etz zV#C+$nv^Yp5Yk>9f2?J3?18pJH73u=l1%E z!S_rZ{mF#Gwlmgo&ITc3I5;e;efcZW>y4u+k z{IL@VXQ9FDoi)0(jO9Cj!P&l*^$L_qoP>NP7CX$Wl0J{WHkb-pp@itv^SnN*kdK~J zSfD={_z-=7h$;v|V}#_(TVdA;2x2!IYfM z*Fw+hKaE{qJFa04!)o_?7u8MzJz~z$yuK!bS!X`+%hcytTdDXlraMwoDFxwEdKel^ z+)QF3WL3?dLTa2%d}w2l%!fJ1@B84sDY#Vl+VK zNOhe(O1xcw=qarXh<}$#f3m}@^5pkA<8to`3;rp+J3g1l+$Ty?06^&vsd zEI<&>5(DBN2(>(=R0^o2(?2YcWpL21w$k`>YD9XLf7d@o%E6&@|LKpeHKv{q5S`V!GQb9#mbaw&&4t+B3ColU5)njf*~K{MbCA_)SoX})uxa-_s;=}5 zUqdhZBva7b?+>|Xz9Kt!aHPOZP42IKj=D>fhykG?s+ynIc$UC?Wxw+5*b?-8s~pG# z8CThMKkW*G8M&{tWBVxkN4D$ccgf;md!IQfR*J>y}ixZ zrL9LB(45$smWHa1$f*`l;KrCd@liMwePAVXW$L}UeM0bsH zh~0`VtzeM=v5j%?gwGYElNh`S#!v+`UmaZ~7Bv*%jxKV_`~*$0c5^gMDSXHNn@l|f z16iBwc0^hK2OF!{Z~b%r_NdqXz9EEj^5;vKU`huJfv#2;1yp%1>|pcR;I&fx7|D#> z3pTW`-#r^J+>T*me(EjEHV5TrJSTK4tMnqi1C}YO^kN=In>cdL>w*Ia3I}_I&%cW^ zkg>Q8zc_vt`*y}F?ByARpD$V<^kR!DbqF~K-(an6`-SX~q`&CJ;A{3w zw=&hfj^xpmA)!^=9 zd8^%D|0aqGd{<`wHX%C%GFct}8g62t5+ubnVN46d!#uY_hf}As8UF5Pl19_(V0FXApU#4v<^iy?_abh)H~ zW9zK2-70iRqNVTDkdPVM%>@@HW}a{V^IhVP++uKn-w#zU#1k{b({Fqe(j!>B?m;@r=0bRtxt)sGhaqKeH>7qUyMy{c~oa;Q>9$tz{X() zKV^p}!*i~g8~0A<`>gB-*2KESONMYu&OBM%8rHAX24lg&1~tdZO(1zXj#jIfe!TIa zA}p>3u;6WGzntYfkQ`<&YYptF(nA@J6oHJQ*D6x6s-=D@H^zI#G`9EpW+vj4mSEV- zgFHZDhr1oIQcrerZ3BA?Cti91*My*u@4aJqi!3q%mxk7IiKa^GKAH=I%iy8DIOIb$ zH33e8MtA>oZVy7Bx))fhj(V<{^Iur^fCYnMb8uD^ti11NZ`J zs^sc{&wIU7nwrW7w_|vql=aH3OY@>iS+?fSL%HgX?>nXSC07&0oQOev3Xntww$00d zn`0PsA~86CIKvo|v7kO#>3Q40Phv1)4BNQOyIMNOD^BGMP7*D-_XOJqok`WPG;g@t zDN7xV9+>u&o&x0hZHus@9)bV^utSORoiy?M_eJI!+P{$LYu)Pv4Jtj2f2w}7{UPSa z#ArMWD}cw-!>NjZjA=An?be+Db2P`l%YdS}ZT$pX_XcO|iI-On-u8XXM^@CuAWqwZ zqvTdB_e1cQ9^^9vks0eG0z(rB&X(aUewK~r@^e$zuEjF61KN_Mq*M5wS~ALh!)3Py zaTMCB7<8Gea4kas8PA$TO(DOtAT|RQdw$9;>}PVmLl5`7f$wA)RVfxcglb9ej%Q>& zfpF9O9kL^XD6g{W?J6baA!8=~d1|XI>Vj~)nGu4WqQxP=V{zXUyX>WN7OwB`N82`o zv6FM1=Ip&GrIgS09VgqF9pM=;n3pRBYmKCzFL~GI>N6(?(n++_l~2*Kaqzp9Hr=gO zD`2~LUPX^$`GOlEOg*FI^)Cq=-d=y?d1P`M{cm00XMCiE-!{H&le$c&KeKQ;0%r%+x>aSJJHhZpIj&dCPWaW|w*@ZES{NKaE1- zX!XVwUR+(u304n{fvXsDJz86_)d^Qh6^XO>wCZ4Eiy!hl41aXfv%eGj{YEP*U0ZLq zEyhcB-C1n*l(rHs#B|;C%a=|kxa_T@+*XYKRL|@vzzNWy3Z|5Ho7oKaEU~+B$U1eu zdzWRv$tV*yx-u@EVQ4n~4O^Um+@fu4{vcu?35u(V_NhE~Z7d;T zm4m!_8>YW6wNU+F-Ec-F(ax!tAo<8jY*DmUC*Aw6F6Z7zH83m}QH&I1B{VmpnN9c{ zN$P7koq{a>kkJW}Ioq_%?*RDd_d}b}yx2!m?^zbPx_mCr>{h7!5wbn0GBa*zcG;Y& zZP}~?p*wf)@`~hOh?;)q8%QPrU9}{gt_($TFGp7T`GS&l@uB8Y_AJU-aSx{<=ia5M zM?D1-eh}m%)w3CkrVQNzDUJT)ArumsEgOUT_`8R4ifk>&1X(?RJp|+__wR+U7(MQh zK&YPpErRg{oN^EvpjnhsOqqRsBxMS}{~QAd%htSy**P1(u%g8UCm`!w?s@-yI&kdh z*8{U8{TNQP`&3sBOVZDv^^x!I9A$u%nSP6^fAP`ofi_0L;9z>@ETC(_SRHV4mmdAO z?06igyKlKS(|mY;mFV}jfxJcEQI#~0{wjUbqn#oS!>D7$ns!;14w=k()|sDz@X;s( zYUVsj!0rImJfM}s&arqnwb;?>;;<~u!P2sCjtcR?OJrO7H-#ZRz8-MjtNEdo#GIpk70XX{|qqzJkme>p;*Y!@e4VU=2s z%Tn=+s+4kK$azQG!B%$wJ3rT%s_mfAm93WF6R=%c(k7KFOAeHS{L}p@NTQ@W%v#l! z(vm>kKr~fpqyZ^C_e=qosy?nr9S9Ve9M<)mjjZqOn}K@9MqbK6aOqyPm7##|Co*3J zN%N^`Ch)>VBIg2Q^?SRvg*3N&H*RB^Nu_qaCZLHMB z#E8ABk1Gd|sguB^Z2JomY|wE(EA_Qi)Nz1%`56zJ(_*+nMhuyfAf6?jBQw9SIAy!u z;HIr&4e2qDXL{WvRV&`*^PiDeS7{r`_fPqZs{%T)_m+Q4i~oK4Pxa7JRFdjao$iaw zdgn88dt8wzewam5$7e3j02@9i7EGs<_N9Z&E1FOx9U6NhH|RlP=ZgNW-l7A{Na@Tp z!@iwUs`Drm#Rl}?WYD~2Xyx~)o}-^?{W^06xD=p6g7TB6O_0Eko-m;(Nj)X;;M@P4 zfY8_ChrpdV!>t8jV+o*qC1&6u6VIOop;rF>bCS4{UBg4<;WEphVgMU~wet1y1>69B zQ8F_z(qXG2IB06ffG}1i0!t6W@JHC#<~vI+(^|)q4CR(W`+q+P_^TXvP^x3xaUf}6 zv4ALBwyL9ttmT31@E%Sa4QJLdxOh^R;bW{|REeJL;L5CY*XXIYtjWIv!+M1gma?L( zc-Dvl+@O}39~{WM&fTr@ZLs`M276*5$#(EQ2F`=$<2wLu8wectqPa(GcrFJvowZ`R z1o8$9HhPClp`^p6(NQd@AW>Ic&!0w?B3` zYwoQW%+(xIao%$efF#-qSeb*dIZ1?q)oLN8r{qUN<9spc{WA8>2y#|rmW>NqBD&I7+*ac|YQF!SzzT@s&uZW2sPwlEZx2yT70REUeluvA3^;9hy;7Qm z2=ZYf+&Tn!Sy8i5pDyc1G7yt2_w4)Ya3?VH-3gb;tm#J;LIBWg1+2?5ZGYyByq`61 zY`ZtK7Lae@t7{k*-%eUJO4~a~=I)NctOqaFW`H!KN=dIq zW>O@^W53sdWtz26elAyaQ0ets7iorjvr|$A7Zu>=-|C{#w>Q!9LpD#Zz3*=3kCX#K ziatvW5>=~d32Ryc;=2pGlGS!5J{)KVy&1#66&Hz&D+pgk_-o<7OKn4BqKhWvQ z?X_mEvOa8EpkAay6%_sypK<~8mYLtK4Ybc7E7&fX455)>Zlwe}25gq~>-TtEe%~`Y z+d*}y0`O*$WPtwLLvV`Z=Eb>MHZkgA@E426V>7kcP(_x1~1*CB?K}lKA)d?OMQP^Az*9)9furb<)Y}pPWCi)StD&yFYtVm+K{BvsU&br zk=jOuB&F0oqnKu-y0tR#9MAsn#svGk?lDQZx_LN9sDeW)Of^Ki-YO#GV!#&#F>1^W zIM&$~<0ww868Y~l$lN3sHsK;*lZeygo!?1L3C_p{;lF0Q9WlHbY%J2 z{`?cPn8bzS#Z(c!6>N8HbShF*+8Cflnj1{V{CyHkA=D3TCu#js%_iG|Ba3H=^7{zU z|8HVLrK${=O?*cA{*Xv~nDbL<>EQD^dh7VL5|`$?@qh>W7XtLHR*wwuPXhEM{}6~# zd;{%N#KpnQJGbnq#Z)C@0^@1p7~@GlbM&tuvqcr-BVvLn)&KaP|C5)oR+)q$e;tR> zZ}~=sXf^m^=)XD25|0EG0h+={>opqsIQU@CbsG`>HO;Sc0u=fAo>gia!U#tCPpk~H z{;$bE@HqsTwJaTE1|_b}>Z3^E#Bso9N|&q@zQLfLvtT53Vmw@)&Eqo5Ekqlf! z+fR&*G~24-_KT9Ib-Oa=ssMY|B~PrsI>)QJ-hpug5I#Bxl&d?Wtp7VHea0^3Yo*y? zLWOtV;U|+bX&wFPS6G$T@F3?t&q3GbyYP3G-ZV*4pFwfc=qggT zq@hW?%uxx`zUjN@;)u$oJm<4zgBhx`O81m@ty1MiGm6Z@KK2?pMnwZlt*$?%5#^Nc z>zO#Pvp`q@1>B#@DGz2pZ4a?2$=N-dnc200l{ymxcI%^iD1RkqARm3~5!DB(%)2o# zIDm!B5%{J%Ce=x`JDU4BWDp4Ip9I|uOXU1+y+KBX0i9DR#`EW1t%HtEZ!mqlH{QVI zs`SUXSw~YjcMyQVFFD(iI}7?~B;cft7cE-#@;XXKG1VL3P>$Yt85~ z1k{x^KP8KtpO0KNw(nH@aOpdPL(iMFzvSus>Uok>2o?C?b#sO}rRkqa1bNX%n{&T- zXNHmkzqFvm$7E*63mE<8O@vqXuD!|9*;9v-ZQt2B(*0Sl=U&YzR@6xW->xk3#jUH} zil8JR4rHVMG&(GFQFY|X95VRBYd^77uEIn7Y_G>QJ%s-f?Ar_*OU{YFYMaC~k@gOQ ztk;p}=le&HBnNISiQ&jRxP1p?VK7a;(VK0Xt4mS^Jjx43PczuL67-ysexv6Poilvb z)bWZ~d4=pb0rb2-fqKgoEOb~e-fgwZqWg0m%38_$TgX$1a!loTc)Z75tN7PJt79vA|nBU2BtT7>pQ4vlYgp z43s`Q0IK9IGXGJMVjjRQ38FNyq7BbLq7ZvQOb-e3UyJGe;NvB}a#SQ-xq(xo-y}&o zf%xzopO}H9VVy^FJ(uR3V=@XKZ^RLu;`hkX*OAGO1nu<--mHH6VypB1jsf0{P58}@ zv9pX!Iq76_i{~Uc^n{;Ft8tlxIZwUvk@zh*t4GBQ2FJJ2Z)pW*z2DjMCCu`_)<-TQ z9~!FT0fs>$TZogu@6nbeqa}Q5l=Jy8!p^Z3^<;0L^$J@YUSVHjxSVZ#pE|?3T2b~{ zpq`!-m(fE{u%{cB$U)jr2FSg>hTsDQOz;rkyCfXFeg=dOPUbD|;|mGo{c{hKx3h}N z0OW9q2PI1m%jaii*FteJ07*c$zgPkQzql!En9kddaLU2|;XZ^>tQeEhq&ztN>qGY{ zdrC8ED()=MGs|4V|;{we~j!ti(J7OF#Hz)&~_5&7SVQ&T3Y>?S=Qvv~%32bol1A8mU4Ze(^I_Kew}*rd9(eeY&c6rW*arOB zN~&-4s;$e{J)qNWrg@q+6#}~7{ZWkYU+kKHFC=K;H^(fzzS(Z|XzqARmH zgJn4>2IB>I-UQ!`Jse7{)l_oXjwczR8}ipHScd^;4>F#43}>8`>yvgxEK1?49%zIqe}lBV-bfyXW>ld zS%uCtZvci&g{O#rg2et<0gLaABQD{e=0T3qHY@x9coY0>l8>MabY|_$>S5b8hP@5 zOY^*ebCQ7x{zuY*tnDNrYV{$>lZexk4G&`i{@0J!fARx|yLapZA=6ZekW4a`MF(hE zTrnyS?~ZLP2nkI~e?@z>zkl0+%0Yc%g9GX1|$$l!1M!Q~k9=9JA<>g-;n2WcD*C2 zAz0_LTa{EJGWGevsa>rh%>sB$dXrLGgVSFI&{2J}8q4L!u+w~ep&Kz?CU($`@30r0 z4Z{74y@7d3$BqV&4=|Wda1lZz&a309VLp~psPB|#b%#`{Po>%Tm z3oxnlB|aui6x`$T`(!?5NW2X_n>lZx%dvS9&k(Z7nR{2TC7|+u@3ql9dFP2-=Kc*@ zO69?FPwS704$1c6t}R}bT3~G-hRhU1hddCfI;}ZuMCn$|RR&vDwSz4HRHdvP+u|(X zYiEiSPTznhDOEp1knM+i2tHmQPq?pPlS{L)V8}3(8avv^sKJ>i%ddJUE99A&)ae-j z-ikO=49qKtSNE-NI{?IFrj?@@+y(lb;8de!I?1%!j$&-EVfHa}yW;;!a&?GIFtiGC z5Rjo%x$!Iky~#is>pS4;`(`r>y>9K@Plzl)V2GU|sP!C72=UR|eR2wdCt$Cnb6lBm zhk;A}>^JApE5B}yI<{y0eFnKg|B#imTs#DvA@P-O$b143hkaV@_$D}{?;M-;~)9h#cs@{JiSUn~Ex?lOzabTqQ8Q;&9^pgi+%|tIB>M5Sh zzLyLioQ%k``u^myVca+HCs>f@Fut~&C)E*d8> zmo=df0s+M-0KDk?%=bQ8cm9-Cl~g#!^?vIJplYskB%s*i(673vz&Cxj9P>r`4q z6D(=l3v<;~CiS1ioiF7qxfN)gZZPo45OWXp3q~sD*~}ftAfM@0PSL76R4BS<{WxIM z!~MNg8BWO2ewkry82CCF6q~Ugh@53CbcPAjB9y$sG2F()A?LC zskZi!f1i4T#fx9Lz1YWr@S`M;YxSMYXen7`6GTL4<~NhZ~MU)G(l_AhdrMt%zSJSl)UAqzq$AMy5E7qYP?#zqc@|6BaKr3MA zgh`H)>3t@MkW5kyt27wJTu8yP1_-8v=2hfp!IRQsw5-UGwWsVQ;7<5sy+g-@aOns1 zCmUGh{y&rZxR8=E<^NrOSD%XNz48{!oYWU z5Q+u487f#~<}lR0neaTfdxcX{jx9i-11V^w*c1{)BTl!E9P97D4Y$eG^9D>4D`nW>;6IEdkA z5Zw-3l)p*sRkH zm~vok3>AAiobN2zr<=ZMf==gob^G_~>fBY<>SoCJ3yNo?%p7^wc)1F~Ssey2PH*c$ zSsiRMu5^lFlRtF2XMy=r$PiDb(+f@6;Pub?{uJI3>`1!?=a6#UxfxDod++%K_svM( zG0~#vpY4FbDhU9pB9e8e5S~-g%}fZ(|0(wpZkAiv@yppHu*i9c3`IN7)~PngxlZZ) zTI%C0eSAqa3zRl1=4}tQSzZMSQB{(7=LO#A_O2!)Q&*{~;T%aW63|hiUhZ8;J6?l} zS|MaUHZLFy-|<*@{Oki5%W%xD-RRNRl?aWD6XLyRi8Ghhg4aeGX3_W#n)~qmKLPtA>Az=*yMnau z6W`zPYyUniWEZ0p9~Dv|)qE-G zo-QhT8t{)?qgHmEz4~kSH(QxoG3@;PjbDiFr21pzJKX3MpZq28IETf8bvH=a@@Rhc zaDK{jQno((+5WfM?=?wtcE*X%srK3Z_r3TdHXXUd1`a;ZNiXRzmuSXGq6y~x^RqeN zK8u-!{Yqf`Ku(EZa*|Ak%)DtMYiyG&FX!l;7Xl{Gj2fJf46W}g=Lw!Yqk2qCsEg`F z&JogWt7zf}YcxOK&2aujOyPINJZ0Wj_8&rSq+MkP1eSf$!B=d!QI|Pe1annNWl_#^ z>(!I(y$~^{Hh%E8^~OaZo4s|-_PWzb~iIHYy4 z@X@8&M7JXw{~W<%#ZVN6y$*p42Y{BfFqr&^n2MaWKahNO(Hle z2SZPoLf*eV0)MU?j3 z@~9^kvuauPCKys$AT~0HL2{<_;P6~d&;60snGxlUNnDj?J&HJIm_^vB1rmABYMqAw zYctZLKZN4Qf$V&o_Yz7ciK|I9r_Q9r979t-J=OHl8}KB%INTxH=KF@BUxNu)XnmOC z$go6k)Z25+d`8p{)^CR@I@r5Y^xwTiNEYyT^7Cs<-5dNPBZA%#$n|-2j{6S}jIjq# z(r%F8x3yD)RRO;TXWq&nsgN%Z2BZ~P_V1;FLD3g^R)SZ+)hqjQsju%FfOlY>G1_5` zMaJ|TXQd9{Psj5H{;WKH#{S427QK+qqqbQiAY$o>GT!Bc70p^ajlovg-rWRvlK=!~ zh!~IFU?lg@1voqJ(3;cPs8!mPlV=;9Y^Ug_Rc;@CN6B9Kg|($%YEAYfM^*vr3HnCk zqwJi^YpbSxKaa>twv-B_hrPo`BCrY=D%-pc5WC8B{~5Pi%y?bUuKO7w$p9b9+b42C zP;P$(0kTyyWLf~varV2gTSNQFOV_1J=0vv@&~1P-WEoOZ>zImC&Q$jho_(sNbtdK1 z`RdV}tMm)b4!rT_dc6>tZ;gs9g!ODpWR}n3Kms`X6(5kwmf7b5O-EY{mZzk?au26< z*dV1f__GJS@){^|CkSxCE3!z-?SnCgNL{vV@3s}lTfkk0ty%

_lKu<*nQG} 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 #Hw>_D#uwK4xJ5qYBjhaf*+j@rm ziYHmSms0bCeD>5mo+R_zfyHUbc^bIN z_dPsgLyS$%AKoTV8#&)lv;b<#IgLF6ek$5FldIEHQm+$WXDY}BVF6Y$~*yOrpBl*ZBWsF?CXmwiy`)B+7D!yXYk*ntEt9!u<}~QLdKIeU~?d%B;EAk z`-ULNO6MG~s&&$pGzp5ezi<2IWJX#yt$(slnP-FabF60_fPG)gm8?rh^{d(7QU$#W z6O%;8bc;f2ut3XIsSQ3x4<{t3uw7$+auYMKs`826EjOgh2Xh4zejNN|8|Svu0b`{? zrlZJ=->~a%2gl02As_DZ!1LReT+Yxfeg3fkCN$HUts18HMfIyEG0sJT79 zaesa73>x1>u{s!kNG4rVuWbeUj0R$;7u#Pp$h^-nyG6+Y!+bT32MJ?Phj?)HLusuk z&AIw-NmD;!yTQ(}u>ybcSED|h3->PYPlMl1DgYQ{SP(Ii?LfA4r0wbnu1%6Ueu8yM zncAR}YGmoR{%a_zBo4Z<-?4#15{&9Ca^!e*ErB>%zpDyCrp3p>W!VUm?@mk7w-Swh z3|Ai{{*7Iels1bllY^eqLiN%T4E%csJGVaD!g>R_?26qip;3*$JXw4M{{SG=?wxYh z35B1xEF#g<_TO|$JOL;4^0@Q^;ax*kifi^~mv)fG%$sdiQOZFu9x(_xkamE-0J=^_%NXB zVYQLHyp`}F;E>eM(bI$BzIK9SI_ES&^uUZYrCeI(v`6|2TU|2P(|vpB(=Vuxyd^s? zS_Q&l0}2ZP&O}>9fru<}*SQ~2(Qp8si7%|E$6!d0yYoB2otrp%O10CG34|EhB1+y} zW=V_8IWGg*I8F>nf`v``wViZGDLrCOtN`U0(|*gDR!By$*nD4GmVE9c77(rhy- zPv388j?3b0tYZ)i=*|OpBLm{WfuHP;Eg--K2A67#V5`YwD82Vt80Gif&{tSbTNVHB zv;x@q>T};?rgYm+4wV3{Q!dYaYNUttcT8z+NSp%F&UnzDKd%DgZAXY4O?Ew0k@)-0 zNayrEXEiyUk)8v&HrT(Lad@TMM~|AJIq?NdIBuNGTn8-`=Q2xJ-2lN11neQODee)Z zGY$??!l?(ML-gKqf0;(!N~MPX>Jf`mFU~#v@G=?WtBOM-Xc_4{2q*R@)a-({%u3;V zdkk7jIAnaxRCeyY(o1d$g7_*Ed=4e;xdU;HqS)@&HPl#5-aiB)19}A6Wh~9L{8COW%xMh9y!zeK?yN`-1;$fKQo8 zG+BK@9Q?Suv$oEAlK;0%clQny^d4*c1H|?YuA==WzI#ilA*N2i`dDh;3d0YG%lgaV zj0G5Dg08_0V*>jKKLZnBS$H% z1$#UO&Nh|EOOFSqj(yD3j{uE;5#3WV;`w(Rszu7cX}FIBtW|7a5wk7$vwyP8w~?!b zyKie$9CGDtO6l#+lyCLny~f+1>Lt8uq+eQtusx};oA!o^R(vMJnEDf3)@Gqsy#>ce ziL-I+i}#Rr;|K1~Btxmr)g@>*-}GWp4KP9>pz+!0)x_3Tdst%Oh|3S=XLz4)OP)u& zsi}ff*vR7`>XDw%vy=3`kLwO(n7{w20pD_Fdi~Lv+9~DD6J=(C{VFpsh#^Kr)>$Ns zN>x{Neo7DaQMm<5NuE1;cQFk3GzrMzv-PunUVE&}&aiDPzhBw6pEfpc^uR&5<#jSo zV34x{f1Oqx>)27s$dhSK8`&{_l{D$0H&9vajD6^Fa*U0i=&;`Vr{!o@0f&^JO*<+e ziB_0kD3{o~`XrSA(#|otX_$y~CutA|1fIqQW*Ec6XPi0u)1#U{k{zsR#@@KqpgeC$ z85rNlXlu@+EgNt0F-Ow5N`+zC`cfT}eDjT5ALEP%Idny5g-5Xcg=l(+e-3zYYU}mX z=wxPEd9%UUWVVor#Y4_$SSEvgdNTPC`{8)`@_n}d1yRJa;%BnryiO}KJ$B=oZ`Re= znoT;C$}No}NIQnVgZ&ae9VN?+V|UiyAaP*9_bAF@8lj04 zXT;t_Z*jJn4$ir*BO85w27&TGrvzVdbOt%;1wSJlvhUOFov?E>=h^bO4Arw^|I=G8 zq1TDlyrqCu^xRDt6oSZF;v)f%SEOJ!udEP!Zso#GoI+ka0zqF}gTJXOg8Pwz^5p7obIvXza1u2uw-Xhz=!Y8LCvHZL8`~)=qCWKhF2)1H?Z{L z3}-_!z{tUny(z#%Bk57A-Isb%N|9Asm~u9wadPh|?T^3uL%|V=;yg1EcetbjzAVU= zVlYh!GERREv}2e)Mt%6d$-bMAdjKoFU!E+g2<+QlS$%91yg$AH%(HuO4|?4gd=m(k zuRip@51??c1DoB)QH-|KwdzqOzZ#EoPxmc9JxpLpwLn%UZ9s&L$?BSCN_QUZM0W^D zU-(Z8`1?bA2**^dlZu7xNnX>{3mnyF0hhCO%?t~l$$j%ameEI)^f5VpkU`Z3pXU#P zuHJbIy0blzdSLPkAjG+Aj=b`jKvt#n^4f;-ASr=nn?;4-QZP~}Ekn68pB)ljl6Ol} zG2%!H>@fR&BmoI%rMF_swqjarP)Ih&|0lNd^b3$3WR$9t;USZBeKyY0g?J@rI3{#6 z8Q8JR`wXY?57T5$E5}2t$e}k7*=IFYY;*#O-fU$qTFN$;zSdbk%VFy8ys~r&9DCN! z6*@SPj~Qux0M-nJ;+=Z7qQH7a6iu(9(9ND?F0ak(j=7h_Q#88Wn67>f-{(La$o$CiR^`c>i&VlUft6$6m`p{ zAx4#hbr7Cknyo%7W?PwL==^x_qGSv;lJ2pM+(CBy-xGfm%Wi#cIpEqEEbUoVpOhM8 zo#pIre0~K!+ZI4}QEo6npfM^40f5`gJ zTwkhtXt7CB1Ou+Dcg`B;WoBUuH35E$pc9l-NAR*UfI6% z`XN_!wUR0s&1W0X+x2aNEzi&AP3fd9R!N*@RuTeK(Hr|S+l^WIQd%p{N}O%I%K?-& z#St^PNa{?dm+xRpjLjtyY{JGhcqCPFW1DnBz#gjA+VZ2*OQc!=gKTqGMFKAq%(cI}Sm5?r!2Mlaysdi^XO9O8ESW)fd4cU)3G zTo(6Xfep(W7W_T?W?htfNSFx#d!L{a(vmU|<|%CIqIGlTq(4p_ddM)|kHMdrOfd|p zXwN9U2*qcYp(lrDo`@jjy3-D%<}eQca_3jqWZz?hx##mB;OFrmz5My)yZz4xW99P1 zfTwzmn*J?Y&H6nxGb>t@B-6jw3DB}`$#3#hvSPE(@SLVi#WEb=DKf6o04j0Z36f`E zwuM3DefsS$onxli*;`g$0z40fQ4DTbjV{YiV^~r^T^JbyFBr}7Wrgsv<9LUmO`u`Q zLlqlUwA607y)>JFI-@OVgpma2Sb*W@I^OkCz zb3NDw&{rC_;EWw;=6KY62o&_VGh9W^jN0xtM)S`=t+?ZQ&rdU|KZunR=L(4;0<%rc z+Iep^kp1D7UOMZQOBMFZ!Te5}jy6HOcx{uE>0UFV{$sX@2C|S~Wcm&Mlz>1=m69aw z`oNabtLKceG;<-r4Bkem%sISkn)BqdDG(R`ZekIgMCTi@v4aUUR2TF|hVHBLqGYjS z=Z3Px=zCNCYF4E_@)-YfQlqYMV=&faXo`zG{A>WPB+qw%?C1og z0X)OGt5zSai@%q6$$532<>Hg$X)Zbw|6_Z;8zb;4on`eLrtM$g5PFfr%`=Ut$Y?#) z5J02z*DIT8DN0*{pR6Gf{R$@j9`zm7!yKLjq>@~*@-NV`#PNCIYq_pgtLfLBX+63G z+1fXbCq9tE>z60;RJI43fgfl2#+7ENo>Py@K3i{TeIZkj9fLeb-kP)4vLG&0%2p$1 zM{Ps=M0{5Ja}=AmnKiAg=*Tak;-`Tm*Z|>ZTiVRF+Ga8ftZtZMt3}veL)>zFX#GWLu7?=J8x3|gSHBP)BeLmr=!@G zhaDm{D_mI<=&5VrByn& zshk0`hvFjsl=R~3Xe{}h#74#ZBt5lrl)45isP*0br}wNMLe%DGDth*kce5C~q?47e z*60kOJ{8-8>_&EK*oWZlTchZ{xF=+KwDG+4`%MCDwfG59Pj$0_nH`2>ZC>i?AMdlP zoJ#t`h|iYi#s3bF=6HN{+nTqsJx?jTy+Woqi{r81>Jich7c)kNneb zfBhUDT!v907&O6wf|0#{;3iGH_)ZQA$D?Q`Ljerj+e2V9rMeL~$`jjtbj9E_-`5L5 z)B)?rBr3m7J@+tSMg%RnX|=Y7sI z<@?6y9^N??^MN(aECugjoy}^Rk4kQ-7Py%sv|}usVzASMC8px$Ook=BRRYcwoPTV_ zEp6F$h!BJDUI)5zB%D*b{10{JUO&|cR%&OBWLwZ6qO_9ehe3B8rFLRL81|Vt1 z``^>fkn+l5Mn;v}3aqW`!Y!ZnP7B6^gQi17A@7?NWdd$1Luqh=*2Bi(#;s4XZ)B1} zjCMacCHuFVG6Fa&=c5gf3tNpEN#Y!@?dYL|{*f~?!ntk)PpexpNoz1WcQY=z zB{7ma#-&4kx=c}ks1VBzYD)EUR-kz=wIIAi7Hv3-*>{*+!otg5`zS~v)p)2iqCayq zb;*q8?6I}uo4*1?b7u~Y`HlqWt=%&(Nv_fg>E_F;dFKph%9+QDoX^p@CYcUxcmBF^ z^%EK7(I?v%`&P87?4|}S@Xvonvsh@?V}jk(kR0_(^PcgbfYjcJ3GO#Mnf{%-r5ZM`Hn~e z?0eCI9GoCpy}G57mI}+Wb0pW-(8W9+Stq7de`VZ_KV3i3WBYcrTSr1j>H$9 zY2F|I+r&bCe{478XD24or#_{mU5(PgTR!XmRLsh-^};0F4wTlcO?0cJmc&lr?wL@N z>V4al;Crf$6q`K|@EeeRx2lXLm45Xm2%UtZDj=~+&<8>4oa+E~VsD470mu(AjUub^ z`9Fh=SFf%;HJU?vMH_!L_&S&_@*a$ziT&Gx8IrAS^Dbv_RN5goxvQUEyD=svGJ6=a zWjyN)kFtaK55-}5Sc8O{tSJTOt_GmESo2DWVUdrm6j^eYD}x%33ij_e2OlfepAdRYKrK%T#a zX9H{pYkrROV810*$x8%qANpjSg?zUl@RY~r;WCv@DuaB@@uguM_x;P|KLS*nmB*C= z5~ecGAqVmX%;y2{1hsV_p+^I9uglB-oqd#o1ztmV{lC08h z#^8GzV>jcUJCvCleD+rM48}_7X~T)-o#Tk+dDcLG@Jj5DNvVM)mK}+CC&(O(7*)dy zaAyZ?WKd(XCJ=ojK+|W&!S(~oAo$_;&y?o0eh+<~CzUjk(vqaY5#spT#{Q{f<8f+n zqA8s}UpVt|R+zUTz$+X@kAtO-ab7!zhdt6fZx6T$O)7p=t{`c@?@aX8XW7Yi@x9{t zymjRQg4UCB!LhxirYzdNi~)=zRsU3#fsY~J48{UYYqbX(rrh6w=o1%gJL*Zq`81#D z9cRbuXaP0!lYGKayrk-DiBR zr{4_-r&2ClTX}Hm>{%!kP~)LWF5A{xe-m5ub02L+CWGX>p4QLNYW*O1nn6oL+4|G= zy`B*O=_%<#iv5k03WQ88ciHN*M0$@HXvhk_=p%{T2H4i#M`K?_HlZ}S^c=>{I5a*h zA9u6Nerx-)W5y9*_Gs9wR@k3M?2*QA$5(wv%MEfLs?6&m>jkiV6KB3880Dvjtmk^l zsXQIoDBFgc>_0f9=20@;&ABI7{gIM!yPrvr=%k6nl>N`%uWGghF*8{dS>T_3UEUd) z8;!E3`~7#VjOl#NoXlpaA%Qveu?2)VkWwkBb;9V+_PgJ} zBbHCdmxJEIXN{}Jl3eOX>5C3{3rFNZw6*=b0&M$!jQIMTEvGhVn++0V>g!GH{6>rY z>^9#ZK{{?vL?i=j79Cc_mqg}D(zB)DMGv=%QL(qo?$kh5j;){h2@48QLqVXN7co_ZkM z9zD$rhw`(f@M_dl=&mu}VU4Z;{*#FPoWLzL6^EHoF~#!_nDrJ!jNXK#97FDmHhc<5 zK}Qd^lx4L9&}l6^^DM>>rZ(QP9F#2Q=P+1x=S85s{SFM3q9Y+qq|=YGNopdi$2uK3 zH_iuP7XKW2^{LPvjG4KP_d36nVfQ<9#SOWNTYqfk%LM1#e4>T(Ql)5XwKzmj`U}PX(QOt z87UKQVXTT2ODn^LqV8lA9)593*_co@?z?x|#*RqQHs0kaw_#w7;j{hxl&w5?FC(l>Ie|((G9`){aqgR%D3~GAjlwQlh1UT< z`FWiIHOR85F!=u`;Hr5UR7a97I|L-`1la)IB8xAGDoIm!vul}*t+5U8eF4HMC3EEc z>Oe9A$h)?*JEV(GwqIFK8KJ!Kw6PZj=@QfT_N^1>WeCOwwOXCed2RoA4Z)NRb-Il+ z75S3!*kM7)+O)P(DfYrn`!WQTvQpmA!_Z+E#pfDiI74;Gq`TE8EAf&YD+b-YH%D8*bCliGw%hoJQ+u{8m-A=(a#Cllv(-B@ z$zJFEg`LP5pySMr@t*a_A-*TGRHjvW@H5zqY1J=&xgjB%K)N)nY-lyZ3BO<}=btls z!QB;vRb2ksh|n9tqZmH*PZf*XqnFeZHjWh`%6~#lrlgpoPY5?dTjefo=H;a7X}{`_V@5S zBrDa;oRrMs$V>qRIaMENROs|s7p~1`S$axjx*0Cl2N_!;p{td{t)#? z1y;BHYN{0+Fs*j_yz9Y!nn*9{C2HGeIdj9Q>}E1i9gzH`Ffu| zms$Aw|NDRaUu*P(9fwP8+`#DL5MWM5TA&{1@@9z;%s62jaLE6By21av28P6Uw*gEH zZ%s1Z7?QRi4FiYlw9PDA#w{RC9FYra1iLZBOL7n!*+}4Z=v^85l=GwN;L72C~L=Xv503m7cbA^JIHyE;>=Nau_ z9=(BT@*HLhZS!JHY}wh4&g zJT{XOH_G*Ot&&t{_>A;UF@Mwz`LHq-poZc$p(YR4N8U^BD}e}m?{5G(ITMm2BDcHV z)1hVgoWaq(3iryX2M_gTFCHrd_l*T3m`^3i^I`Rq5z(p5O8<4~ru3fd+njmZ99ExN zsy`*1v{+e3g;8+@3kIYjoBG#AC`1Q$pdt8lMm=*T=9p}F`}}Rlvf5Hr#IioH+h+1N zJI2Ayp0U_vrk^w4AVU$58IZu-4{w}1MpCik1GQ4!c-Ecsy z>1Q*w$&tE$l<#RNJDPRajvsum2oz)Z66?%!Iw)kCTPgppJXzqj5u~6 zt$+m|UhVJseMS%tI2^1EpZlKclD2+S{b5@JJD25-3{|adpLNC#f^K9&AHpkrZ)7iC z0_3Rbr%XbL?TYQ)UhX^}_kKbUe$FjqkgBPlk#_oW2y4A}kc>eOL~|GOakylx<@y7% zCujCD9WY3)JmJjDamS+go2D3&bP`hXel1#6{O!Kt<;$D zwiAJk)`uV+>p;jMbk=#8Y(s;BVB@?{S%Paerfi zXNO)5x`6+g{XAy5OfZYUINv}^%tb;565t-@^DN#$z6p#>@HNN&NOMe&yU3PgF?H*bdOz#J1er!3aJGdQQWo9(#eH9 zTl08BAeze7`0(l4o^-3g(e#Dnw0=woT3)brpA^qE$AoTu^hA<()64BDr*!gsiu{+q ze_k?SM4-ad%8|)NrNVaLQt54y4~kqPNo zXLj(QkTcIFI%|V7j5$5cX_Htj7>)$&;CTZMv@*+UPPv*{kaLHr?O=~nSJkfG=>TTY zURVQ8dS@V*upg}f;=8gUJNBneqOx@>uZ*7HCG5TCjX~NiqVetd9Vc(DW*((2FVDM! zGfSR<#9Wwd9VD|{5D*(Ec6swfe=aHdbmFahf9MK?ygG|rsMmU~XMSq{sRkq;I z{5)#(zvF}%QU0Hx+8^4b^#_|ZC&tm(cO^O3R$u)5+4~6$*?%Tk3c=ER+|GyST8!rB zij95~E5R%V<`G)QDH&@2iu@NN<_xiS_1?SAsHq-!Z51jHdF$)@*l^|V?43`T26DQY zJrJKC>=QNe{ngt>6R0j%V`6w!v6dB z&T(mef{rb@l9{vj<@Re<^KR!4`t1cRDH+`y+%i!(!myAI)XyrKbSX0;DD5_5zCi9R zm5vbD=m)@IoEL+>eH@b4`!qt)$=ntK^n8tKe?GtU$4a|dpkg7&4pR%Mg}YUb=Z5?( z?4}uUK-N?4;RAdOVAJ3bH{QOZ8-b=8#Pb3;yMr+$=+E;mL?{P0gI915Eqbu6CkLZp zcvk0u9fbj`0d>4aq=X^R=HK}Hc5r#33?FuEFkqxYctI3JvDiQrPBGgp&Ipyl;RxBBhF z^hLuX`TTyIQQ94BOJ<8e66A^54<}ih7@e-|Q+4ov_Wd;pz`q72Z7MGqYuvJa^dq~u z+W}H^NV793?Ek%TLJy~weFoGDl z?$R&z#NVtDZBWI#x*;1I1rRG~FH`Ox9EMkr2vQi=EhWc}Y(<5_K%)rKf|BU;l>`3K z@Esw-{7$JZ2$ASvTrG79!mchEBf%p3{IRJx+Bwo3s(xZq(M3N?0(8#)jIw9>4rQfk zXRQN3a7}$A8`l;zr7# zPA$RW&(F$AWBmd|_)izK)uSgMN~7uQLVl!V0xLwJ0d2Q`+AhmMYhNgcWLtRtWSQrQ zzjn6c&al0*Xn!fnnWdDv?i`CT@(UKIl{k4*pY##nex!yGT3`lmNoE-sgt} zYtizN>`Q6ah{{!r&&jM0KYN#hz=?dz@8a*V1NcEw1WpF~xEioEw?E{hdzhPN@DBUe zCoj&b+2H#(k++p9@JGGvK9Vl>$89H|(Y+7Yk3HjC*K4A77^0ldHhzGx z>RG}y{lnR`vRUK|Fjei}^~j&gXJ(rI#b-9zVKmhNpN)<6eB~qZ%B=*eYW%a6^~j~U zbnXw9xp@9mZ;$}$Ig}p1r0Wu_X7BZuwu7&bojs#|6FB)#k6Zn^dV|q3p5VXyL;RT7 zFm$j-Wo+EsPY*MQ(4oSP_v1q0POvp0{K23VL_0WT%lEtH*1q%-OxE0lTf`3NXK+H> zhD5}?xq?cODY;_jdIn1D6X&(b!*WX#@Y}69K@-!ubEKbbZ>!v1kje%1>r17@_jT;w z=4^cz_N|nJ;tp8E&USQm7I`S4Uf#bUdUu^_OJ2nX5r_apZguI!ZZV(aorR&!%nlj9 z&ghnHyP8Dm4M}gk>Y?^SFHc7CvD7D_Fa zw5?71>L-Z{E*JLFvE2AzxzndTm!^3?`@CYFo0c4ktvEUgMlO6&NA~P6JeNwgvHnVY zQzOxRKLnTMZm0}OiK5#msqnb{%0d~(cIW6js61m)*$)$cCw)g!+ey?;Srf*tZgL{ zLvaj$oH0BBzftQ+&psevqV)6{PkvXMAb0653X?KJjB9E1oQGcH(lZC=hOq`3oJR_E zn#sF%bQq;SzKcNAy`l8T5scQ}+j!8Q+~$y$1mn;@0s-j{kbdYRN~XyM4HDy&{u34y zaKiv(pV2x)zHG844*6`527r3b}iH4pzol zqvI@R`+OgiGMOQJCd|jqa3F*zsjvG*Z7k>o0@O#jj*jkqA#81gtoY5M#4Ui-|OXMWsuL*oka$e&$$KWj`c;110?J&yBtig_rkns-Zj*n;n zLyeT#7wPpCK!Fi$1o>ABKDWdP!-{O2Dwnm9pby!2-E63kq9$*gRdz2U7R8K>D@MKR`I-|*qO@4d zI(wYEvc*Bmo_{~TgfkS`EGl9eXBY?i?pEYoAcz9Siors~5Uoku71cf+;-Dq522TOH z8Ini9;XS$7l*{J=tQy&A4aXOFN~!yZ)n&Frr;g4;7VZ8%C2By+iK<+$ic@86t~+~x zbppuQDQ=yON^C?yI++e9-Bt!CJz)isyv;QF1e1!K^Zn&>6r`BRH$H!|v)(#qlkd-Y zG@e>s3Vn~u8M%DfcJK)>l>a;)x|uF}&RKG}CO*PcXJ=hn`Ps_o0qENR%%Nm4<=Fia z2HIMJB^6Y&L%@2$7gah+2Fzgpw#bH?+#69IDb8H-Jxw4sW%B6eZ;Gs3e5Gt36d+wX zX(QWrGZEcXlszg21zs#~?_etvthJuZNx9zOwA(&?nr%8c4RmulLK zPc*7m7`-A8;<+6(xrf;QZhR0^n4gXR@faWQMVEe>#Yd%(;Kmu})`Gfc0lDv|x?C+a zp7o=XbFh7#@kWm{p=DihL6Eshut8e!W#F-C)$e@Pi`h36-lKAV1E%8_19_d@kAHax zCWYN};^-%QjUR6BCzUCg{iKj4!BFSZHyq-;=AB)%ts|E2TdgYl&=Y$K*%)3t3pI-5 zmt9K|2e0mk9or^c@sG&}%ip8ApSeA=_~%ghbB16wL!O!3FIrFRrmTEvMM{rGhU!Kv zeeU*UrzIU{j@MSqVcwId!sAShHV8KOFYC#o|E`c&$iNv$b=<0Uru3XYx=a~xHnHPpgYhne6D()B_Clk{OsjciVE(8@Dio@M`FlfDH{iX?iovFNixKfVv!F-H%WO0?)aGNF)F#Yx844mc}r_i20bAdn%qPZFc$$^U+Kl7~Y7V;hxY zh_BVQk(rP?j@^dDrv9+FL9xEsCh6nE4hZkG-d2|4bF{5>mYe*w?;vr_%sU&x-%v`s z*i)strN86n_Sd?-PUZM?+6kb$0C*|`K+pHVbCrSq1~Xa1CugbsUI(!E9!h7M0FI{t z8v<}-b(O9IBgJqLI0Wzqc<5aB~U}+UR#Cb7*;;rB=HP&X(vvt6UC|C(m|3y7aFbDC*A!*a*4Z``WeNX|N{Om=O6N4#F9 z$U8WSA@Bvyo@r!Q7(zSQ=yhU*dS;DLtcS6e@3okF@m(2K(kiqv_aNtj(`$x-{r&mf zpKA8q`h9i~QXE1RnUsLh#~GE}nQU2}b=vf*J?6^izcP3|^-nffm3Vj5Wk;N9l{NS^ zI-R_&%p4cafrmVDCUtC?VbYNum{JEBXF)_=8=p$gA%*`-y$tM#@6Wx5 zj~{G@&n@zH0rR=exo#~vkSv++x$B7{zunqDs086L{?g3vo#@_V!#e=LvQYVX4H=rq zXTUK(OK-OIY7Bz1rC|7c`pUq6%i=53pRAb9L=`%pbD+ojI~~3NkuEzQF-S!sXz1BO zdjD}B13GNsp3P4XDP;pd2BInN+icU7iKF>!kqAiNZ+SL|nK)hsbWVHXcyqrYI+9WG zzUtSVCLo>uGf+vk+6CU@om`cMQsFtGAB+BWEn!6O};Z>}SPxR%~bu zdh_u=BV{$3=hYl%4~untGaDq1Z2PjB(*tMk+U+Eu00!30pY+6bcyinZ63?Oc8rj)d z7_>=Qk4@C29Y^V7ZQJ5&A=7RLnm>7ewl<67YP~g(;1`1HGk|ORmbu6qM2=W5*)8dp z;6K5d?ac-bz3DLf$7GSvx0#R@_1=emeixN@$8&z4T0GSpS3QOZ$oromAw*@EaxXS) zg>My=0kM^%1R2M`N{h|f8Hk< z%J@B38iXkAys>Q~L)lzmQp|PuR+GdwNv3|hj&rD#pj}u=JnfJ^7>`cLewC+%%GjuH zu+Uk1$*m>XzlA>?Ih|xsG3)-MCD5y#)wf?uTil^i#j-h<)`&UVE|NBzgMWPcrNPkr zzmOR1jqGcvcy|ywzy%u+#yyQrk*U%F=8c1=sGj^nBq#rt+MBs~c zrS69qQrnV&&@7pPa_XpYyGi)b5*zAgfApv`9DUNrcUFJ3m;qn$fWIG;WpH=$Y=qd~ zvpOD^8e3JODwU+jRzvR(8Y4eD zX_K$vGh-h@K6nk=WxVnM%m~(^)-c%s5ZCr5?cWDDn}OsTw9Xpi=a)@a`cj28FiO zd4W?{on-tKkUD1pQP%ibyCWRjc_m;a_{R90lGnS0^;79NvzddDRL?;OaL#V9-se!> zw`OMn`0*<)+5qWr=QArLhsf%g-g4$z2jz+jmEJzrb95+8a%oWHq3Ag`u;_wuPGb-T zWw@`=0VLS~DOD8_-Z<)j!Bg+wYj#lKNuL|9S#sa)&K^*lk+U9G0ooBUpLfU+Gw^S( zV#@WameoM60Ta1P&Q5@IRjF_7;FbLKo6!I-U|j3;%Fj8M>E$+uk6cYN0PYd}Y}bJ0 z(BoDLN%^wjVf)Xt&T+|M^vbOhHbSG)`3sxmwgPuZ2%ymGI!}tS; zNZX2fHn7j7apv&JW{^CB$0~Gky2hBPnCgr7AgAR4q1g6>3P@gaB+T4=v|vmyhftB_9qroAqjJ?!jj|$Wiomb~`jfkd-NyEMnB4V!sBzF4 zbn^y2Dg0ECjTtR@Yy=N85797jL9s38nzSS99MIgU`ly`0X}UYsCx5eA$-@3uHz?ne<(evm)Dd zq-(bS^+$7gr$+P+BH7b#ghswc9E!R4t#iMG@~zDif8@gD%iT7X=v zb-fz7jY*SI|I#J1zbNJ-KMCTKkv6d|m(z}0hI;+0G-F#>t=Csf1_8SPCDk61+;aAx zA;~e!rQlhVHMzs{8ZWs=W1M1kJQbDhqb#KbSj|oMq@tlbs<4UWZ1#kB=OGpJ0E$|PZ6A^ay5yPJ45#P zq2j=Ik|EG%1jR|fRi(!-W*-}TBm%F;_w+YBWIJI}x=V&gX-A3A#F15*um!W(Z1!u1 zPslRkr#_`iRTT(x1J2ATOI378M{<@gj^`d+ip^s@#_vg5Dcauo49Lhsn_W=K$5(~E z5i)&dmwN7Zizoj+%euGH;?_iNwE>2O&j~N^3*^*PiEc>-m7>2#45j{5xt1aDsiv*U ziNh*yNo;J!6Z=P8BG!_|iaw>SLc{&)eY=AV@H_f0&ie4Qy^I9@o5lQHwz-9Uv?uFN zY~c67ZEjn-N}jJVkVAZ4TDs3{ZIa$9S!_ejM@N@3q7!@%;4ew?(1+0TPj}G5$ z+jJVgM|`vKTNOz~QfT;RtAy9FmZ+vecg`i0$aC+Pw=eKm13p1m{F^1;u7^@;GMVHe zl}VZ>K|;L_Fm7XHVarEa3=SF1TA+4vAV5lyC5arbJv#sT?2zp`FMJ83#a?E%Zi=_AQ)M~;_T&qX=Bc#Y(W1+?~AwA`FFZK z>)o4I8$ z%%&%}z2VN{LsgVGl7%`GB8wRv6QM`+76cZ|e7MDuC?Q{cy|d-A26Ew>g-pzwEm?U1 zO!ArLd;Cn86gy0;NC1#3+^qaM3a-Ka)0{V)n&s z&^_hyDrKVkucW?||2e>sJU}gg-1;)gT#4#OtM(PZY56gUbn-&jqJ@DFWU}1Gq3j8~ z1~k7my2=2yDe2FQmMh^opQNMfvF_ER^b!5U2`1*S(Q?rLG4(OSFNr8$? zl(J9!)qw;!*u5E7X0>$sXV5hUaAacQfE}%@VCx~QWBuj z#&Sl>+hCI>Fp=P=M)fQ0>Of9o$RbUP`5D$Pe+E7BeB;BSk27guvFyfuI3po&9Dy_~ zcvl8}k>M&SWtSqjastGE@6R}@zO?F;iHuac0oMYK4P2c4&A=)jEB8+|PEnl`4$W9% z-ZMO0_w`*5K-_D;r1N_nY4uA~{zEtb^jtmJpTLv%qH=DD1rD(;80SO$x?OF&NAjjg zqt`#!RvKp<`slY;75VNH8Mk90AEaWYfaCzB?^|hd_1c#@F2SyxHdRpP6NtxuS)US+ zzP8UKbZu40K%gE89{{@hrP6Di;06aZddZKPB`4H>(j?CptmAjOI{J0+3TvR5rByVvTb9 z+|#x%>fQlzFUk4Y0P&ICNRQMyKiUn7N}-9R!>&|eGDh#*3$JiiO=}{lN`_~ z9jb3m#n<*u$af$MzCYBNoeS9;UuDJI^6|YpS?2lu*suII6W*=Y1e~{2*qFn+g%nAV z;Y40ZZn^U3iOJkA@ZS%|gx1=Z+Fx3N!r$Q_)9tgbY+*ckQHYl05ic(f@t+}h z-h@VAB7v)oZHFX6e71?5&-0(rGslGAHHNedhe+iPl9edQ)mLmH>*yaDn$r45CE-*h zQK7u?4b>i%?|U;-8r~!WL$!B2&u;n7pBe5BI{gEe+~fQ4Pp z!u7hB-c(IWtAF%S`K)l|r*w)HLJw!IyMcu$jT-Iot}wWCHGO$yB|Hv7@_dRJ&-?({ zdH4g}k6NeHx-L))6*p2n4A6_>&+!C%3{92q&&HTwVoaO}`SBF=~VSBXU=Q@GQT>?gy;;1y9?ZEpW|d|Zc)Z30-`x&j%+^;L{>rk zc-@Wd(-H(!hnV~v;NBq(D3|S7O?niaJ@p>yQ9l4){mFrg@8lkBG<;7y7)r@8W;CwJD&pkI97 z0&f`FypIv}B113A*E=d3C z*N^&IP?XwaMkT;VZ{X7_eA&}bQ*%W^dDt% zOdogI>I244^y{OmzT1J&v7b*Rregzi_4vI`x$5s$ZxscWMHw7f8bHwnL*N^prLqlo z`TVX=e=QprepkknsX~Hi8x=F2daD-{jP(KBu}`N)Iu2M|Da%|diHZRd3RBYkvo1P< zv|p;dB|m#fe@Cjn$Im_Wrd<0^+Xgng|8Q3!q)9qRrQJggR>)-WokpIZ@VxuyXa6Yx zC`qhS^6)BcLZBJgxuwqvQBhzNNF;oU^tZlx2i|6D!q|R!rCy=KWQtSSSLxX&DMKY_ z_i7+w)dSYv829%e+1r1f;N84px8vYr4YrmD=of54`NHd|GP?0 zJ$t@|k64d0!<;O~5(!#QCz<19TH=5??JW;UDwH(mEpgBJD)CTi(`$5lG!#~AufY)^5@*ZWQluEiAR13KQQB5UAi<-{Fe@pEPQR(2 zzh-m*U2e;8-<2nQmsBnZt#dH)FFSp<{LGFcyMn8jK779K>cD0S#+E@uuGXHn8et5y z=3{WHV8<|!0}FU4i7aJE7xF^6upQQQi5e9hJz=J6ugwHOvin-_;U3(pu&5JRO(3Xb zJ!Pkrk`B=~RRNiiD+f7}cF2=wC$tBtlzYj84ZI5+`LgFwwjM|%TF)CqJlmHqp1HPU zarEe^jcC^4{^m74f=M>$!^z~%F<3qVdTd$gbR@T`9GL!2pp`ru?=YV5>*Q*JQjF$E z->ksCLq14FU!V2mmmsU&K=ApHaHGJdHYkFG%y-mfTSun~g#G3O9JA_OYy!}dng&=G zhiaLgw5v>MD9f_UMAl*r`FvVAJZQ&Ce_AljTvDDTW#qE{Hej<86wPbDTef9h*<*WH zORP$Dn?T0YP6!J-&UaXuH0!kezh^Uo?vLl(tj+5mGK1cv08$=6f>(TWUm%D+^)s4t zwhYy$*=zTV^{pu{q1TkXmpoY?pgsB|0|1{xlhVZIiJ~$G(XC{SC$Wu0b;Qhz7o2c8 z`%cCp9v&PtuiOV?G`~cey>jrBtD{-5I%K%*A+71EOv=<6#)JsBUz7_HNxVb z({fh0?Y~Bs%q8+u>C3h3JYDv09a|=Bzm&1sS#PYh5wASV$Ej^~R>^j9q&uFR9(t!0 zUo;y46zx31EToOX!3*~Zh6{o3fHA~#xk_RnpmW9ouMLujfTlgDRa=eP{C$GKuEP*Z z-$z!Yw!XN=c-DUOQdLI_V&qGO3|iJq#v7+T2YZ!4uzKtnu-gLr6*8aTut^kodjMp^ zxVHPv+`hV|53#UF<&4O@XuFUrp=)ex2nMWg;iG0$bxA7yIUbIG%O&MZDdN)Y<$2LcFA_V>5LhLw3IUoTs8eD(*K7?Gs?*Q0u- zi58-I-SIQX>Rp$6i3duftr*OGO#*J)m%*+A5!X&DNwZ^TT_=@ywgug>4X&k^Likn50bu`XF`$6Dy@LqZC$xdp36_QU;mcnn`o=~AukQeCF%Lsn(s}LwCXJAf^b9%%XBay_`}l#Z zOaJTt`CnxGxlGx3q!=g6goU>^&`POh_G3QvI#2_p+J~BWFlC#M< z@-YKBquqlJKne5mRQlyc8A@5@&w1qEpI76+^xEOD z!W3?QDBr(UHt3L^{EbxdbC+``<8T847?ydSW59r-KV;XoFAFe>*nU9S!V1pOWY11h zhQx6RGP$e(Gy3Sg&c;BcDQR%v#w=wpnoe?~{0C=LjXmhuy{!hvsj%qvM0H|wW{rK$ zuch66o)tz38tWM|)d;Fr{c(uR?22KhJUyEAd_VNfVvOeFe9sPqtXmqG@cnrREbBLx zGGeJ0e4Zfrlp)G;95Kjih7dSI5P?ibj;5$~iX8!PlK?c3B;emnaWcZA%_=`-Sr;l9 zSq&-T?;8D8a;Df180Grso?qfIK(^!JK4$V9$vq%cfyK9e!#U3^ z$UO1dz|k<963iQLtbL}SQ3vb*SG_^3l`OhJ3Sk|46o`RNkh>yS8p?bv{h3ZckPzrNPKg^c04PnY-qzk>dArVV3PqCF33J~~=&wB5Uz%8lLl;d&^zSiKX$w@AV z@fAaIG#SXgD^r*>bVe(|w&_js#P_r?c7OLRJ=Qrcjd@^HTS$2(Ap6cYZ|-w4|=H<<+}_Zoq_y{QLI!owYyw$sIDAEob|COQNgJ5(>t{ zN8OFw^Jk;QC(4G0W3y6EF*_ti1^+^Y>*~XBv-pSo>Db$HXnseuUxF2rIN~!rmxH!u z?Px;ffnt^C$Zc(zcaT$ocxc)O;+zkDWe5aI$3f>wApapVBHQarnHePJH9dL$*VYFf zRQw(`#L2Vff2VqF7U!k?sKCjyLAoV;&UyU@*y(7tGC9!HXCGf>q45AzJCdo_w^={@ zjHlipYukpg2f@<*&B(2N@%hZR@IxHrc2@r)05jT+Icafr#qd?oM&5UUV({QORKpCq z!0e;?J>;A>4bhm!eInN73pN5R$c5To6Ap`ubJwr|M|zx$!( za(J>GfQ%+ba!t@6#r1WI+!1(L$WK+vQ#}N`RsISgaQ3j7OA^d@doC~H=feST86jCvkg3UrbwHUv>|FY!;+Rg9$1*o%qtHw^?vrd9)fz|gq+uJ8Oev3XJAgz_ zhb_L>Wytf^|L*VQtYXv-pfKh0ZnKD7`QB&9l2qVDeqYN(zq(0?6|jb0&9U=JxL$fO zs^=LX8S|E-zG$N$XNF8ZcRDZFb8sDJ^2r#8z*dE`p~Q(`Bw0X;>HWda=+u?lBG|)w z3{Ep!p`!Dg)prKSrmD#1I%Y4bDUL#-Cm3yc(rtp6s;vDw1YQ{18B#uHTR1!nboTrX zgh%$w7DSh`Eg0B2svSIcy+vT`JlSumu&bxsCVp3eH)rDiOU-{ztDpMF1FaDGcR+LO zOTa{kx1iRV^ynjLl)L)(X~igVCmnF(tgx@fC2KR8^1$VGljg}m2r8( z1hJg`3o4u)DWfvGDD0O(kFzi(sUGQPhU6uFN2-*$CZjE9cy$f~35)m>yH(LITyt{4V!1f!Js;4M9F6r9loar4>=ki49-4I~=o6^P+V0g<%t@m|m zd!;Qahu=ej>TPNA`T2Ywg3j*RUe3vVY!yOmP7`wjUd>$C;A@oa6UGP65;@7L?R4j! zm5#Hv%yM1?u@|}CY>x6VS50cj85;v^B`c&CVCrerVOsOC{?u_s_@~ho(P&9-Yspg~ zKmD_AAlE#K)#vdrCTGkN4A83BZs&_t$ckI3bmylbm<-6SakW?~UM9W7A!Avw>Gh{S zi6lqmS&+#gRX&#rn=L)`J)SD`T5Ja%R{;?0sxGC%^myOccTce%hSNq@)sQWceJz4A z<7&K!r-5Fo^y)TSJva(N4H16WR_Z6aVLCruyB(JeiBJkYqobjlNK3qHl#d? zoFu^4{m%vdiOG8Pzo=-MlosbP(18OmR_C0ho@AUuGTJ_zGEQsswIFe)n+l)6`dYi5 zs)9`K&-R@mv9ZI(=ID7|%G^Uw(-VvzpU^Xq9EiHVkIdkapJP}jcdW-Dv9gL2aBut9 zuRo5jb}V=ECm&K1%lkNibwcLLzO5u?K?rC~(3j|4ZzVzQGyW*Ef{dMvtCP)iskxNa z02OVF$zEZIJe~iNU44Doob=-R{pLK%8o|@!>^A!Br!0~l!E%1MNkG=ocS!I`)s)nf z7pEOGIKRXuFDfl={3E*juy%M#+P$}R)_37BB(*LBEFPn?gFR!a z9Y^%1WV~|UgTKJPyJ}NQQs*A$bMCsl_pzMDk8D^rwj0Su$1#K)nM&N<@0~(?4gY7! zVugG-d=P9_*w&(Kw#&rc6Xny79?S!nJ_urlZfFl_%jc?e4t*j#xW6{PYbB2{9LtyP z9M#{vyPz-8Ql4$-tHxPr4khMi+YOQdNB5OMdxhaIj7_HPPd+C!rbXFXEeq;^ z5Lo=j#Z45_Wob`AHW2ho9S@43AGZ|0-zZgt$lv}bJ!1iDKC7Q_#GKqoPv$T$AZeS* z-qV+4+01RZCrDu)%M9lMq}24z6ky@0ego^ctqqT|T4Q>alWPFoDVGsjPm)q#pcX9V z<7ihI*7j7S)@8xxh<(XY)6;)(LLNYc3lDhW=E6C-G`<14SqVZ$t{i}tds7TpQP>QJ z@l~LZQ<~$IXUIJb$FYPGf|ng8ZD_OAGALGcRz6w+u#lGbJ{xMQ_^! zSWGGVcT#sIlBG;7nf?qX>}ljjIAiqV&mF>UvJ(cE^KCobqf$M|U_OwA7^=zl)b`m| z3}0c`4>AsD-{2gB_jklR00o-?$a~LCWg^1IV#m|``Hrmu5ZQ>j>cr4#-9MnW{)!tvao3mI2$1O1+D_Hjw{Dp;(*CYNwDv}Kl0<3e2JFE*CfjtKjj{q zmMA}W?{ygWXq#JKdeVZ!dO$$CVI-y50bNTZ;_%3vb{{6?`_D~0Q7%7z-KSma@Dhl~ zU%$S#c_xDf`!UHx;5i5Ii(Rfpc3Y<(lXU?RYX=-Si{W9dtkg>`->n-SLR8$7d%6!1 z$CZIkwHz>x;tg~UW%;64u}AFj^*!8Cce6SU`@$fiBkU;Gr8DkBhtS)SvFK8Q9?BN`!aYU2KAE~{<2t;a&dKZ|^k+<}SM+vDf8aNt@lWYXZ?f}M ze*jx6Ppdp5O0mPSo(yk;^09T9cDG@8L{96(s{tf(XEM3!NSg? zkkpbtGxKI9dV?)5$bbVbt3&Czq$;ljJgTkm3Msoo*sYQ5MOhr@bJN z<})`Vi9wBA9S{f(ZfvlzO78oHK@7Ik*ijdcW=wPmI&tr(gZ44eaNh-5wyB2w&`9VlGlG zKXT;O4l$!7N(#C$_0deqO_pA7p;vQESeC%P)0>9LJE zNm898AHYwNin#>-r+mgIeg_PFM5X*Ft$?o3Ie8#jWAw%={m=&TiSr@~yqS4^2CSqn zie(N2+&}HE^qLK*;k0bfJ4#{)6D3a{od7CBxjiP>&PMe5%sXvU;|qLpxzc9JEb?T9 z=qnZwuI|g|3uAw#*Gc8CS{@7-kaOf-%afp*J*GNq#zQhGePE1UkovBYnjN%907pQ$ zzi>c*7RGPppQKW{vb+$T&l*=#T=6W)qGLb;s+?uZWw-tiSu16kFd?(DtJ2n3_-+nL z@q+939nU<{f)DG0D!ptLsObzC8OoS!IHzI&F zR1+u5h~%B>JGJ0@J#FXTMsEw(|JT*Krb&|JIC~&1W+D0{?SFxjM(PJ%(7aUh^mKJ* zguB@}ynx`Xj<~&q1ew2E8$^$12!zE>ChK6yl~O?g7Ik1Sb#rNUns(Y`IfB{C&$a=( za>+EZ-R$X3#=~a<*+X{V6~xHuv>`r(Z}bbkeVG=llV9N9duVLQI9`=VmJKj9V67v{eXde7 zGpF8GW@so9_hVlKmN2gsvT1o1NN8DCZ)*C}2lO3#F(hlSfAJlYIY!pso|0bcRR^6; z?(Z5zEU^_IQ9t);!TV2H=|XBFw~K9iL3}qQ9UUkJQcb_-=e-L)rl33kSdv~QRTIs2 z?nCwu34C{L|For=*Wmw|&wh%EB>ZJ_Cef)y7lXP}`kQQb+5*zb(+rwRS?xdMczy^W zKNN)bj-*H5D$G}J{ZsX;Ox&;W-`lQ?-g0GO(kE#ljJ>mrErh-2DL83iU)OlNUH^UM z{lw=W4=E;kbN;*E`EKKvAz{FAC6m7mPB8XcB{Q7iy)BVhTK)S8e(Q7&0&DAH<_tV_ z>qd#K^1iPtKN^DN_6~9waS=4V+^@jbPd@H2mN;{9+6iV{s{rT`IKFepn`V`+jJ@)J7mv!u? z{Jg8L`iZltog;^|34-y_;2m|7t)3%EtnPmV>mNp6fQzB_x2n*p)WylEe7kWRh0|@0pR}m*Kcdn&(IZZCWQi zJEn$MYYURn*wpwtge>-Z9+KA4?ZGVzhIlm%l13?>2ZsHcpgEAdKzwJxG@gci5 zF7Kz+_gev3Zi7tzF0oe3SqyfEAcbt<{_HzL#0<8^_IoxsEo9F?m{h(xzagoA+FW*E zDHo9<3)l(jb>#h=%lRukM zM3uUk)ZO}o{PB1AHvu*Ez+|Bqd{1qv03u_Q8JDUwvT@Q&kf5b>a&-0Ag$x$p<5A3mE<;Fm zKEng|PdJ28cBY4k{_PhV`Lpe^Bu^ZF{e9woRb+~B%=j2jgr>xDD67-rWPx(!-Jr>O zWrd$QU8{iYfHSTs1l*^;(W?L@uCxBp4(OkI0%&nZ9Veh{PJq=Hpa-((*zTC21P^#i z2L>bW7I%h|YCY`(F$Mv07PVGI*1SsuwV!QqyG*8;JCirhy3(k<0pM{O(mI$5g98Zu zESJoAPrVv8U%3N);5&e-oJC0%wit|f1LJCM(tUQvR>kO0ZdnhR%RR6Wf+vAN6XYL> z>K{G3W}lUF&6#md*~CC^ck)B3pxI);rrWDlEe*r%E+7NE(1-48Nic%_t6-~kx%XQ4 z63Aw_RC*%|d#Kaws9BzGegKsRF?}mYKe?@|`m#KG{SahZul~XWNK*Eyvvnnz*JQ^X zl*TdvC_-gC$+DKxohl}%e?5>OxPdt5tNY#?f;kR{bM9VMXP9KkjruYn`{Y^jLGJ~c zsRBCtzu1M6$*CVdC2Va#zVKV=jg*$zI=+`-;HcMK+V;(5IVlZK!1)9u?aiWC?&1yj zc@}^#&A(3u)~OL~e?uv~s?_B7l_2jwpF8B!;a~`w^gQo)!0&M1NHhc;C9`E=JDG_* z5&&4v_;}vMc`$wVyZFpA5G!?B7LqxJtfzcd0M;8;InK&QKhm=0s)x^b7q+X}#$oax z$r$VS<~fJTu1!KFWa1_-WD(<3G_mNcI*cE!)wK$hgMI6~ThO3IbwnO=6JJ_sjVuQU z4}jg97kLG2{G&aC__Ev zwO||VcSYdfkg`^>s_**^%-L*$PP@&PVSTA^lFzT&S?dk%+Rr@}mf~4`7*_u7Jl_qG z+&-dqNbK~aES%5%k@F&mn{pLK|J-wz2a2WS{;HtSt(B`fO$_$gMf-aQP+2x__6bQ% z=N0_tNe)itSI7aksJh9}=SQv5-&JEe!NfUymfU*EYuJXSihydk^4t-vn67Vsxl?Cn z%`bSsw3c?kw0yyGEV}YkI__nRf!xPtqz(E=z#|)IO?~XsZKFBQR1U9gM@jmVe(;1d z@Q?l}U7(H4b}$S+*;KXRU*xj*-qKYvCK>d^&V425eF2I8z+DV`{<#wkr$TE#EaX_v z?=_0Q_~r#Hc=MEAZQQ4!;!B=A0oJHxy`iM)_YD2n$yDiJZfEI5BN*JS7;{D&x&NmMRMShfLCJs?59)mZWeDv6> z#B}uj42^^s)})K|K#$MmHL9VHsED{^~p{*&ZmmcA{(Hh?_L&s4;}p0>J>^^ zE$y3ww6J{6tdt>7kr`*8Z8&@10}RXar&qZ!I$jMjs{OKA!{-@i1|Zu>I4Kx5Rn(38 zhj*W^$D{lX{R|ip{%ez6Ud{Y34qjKT_MvOCC>5b)NR|Q$Z3u-^soRrD#+^Ys&04br z661*1prMu_Yaes?os;j!3&VUR^tvZwYa&Chn1H^Y;)&R1u<45s@V&?vPnzbGT1Q_;|^fa01 z7J)4)v(HeTgiK5Nt4Bjt#KztR(0!VIhBqM4o(%A2rx+Bmvr4(*4s8-mppyWx7#61x z9dTwjg%-?k0vc%_vK(Pwi*p%gIYgzx);~|x4Uv^h*-CopWqsS1AeiUZLeQ;=tof65XLZh~@wz>)L_h1qmf|cn)jeBsCTWj!j3dnPn^>jl zWLIiCk;(1{f8I>Rb}4a!d=qy#t;KF8YZsEh4_muX&<+IeCYQGAqQH>;5+y)+6>vEkYvR}5L{1Rru0oVo64uR zWul_S{jBwsdOz<+QTJxIxb(XcQkQuyRoXY!AUge>HStGf62b`jT4>C_vyv=!t z@NzvaEj1Q+)1K9|IW9y*e8dn$62x!%i2srG=6sV(=#Bj>meez8Ub?oH6!3XlhV4hU z)NFNd@KI!X@u49x(0}2hucfP`Kg2tD!^UFck+D}lfxk?WzYv4{b57BiiTtkUJI0qN z+2QrTzjDqy#C<=@jEj&}wt1-(@jWs3zP59wRQ_7Dh{1Sb~+m&rmn4HF&l`~CU7M)tMw@03$l zX{+_5nz!6jT_w)}X?^kwKB^KKd1IYdrKg?jGp^u0u<2MlX&wB}%JTkiPEY>E})3dt|C2%sUN~Fy*Xt6Y3zRGzg}Y#s?ay9t?xmIW5nI$DT;U9#LtqG zYNr`i2JLtiZd*^;M^11#8KsIqbET|KP5F{9MdLyvqhxQy)J-(PZ~ z7*n3ZOdUa|n#+U@QgKX9lvGJVePO)$*4W>2tC(t$M&3)bxtzeV6*9IKjMWyt|5LJQF;?Vsk6<}E;wPiBfU z-}+%Y#Q=>@S^Z9I*Bl)~Fm2G27J;k)ONr1T?EU_6xXGTxxTK`zIdD4xz#B&rW$Zhu zB?IrSmBQEn%=y_K-9BlTsRO&WDC>0jr`Mrj2vyp@((NbZyS>N!Gw2hiqvf6d^sni` zuA;i-0SJ&Osj$P&lKB-M2(msWGm>7i^9iyZS&q7OfFe`ZjSB(lyUMh3Y4xw9e|nW3 zBM=cl(t%AtFyd+;bAucKmp|E#$iq{TR|DzpwnQJI(if%+3Rk7HKUUDCP>qyM}-^$PGWBsvjBV`Y`ouc*T=_IvFYUbIfHDs=? zl5cFQUfKY|J^1fmW`B4oUT@mX0COp$EVt#<>mL3WW7Iw_CkVLzH}*X&6LMzK7+q`H zqR_cz28hbT4F3st1M%z3(tH7X?fEfhQGGrR0@3LrV|YN4_KE$5qS+^uvL3e7df&*j zuywYqz3E5K%04N>(QXA^ZjOqmp)chII&a;uzk5uwjTW&zka+Jt#$w;^i|qFvQHe9K ze^&N}5ah&`{mf<>?58Kh%RwXo|E)@$B&QM-X3%yPHQ& zcz|C!gu=+gTd;_VtY}}*+QF>^`|4F@@EjrU12BGlY$vB4xI^2o2^NeU*yvbEjh{;| zca`?>?2`;ie!yZaT{ZHPXQ~9CB-ggIk1iqT>H3yTSIIIUvHU)XEV@?J9+n(L@q%5P z>4qri2c1PW+IHXfELA=F?Qc&Fc~P7=9a}&i9Gie0 zYh*y^a<_4BjXcvt&({jBIdc968<+Jk!@XON_F)h_+p~PO#2-%*NUf?rA4}$Bm1Dk; zuo{wt0&nbozC^{mF3W^T?Uc#;-3}XrbJH?x&ZN%HngTM8dPq1q=r59)=m-g}q1{Fd zpfuM84wbR@3Rw&>v6k0t7V%B@*_ElixbTLWl0<9%Y_8Om+n{>rF%%=pSPIY9*+4%- zA1L}(C-^{SSNb1bQ2S-33MSB24`BMsB+1T!zPdl9OwZq=jxjI255F=bh4sdPZGxlGHAU-tSNAW~IYU){Q=0ct-(a7BIKhs(w<^vo=ipc2 z)K-^)@p+$FR`!;EJ@sTd&!N=^?3ApuU-E6TKk`{SQ~C8>=jZZhFZ)0@KJ=Pq{`+0@ z76|ML@sTjv-odhf+_dE*0Z&-z1Vt%hGq5nw88Y84!SQIA3Ryt)%IIZog&oNzGk}vF zl&@0uCrRDPK(;=j;$si@q=+6U`ai1yA^r-29m`ZzCKqE!AO~(DjZ9KZoR#*=`tF__ zCi6dWuIXS0sF9o1vcI;Nf@=_O@@nZ`x*V$4}#jYXPD2Eq#DWz0&BnNC-&rWc`F}5$AUIZ}6MiEFwuXA1@ZX}E|5|MT& zSIqp&8#$}RduCem>UEF-(J9`2PpF*%^%_O8J^7)McK@NDjr{xXW>?Rk-_f1o9%ENa z5T@3Zp>#A_`J{yR);Y}q%T|CgJ0fP7P0-i-YB45v2l4iOlD>P1d=p4{>hJ(^Ig>70 z4u-Q9c4#Qy46yY(4K{zr+hS_IY)y;cH5rzbXCNS`yY$clni>c5>=Kxbrm^b@)B>#5 zwjp<{l)}a@VfPmQvgnW4tnu(z=o%nl~R|SINSCrTHIGHRD#f zZL&i@);mFgfmgd_VB-G>KmgAhpTt>cJ(y1?kJu^gRpd>T-umaiP4-JGy|)uYZ;9S> zugO&}n`>gH=Q6e--=&X03aU;2wEx{%MvLp0T}pqni8b`F9I%zrR#Mm}@W{vNU5lUP zKlp?1X$P40sU}Wd?})W7geQ<3I6%f4v$XcP{O$RtG@A7rVi{kxd|x>znvk6P>0s`~ z!+sNxNvVtp?n+hD6C$MA0}Vw0-E{=ul^^9m78}NMdbpwwIkVJ;Hb-|Ek)oIcV32e> zP9|`-oJp`oJl7auX>$I#@ z>8GNW>~=61g0_0_DUJ~=KO1OefEX_q-{v@Q6eH@A6M7hR;bZc^(pdRQnq(U?M+to zPg&DiV5(OkM;&9$tkh$FitN6c!xDNO*e(6}nSWth3lZC?&iqKk;E*LDvB>*gJ8h{5 z2wTMpK5QsS7e(hQzVovOZaEx$H|f{;NQWSYJ={jZNm+g>Y}cxuv~8yHghY!o7dn$$Ipw*CVqN+6kyYDy=1slKSLq}fgHyy zgA_ecO5Lo1p?vX@QfuRRrB2d;tt-3Tfc&pKPwQ-IF>E7jc6x0z79dq!0J9w6P7L5G z!`VF840dQRo?OH;ZH0Uc3>8+XeGv~%3KM-`bXBT9m@0%NJCGZxebhQ4D$(;$A_E$& zvS1cj5E}|mGDhI9m%bMp;|C_weg8K6HO}m;J+idPs%1;S{*;T7K|nDdw4!#juhs05 zk06R3i-1cfaW)yyL=UFun=YBfPPFXD$eQNIrXX=Lh&__iLEFC|}V3igL92vU5{5sM6{t)5_$*{x7mII3U;WsK?ba z`3y~fmG!`U(}RijyH^Enm#(z6C0A9%aA0unK6TwbCgB3?`+Ls~P>bZ;n<0IZ{MJR=7d;57&0C{~Fc?9m@joGJ(tl)RU``fFiPtrkJnk7drMtYm>a-M#L4 zBBn23ZnqAkxk|8Yr|kC%WBehKL?j!{|RI)dI?h@r1i?hkQP;X{$Z4pg)&M+ z4Q$KihA?5LTFMmncbD>KY*)!c%LweY%ByHT{!DLr<8dlhWptY)zYfs&&?oKGvCNKgMjQC>{s*>tiFZ3f7zS-@853ZqY`NE zabhwyAE)e((!4q{Kx*6gk5Lb#HQ?ZVT>+aVP*T0GK@IO4Li+<6wqv$i*zQwsz|nsC z>^T)=Sg@t5k0?ygoOMovjs$F6mP?cyn`zQZuhoHNd`Ge@pMQtggs@A7)uo)V!9b^> z7o0Num6&tGKN~^?l6%sUhd!wY#BHmYo}pDMLs3oFBLA_C5d0ZXYz&bU2lp_opX7<{ z{y0MwmU-|cH^^&VGB{)xr><{5gVdgG0=jbVi4mZ)R_HpRGz7uMBB}N~2Skr`=OlPb zo>2j@IiHNQF4U?SHdk4`gV93RUa}0b+a$d& zy3iM?Zaa2-@3*#FWa~rh221j9*n%r2da-pUhs~opY`^7$0 z^Tex`je4Zt?Q|Dk70;_R2Heah0e}9qCpA@gN9tZ4F7fY!t>%2{`%hKs>a7PM%rkhs zu?voOASdVjh<-^~X=(lQTe@<^l|ybt+f}9}Cv%k{1u;CrWMs1Z?&w{zq6oR2dWNm| z^WtEV5lQx^-ZgNzPbT}Lx$-arntUI*R602z(@;Z$>mDfjZ*Iux+$7D_+C0|>alL(E*G ztwI?51q4_RK32KghIZ6f%`x=UyY}we{p^0u0{ofV7VATbAT|oTwQ6S8o=(C=~GNo zwX#drXGsvFkH~X>rlHT{-?DQm-j&k$o;rD5`d-zk+VZ*HZrrs^N`*yA_-YvKx`46v zYPhuSY`p1W57vNeM*8#j*gHs33Hx@z62QJ(_8yt<$ibPku=#+QO+c`${ee7S zKXS}PfN&$Xf~+i=T-Y%Cm42q@OmRf!K}V)a^Y(YQ4BFD4D{5Yi_fD(M##c&O`^$Ex zO3iz=8(l^IIM0;*Zte-6`fo#2p4a;TKEUx?&&J>*SzZGpKQ(n;r!j!HPV9$N4zSR( zmkmwEwdM;df-x{x5SNjEpVQDjpbYj(1wkd}M2<4#2!Ve+mLE@Hx6OH8TTCFMZDfN% z<^vAV9rue*3=G*z|IY{ika-*bwL|4hUsu296LCX#`%|ou&OJGg)$v=>y%^ zo3oygefyISn#$+TE6^DW;TGyGA+F177H!%$a#u2d%-_aNDAYd1WaC@ z6ryb|SayY0>)-l*12rvPCOMMaT8M%o5ZRTUp+#d>+42$W@ec!;?4SM5e$R#siT9js zW;r?1a$vCEEGL^n<*5do6JdbU;a=x5asQ4?c)>HA7qg^7nrTb>FVtA7@aBpucI#&) zEQtnY1_5fQV0s8Xb@voT3Q~rdM2wZ5(1MsD4h)j2>AxLb79)s z6ttC>K1n{JHq{+TRL$xLa?jl=&sfL%cd&7a5^xfX+uqW3d($}#7B$OU+#Ih zK2)fb7LfN6CT1R;Xz>7J@W~Jg(l4?D8 zH3`70wAe2Wu8UMgs#pZ@#cir8Ka6+`-`0YzN$ zBLohZE7BCS6Te z7|O4tHxt0WdrM9+@*lw5cdr31$MSX<@1J2QQT-mZ4 zu$=z$BFo?U>kTiW)_Ty4Mzyab22>{SgC*AUQ{@ufrgh}q=%{mJ_^(eltB;kQy9;EH z3`Vl9e>WJgnaT<~U&+MvIgW4IE-toS_q+oJPV{Q8dX z|A{^+!JVB=0Tcs-Y@^=u6#_gu)0f{bN&oO|F~~Z77F7r^CI-~lt@PPmh0Bv*_Xk{H zgI_-Mz$wGn3jJ_z^q2X|D!JL!U;Hn@MUiR$ZE;IXB=ya+*nJ5g|6yzEN`nm=zrbKc zaGzi{nJ6?3ZB_<)X7j@VA0FUc2VXCsO6XX2PJe{;Tt@5Rovj3YM5DX}FXusykipDhie2%pdMYW}XY4?B zh+UD-mHKZ@R%5TKOq_aNX}Z2zViBm33(Q+0!qUlO8Z5>vDlOwK%K^XN zK40_RLI<~HZ8XG7om{GTdU+_t1`<}TsS`#Yn-CMEu85+T_(wj{hBe1{2x zk1%qu`cu(`fzK#guOw_;YqLsK53_0#7(+f#9cB6AXIAdXudju(6+40@4%WFCBza5Y zYFFdZL%;fZ|CJb}_1EB^&ddn^`)K6Vf#7tx>bKUxe?wjrx7=kiXPb=@js5DzfLiW7 zgJ7`FX+>od9riRBE%;T$2WF6BtK)y!ildka%U|q8J)|v(ulC{~Dux%rs>G}ZLuZp< zkN&jUayrH_?DuSoyh$cOdJ7zj%?e|SUL-cP4f^L~(Xkclp_9STvb@_rFuO(m{V#FT zmfQdP|NLLN)d#bhr&aGTM8^S02%g1sHlS}aIID09?GLWqoHtIg?v&#+?~gc~1+bfV zg848ltPB(^9NOj}NabAMf+6=CUD^~zV#44EP07RP(xs3$2_pbgq!MRLMvZc zq+s9#rJOI%<6wpBIg+O7)eOndr!3a4VbUaP=f)E43=~Sw{aF}cYS-(R{+pSba}Zho zBLI{q@{(y-hD(z1b6`Rn2M%;`;8m}K3hiY%wVwg3^vmTLGL(%|GGope6U4?CoPWHT^ zS52m7XQaQ9{_*=ES2iTrEB!r8i#|-G1PJ6So#mWyX=vmovP__hMf@_aqoj3p3=c$B zvXmh+Ca|%%3;Mu3R43WZJtyUOqojE?kDaEC1u@)e*H+ok$$@PaW042m=C9Nm&(4-&(n53-)& zVvcvtB~h9dJ76Gq1Pt=;%q6y}>&`azI%T-e*4gg{WQWL}{U%d?T9bfrzW^0;nE^dx zY;iry<{|tdQ=d)JHnQ*qcKga}(8wIbAueBHP-=oO3Q}Y&HV!#Jk}PE2AvUnM4rdkX zY)H*sM@Qy9Wa!$>DmY)`fW0KQtR>5UepdAnMNxfMoV4}#>0Bh4xm5;>q5Z1R`t2Zc z&nIpi)yYzw1am%+N2)#Wg?Qds*_ZPU_4$WIZ)Q3tZ~Ha>l)*2xwp*7Jh~=WqWIKTt zGOxw9;^)hmP{(o3JUK}LP|dBZv^5SecMPsGLqP3q4;>jSFv(E0*O1JS4bE#E0R02V zr^mML= zkn)2(-1DI?H=kvBuVa+HXUp)y)O^4;efP1p&Y5fBwt!N%hm&sQyLEPRwTICj?8``B zfVcH?e{J}3Et6DT-D5bAd@E#^|E~EwRWLzhNJ>C8`ln|zTsk^=(twOaR&xqv459Tq6GY!2ZG7R@Jf12x;Hndn_{;>Lfhm zA6QuU%_N596?}!RWa~{ZW1Vxi?0#n!LP#GDQpns<5@=mgD%Mx!ijlES?RTx*LE75U zm2#{R*!cybA$al>M(;nCj=05kyTO;K-ZBOPD{GJis*b26RekYO-v#XXWc90kNu(v4 zu{x5ylE1nZcPTBmo;3k>i#*j{KDX+VCmvm8$?{M$0q|-_`8fUI!+bI}P3i=&f)Qzg z(U!D-pK;WFV5?%lLsjoNq~fMx)G}vL1cb)K^#%W0`V7q;XHbT}heHeSPZpvCgVo9) zyp$rP4D;3};4HV6AWFwruNbJc{RQYr4$027q890!FIth?f0ilvLx5Wt6kn3Tll@g# zO)@LxKIS+TN!m8MR8JYOXRrGJC~)MR3#X(dQ~&oE!hll59U^1b4kNu(W?th!S6M4p zqy`$Px?t)NrImZ^Yj!7xIj?2+C9+TxSgFfGJq!iYreAtd85_osL5~2bIe3D~Ue@0M zG`r%CY-AouH++MVWs^D%c*4{c&g0faN(X``1Pu2RBj#+jyk>ACsjGbxw2ZP_K48uO zY7R_HFa0{mbG%cO9Ps+xn#n!GDuIh%<8VjsdPupKdr7C!b84O6W5$KVK$FOD?fq>5=|N<=*ff z2CN7}?chR{p!ZKIhWkkJ(9Jnpb>a)4t9YGhXCr)}YNw;2P1lv5Kx&TdhhH`2G-zD2sO@Al0dlP8; zVxI%PeE+prSbkrL&$UdZywCawLTirzOXj>vY~sL<5YUL=;*WP$mnK6WmuD&i*p!af zNcCr3?+s~;iw{sra64oW%glYQwY1EMihN_EkDOZiC=rZJmChcqVL9moC5pb}2AjaS z*7~*9d9N#*#KYtzEF^H^?d+~LLrF1{%(%QP`4@s;0 zpWk|_3#6DKq1Kg;Cm2($tN19(uk8!OgIc}DY)ww{eZkJfGfdT0J|uwH>Tio!uf*`Q zZ`fUIi{zoBeBxuh`VR)HkRDE|R6US1h?XHSKYRSy6=r2k<@)Q#Y5<%42ZP*3yyDHWyC9KUp-388#X@pEII~p zy8H5ea~0x0jlRaEb!jN2lsoG^nat-iD2TdQd25e9tMvuMC@Jq|A5bc72Gvq=wC|q$ z$L4M9x4^t$EpxuZnIh--u55Km&805qVx_1D$J4esv40`2Tk-(L{^Zuxlwl{9A;I|1 zR5`9(#i3F&i^?``E}(qD?yJ@NB=`)zOQn+E^Sz7v3H}#|Ed1-m7s5{PGxaJx$IUL@4Tt3L5IN(jW(A- zXu2fzBZlL)>h(!qZVCoBtylKv+-)ib1;MCR{S(sNmpD|~hu5~QAht4Nh;R$Cc-day zKXViP`ibV-MB~aduvt46T{&K>dG6fwJ3|0+{AuD3sxUg$8-;yOLLv}q37C&MQ87$O zC=G)pBpc!wMgsbf>vxEqK)MgG+Q30B#6-M(#`OY1wYDBTMW$}-Eb@E_<{vG1BfVuWs$ z{!R#QeT4GN{RPpT=f@GSUTfb~`dr>PYO)_Ui59?p%r4G(N*Eo)s8adB&@KYKiLpqQ zH8NLHZ)@uBz;mykV;s@@9!Vo5L*$?@gJB-S$MyF|`STrD?ujEQstE$bo@6X>D%A;q zzCcL;CY!iDaC1XX#%KR(sSMw*e^Vl;bSPscFUE?M9zdSJ${?Eyh$nf3Jz1?c036`(z8|o+=k)vV znRLMU8D^LSEK8v3X0LY|mV*Hk_!X;U}VDrMZgggj2 zkxd!)@eY1|lUl!wf83=pukUYfdrYaSP0s2cNTLs5ZMpr+JLw^ccHO#n<$M5XiC#b{ zC5|Q$(EHbZBNbRz68*Yla{`#xu&OGVWJsoUw~rw!001};Nkl(x||np8*z-T!FXUXEOmKJY7MIxdka=acowc{J zjZeC#>gJpT3v}9RHadwPBhbno_?6E{qvTew)pgZ$U!%lN8)bY>3_OHoDzy}GuabvM zGVADpxD$j}y!rdy{qZY`?|&+-M0*58tssh;1qT>C;CWJF!b6tU}_CUK^w;jK!a-c5!vs}HBgou-6s~D70 zou5v-=mUmV8zv+Mn=04R&{;sPXA@MBFEzpZ;84yYvk|hD2oy3Rv)f zjnq`J?VKEh&?*35hJB~qMq0f|1Uz+n+K=oEF%OB)6t=)aNe7JS_)#(Qs-H8$>+{^#ZYy7c zV=Mg^yO*v4Fv*)GX83erj<`Y`^=IMwh#2lKGKW~{NgQ0#{>_K|^d-t-W@d+Wd)xjH z4MpE6CW<)j&J2+$l&$R~x}qvJWG0d;M7>hnLyGu>c&hy2XwZ{!N$bq6!J?hD9r~Xy zu}YiuDMS=5C2#%!)}(SN4(Be5rA3(r|7@+EcHh`a*JtL; z;ArI~wF!(-rjx;E^L_@((?3Bj!OIOSlDLQBMkzn$EiB(HJsH@-gKUgrOL}eO*Jm5v z*MY^0?Eq0O@UhUjlGv6j34kl_G4A@a;e%EUlzss8&$jo-mxJ*Ak)KxPg4ih5n=HmE z8K*zQ#IgjP1nAxBAN|EqcJ|nQeQ<-59p+G&8P7VW{8=5~=z0u>b{$Y8maC#<4A2y^ zBS9Vd(Ks9s4R((6O(`(<5MY>rPB+G`?3j{_aLify2iPmGWbxTG8E;Ak75g{!or?lq z4XB*uCez%O|4pz3$r&f;$K3-wssE2o-y9I>tK5)hGCcXS#&#|auO1IH8aaWcpX?7d zAOY%S^F>B73fHOkNp_zsybO|5E(!fdM$tW(1ONv*(av4%KmBJI>{Xie7qrlE^VvWG z36V+M>&-0tlr7z$UZv9HJFr&CQ;I)4>ww)eIi6wz0uFLwc-dlc8H+AGZ|sXyZNjcA zWxHY+r2{F?q!If6C^Pr=g$!M<$Mpn$NL^&O+QC8W(Il9Tza^v5qoaYQZEe$L7u$Qf zf{uF2!JckFe1oNcInh+0}-sfCv>CQJ$~xxvRPsp5fo~u!AYgY#i+}L&tLSNY|&^ zCueoClwhU>_-4*h;qU52_g4@@DcgNKkaoy;iNBxqH`WvUtQ~pH<%-{rHv2s$!G&}< zQQJq3xD-6PgYa;+CT{w}KM6Y8>ts90l0(se{54ui`>WR_^P&PHiMc>LpG}+PsPrcU zR&PnuGQ83&4TZ4~e0og>wDusxo3;fS(BclYfo%XLPy^Vatzdft!=Yn4$ThD&@V9iX^1|2Vk?<}3YO~OzLiAIz~ zD}!f+k!%Bll&mw876Rm^unSK~)vYV{U-Y9|nunp>4{dIKmbVfNn?&fR1)GM5!A#ws`RBg*Gu5u9*dsYPXY5tsBeEWQQ*o|GS$Udt zp{s2D9&dtvvO>Y2${^>qUo8he=Pxq*YvmS}Y`QVA`jP*x^C$5Y=or*m+W;v$)VLgT zu)c)h7tBOC;ITkEcq0uUgWW+1zW{m&NV^R(N;)IsHz$ZH_cWftD(rKu7$JPex1=5S z=kni{4`QqjE0W+To^QRCZ{7zwvX_~aLxokrP zLNSYAPrv7k#xm=|y8ch46as(FJOQy~-tIgkk4eB@gN^7x;y5WiifyS9m*JVTP&*uD9FXzmPL+jgolffa*cC!*rwpAB&B7dab>si&j_gX{S z+ECdyoYG)tq`k6VaIHyT@t=yl<^wf0r27qXOD0qqsN2hr5LEW37Y1Z=vf=6A5A!2z zD{l8T8JtY1z6sKqEkkzMNeYViX}9vdv@@k4a@!4^Pp$SvXp*(6(I3MRb*1H!8q)T8 ze`HV!Nhj$W;vKLYIaUa22dqw9Lz+VZha|aO;@nFJ-c1t2sVR2V$G#?WU-CAcG4{$P z1F{uekMYSLxT(LP!KXJN$l8<9qvL5QsA8Dp1ozaBD3ordf{K%nc?Mo zo6NG`$1O;<=O!80EB&3L{P|0(o9l)8=1|?P`jmTHX-HD)KZ$@9?J*O((3ddC`^CRU zPDB0}g3Jf)@HY#yZtO?J1%oPmU+-01H}iSY_EuDpgl_G557W51h$rz7pu>lQfAzK} znEk?jW`hE@bAIlq5;uS!GceGv7BUvSjSTiGRdC*Wf7S&(N^4T?7l_s`XGpxUwkfUH zN3)2Ndp*2lA2bWe9&=Wu=O%=XKFs4u1dHz71|(YAgO!i?t&JnM{wp>k(Qy)fQi^q5 z9pqSUz^@xD6kKZ`QhZhh1gYv95_6Ez z?@$4<86Kt2`B#F2WDa??F2FH{QZcpZJK9_p8DSKpdI|gxz}>IMPZruQTSl2yW;rvlAeWgIna1+a zyglPtkzw~_ZOEx873zoq&)k4;2*bODlu33a;#C1ty(>Sz6rbGTWLR(mXF)tHs;ufI}1=Xn5f z_!(?bY(X)fFKZ-o7gAkiO59;38_X*O@MZ==1_CBCgg{~AxKHfWN5ri(RC_G;%IOUp z8al332*3sd2P@fr)n(G6bi3tNlCUl@P&nKro1zSI!bY|ntbLU?V*TO6qggWkYW1%u z13u?QXf@?wd-#Le2XF>;2C-yY8eQ8@FDreg0oH!Dn)02E1Aw{A1X(@a^t0X3@sjq{ z!vLKd-M<0Bvt zXTbUZIP2YyOhJByT<_*~uCTeTfO_#I zt~gl&$YK^nDV3w|5s*@R$9jM<7ge&~OI02{lIXYRF_~m+by}RjIO@-jrPU>PCJ6;& z-q8-d#wBTx)jJ66M*P3Pw*}VRH-Z=LOM|`?*wVIQJ|arSK$#J&%*DbI+dmU^7y$H& zmWp}>u~^C=Rw7JYk^o|>LU!{WX@fmHlk7RzF^RrCGW7>fRe5&C_^xVQnOs9qdBfy5 zFMMnU$6_dz;kYKE93%DN)c@b-AT`-s6daj{zB}!`7Q`ElNFegE9p;`^HF`V*pJfqV+&$kXM3{g;3}5?^L(Gr zjSaY4#=l+C8Xe5vM-%<4RK)FTe_C<>rS?Pfe)?f=~t8(vf?e#qJUw(`s1DCl4gY#zSjYNWAbeZwjz5?ex*9!mb zwOtiutEJYwDAx}OLhc>1D?kbIr5+skp1_=;UGL`2+L-kFxDU{XXioaC) zo+vOUQ>%Iz8u_BaJewIy&mOpSoWg1K2a5FC(eCTY0fTxQtqBO8|BUI;f5@hBVCWuH zhR;xnbtKlxprvhmu3cAsJzWx$u=h03dZhs%*+4EVw3aLaB#`y1VMC?c_#p%E$ZV6w zxkRXj%yfF!$1wi zI9nTHH{ed?86?tGbER8%=gVq@L{~}sP*&Wl44&Qi$M_Cq?ufy)BQS$UCldQ36S3_X zAhrVo4yE4mcV=(;O|wqG8h^I2b9r|YU4H#<&W4A)xr{EY51U&caGy88OA3Pf;^6s$ zzwM7;D!gqhn&ER*k`q?o8A&W z*S9XJcTS(yt5ZEUp6+*JgLqr)iwVA@2>1AHDJ0LA=`MW7 zPWIkgZks{Amz68;nm?jnCW1T`f%B{)tCma^_glO_ft0gkkKcO<#IK|s`x7DmQauD? z;0#=dJ^zr|Gs4kz~pJ6-(zf6YELhq+Q$T ziTv-2uNXcDo^M~J;={jd!d*Obm5H#e*JbRn*PR?P?M5plVBQK28*oxbJ(LQGCHQY% z-OvB9oy4EFsSvq}T>o%w>EGBM-1x6~rRPy3cyrd9);>t3vSFCmk(K_3(&z!-r1I~G zqa;c=yZGJowFhtidLN^ohr~#S`?AH{e1>sq&zBu7X0n(}3Fd`V7l0VdbQ_FTD&i88 zZ3#fJJ(a(=DyT~{tv5k&FbAaA^Dr|Yes~i6$5K*ldu`6rv5Y^-9aSGWn0xaq8w-QY z59G%hS8j>%JUOH}lES{|JLehh>@b)_FmOKJb74OJ=%g4vpR9FBs+TINHt}HhHy23T zW@8Uk_`ZBEr1I{yQKp*d+kWz%e@UBkt+eAIc$yGJXwJ*(N^o;l)HVh)Efc=e(acNC z`KosHGLOMSB$1o>&MC2JbkwVFpYxvre|M4=K|GYzZ^y>sPFBj+4p%n6=Z`%b<#mE2 z$z^>1lY5pwH`PwT9?Ln3q`WIu5RC=T{KVe_t~L4USj+lheM;5o&T7Z!?jB@_zW?+8 z{NGgJ+Ea>Z-o!wnbz5ZRIb>*p4JF;HnG_TVYV}KWwAN)FLPd(8C&HK>j*bJR2AVbYbE{d z4HV17a#xb@{l)iHvNDvCS1U>LIHQekN9huED|LzyGp5M};mFuUZw0xM%zGrO!i7oCsW)=T|-=1XeKc_E=g4JL7 zJ_SoPQUukcN8$Y4Qt;Wslt?FQJ9?dw6quz-#riHybk#H9FNa>M{U^_I;rwQcGfkkO zFRQB3tIo~^{rzB$W|)$AQjd`g}|pF@U-!dds((Py=X=E>ffMq zv=UlAqI3>4o{{!x?fZVdVSX?gekzKZY41g#}L?Ed(@hPj?{1<^f9eTlKJ`mXLASoG$u_q(eP zCn_@n2zE-wb=|ff#`W<=)_sdBf{-(m&eln`>mgp0xFqq)e$`b$8pidlnvh@KS%&O^2j7-Dz9?n9Yv`kegHGwc9Fe19C-lwOt5lM z_2kdpjjjIhOrqyAS&*}Tl;Ms5*YAs#q6B~jrn4IfS!I!Nkf(V<;7W(3t zJ^*5!`*QX5$%iefQWcPRZtrmGyXT@RsdTY}ZMN|sfsI&@^TEjYUHw+o%;Ed!MaW%Y ze|l2+%Bf;6vZ^=AWjpSwoK$Ep=icbw`L8=s{5k${?>sL zcg*iY5CChDm20cNFKbL@vy-u&a^_Qy0rRZtVR*xmrM}Dcp*Ob1J#RM9W{e_)5dc9v zL}^-IsydPeSfX#CT$x$|e&xX~k3-(3=L}O&j!%POnxqY3> z$Fw>4#*od33ATOl_R311Y^TpWj@ow~+|vPa#{fUdu$N3NHjDa`lXJg_u`fd z&fId~cNnqSkq2o}{w)Eh0sT~qWa#LTlRLMbDFm4$kI%-g#3@uIvE>ZQ{+wqrjv=z% zUH#+l<6zC&T6R}qia%#xlUS?2p;`5~vMJzm%b9Gzm+}>=%P3+(0Wot~q~d(eJB0x* z>x!pYe;JL$e#^Xp*>5nPO&)iF{g3YDWqB;iLVRtQ?$j*~_99@PIS@=m6u)OF1>(;Q2t53Ew`{3(?@`^$C38NHM z{{H=@3pnV~2i`fmm7jIrkOYHXcF?Wg75RS^0?zs!8)QxA%xSlU06y;?mWJ_XAgq`;ZM)U#frl zDh*6v2bBALG9Ms*Y!ldQoedt8Zbfj`lJrm6wlUnvoIjtRY9G{R{>j7K0+@dOeucj< zR_gJDww)&UA4&f{Qo<3T<>}2K(@OCgoL&j~nUnX_*p=t&3}WF!*UxVI^^cPMAj`Os zx|u2QdHYgwKC7O)aqR<9H3V=%m-n@g4McxG^3HP2cBDiMH$d;xttJ?`%F+8Lozu3j zt%e{qfO3UNU+^gIb1*o|^P9AQTcA>Al1Q26t~q~!i$-MlzPT#OpuLr{S!JG5+7(Mf zizT`qH~_FO{_j5(3d+nBUt|$AaD=u;F`k>#sGqxpd_8|=!OaX3o4l3RFrT*L_X!4` zV933y(_JSQD(urH+ZuZ-;*}mcD zo?>1IGGCIbUu8_yA-&JG`1f6T@$2`>EeZqCF;eLuS5{PpZ&uT z{Nj5PiTnn#@x^CSR&guVzoMVPw*37V+YZ6MTOoh?>qT&$@;Q7uX)R?|04lF&5!dKv z>p5STMAh;>ih1XK1B}miPRIcnCxbJ0?bqBoB9eD~cWC0f&mgCDX!^UW_@Md&0L7_@ zWTT#sfQ@bt9|kAHN9Tu31D#$b(XYM%K}v4vE-gbf(%0?s!oL33l=)SE%=aLvnHKI{=5{K~IYwMx)Kxm8yTxR?fan?wv3U1aSw&-@^eKXW zfAz>&mXQagG!Cfc&v3j?#-sfVF1epCvzIenEA#&V)~-#$Q*%7v5-V6*M@@_`9{H@g z%Dq2Y=`q<7XOD$Z?GX4m2znG*j+s5$mC~UEA@pHVS@ID=oaai@57_1dSUaCl@E}1y zt=A3JSMog`rglTGmTHcjBS#kCRO*{L-2p-9$;165%xZmQr!I*z;jkGJO2oZGmK-3K z>}Dpqx~&qqCDUU-KsW>otXBZ^*WeIGB^;-LcsUEhx7B4oAtM*ySpGiGo2av#E1RBY znfSj9WQqM~VINlY52r<>?fyD~E0DnMsE3lV!T~g76Qzwi8F;BrrmDP7%g9QKJrnk6 z`QefdnU!UR5jaX5>cD*!jx4P=@fc2ekTorraR(qS837LpLw~DifxzR0acU&JlR?{a z=7W<>TbJWc$R8xiW&FXPfVBfUe$VE7Z#7cQzdo5qK8+;Zv>gcF_ zPJSlYng4*;7aJJFj*EfCZtg<#gM=w<|RyWTa@jumKo?$L9m}u3uIc zt%e6KsrahLexg@T?-7&zF2sh<<3YzK&s@ez6JoC9wuQ%b?eh5mc)<13L54Bpr8FS8uF`J@cmSko^czt%JnbY%lecQVhq^ZeFD<5$OL^I-OrcOmJe=Nq7Wi6^3|1%F3JZNLV9B&EXV zo8|Rk9_#0NHG0r*_00scP1*~!&Mx2Yhb(k#=)3j%rwXzp)ia+AD1Ja-N^qN*Oj`8Z z%6e=2c=xO#&amG)-${cZB*j8_YDztM%KGFB+wn^3*NLhnA&`nClLC#r;kwKqx8vj6F_Z>kU*_{>|Udp0WQnQvj*dVz0J!eaWFSTsZh@ponh zR08+??ynNhq9JyXrLF{In}I=}kW4@p{|rJe?yV*auwYjRv=aE{8M?IIkpuJB_wMze z2or`LV_16tDOrcFPd-LFiuB>$;4iype|O1_xNAsKanvcpkMiLVJVn?-Hpd|8kn_TZ zhIPyLzku|w{0xTxFwI`wE|KINO49;O- zrCVgM5OO>I>GfJQOqRImHJ(ECwwfWFC;rO zeWrc#rm++D1W_Nt9uX14Gh}m9p#U@joMbpl9B>IXTgbEI48MKt4Vc?Acm@~M(%%K~ zIOxI2J)bj<^Rscc0;aO8_#;J0X0W4SLS z*yKcB%IL5KA+TIJcL;{oV*g$$XELGM20go)EuZtQs%;P(cC!e0|H}PP+W;x53P_wC zNjQ@sVW0O*zdF7|s^xg?h$2CS({hV4k`~5$`FZpyfmG%lJdSYStM(Z3^l5^KA(q%) zfNXu)B|k;w`B%CL$MrZHw+6==21IT8yuA_)ix0^?mr?2|^u@pP%`EU&J;7`$xgEyO zsd_(_7^gX2`9Rjz@}rg8sIYYb;ZyqW3=P@d?^v3;Iq>xvCG%d`DwBT>5T1R`UKnf5 z-49SkCJWxPX}*uhw%m{bs4v08S#l6wZ<(X zP!=)~W1rPiUp2+pi@<$;S@}9imNqRNmYm(lId*Yh^=1f^&+1WYUIK^`Vd_@`Dp{W< z0apP&u}63`eGgH}`nsKeH;Y3GVW=ZZ{^RFrl}YJ#X+BT^ggBPQBMe^pZ5jJ z%w~3hv@aV|5|~toY2W358HxCJ>H+H_8%?sG;j=dAZ{vhpY(9I>Y$j@EHTwR8K<>$Vtw*AS_ z@%~>J?0wJ>EV`Dnh^#*G)%)q+O`jJ@l$#S}#r-N*AkD%eR2?bNNe1Dr!V-pWeMT47J8<~g z>1Ov^J$o7`srSZ)NL0@u56}uqtHgFo-Bi~0%{P)v{)8Ov`fQ!!+y~$6WI|SiZ`=3f z4(r032KV@&AKpzrK}`H^V+ZE?xbTUUHzz4nFM)w|T`LFv41C*_gK>zA*s4qHq=GLA zs#)dW{Y>+Nf2ELI1>}Qp^kzE>)su3uD5(e}0Z|5sVe)dV{(C6F3%J6vr408$)ZPQJ zK0Cios~!4F`41Zh3%xC)n;BM3uTASY*TJb#w_HBM@9*CVzKW zzVz7P$g;csf`L6Y+DaNlVJH?odaZRvJVO1fv(&I{O9_|n|IsiAqW%B}&tuT|NVobB z)dF{4S+~_sa_{0#HABz!3`4`Acz)NA0R2nHmIwF5K#g#+AqvR0HpYZ_Eh2yn`S#rp z`mOM>9@RZ>#c1$&BV9>$HC~+eErM;I-$UCB*_YKPFB83}J6}Ctu&J>u91k1eMRdtFJod<@}3m&MUdJ zp1?Q(dtofC`k`1|S@6FH6bcdGOci-{MNq2PT;_%&#V|MbBXmN704quWuVO{|`vIH( zFdqGwy^aYPH2ojv?^5Sf@DMb#?MF{Tj@S`q214(uo<6&%A}C5<82_=2X$Z2AM6J@_ zIjz|0qHOj^MY0Ny>e{#pgy9GXx|;KL00>-S!=ZluWC^)-pItI&85rnxnm;%( zZ04>u6(w2*F%rmhz>Jc9`AEuv>{MN{xlxG0b~&h=vrmcztG#un_3X)d%0KM~pLk<| z3-v&#_)#9u@{qU}5JpS8kMCXjvM^0cQ>tRQ_ zzjp%A{u=W4?|`EFYGcRwdt~%cxdjk=Hy41^1<3;_wUjmfo;Jj1$hr9Z=Ecgb@z({` zi6!zJQW8x{l1JJPJO@AQeywVfvCx1W2;hf+F`p^yc!KLKDMS1|7alubR|YRNE40dO zgy?H<--MOl*s_p6{oyM7PJ({%d{QbY0$E<7&eI2yf*;tNus3Bv4vc zed$V&hv1_T53-{du;zRu4~1T@tG>aG_#bA(%mw-J|HcQFamc=l2y>6E5NIzx+dl@j zate%+@`h|Gp0BCe@K2><<&oS<&?fw=g5OiUMoZ9C43_m@Y*LYw85T7`UP~Np`##tz zHefs%ZOr+dO@BAA_^?^jva(z}HbS;PZ96o_x8Q@ckp9F@?UrVn)OOOg1F!_H@wl?gdEJL3E@#tDyx}-mG06}t((HCF8-2MLA z3Et6beQiTpue>{&Oo3~bN^dhzrs}R_a@eruFAfB1+HM!$G8`Dsc$butD*?*FI=eE! zFa6+baPc-?7z6+An%Q0y{6me$>VBcma1dPR15Cgfu1eim1z~|nIaqwxwud=wfKAEe zAqq$(yR)Tz9`EwyfT>DWX;lCAW6lnV*@0ymY8aMN+;s-qEG=0JB>W3M%2P18?5@(h z4un)+OFf7-#M@}trTj9JI{(*4bD#jv^*t(K@VZ5xz z0R)^Izf%vZO{(SIVHCK8F@J0n`(s#FqnB0^{RAvaP$x*40GpkakgvT=1q#kE!c+uY z5EP?QlJ7{@7AxL!WUv$gBI$t&(BTOmg@=nF@%IP9QTnETKx1n_qxd=8k{dm~< zWQMh@+)NSnnd-}MSYbv}|FrYd*N&qaGRfB>@T|i6hfuLSc%^zT6SWs4Fba?@55Tem z3q^1wwkF!j#?CTC&N=#_K)Yr?DqyUx%t{qy}7zT!zhz2}#v zLJY66(>@?I0c^+&n=OoJeOZIj>e)X1un`4JP||FXvHnHZLr@GEC7&_X5g{V5t+5-^ zJOcysrXXJ&F`-{PMgbD_&oVA)^m=xU;8yVKol|%x>)eVoUQDy>} zsQ2G(7eQxQ7fT!Ps`SlbFX$^bhUWw!`R?7qJOH9@+lwPV)jB)9^_|^iqF2gV;UgC3 zx%QT{Mty51$D5M2^zJ`v9QL3Hdi(m>>$9i${o%ho@8O#{fg91SymMr2St*F1Nn^*0 zkNSv3n+@n>Ry6x8`}8P@yd4*Z59!`2>1piag4rj&_oZ6NIEkdC|2;naj|$9tPw*iA zwMp`1<>XEh9=u0cmzQ_WK+xpYLt494B1D^8DUE^aT7qYb#(Wc!D*ep3@pmmYE4Ey3 zom@U=NA_Zd#U5YFS=km==1W2F1bf_2(AXkauaJPr&L*TB{8LtF+K-ynoh_tkUa9Xge^j_tUBwZCqi2{Qcdq4jcA}~t&ZAaaf9Kx{dlB?z9ijSB!tQ((1If5AGbIYUmnsaCBHs)v<6$Q#t)un> ziGvNtH|D@tsLSnS0-u8K6q$rn$i1Z1?g~yM6XLs0#DXmrU4$2g5Np7wev)bSPj07& z79mLQ?;FVVf;)!yz6gu$H}o7;AN6T+h3tQ9dZm4QFr>Bc;5U$^T&g328h}y2W7yy; zEsVxd3UZ|{1l|EF$1=lCWZL>!=*d78KoDSjpY@t0F4I6n%Al59Ub??xd{c&61c5_p z`^vgY(!M`osV_OWw9cBu<`$)Od=m^|Gp8hhq-RSJWMcP{*>HBs^AkELA&hP&AU9=y z>91I+|-5Au+zU+%WZDEPZ6>Jv3?@*1QtWeKo= zJ7Gc=pde>$(i~f1-!Mc5CpHwnlTz;a0GA^N2~O}L@X7epFoK-bB8n$MIP&{ZTulmzJE97y=LOa!Xk`D67Pj-9i!Ze0Oo{vYJnv%arL4duXI@!`8Heo4 zGi1lC?Er)yAozFJ{0R9e1K{5DoKx;4*3TRW)j4NXK!@4p8+iA|0agsH?aC|5a;?|S zNZfyW;NTB?^znlZC<+r6V$1&t4eoPX?G5GO+~(N<|K(d_9^NXF6}36M$UnL_Qo&Gt(zTD8!{!O=d#kG=5$0H4wUf2{{i z?uNE&1$jLoxwwCcW8=@cWq={sJ<9!6rT+=~)80WYKNFq5*)rUv+N;#|ov-@owR4P2 zM*=@WH2&uvU9DHGVIOvaE721kLq*n-L32k2m85=|lY=i#wa<>EKh=w^olkcxS^WGm z-DZE!4WG)nXYin>RL4)CyQ51+m^8vZs$AMUbEJMq*ARw_+&uVAm!;cxx%Do{S_bO8 zyaz|do{sfSjciekwhi)uUXD(1uBFKRtKMuk__FlHfT>;C$1H@wi(P|&{DY_)*&gn{ zw9?ecp2?Wwh41t1Ylc4i7sOerFmwcz*h;^w7+xoV)cR4d1m1(7tL6ROSROEKz9o>}qebC&#_dUF!!v7-+ z1o@8=Oy;TUt!srKKXS6X#aqz9Ad1_xGnO=>g>;cZucR zRQr)o`tDfh7t!pw>|l@loxiQpp20Ju5-VGB7HZ$H%=XQsy5oia50-c$nBhaaI{*Lx M07*qoM6N<$g1s%Y{r~^~ literal 0 HcmV?d00001 diff --git a/docs/source/_templates/module.rst.jinja b/docs/source/_templates/module.rst.jinja new file mode 100644 index 0000000..2644b73 --- /dev/null +++ b/docs/source/_templates/module.rst.jinja @@ -0,0 +1,8 @@ +{%- if show_headings %} +{{- [basename] | join(' ') | e | heading }} + +{% endif -%} +.. automodule:: {{ qualname }} +{%- for option in automodule_options %} + :{{ option }}: +{%- endfor %} diff --git a/docs/source/_templates/package.rst.jinja b/docs/source/_templates/package.rst.jinja new file mode 100644 index 0000000..8e47918 --- /dev/null +++ b/docs/source/_templates/package.rst.jinja @@ -0,0 +1,49 @@ +{%- macro automodule(modname, options) -%} +.. automodule:: {{ modname }} +{%- for option in options %} + :{{ option }}: +{%- endfor %} +{%- endmacro %} + +{%- macro toctree(docnames) -%} +.. toctree:: + :maxdepth: 2 +{% for docname in docnames %} + {{ docname }} +{%- endfor %} +{%- endmacro %} + +{%- if is_namespace %} +{{- [pkgname, "namespace"] | join(" ") | e | heading }} +{% else %} +{{- [pkgname] | join(" ") | e | heading }} +{% endif %} + +{%- if is_namespace %} +.. py:module:: {{ pkgname }} +{% endif %} + +{%- if modulefirst and not is_namespace %} +{{ automodule(pkgname, automodule_options) }} +{% endif %} + +{%- if subpackages %} +{{ toctree(subpackages) }} +{% endif %} + +{%- if submodules %} +{% if separatemodules %} +{{ toctree(submodules) }} +{% else %} +{%- for submodule in submodules %} +{% if show_headings %} +{{- [submodule] | join(" ") | e | heading(2) }} +{% endif %} +{{ automodule(submodule, automodule_options) }} +{% endfor %} +{%- endif %} +{%- endif %} + +{%- if not modulefirst and not is_namespace %} +{{ automodule(pkgname, automodule_options) }} +{% endif %} diff --git a/docs/source/author.rst b/docs/source/author.rst new file mode 100644 index 0000000..688188b --- /dev/null +++ b/docs/source/author.rst @@ -0,0 +1,7 @@ +Contributors +============ + +decent-bench is developed by `Elias Ram `_, +`Simon Granström `_, +`Adriana Rodriguez `_ under the supervision of +`Dr. Nicola Bastianello `_. diff --git a/docs/source/background.rst b/docs/source/background.rst new file mode 100644 index 0000000..7370504 --- /dev/null +++ b/docs/source/background.rst @@ -0,0 +1,3 @@ +Background +========== + diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..f95654f --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,158 @@ +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +project = "decent-array" +copyright = "2026, Team Decent" +author = "team-decent" + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +import os +import sys + +from docutils import nodes + +sys.path.insert(0, os.path.abspath("../..")) +sys.path.insert(0, os.path.abspath("_extensions")) + +extensions = [ + "sphinx.ext.autodoc", # Expand rst automodule directives generated by `sphinx-apidoc` + "sphinx.ext.intersphinx", # Link to types from external packages + "sphinx.ext.napoleon", # Parse Google style docstrings + "sphinx.ext.viewcode", # View source code +] + +nitpicky = True +nitpick_ignore = [ + ("py:class", "numpy.float64"), + ("py:class", "float64"), + ("py:class", "numpy._typing._array_like._SupportsArray"), + ("py:class", "numpy._typing._nested_sequence._NestedSequence"), + ("py:class", "T"), +] + +suppress_warnings = ["toc.duplicate"] + +intersphinx_mapping = { + "numpy": ("https://numpy.org/doc/stable/", None), + "python": ("https://docs.python.org/3", None), + "torch": ("https://pytorch.org/docs/stable/", None), + "tensorflow": ( + "https://www.tensorflow.org/api_docs/python", + "https://github.com/GPflow/tensorflow-intersphinx/raw/master/tf2_py_objects.inv", + ), + "jax": ("https://jax.readthedocs.io/en/latest/", None), +} + + +# A way to link numpy.typing.ArrayLike and NDArray correctly +# Seems to be an open issue, see https://github.com/sphinx-doc/sphinx/issues/10794 +# https://github.com/sphinx-doc/sphinx/issues/10785#issuecomment-1321100925 +def _fix_missing_ref(app, env, node, contnode): + if node.get("refdomain") == "py" and node.get("reftype") in {"class", "data"}: + target = node.get("reftarget") + if target in {"ArrayLike", "numpy.typing.ArrayLike"}: + return nodes.reference( + "", "ArrayLike", refuri="https://numpy.org/doc/stable/reference/typing.html#numpy.typing.ArrayLike" + ) + if target in {"NDArray", "numpy.typing.NDArray"}: + return nodes.reference( + "", + "NDArray", + refuri="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray", + ) + if target in {"DTypeLike", "numpy.typing.DTypeLike", "numpy._typing.DTypeLike"}: + return nodes.reference( + "", "DTypeLike", refuri="https://numpy.org/doc/stable/reference/typing.html#numpy.typing.DTypeLike" + ) + if target in {"DefaultContext", "multiprocessing.context.DefaultContext"}: + return nodes.reference( + "", + "DefaultContext", + refuri="https://docs.python.org/3/library/multiprocessing.html#multiprocessing.get_context", + ) + if target in {"SpawnContext", "multiprocessing.context.SpawnContext"}: + return nodes.reference( + "", + "SpawnContext", + refuri="https://docs.python.org/3/library/multiprocessing.html#multiprocessing.get_context", + ) + if target in {"TensorflowGenerator"}: + return nodes.reference( + "", + "TensorflowGenerator", + refuri="https://www.tensorflow.org/api_docs/python/tf/random/Generator", + ) + if target in {"TorchGenerator"}: + return nodes.reference( + "", + "TorchGenerator", + refuri="https://pytorch.org/docs/stable/generated/torch.Generator.html#torch.Generator", + ) + if target in {"JaxArray"}: + return nodes.reference( + "", + "JaxArray", + refuri="https://docs.jax.dev/en/latest/_autosummary/jax.Array.html#jax.Array", + ) + if target in {"TorchTensor"}: + return nodes.reference( + "", + "TorchTensor", + refuri="https://docs.pytorch.org/docs/stable/tensors.html#torch-tensor", + ) + if target in {"TensorflowTensor"}: + return nodes.reference( + "", + "TensorflowTensor", + refuri="https://www.tensorflow.org/api_docs/python/tf/Tensor", + ) + return None + + +def setup(app): + app.connect("missing-reference", _fix_missing_ref) + + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +html_theme = "pydata_sphinx_theme" +html_theme_options = { + "logo": { + "text": project, + }, + "icon_links": [ + { + "name": "GitHub", + "url": "https://github.com/team-decent/decent-array", + "icon": "fa-brands fa-github", + "type": "fontawesome", + }, + { + "name": "PyPI", + "url": "https://pypi.org/project/decent-array/", + "icon": "fa-solid fa-box-open", + "type": "fontawesome", + }, + ], + "icon_links_label": "Quick Links", +} +html_context = {"default_mode": "auto"} +html_show_sourcelink = False +html_logo = "_static/logo.png" +html_favicon = "_static/logo.png" +html_static_path = ["_static"] +html_css_files = ["custom.css"] +html_sidebars = { + "author": [], + "background": [], + "developer": [], + "user": [], +} diff --git a/docs/source/developer.rst b/docs/source/developer.rst new file mode 100644 index 0000000..bfb018e --- /dev/null +++ b/docs/source/developer.rst @@ -0,0 +1,203 @@ +Developer Guide +=============== +Want to contribute to decent-bench? That's great! This guide contains useful information +about development tools, processes, and rules. + + + +Getting Started +--------------- + +Prerequisites +~~~~~~~~~~~~~ +* `Python 3.13+ `_ +* `tox `_ + +Installation for Development +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +.. code-block:: + + git clone https://github.com/team-decent/decent-array.git + cd decent-array + tox -e dev # create dev env (admin privileges may be needed) + source .tox/dev/bin/activate # activate dev env on Mac/Linux + .\.tox\dev\Scripts\activate # activate dev env on Windows + +Optionally install development dependencies with proper gpu support, e.g. for PyTorch and TensorFlow: + +.. code-block:: + + tox -e dev-gpu + +It is not recommended to use the development environments for regular usage of decent-array, as they +contain additional packages that are not needed for that purpose. This may cause performance degradation +due to multiple packages competing for resources (e.g. GPU resources). + +Tooling +------- +To make sure all GitHub status checks pass, simply run :code:`tox`. You can also run individual checks: + +.. code-block:: + + tox -e mypy # find typing issues + tox -e pytest # run tests + tox -e ruff # find formatting and style issues + tox -e sphinx # rebuild documentation + +Note: Running :code:`tox` commands can take several minutes and may require admin privileges. +If you have mypy addon installed in your IDE, you can use it to get instant feedback on typing issues while coding. +If mypy fails with ``KeyError: 'setter_type'``, delete the ``.mypy_cache`` folder in the project root. + +Tools can also be used directly (instead of via tox) after activating the dev environment. Useful examples include: + +.. code-block:: + + ruff check decent_array --fix # find and fix style issues + ruff format decent_array # format code + mypy decent_array --strict # find typing issues + pytest test # run tests + sphinx-build -W -E -b html docs/source docs/build/html # rebuild html doc files + +To verify that doc changes look good, use an html previewer such as +`Live Preview `_. +If you are running :code:`pytest test` while using ``WSL`` on Windows and it starts to randomly fail (or if its really slow), restart your ``WSL`` instance. + + + +Compiled hot path (mypyc) +------------------------- +The :class:`~decent_array.Array` wrapper and the entire +:mod:`~decent_array.interoperability` package are compiled to C extensions with +`mypyc `_ at wheel-build time, so end users get the +speed-up automatically when installing from a wheel. During development you can +manage the compiled artifacts with two tox environments: + +.. code-block:: + + tox -e mypyc # compile in-place (drops .so files alongside the .py source) + tox -e clean-mypyc # remove compiled .so files so Python loads the .py source again + +When both ``module.py`` and ``module.cpython-*.so`` exist in the same directory, Python +imports the ``.so``. This means edits to a compiled module will not take effect until +either ``tox -e mypyc`` is rerun or ``tox -e clean-mypyc`` is invoked. A typical +edit-test-edit cycle therefore looks like: + +1. Run :code:`tox -e clean-mypyc` once at the start of the session. +2. Edit, run, repeat (Python loads the ``.py`` source directly — no rebuild needed). +3. When measuring performance, run :code:`tox -e mypyc` to recompile and re-bench. + +Compilation takes ~25 s from a clean state. The build emits a hash-named shared-runtime +file (``__mypyc.cpython-*.so``) at the project root that holds helpers used by +every compiled module; it must sit on ``sys.path`` because the compiled modules import +it by bare name. The file is gitignored. + + + +Performance tools +----------------- +The :code:`benchmarks/` directory contains scripts to measure wrapper overhead and +performance of the interoperability layer. + + +CUTE Design Principles +---------------------- +CUTE is a set of principles that serve as guidelines for code design. They are meant to help keep the +codebase simple and the development fast. To mitigate any conflict, the principles are ordered from most to least +important: + +1. **Correctness**: working code is the top priority. +2. **Understandability**: others should easily understand your code, avoid bloat, unnecessary indirection, and fancy + abstractions. +3. **Testability**: code allows for short and clear tests. +4. **Extendability**: code allows for future extension, but avoid premature generalization and keep YAGNI and KISS in + mind as trying to predict tomorrow's requirements can cause more problems than it solves. + + + +Pull Requests +------------- +To give other contributors an opportunity to review and to run GitHub status checks, we use pull requests instead of +merging directly to main. The process is detailed below: + +1. Fork the repository. +2. Create a feature branch. +3. Make your changes. +4. Update documentation as needed. +5. Run :code:`tox` to ensure that all checks pass. +6. Submit a pull request. +7. Doc changes? Click the readthedocs link found in the status checks to verify that everything looks good. + + + +Commit Messages +--------------- +To keep the git history easy to follow, encourage well-scoped PRs, and facilitate changelog writing and versioning, we +follow certain rules for commit messages when merging pull requests into main. Each message uses this template: + +.. code-block:: bash + :caption: Template + + (): (#) + + + + closes # + +.. code-block:: bash + :caption: Example + + perf(costs): Cache m_cvx and m_smooth (#105) + + Cache the properties m_cvx and m_smooth where applicable. This led to a + 75% speed up when running ADMM on a logistic regression problem. + + closes #101 + +Notes: + - See table below for types. + - Scope can be a subpackage, module or build tool, e.g. metrics, costs, or sphinx. + - Max 72 characters per line. + - Capitalize but do not punctuate subject. + - Start subject and description with a verb. + - Use imperative mood in subject and description. + - Description explains what changes and why it changes. + - If the PR has a related issue but doesn't close it, skip the "closes"-keyword and simply reference the issue. + +.. list-table:: + :widths: 15 40 + :header-rows: 1 + + * - Type + - Description + * - feat + - New functionality + * - perf + - Performance improvement + * - ref + - Refactor + * - enh + - Small improvement that doesn't qualify as feat, perf, or ref, e.g. improved variable naming, additional logging, + or prettier plots + * - fix + - Bug fix + * - test + - Change to tests + * - docs + - Update to readme, comments, docstrings, rst files, or sphinx config + * - ci + - CI related change, e.g. modifying GitHub checks or tox environments + * - meta + - Update to metadata, e.g. project description, version, or .gitignore + * - license + - License update + +Inspired by `Sentry `_. + + + +Releases +-------- +1. Update the version in pyproject.toml using `Semantic Versioning `_. +2. Merge the change into main with commit message :code:`meta: Bump version to .. (#)`. +3. Create a new release on GitHub. +4. Publish to PyPI using :code:`hatch clean && hatch build && hatch publish`. diff --git a/docs/source/index.rst b/docs/source/index.rst new file mode 100644 index 0000000..f9ec474 --- /dev/null +++ b/docs/source/index.rst @@ -0,0 +1,15 @@ +Welcome to Decent-Array! +======================================== + +Decent-Array is a Python library for efficient and flexible array computations. +It provides a unified interface for working with arrays across different backends, such as NumPy, PyTorch, and TensorFlow. +With Decent-Array, you can write code that is portable and optimized for performance, without having to worry about the underlying implementation details. + +.. toctree:: + :maxdepth: 1 + + background + user + API Reference + developer + author \ No newline at end of file diff --git a/docs/source/user.rst b/docs/source/user.rst new file mode 100644 index 0000000..735989b --- /dev/null +++ b/docs/source/user.rst @@ -0,0 +1,12 @@ +User Guide +========== +This user guide shows you different examples of how to use decent-array. + + +Installation +------------ +Requires `Python 3.13+ `_ + +.. code-block:: bash + + pip install decent-array diff --git a/docs/sphinx_theme.txt b/docs/sphinx_theme.txt new file mode 100644 index 0000000..6246669 --- /dev/null +++ b/docs/sphinx_theme.txt @@ -0,0 +1,2 @@ +pydata-sphinx-theme +sphinxcontrib-bibtex diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..38542cc --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,190 @@ +[project] +name = "decent-array" +version = "0.1.0" +authors = [{name = "Elias Ram"}, {name = "Simon Granström"}, {name = "Adriana Rodriguez"}, {name = "Nicola Bastianello"}] +maintainers = [{name = "Team Decent"}] +description = "A library of array operations and linear algebra primitives for interoperability across ML frameworks." +readme = "README.md" +requires-python = ">=3.13" +classifiers = [ + "Programming Language :: Python :: 3.13", + "Operating System :: OS Independent", +] +license = "AGPL-3.0-only" +dependencies = [ + "numpy", +] + +[project.urls] +Documentation = "https://decent-array.readthedocs.io/en/latest/" +Source = "https://github.com/team-decent/decent-array" +Issues = "https://github.com/team-decent/decent-array/issues" + +[project.optional-dependencies] +dev = [ + "hatch", + "mypy", + "pytest", + "ruff", + "scipy-stubs", + "types-networkx", + "types-tabulate", + "torch", + "torchvision", + "types-tensorflow", +] +dev-cpu = [ + "tensorflow", + "jax", +] +dev-gpu = [ + "tensorflow[and-cuda]", + "jax[cuda12]", +] +sphinx-tools = [ + "sphinx", + "pydata-sphinx-theme", + "sphinxcontrib-bibtex", +] + + +[build-system] +requires = ["hatchling", "hatch-mypyc"] +build-backend = "hatchling.build" +# Compile hot-path modules with mypyc when building wheels. End users installing from +# a wheel get a precompiled .so; ``pip install -e .`` and source builds also run this +# (a C compiler is required). The ``.py`` source remains shipped alongside the .so so +# Python keeps a fallback if the extension fails to import. Tox envs that only need +# the ``.py`` source (dev, dev-gpu, sphinx, mypy, ruff) opt out via +# ``HATCH_BUILD_NO_HOOKS=true`` to keep their installs fast. +[tool.hatch.build.targets.wheel.hooks.mypyc] +dependencies = ["hatch-mypyc"] +# Compile the Array wrapper plus the entire iop2 package as one mypyc group: keeping +# them in a single compilation unit means cross-module calls (Array → backend, iop +# function → backend) are direct compiled-to-compiled calls. New framework backends +# get picked up automatically — no edits needed here. ``--ignore-missing-imports`` +# treats torch/jax/tensorflow types as ``Any`` when those packages aren't in the +# build environment; the wrapper-side boundary cost is still removed. +include = [ + "decent_array/", +] +mypy-args = ["--ignore-missing-imports"] + +[tool.tox] +envlist = ["dev", "mypy", "pytest", "ruff", "sphinx"] + +[tool.tox.env.dev] +description = "Generate dev venv with all dependencies, active with `source .tox/dev/bin/activate`" +set_env = { HATCH_BUILD_NO_HOOKS = "true" } +deps = [ + ".[dev]", + ".[dev-cpu]", + ".[sphinx-tools]", + "git+https://github.com/microsoft/python-type-stubs.git@main" +] + +[tool.tox.env.dev-gpu] +description = "Generate dev venv with all dependencies including GPU support, active with `source .tox/dev-gpu/bin/activate`" +set_env = { PIP_EXTRA_INDEX_URL = "https://download.pytorch.org/whl/cu128", HATCH_BUILD_NO_HOOKS = "true" } # torch 2.11 uses CUDA 13.0 which seems to have broken linalg.norm, use cuda 12.8 for now +deps = [ + ".[dev]", + ".[dev-gpu]", + ".[sphinx-tools]", + "git+https://github.com/microsoft/python-type-stubs.git@main" +] + +[tool.tox.env.sphinx] +description = "Generate rst and html files using sphinx" +set_env = { HATCH_BUILD_NO_HOOKS = "true" } +deps = [".[sphinx-tools]"] +commands = [ + ["sphinx-apidoc", "-o", "docs/source/api", "decent_array", "--separate", "--no-toc", "--templatedir=docs/source/_templates"], + ["sphinx-build", "-W", "-E", "-b", "html", "docs/source", "docs/build/html"] +] + +[tool.tox.env.mypy] +description = "Run mypy (static type checker)" +set_env = { HATCH_BUILD_NO_HOOKS = "true" } +deps = [".[dev]", ".[dev-cpu]", "git+https://github.com/microsoft/python-type-stubs.git@main"] +commands = [["mypy", "decent_array"]] + +[tool.tox.env.clean-mypyc] +description = "Remove mypyc-compiled artifacts so Python imports the .py source again (use during dev iteration)" +set_env = { HATCH_BUILD_NO_HOOKS = "true" } +skip_install = true +deps = [] +commands = [ + ["python", "-c", "import pathlib; ps = list(pathlib.Path('.').glob('decent_array/**/*.so')) + list(pathlib.Path('.').glob('*__mypyc.cpython-*.so')); [p.unlink() for p in ps]; print('removed', len(ps), 'compiled artifact(s)')"], +] + +[tool.tox.env.mypyc] +description = "Compile hot-path modules in place with mypyc (drops .so files alongside the .py source)" +deps = ["mypy", "numpy", "setuptools"] +skip_install = true +# First command clears any stale shared-runtime ``.so`` at the project root from a +# previous compile (its name is hash-derived from the file list, so changing inputs +# leaves orphans); second command compiles the Array module + entire iop2 package +# (including ``_abstracts``) as one group so cross-module dispatch (Array → +# _Backend.add → concrete backend method) is native compiled-to-compiled. +commands = [ + ["python", "-c", "import pathlib; [p.unlink() for p in pathlib.Path('.').glob('*__mypyc.cpython-*.so')]"], + ["python", "-m", "mypyc", + "--ignore-missing-imports", + "decent_array/", + ], +] + +[tool.tox.env.pytest] +description = "Run pytest (test executor)" +deps = [".[dev]", ".[dev-cpu]"] +commands = [["pytest", "-rs"]] + +[tool.tox.env.ruff] +description = "Run ruff (format and style checker)" +deps = ["ruff"] +set_env = { HATCH_BUILD_NO_HOOKS = "true" } +skip_install = true +commands = [ + ["ruff", "check", "decent_array"], + ["ruff", "format", "decent_array", "--check"] +] + +[tool.pytest.ini_options] +addopts = "-q -W error" +testpaths = ["tests"] + +[tool.mypy] +strict = true + +[tool.ruff] +lint.flake8-annotations.mypy-init-return = true +lint.select = ["ALL"] +lint.ignore = [ + "BLE001", # blind-except, complains when catching `Exception` + "C901", # complex-structure, complains when there are many branches + "COM812", # missing-trailing-comma, may cause conflicts when used with the formatter + "CPY001", # missing-copyright-notice + "D100", # undocumented-public-module + "D104", # undocumented-public-package + "D107", # undocumented-public-init + "D203", # incorrect-blank-line-before-class, incompatible with no-blank-line-before-class (D211) + "D212", # multi-line-summary-first-line, incompatible with multi-line-summary-second-line (D213) + "D415", # missing-terminal-punctuation, D400 already enforces first line to end with period + "DOC201", # docstring-missing-returns, always documenting the return value is too verbose + "EM101", # raw-string-in-exception, complains about putting raw string as error msg + "EM102", # f-string-in-exception, complains about putting f string as error msg + "FURB140", # reimplemented-starmap, wants to replace comprehensions with the less efficient itertools.starmap + "PLR0913", # too-many-arguments, complains when there are more than 5 arguments + "PLR2004", # magic-value-comparison, complains about dimension checks in cost functions + "PLR6301", # no-self-use, complains when self is unused even when implementing an abstract method + "S311", # suspicious-non-cryptographic-random-usage, complains about `random.random()` + "TC001", # typing-only-first-party-import, reduced rt overhead but slower development and messy imports + "TC002", # typing-only-third-party-import, reduced rt overhead but slower development and messy imports + "TC003", # typing-only-standard-library-import, reduced rt overhead but slower development and messy imports + "TRY003", # raise-vanilla-args, complains about simple error messages like `ValueError('Matrix A must be 2D')` + "FBT001", # boolean-type-hint-positional-argument, complains about bool args with default values in functions + "FBT002", # boolean-default-value-positional-argument, complains about bool args with default values in functions + "ICN001", # unconventional-import-alias, complains about common import aliases like `import numpy as np` but it doesn't work for most libraries +] +preview = true +line-length = 120 diff --git a/readthedocs.yaml b/readthedocs.yaml new file mode 100644 index 0000000..3b75931 --- /dev/null +++ b/readthedocs.yaml @@ -0,0 +1,27 @@ +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the OS, Python version, and other tools you might need +build: + os: ubuntu-24.04 + tools: + python: "3.13" + jobs: + build: + html: + - mkdir -p $READTHEDOCS_OUTPUT/html/ + - python -m sphinx -T -W --keep-going -j 1 -b html -d _build/doctrees -D language=en docs/source $READTHEDOCS_OUTPUT/html + +# Build documentation in the "docs/" directory with Sphinx +sphinx: + configuration: docs/source/conf.py + fail_on_warning: true + +python: + install: + - requirements: docs/sphinx_theme.txt + - method: pip + path: . diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..6810e44 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,121 @@ +"""Shared fixtures: parametrize tests across every (framework, device) combination. + +Each test using the ``backend`` fixture runs once per (framework, device) pair from +:class:`SupportedFrameworks` x :class:`SupportedDevices`. Combinations whose backend +package is missing or whose device is not present on the current host are marked +``skip`` so the test report stays interpretable on machines with partial accelerator +support. +""" + +from __future__ import annotations + +from collections.abc import Iterator +from typing import TYPE_CHECKING + +import pytest + +from decent_array.interoperability.backend_manager import reset_backends +from decent_array.types import SupportedDevices, SupportedFrameworks + +if TYPE_CHECKING: + from _pytest.fixtures import FixtureRequest + + +def _framework_importable(framework: SupportedFrameworks) -> bool: + try: + if framework == SupportedFrameworks.NUMPY: + import numpy # noqa: F401, PLC0415 + elif framework == SupportedFrameworks.PYTORCH: + import torch # noqa: F401, PLC0415 + elif framework == SupportedFrameworks.JAX: + import jax # noqa: F401, PLC0415 + elif framework == SupportedFrameworks.TENSORFLOW: + import tensorflow # noqa: F401, PLC0415 + except ImportError: + return False + return True + + +def _device_available(framework: SupportedFrameworks, device: SupportedDevices) -> bool: + """Return True iff this (framework, device) pair can run on the current host.""" + if not _framework_importable(framework): + return False + if framework == SupportedFrameworks.NUMPY: + return device == SupportedDevices.CPU + if framework == SupportedFrameworks.PYTORCH: + import torch # noqa: PLC0415 + + if device == SupportedDevices.CPU: + return True + if device == SupportedDevices.GPU: + try: + return bool(torch.cuda.is_available()) + except Exception: + return False + if device == SupportedDevices.MPS: + try: + return bool(torch.backends.mps.is_available()) + except Exception: + return False + if framework == SupportedFrameworks.JAX: + if device == SupportedDevices.MPS: + return False + import jax # noqa: PLC0415 + + try: + jax.devices(device.value) + except Exception: + return False + return True + if framework == SupportedFrameworks.TENSORFLOW: + if device == SupportedDevices.MPS: + return False + import tensorflow as tf # noqa: PLC0415 + + if device == SupportedDevices.CPU: + return True + if device == SupportedDevices.GPU: + try: + return len(tf.config.list_physical_devices("GPU")) > 0 + except Exception: + return False + return False + + +def _backend_params() -> list[pytest.ParameterSet]: + params: list[pytest.ParameterSet] = [] + for framework in SupportedFrameworks: + for device in SupportedDevices: + test_id = f"{framework.value}-{device.value}" + if _device_available(framework, device): + params.append(pytest.param((framework, device), id=test_id)) + else: + params.append( + pytest.param( + (framework, device), + id=test_id, + marks=pytest.mark.skip(reason=f"{framework.value}/{device.value} unavailable"), + ) + ) + return params + + +BACKEND_PARAMS = _backend_params() + + +@pytest.fixture(params=BACKEND_PARAMS) +def backend(request: FixtureRequest) -> Iterator[tuple[SupportedFrameworks, SupportedDevices]]: + """Activate the (framework, device) backend for this test, then reset on teardown.""" + from decent_array.interoperability.backend_manager import set_backend # noqa: PLC0415 + + framework, device = request.param + set_backend(framework, device) + yield framework, device + reset_backends() + + +@pytest.fixture +def reset_after() -> Iterator[None]: + """For tests that touch backend-manager state directly without the ``backend`` fixture.""" + yield + reset_backends() diff --git a/tests/test_array.py b/tests/test_array.py new file mode 100644 index 0000000..02afb4a --- /dev/null +++ b/tests/test_array.py @@ -0,0 +1,274 @@ +"""Tests for :class:`decent_array.array.Array` operators, properties, and dunders.""" + +from __future__ import annotations + +import re + +import numpy as np +import pytest + +import decent_array as da +from decent_array.array import Array +from decent_array.interoperability.backend_manager import reset_backends + + +def _np(arr: Array) -> np.ndarray: + """Convert a backend-native ``Array`` to a numpy array for assertions.""" + return da.to_numpy(arr) + + +# Construction ------------------------------------------------------------ + + +def test_init_requires_active_backend() -> None: + reset_backends() + with pytest.raises(RuntimeError, match=re.compile(r"No backend registered", re.IGNORECASE)): + Array(np.zeros(3)) + + +def test_init_records_active_backend(backend: tuple) -> None: + arr = da.zeros((3,)) + assert arr._backend is not None + assert isinstance(arr, Array) + + +# Binary arithmetic ------------------------------------------------------- + + +def test_add_array(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + b = da.from_numpy(np.array([4.0, 5.0, 6.0])) + np.testing.assert_allclose(_np(a + b), [5.0, 7.0, 9.0]) + + +def test_add_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(a + 2), [3.0, 4.0, 5.0]) + + +def test_radd_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(2 + a), [3.0, 4.0, 5.0]) + + +def test_sub_array(backend: tuple) -> None: + a = da.from_numpy(np.array([4.0, 5.0, 6.0])) + b = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(a - b), [3.0, 3.0, 3.0]) + + +def test_sub_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([4.0, 5.0, 6.0])) + np.testing.assert_allclose(_np(a - 1), [3.0, 4.0, 5.0]) + + +def test_rsub_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(10 - a), [9.0, 8.0, 7.0]) + + +def test_mul_array(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + b = da.from_numpy(np.array([2.0, 3.0, 4.0])) + np.testing.assert_allclose(_np(a * b), [2.0, 6.0, 12.0]) + + +def test_mul_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(a * 3), [3.0, 6.0, 9.0]) + + +def test_rmul_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(3 * a), [3.0, 6.0, 9.0]) + + +def test_truediv_array(backend: tuple) -> None: + a = da.from_numpy(np.array([4.0, 9.0, 16.0])) + b = da.from_numpy(np.array([2.0, 3.0, 4.0])) + np.testing.assert_allclose(_np(a / b), [2.0, 3.0, 4.0]) + + +def test_truediv_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([2.0, 4.0, 6.0])) + np.testing.assert_allclose(_np(a / 2), [1.0, 2.0, 3.0]) + + +def test_rtruediv_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 4.0])) + np.testing.assert_allclose(_np(8 / a), [8.0, 4.0, 2.0]) + + +def test_matmul_array(backend: tuple) -> None: + a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + b = da.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + expected = np.array([[19.0, 22.0], [43.0, 50.0]]) + np.testing.assert_allclose(_np(a @ b), expected) + + +def test_rmatmul_explicit_call(backend: tuple) -> None: + # Python dispatch never picks Array.__rmatmul__ when both operands are Array, + # so call it directly to exercise the code path. + a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + b = da.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + np.testing.assert_allclose(_np(a.__rmatmul__(b)), _np(b @ a)) + + +def test_pow_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(a**2), [1.0, 4.0, 9.0]) + + +# In-place arithmetic ----------------------------------------------------- + + +def test_iadd_array(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + b = da.from_numpy(np.array([4.0, 5.0, 6.0])) + a += b + np.testing.assert_allclose(_np(a), [5.0, 7.0, 9.0]) + + +def test_iadd_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a += 10 + np.testing.assert_allclose(_np(a), [11.0, 12.0, 13.0]) + + +def test_isub_array(backend: tuple) -> None: + a = da.from_numpy(np.array([5.0, 6.0, 7.0])) + b = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a -= b + np.testing.assert_allclose(_np(a), [4.0, 4.0, 4.0]) + + +def test_imul_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a *= 2 + np.testing.assert_allclose(_np(a), [2.0, 4.0, 6.0]) + + +def test_itruediv_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([2.0, 4.0, 6.0])) + a /= 2 + np.testing.assert_allclose(_np(a), [1.0, 2.0, 3.0]) + + +# Unary ------------------------------------------------------------------ + + +def test_neg(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, -2.0, 3.0])) + np.testing.assert_allclose(_np(-a), [-1.0, 2.0, -3.0]) + + +def test_abs(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, -2.0, 3.0])) + np.testing.assert_allclose(_np(abs(a)), [1.0, 2.0, 3.0]) + + +# Indexing --------------------------------------------------------------- + + +def test_getitem_int(backend: tuple) -> None: + a = da.from_numpy(np.array([10.0, 20.0, 30.0])) + np.testing.assert_allclose(_np(a[1]), 20.0) + + +def test_getitem_slice(backend: tuple) -> None: + a = da.from_numpy(np.array([10.0, 20.0, 30.0, 40.0])) + np.testing.assert_allclose(_np(a[1:3]), [20.0, 30.0]) + + +def test_getitem_tuple(backend: tuple) -> None: + a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(a[1, 0]), 3.0) + + +def test_setitem_with_array(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a[1] = da.from_numpy(np.array(99.0)) + np.testing.assert_allclose(_np(a), [1.0, 99.0, 3.0]) + + +def test_setitem_with_scalar(backend: tuple) -> None: + # __setitem__ wraps a non-Array value in Array internally. + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a[2] = 99.0 + np.testing.assert_allclose(_np(a), [1.0, 2.0, 99.0]) + + +# Container / coercion / repr ------------------------------------------- + + +def test_len(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + assert len(a) == 4 + + +def test_float_coercion(backend: tuple) -> None: + a = da.from_numpy(np.array(2.5)) + assert float(a) == pytest.approx(2.5) + + +def test_repr(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + text = repr(a) + assert text.startswith("Array(") + assert text.endswith(")") + + +def test_str(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + # ``str(arr)`` delegates to the wrapped value's stringifier; just check it succeeds + # and is non-empty rather than pin per-backend formatting. + assert isinstance(str(a), str) + assert len(str(a)) > 0 + + +# Properties ------------------------------------------------------------- + + +def test_shape(backend: tuple) -> None: + a = da.from_numpy(np.zeros((2, 3, 4))) + assert a.shape == (2, 3, 4) + + +def test_size(backend: tuple) -> None: + a = da.from_numpy(np.zeros((2, 3, 4))) + assert a.size == 24 + + +def test_ndim(backend: tuple) -> None: + a = da.from_numpy(np.zeros((2, 3, 4))) + assert a.ndim == 3 + + +def test_transpose_property(backend: tuple) -> None: + a = da.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) + np.testing.assert_allclose(_np(a.transpose), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]) + + +def test_T_alias(backend: tuple) -> None: + a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(a.T), _np(a.transpose)) + + +def test_any_true(backend: tuple) -> None: + a = da.from_numpy(np.array([0.0, 0.0, 1.0])) + assert a.any is True + + +def test_any_false(backend: tuple) -> None: + a = da.from_numpy(np.array([0.0, 0.0, 0.0])) + assert a.any is False + + +def test_all_true(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + assert a.all is True + + +def test_all_false(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 0.0, 3.0])) + assert a.all is False diff --git a/tests/test_backend_manager.py b/tests/test_backend_manager.py new file mode 100644 index 0000000..3c656f6 --- /dev/null +++ b/tests/test_backend_manager.py @@ -0,0 +1,189 @@ +"""Tests for :mod:`decent_array.interoperability.backend_manager`.""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import pytest + +from decent_array.interoperability import backend_manager +from decent_array.interoperability.abstracts import _Backend +from decent_array.interoperability.backend_manager import ( + _instantiate, + _normalize, + register_backend, + register_backend_listener, + reset_backends, + set_backend, +) +from decent_array.types import SupportedDevices, SupportedFrameworks + +if TYPE_CHECKING: + from collections.abc import Iterator + + +@pytest.fixture(autouse=True) +def _isolate_listeners_and_backends() -> Iterator[None]: + """Snapshot+restore module-level state so backend-manager tests don't leak.""" + listeners_snapshot = backend_manager._BACKEND_LISTENERS.copy() + registry_snapshot = backend_manager._BACKEND_REGISTRY.copy() + reset_backends() + yield + backend_manager._BACKEND_LISTENERS[:] = listeners_snapshot + backend_manager._BACKEND_REGISTRY.clear() + backend_manager._BACKEND_REGISTRY.update(registry_snapshot) + reset_backends() + + +# _normalize ------------------------------------------------------------- + + +def test_normalize_accepts_enum() -> None: + assert _normalize(SupportedFrameworks.NUMPY) == SupportedFrameworks.NUMPY + + +def test_normalize_accepts_string() -> None: + assert _normalize("numpy") == SupportedFrameworks.NUMPY + + +def test_normalize_unknown_raises() -> None: + with pytest.raises(KeyError, match=r"Unknown backend"): + _normalize("not-a-backend") + + +# set_backend ------------------------------------------------------------ + + +def test_set_backend_with_string() -> None: + set_backend("numpy") + assert backend_manager._ACTIVE_BACKEND.get() == SupportedFrameworks.NUMPY + + +def test_set_backend_with_enum() -> None: + set_backend(SupportedFrameworks.NUMPY) + assert backend_manager._ACTIVE_BACKEND.get() == SupportedFrameworks.NUMPY + + +def test_set_backend_idempotent_same_backend() -> None: + set_backend("numpy") + # Re-activating with the same backend+device must be a no-op (no exception). + set_backend("numpy") + assert backend_manager._ACTIVE_BACKEND.get() == SupportedFrameworks.NUMPY + + +def test_set_backend_different_backend_raises() -> None: + set_backend("numpy") + with pytest.raises(RuntimeError, match=r"already set to"): + set_backend("pytorch") + + +def test_set_backend_with_string_device() -> None: + set_backend("numpy", "cpu") + instance = _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU) + assert instance.device == SupportedDevices.CPU + + +def test_set_backend_invalid_name_raises() -> None: + with pytest.raises(KeyError): + set_backend("not-a-backend") + + +# register_backend ------------------------------------------------------- + + +def test_register_backend_rejects_non_subclass() -> None: + class NotABackend: + pass + + with pytest.raises(TypeError, match=r"subclass of _Backend"): + register_backend(SupportedFrameworks.NUMPY, NotABackend) # type: ignore[arg-type] + + +def test_register_backend_replaces_cached_instance() -> None: + # First import registers the real backend; instantiate to populate cache. + set_backend("numpy") + cached = backend_manager._BACKEND_INSTANCES.get(SupportedFrameworks.NUMPY) + assert cached is not None + + # Re-register the same class — cache should be cleared so next instantiate is fresh. + from decent_array.interoperability._numpy.numpy_backend import NumpyBackend # noqa: PLC0415 + + reset_backends() + register_backend(SupportedFrameworks.NUMPY, NumpyBackend) + assert SupportedFrameworks.NUMPY not in backend_manager._BACKEND_INSTANCES + + +# register_backend_listener --------------------------------------------- + + +def test_listener_called_on_activation() -> None: + received: list[_Backend | None] = [] + + def listener(backend: _Backend | None) -> None: + received.append(backend) + + register_backend_listener(listener) + set_backend("numpy") + assert len(received) == 1 + assert isinstance(received[0], _Backend) + + +def test_listener_called_immediately_when_backend_already_active() -> None: + set_backend("numpy") + received: list[_Backend | None] = [] + + def listener(backend: _Backend | None) -> None: + received.append(backend) + + register_backend_listener(listener) + assert len(received) == 1 + assert isinstance(received[0], _Backend) + + +def test_listener_called_with_none_on_reset() -> None: + set_backend("numpy") + received: list[_Backend | None] = [] + + def listener(backend: _Backend | None) -> None: + received.append(backend) + + register_backend_listener(listener) + reset_backends() + # First call: immediate notification with active backend (because already active). + # Second call: notification with None on reset. + assert received[-1] is None + + +# reset_backends --------------------------------------------------------- + + +def test_reset_backends_clears_active() -> None: + set_backend("numpy") + reset_backends() + assert backend_manager._ACTIVE_BACKEND.get() is None + assert backend_manager._BACKEND_INSTANCE is None + + +def test_reset_backends_clears_instance_cache() -> None: + set_backend("numpy") + assert SupportedFrameworks.NUMPY in backend_manager._BACKEND_INSTANCES + reset_backends() + assert SupportedFrameworks.NUMPY not in backend_manager._BACKEND_INSTANCES + + +# _instantiate ---------------------------------------------------------- + + +def test_instantiate_caches_instance() -> None: + a = _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU) + b = _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU) + assert a is b + + +def test_set_backend_device_mismatch_raises() -> None: + set_backend("numpy", SupportedDevices.CPU) + # NumPy backend rejects non-CPU devices at construction; check behavior via the + # configured-mismatch path: re-set with a different device after first activation. + with pytest.raises((RuntimeError, ValueError)): + # The same backend cannot be reconfigured to a different device. + set_backend("numpy", "gpu") diff --git a/tests/test_decorators.py b/tests/test_decorators.py new file mode 100644 index 0000000..123893f --- /dev/null +++ b/tests/test_decorators.py @@ -0,0 +1,107 @@ +"""Tests for :mod:`decent_array.interoperability.decorators`. + +Note: this file deliberately omits ``from __future__ import annotations``. The +:func:`autodecorate_cost_method` decorator inspects ``__annotations__["return"] is Array`` +on the superclass method, and PEP 563-style stringified annotations would break that +identity check. +""" + +from typing import Any + +import numpy as np + +import decent_array as da +from decent_array.array import Array +from decent_array.interoperability.decorators import autodecorate_cost_method + + +class _Base: + def returns_array(self, x: Array) -> Array: + raise NotImplementedError + + def returns_float(self, x: Array) -> float: + raise NotImplementedError + + def takes_kwarg(self, x: Array, *, scale: Array) -> Array: + raise NotImplementedError + + def passes_through_non_array(self, x: Array, n: int) -> Array: + raise NotImplementedError + + +def test_unwraps_array_args(backend: tuple) -> None: + seen: list[Any] = [] + + class Impl(_Base): + @autodecorate_cost_method(_Base.returns_array) + def returns_array(self, x: Any) -> Any: + seen.append(x) + return x * 2 + + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + result = Impl().returns_array(arr) + # The decorator should have unwrapped the Array to its underlying value. + assert not isinstance(seen[0], Array) + # Annotated `-> Array`, so the return is re-wrapped. + assert isinstance(result, Array) + np.testing.assert_allclose(da.to_numpy(result), [2.0, 4.0, 6.0]) + + +def test_does_not_rewrap_when_return_not_array(backend: tuple) -> None: + class Impl(_Base): + @autodecorate_cost_method(_Base.returns_float) + def returns_float(self, x: Any) -> float: + # Use a fixed value so the test doesn't depend on framework-specific tensor + # methods (e.g. TF eager tensors don't expose ``.sum()`` without enabling + # the numpy compatibility shim). + assert not isinstance(x, Array) + return 42.0 + + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + result = Impl().returns_float(arr) + assert isinstance(result, float) + assert result == 42.0 + + +def test_unwraps_kwargs(backend: tuple) -> None: + class Impl(_Base): + @autodecorate_cost_method(_Base.takes_kwarg) + def takes_kwarg(self, x: Any, *, scale: Any) -> Any: + assert not isinstance(x, Array) + assert not isinstance(scale, Array) + return x * scale + + arr = da.from_numpy(np.array([1.0, 2.0])) + scale = da.from_numpy(np.array([10.0, 100.0])) + result = Impl().takes_kwarg(arr, scale=scale) + assert isinstance(result, Array) + np.testing.assert_allclose(da.to_numpy(result), [10.0, 200.0]) + + +def test_passes_non_array_args_unchanged(backend: tuple) -> None: + class Impl(_Base): + @autodecorate_cost_method(_Base.passes_through_non_array) + def passes_through_non_array(self, x: Any, n: int) -> Any: + assert isinstance(n, int) + return x * n + + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + result = Impl().passes_through_non_array(arr, 4) + assert isinstance(result, Array) + np.testing.assert_allclose(da.to_numpy(result), [4.0, 8.0, 12.0]) + + +def test_does_not_double_wrap_when_impl_returns_array(backend: tuple) -> None: + """If the decorated impl already returns an :class:`Array`, the wrapper should not double-wrap.""" + + class Impl(_Base): + @autodecorate_cost_method(_Base.returns_array) + def returns_array(self, x: Any) -> Array: + return Array(x * 3) + + arr = da.from_numpy(np.array([1.0, 2.0])) + result = Impl().returns_array(arr) + assert isinstance(result, Array) + # If the wrapper double-wrapped, ``result.value`` would itself be an Array. + assert not isinstance(result.value, Array) + np.testing.assert_allclose(da.to_numpy(result), [3.0, 6.0]) diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py new file mode 100644 index 0000000..1e2af5c --- /dev/null +++ b/tests/test_iop_functions.py @@ -0,0 +1,448 @@ +"""Tests for the module-level functions in :mod:`decent_array.interoperability.iop.functions`.""" + +from __future__ import annotations + +import numpy as np +import pytest + +import decent_array as da +from decent_array.array import Array +from decent_array.interoperability.backend_manager import reset_backends +from decent_array.interoperability.iop import functions as iop_functions +from decent_array.types import SupportedDevices + + +def _np(arr: Array) -> np.ndarray: + return da.to_numpy(arr) + + +# Array creation --------------------------------------------------------- + + +def test_zeros(backend: tuple) -> None: + arr = da.zeros((2, 3)) + np.testing.assert_allclose(_np(arr), np.zeros((2, 3))) + + +def test_zeros_like(backend: tuple) -> None: + src = da.from_numpy(np.ones((2, 3))) + arr = da.zeros_like(src) + np.testing.assert_allclose(_np(arr), np.zeros((2, 3))) + + +def test_ones(backend: tuple) -> None: + arr = da.ones((2, 3)) + np.testing.assert_allclose(_np(arr), np.ones((2, 3))) + + +def test_ones_like(backend: tuple) -> None: + src = da.from_numpy(np.zeros((2, 3))) + arr = da.ones_like(src) + np.testing.assert_allclose(_np(arr), np.ones((2, 3))) + + +def test_eye(backend: tuple) -> None: + arr = da.eye(3) + np.testing.assert_allclose(_np(arr), np.eye(3)) + + +def test_eye_like(backend: tuple) -> None: + src = da.from_numpy(np.zeros((4, 4))) + arr = da.eye_like(src) + np.testing.assert_allclose(_np(arr), np.eye(4)) + + +def test_device_to_native(backend: tuple) -> None: + framework, device = backend + native = da.device_to_native(device) + # Just verify the call succeeds and returns a non-None value (varies per backend). + assert native is not None + + +def test_device_of(backend: tuple) -> None: + _framework, device = backend + arr = da.zeros((3,)) + assert da.device_of(arr) == device + + +# Array manipulation ----------------------------------------------------- + + +def test_copy_independent(backend: tuple) -> None: + src = da.from_numpy(np.array([1.0, 2.0, 3.0])) + dst = da.copy(src) + np.testing.assert_allclose(_np(dst), [1.0, 2.0, 3.0]) + # Mutating the copy shouldn't affect the original. + dst[0] = 99.0 + np.testing.assert_allclose(_np(src), [1.0, 2.0, 3.0]) + + +def test_to_numpy(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + out = da.to_numpy(arr) + assert isinstance(out, np.ndarray) + np.testing.assert_allclose(out, [1.0, 2.0, 3.0]) + + +def test_from_numpy_roundtrip(backend: tuple) -> None: + raw = np.array([[1.0, 2.0], [3.0, 4.0]]) + arr = da.from_numpy(raw) + np.testing.assert_allclose(_np(arr), raw) + + +def test_to_array_from_scalar(backend: tuple) -> None: + arr = da.to_array(2.5) + np.testing.assert_allclose(_np(arr), 2.5) + + +def test_stack(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + b = da.from_numpy(np.array([3.0, 4.0])) + arr = da.stack([a, b]) + np.testing.assert_allclose(_np(arr), [[1.0, 2.0], [3.0, 4.0]]) + + +def test_stack_dim(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + b = da.from_numpy(np.array([3.0, 4.0])) + arr = da.stack([a, b], dim=1) + np.testing.assert_allclose(_np(arr), [[1.0, 3.0], [2.0, 4.0]]) + + +def test_stack_empty_raises(backend: tuple) -> None: + with pytest.raises(ValueError, match=r"empty sequence"): + da.stack([]) + + +def test_reshape(backend: tuple) -> None: + arr = da.from_numpy(np.arange(6, dtype=np.float32)) + out = da.reshape(arr, (2, 3)) + np.testing.assert_allclose(_np(out), np.arange(6, dtype=np.float32).reshape(2, 3)) + + +def test_transpose_default(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) + np.testing.assert_allclose(_np(da.transpose(arr)), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]) + + +def test_transpose_explicit_dim(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) + out = da.transpose(arr, dim=(1, 0, 2)) + assert da.shape(out) == (3, 2, 4) + + +def test_shape_function(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((2, 3, 4))) + assert da.shape(arr) == (2, 3, 4) + + +def test_size_function(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((2, 3, 4))) + assert da.size(arr) == 24 + + +def test_ndim_function(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((2, 3, 4))) + assert da.ndim(arr) == 3 + + +def test_squeeze_default(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((1, 3, 1))) + assert da.shape(da.squeeze(arr)) == (3,) + + +def test_squeeze_specific_dim(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((1, 3, 1))) + assert da.shape(da.squeeze(arr, dim=0)) == (3, 1) + + +def test_unsqueeze(backend: tuple) -> None: + arr = da.from_numpy(np.zeros((3,))) + assert da.shape(da.unsqueeze(arr, dim=0)) == (1, 3) + assert da.shape(da.unsqueeze(arr, dim=1)) == (3, 1) + + +def test_diag_from_vector(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(da.diag(arr)), np.diag([1.0, 2.0, 3.0])) + + +def test_diag_from_matrix(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(da.diag(arr)), [1.0, 4.0]) + + +def test_astype_to_float(backend: tuple) -> None: + arr = da.to_array(3.0) + out = da.astype(arr, float) + assert isinstance(out, float) + assert out == pytest.approx(3.0) + + +def test_astype_to_int(backend: tuple) -> None: + arr = da.to_array(3.0) + out = da.astype(arr, int) + assert isinstance(out, int) + assert out == 3 + + +def test_astype_to_bool(backend: tuple) -> None: + arr = da.to_array(1.0) + out = da.astype(arr, bool) + assert isinstance(out, bool) + assert out is True + + +# Linalg ----------------------------------------------------------------- + + +def test_dot(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + b = da.from_numpy(np.array([4.0, 5.0, 6.0])) + np.testing.assert_allclose(_np(da.dot(a, b)), 32.0) + + +def test_matmul(backend: tuple) -> None: + a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + b = da.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + expected = np.array([[19.0, 22.0], [43.0, 50.0]]) + np.testing.assert_allclose(_np(da.matmul(a, b)), expected) + + +def test_norm_default_l2(backend: tuple) -> None: + arr = da.from_numpy(np.array([3.0, 4.0])) + np.testing.assert_allclose(_np(da.norm(arr)), 5.0) + + +def test_norm_p1(backend: tuple) -> None: + arr = da.from_numpy(np.array([3.0, -4.0])) + np.testing.assert_allclose(_np(da.norm(arr, p=1)), 7.0) + + +def test_norm_dim_keepdims(backend: tuple) -> None: + arr = da.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]])) + out = da.norm(arr, p=2, dim=1, keepdims=True) + assert da.shape(out) == (2, 1) + np.testing.assert_allclose(_np(out).reshape(-1), [5.0, 10.0]) + + +# Math reductions -------------------------------------------------------- + + +def test_sum_all(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(da.sum(arr)), 10.0) + + +def test_sum_dim(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(da.sum(arr, dim=0)), [4.0, 6.0]) + + +def test_sum_dim_keepdims(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + out = da.sum(arr, dim=0, keepdims=True) + assert da.shape(out) == (1, 2) + + +def test_mean_all(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + np.testing.assert_allclose(_np(da.mean(arr)), 2.5) + + +def test_mean_dim(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(da.mean(arr, dim=1)), [1.5, 3.5]) + + +def test_min_all(backend: tuple) -> None: + arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) + np.testing.assert_allclose(_np(da.min(arr)), 1.0) + + +def test_min_dim(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) + np.testing.assert_allclose(_np(da.min(arr, dim=0)), [1.0, 2.0]) + + +def test_max_all(backend: tuple) -> None: + arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) + np.testing.assert_allclose(_np(da.max(arr)), 5.0) + + +def test_max_dim(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) + np.testing.assert_allclose(_np(da.max(arr, dim=0)), [3.0, 5.0]) + + +def test_any_true(backend: tuple) -> None: + arr = da.from_numpy(np.array([0.0, 1.0, 0.0])) + assert da.any(arr) is True + + +def test_any_false(backend: tuple) -> None: + arr = da.from_numpy(np.array([0.0, 0.0, 0.0])) + assert da.any(arr) is False + + +def test_all_true(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + assert da.all(arr) is True + + +def test_all_false(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 0.0, 3.0])) + assert da.all(arr) is False + + +# Math elementwise ------------------------------------------------------- + + +def test_add_two_arrays(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + b = da.from_numpy(np.array([3.0, 4.0])) + np.testing.assert_allclose(_np(da.add(a, b)), [4.0, 6.0]) + + +def test_add_array_and_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + np.testing.assert_allclose(_np(da.add(a, 10.0)), [11.0, 12.0]) + + +def test_sub(backend: tuple) -> None: + a = da.from_numpy(np.array([5.0, 6.0])) + b = da.from_numpy(np.array([1.0, 2.0])) + np.testing.assert_allclose(_np(da.sub(a, b)), [4.0, 4.0]) + + +def test_mul(backend: tuple) -> None: + a = da.from_numpy(np.array([2.0, 3.0])) + b = da.from_numpy(np.array([4.0, 5.0])) + np.testing.assert_allclose(_np(da.mul(a, b)), [8.0, 15.0]) + + +def test_div(backend: tuple) -> None: + a = da.from_numpy(np.array([8.0, 10.0])) + b = da.from_numpy(np.array([2.0, 5.0])) + np.testing.assert_allclose(_np(da.div(a, b)), [4.0, 2.0]) + + +def test_iadd_func(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 2.0])) + out = da.iadd(a, 10.0) + # Returned wrapper is the same instance. + assert out is a + np.testing.assert_allclose(_np(a), [11.0, 12.0]) + + +def test_isub_func(backend: tuple) -> None: + a = da.from_numpy(np.array([5.0, 6.0])) + out = da.isub(a, 1.0) + assert out is a + np.testing.assert_allclose(_np(a), [4.0, 5.0]) + + +def test_imul_func(backend: tuple) -> None: + a = da.from_numpy(np.array([2.0, 3.0])) + out = da.imul(a, 4.0) + assert out is a + np.testing.assert_allclose(_np(a), [8.0, 12.0]) + + +def test_idiv_func(backend: tuple) -> None: + a = da.from_numpy(np.array([8.0, 12.0])) + out = da.idiv(a, 4.0) + assert out is a + np.testing.assert_allclose(_np(a), [2.0, 3.0]) + + +def test_pow_function(backend: tuple) -> None: + arr = da.from_numpy(np.array([2.0, 3.0, 4.0])) + np.testing.assert_allclose(_np(da.pow(arr, 2)), [4.0, 9.0, 16.0]) + + +def test_negative(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, -2.0, 3.0])) + np.testing.assert_allclose(_np(da.negative(arr)), [-1.0, 2.0, -3.0]) + + +def test_absolute(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, -2.0, 3.0])) + np.testing.assert_allclose(_np(da.absolute(arr)), [1.0, 2.0, 3.0]) + + +def test_sqrt(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 4.0, 9.0])) + np.testing.assert_allclose(_np(da.sqrt(arr)), [1.0, 2.0, 3.0]) + + +# Operators -------------------------------------------------------------- + + +def test_sign(backend: tuple) -> None: + arr = da.from_numpy(np.array([-2.0, 0.0, 3.0])) + np.testing.assert_allclose(_np(da.sign(arr)), [-1.0, 0.0, 1.0]) + + +def test_maximum_arrays(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 5.0, 3.0])) + b = da.from_numpy(np.array([4.0, 2.0, 6.0])) + np.testing.assert_allclose(_np(da.maximum(a, b)), [4.0, 5.0, 6.0]) + + +def test_maximum_array_and_scalar(backend: tuple) -> None: + a = da.from_numpy(np.array([1.0, 5.0, 3.0])) + np.testing.assert_allclose(_np(da.maximum(a, 4.0)), [4.0, 5.0, 4.0]) + + +def test_argmax_default(backend: tuple) -> None: + arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) + np.testing.assert_allclose(_np(da.argmax(arr)), 5) + + +def test_argmax_dim(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + np.testing.assert_allclose(_np(da.argmax(arr, dim=1)), [1, 0]) + + +def test_argmin_default(backend: tuple) -> None: + arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) + # First occurrence of minimum is index 1. + np.testing.assert_allclose(_np(da.argmin(arr)), 1) + + +def test_argmin_dim(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + np.testing.assert_allclose(_np(da.argmin(arr, dim=1)), [0, 1]) + + +def test_argmax_keepdims(backend: tuple) -> None: + arr = da.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + out = da.argmax(arr, dim=1, keepdims=True) + assert da.shape(out) == (2, 1) + + +def test_set_item_function(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + da.set_item(arr, 0, da.from_numpy(np.array(99.0))) + np.testing.assert_allclose(_np(arr), [99.0, 2.0, 3.0]) + + +def test_get_item_function(backend: tuple) -> None: + arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(da.get_item(arr, 1)), 2.0) + + +# No-backend errors ------------------------------------------------------ + + +def test_function_raises_when_no_backend() -> None: + reset_backends() + with pytest.raises(RuntimeError, match=r"No backend active"): + iop_functions.zeros((3,)) + + +def test_to_array_round_trip_with_bool(backend: tuple) -> None: + arr = da.to_array(True) + out = da.astype(arr, bool) + assert out is True diff --git a/tests/test_iop_rng.py b/tests/test_iop_rng.py new file mode 100644 index 0000000..0b56e12 --- /dev/null +++ b/tests/test_iop_rng.py @@ -0,0 +1,196 @@ +"""Tests for :mod:`decent_array.interoperability.iop.rng`.""" + +from __future__ import annotations + +import random + +import numpy as np +import pytest + +import decent_array as da +from decent_array.array import Array +from decent_array.interoperability.backend_manager import reset_backends +from decent_array.interoperability.iop import rng as iop_rng +from decent_array.interoperability.iop.rng import _set_seed_without_global + + +def _np(arr: Array) -> np.ndarray: + return da.to_numpy(arr) + + +# Seed management -------------------------------------------------------- + + +def test_set_seed_records_global(backend: tuple) -> None: + da.set_seed(123) + assert da.get_seed() == 123 + + +def test_set_seed_makes_normal_reproducible(backend: tuple) -> None: + da.set_seed(7) + first = _np(da.normal(shape=(4,))) + da.set_seed(7) + second = _np(da.normal(shape=(4,))) + np.testing.assert_allclose(first, second) + + +def test_set_seed_makes_uniform_reproducible(backend: tuple) -> None: + da.set_seed(7) + first = _np(da.uniform(shape=(4,))) + da.set_seed(7) + second = _np(da.uniform(shape=(4,))) + np.testing.assert_allclose(first, second) + + +def test_set_seed_seeds_python_random(backend: tuple) -> None: + da.set_seed(11) + a = random.random() + da.set_seed(11) + b = random.random() + assert a == b + + +def test_set_seed_without_global_keeps_seed(backend: tuple) -> None: + da.set_seed(42) + _set_seed_without_global(99) + # The "global" seed observable via get_seed() must be unchanged. + assert da.get_seed() == 42 + + +def test_get_seed_initially_none(backend: tuple) -> None: + # Fresh activation via the fixture: nothing has called set_seed yet on this + # coordinator instance, but the coordinator is process-singleton and may have + # state from earlier tests. Call set_seed/then-clear to assert via reseed instead. + da.set_seed(0) + assert da.get_seed() == 0 + + +# RNG state snapshot/restore -------------------------------------------- + + +def test_rng_state_round_trip_normal(backend: tuple) -> None: + da.set_seed(123) + state = da.get_rng_state() + first = _np(da.normal(shape=(4,))) + da.set_rng_state(state) + second = _np(da.normal(shape=(4,))) + np.testing.assert_allclose(first, second) + + +def test_rng_state_includes_python_random(backend: tuple) -> None: + da.set_seed(7) + state = da.get_rng_state() + a = random.random() + da.set_rng_state(state) + b = random.random() + assert a == b + + +def test_rng_state_round_trip_uniform(backend: tuple) -> None: + da.set_seed(456) + state = da.get_rng_state() + first = _np(da.uniform(shape=(3,))) + da.set_rng_state(state) + second = _np(da.uniform(shape=(3,))) + np.testing.assert_allclose(first, second) + + +# derive_seed ----------------------------------------------------------- + + +def test_derive_seed_when_seed_set_is_reproducible(backend: tuple) -> None: + da.set_seed(123) + a = da.derive_seed() + da.set_seed(123) + b = da.derive_seed() + assert a == b + + +def test_derive_seed_returns_int_in_range(backend: tuple) -> None: + da.set_seed(0) + seed = da.derive_seed() + assert isinstance(seed, int) + assert 0 <= seed < 2**32 + + +# Distribution shape checks --------------------------------------------- + + +def test_normal_shape(backend: tuple) -> None: + arr = da.normal(shape=(2, 3)) + assert da.shape(arr) == (2, 3) + + +def test_normal_default_scalar(backend: tuple) -> None: + da.set_seed(1) + arr = da.normal() + assert da.shape(arr) == () + + +def test_uniform_shape_and_range(backend: tuple) -> None: + da.set_seed(1) + arr = da.uniform(low=0.0, high=1.0, shape=(50,)) + samples = _np(arr) + assert samples.shape == (50,) + assert (samples >= 0.0).all() + assert (samples < 1.0).all() + + +def test_uniform_custom_range(backend: tuple) -> None: + da.set_seed(1) + samples = _np(da.uniform(low=-2.0, high=-1.0, shape=(50,))) + assert (samples >= -2.0).all() + assert (samples < -1.0).all() + + +def test_normal_like(backend: tuple) -> None: + src = da.from_numpy(np.zeros((3, 4))) + arr = da.normal_like(src) + assert da.shape(arr) == (3, 4) + + +def test_uniform_like(backend: tuple) -> None: + src = da.from_numpy(np.zeros((3, 4))) + arr = da.uniform_like(src, low=0.0, high=1.0) + assert da.shape(arr) == (3, 4) + samples = _np(arr) + assert (samples >= 0.0).all() + assert (samples < 1.0).all() + + +def test_choice_shape(backend: tuple) -> None: + da.set_seed(1) + population = da.from_numpy(np.array([10.0, 20.0, 30.0, 40.0, 50.0])) + sample = da.choice(population, size=3) + assert da.shape(sample) == (3,) + + +def test_choice_values_in_population(backend: tuple) -> None: + da.set_seed(1) + pop_np = np.array([10.0, 20.0, 30.0, 40.0, 50.0]) + sample = da.choice(da.from_numpy(pop_np), size=10) + drawn = _np(sample).reshape(-1) + assert all(v in pop_np for v in drawn) + + +def test_choice_no_replace_unique(backend: tuple) -> None: + da.set_seed(1) + pop = da.from_numpy(np.arange(20, dtype=np.float32)) + sample = da.choice(pop, size=5, replace=False) + drawn = _np(sample).reshape(-1) + assert len(set(drawn.tolist())) == 5 + + +# No-backend errors ----------------------------------------------------- + + +def test_rng_function_raises_when_no_backend() -> None: + reset_backends() + with pytest.raises(RuntimeError, match=r"No backend active"): + iop_rng.normal(shape=(3,)) + + +def test_set_seed_raises_when_no_backend() -> None: + reset_backends() + with pytest.raises(RuntimeError, match=r"No backend active"): + iop_rng.set_seed(0) From 49226bc3cd6dd1ba6ebe669671612297d0606b95 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 03:53:44 +0200 Subject: [PATCH 02/11] fix docs --- benchmarks/profile_hotpath.py | 2 +- decent_array/__init__.py | 151 +----------------- decent_array/{array.py => _array.py} | 19 ++- decent_array/interoperability/__init__.py | 143 +++++++++++++++++ .../interoperability/_abstracts/__init__.py | 3 + .../{abstracts => _abstracts}/backend.py | 4 +- ...backend_manager.py => _backend_manager.py} | 36 ++--- .../{decorators.py => _decorators.py} | 24 +-- .../{iop => _iop}/__init__.py | 0 .../{iop => _iop}/functions.py | 18 +-- .../interoperability/{iop => _iop}/rng.py | 10 +- .../interoperability/_jax/jax_backend.py | 8 +- .../interoperability/_numpy/numpy_backend.py | 8 +- .../_pytorch/pytorch_backend.py | 8 +- .../_tensorflow/tensorflow_backend.py | 8 +- .../interoperability/abstracts/__init__.py | 3 - docs/source/api/decent_array.array.rst | 7 + .../api/decent_array.interoperability.rst | 7 + docs/source/api/decent_array.rst | 14 ++ docs/source/api/decent_array.types.rst | 7 + tests/test_backend_manager.py | 18 +-- 21 files changed, 265 insertions(+), 233 deletions(-) rename decent_array/{array.py => _array.py} (93%) create mode 100644 decent_array/interoperability/_abstracts/__init__.py rename decent_array/interoperability/{abstracts => _abstracts}/backend.py (99%) rename decent_array/interoperability/{backend_manager.py => _backend_manager.py} (83%) rename decent_array/interoperability/{decorators.py => _decorators.py} (62%) rename decent_array/interoperability/{iop => _iop}/__init__.py (100%) rename decent_array/interoperability/{iop => _iop}/functions.py (94%) rename decent_array/interoperability/{iop => _iop}/rng.py (95%) delete mode 100644 decent_array/interoperability/abstracts/__init__.py create mode 100644 docs/source/api/decent_array.array.rst create mode 100644 docs/source/api/decent_array.interoperability.rst create mode 100644 docs/source/api/decent_array.rst create mode 100644 docs/source/api/decent_array.types.rst diff --git a/benchmarks/profile_hotpath.py b/benchmarks/profile_hotpath.py index eee9451..70e6d8c 100644 --- a/benchmarks/profile_hotpath.py +++ b/benchmarks/profile_hotpath.py @@ -34,7 +34,7 @@ import numpy as np -import decent_array as iop +import decent_array.interoperability as iop from decent_array import Array diff --git a/decent_array/__init__.py b/decent_array/__init__.py index 9694575..9893247 100644 --- a/decent_array/__init__.py +++ b/decent_array/__init__.py @@ -1,153 +1,8 @@ -""" -Interoperability layer (v2). - -Single-active-backend variant of the original interoperability package. Each framework -implements :class:`_Backend` and registers itself via :func:`register_backend`. Users -(or the cost-function machinery) bind a backend once with :func:`set_backend`; from -that point on every call in this package routes to that backend without isinstance -dispatch. - -Typical usage:: - - import decent_bench.utils.interoperability_2 as iop - - iop.set_backend("numpy") - a = iop.zeros((3, 3)) - iop.set_seed(42) - s = iop.normal(shape=(2,)) - -""" - -from decent_array import types -from decent_array.array import Array -from decent_array.interoperability.backend_manager import set_backend -from decent_array.interoperability.decorators import autodecorate_cost_method -from decent_array.interoperability.iop.functions import ( - absolute, - add, - all, # noqa: A004 - any, # noqa: A004 - argmax, - argmin, - astype, - copy, - device_of, - device_to_native, - diag, - div, - dot, - eye, - eye_like, - from_numpy, - get_item, - iadd, - idiv, - imul, - isub, - matmul, - max, # noqa: A004 - maximum, - mean, - min, # noqa: A004 - mul, - ndim, - negative, - norm, - ones, - ones_like, - pow, # noqa: A004 - reshape, - set_item, - shape, - sign, - size, - sqrt, - squeeze, - stack, - sub, - sum, # noqa: A004 - to_array, - to_numpy, - transpose, - unsqueeze, - zeros, - zeros_like, -) -from decent_array.interoperability.iop.rng import ( - choice, - derive_seed, - get_rng_state, - get_seed, - normal, - normal_like, - set_rng_state, - set_seed, - uniform, - uniform_like, -) +from decent_array import interoperability, types +from decent_array._array import Array __all__ = [ "Array", - "absolute", - "add", - "all", - "any", - "argmax", - "argmin", - "astype", - "autodecorate_cost_method", - "choice", - "copy", - "derive_seed", - "device_of", - "device_to_native", - "diag", - "div", - "dot", - "eye", - "eye_like", - "from_numpy", - "get_item", - "get_rng_state", - "get_seed", - "iadd", - "idiv", - "imul", - "isub", - "matmul", - "max", - "maximum", - "mean", - "min", - "mul", - "ndim", - "negative", - "norm", - "normal", - "normal_like", - "ones", - "ones_like", - "pow", - "reshape", - "set_backend", - "set_item", - "set_rng_state", - "set_seed", - "shape", - "sign", - "size", - "sqrt", - "squeeze", - "stack", - "sub", - "sum", - "to_array", - "to_numpy", - "transpose", + "interoperability", "types", - "uniform", - "uniform_like", - "unsqueeze", - "zeros", - "zeros_like", ] diff --git a/decent_array/array.py b/decent_array/_array.py similarity index 93% rename from decent_array/array.py rename to decent_array/_array.py index 142a82d..a4c1662 100644 --- a/decent_array/array.py +++ b/decent_array/_array.py @@ -2,14 +2,13 @@ Lightweight wrapper around backend-native arrays. The :class:`Array` class wraps a single value of the active backend's framework type. -Under the single-active-backend invariant maintained by -:mod:`decent_array.interoperability.backend_manager`, every :class:`Array` at runtime +Under the single-active-backend invariant maintained by, every :class:`Array` at runtime holds a value from the same framework, so operators dispatch directly to the active backend without per-call isinstance dispatch. Operator contract is *strict*: binary arithmetic and indexing accept either another :class:`Array` or a Python scalar (``int``/``float``). Pass other framework-native -arrays through :func:`decent_array.iop.get_item` and friends, not through the +arrays through :func:`decent_array.interoperability.get_item` and friends, not through the operator path. Hot-path notes: @@ -26,17 +25,17 @@ from typing import TYPE_CHECKING, Any, Self -from decent_array.interoperability.backend_manager import register_backend_listener +from decent_array.interoperability._backend_manager import register_backend_listener if TYPE_CHECKING: - from decent_array.interoperability.abstracts import _Backend - from decent_array.types import ArrayKey + from decent_array.interoperability._abstracts import Backend + from decent_array.types import ArrayKey, SupportedArrayTypes -_BACKEND_INSTANCE: _Backend | None = None +_BACKEND_INSTANCE: Backend | None = None -def _update_backend(backend: _Backend | None) -> None: +def _update_backend(backend: Backend | None) -> None: global _BACKEND_INSTANCE # noqa: PLW0603 _BACKEND_INSTANCE = backend @@ -55,7 +54,7 @@ class Array: # noqa: PLR0904 __slots__ = ("_backend", "value") - def __init__(self, value: Any) -> None: # noqa: ANN401 + def __init__(self, value: SupportedArrayTypes) -> None: """ Wrap ``value`` in an :class:`Array`. @@ -79,7 +78,7 @@ def __init__(self, value: Any) -> None: # noqa: ANN401 ) self.value: Any = value - self._backend: _Backend = _BACKEND_INSTANCE + self._backend: Backend = _BACKEND_INSTANCE # Binary arithmetic ---------------------------------------------------- diff --git a/decent_array/interoperability/__init__.py b/decent_array/interoperability/__init__.py index e69de29..7893d88 100644 --- a/decent_array/interoperability/__init__.py +++ b/decent_array/interoperability/__init__.py @@ -0,0 +1,143 @@ +""" +Interoperability layer. + +Typical usage:: + + import decent_array.interoperability as iop + + iop.set_backend("numpy") + a = iop.zeros((3, 3)) + iop.set_seed(42) # Optional: set RNG seed for reproducibility + s = iop.normal(shape=(2,)) + +""" + +from ._backend_manager import set_backend +from ._decorators import autodecorate_cost_method +from ._iop.functions import ( + absolute, + add, + all, # noqa: A004 + any, # noqa: A004 + argmax, + argmin, + astype, + copy, + device_of, + device_to_native, + diag, + div, + dot, + eye, + eye_like, + from_numpy, + get_item, + iadd, + idiv, + imul, + isub, + matmul, + max, # noqa: A004 + maximum, + mean, + min, # noqa: A004 + mul, + ndim, + negative, + norm, + ones, + ones_like, + pow, # noqa: A004 + reshape, + set_item, + shape, + sign, + size, + sqrt, + squeeze, + stack, + sub, + sum, # noqa: A004 + to_array, + to_numpy, + transpose, + unsqueeze, + zeros, + zeros_like, +) +from ._iop.rng import ( + choice, + derive_seed, + get_rng_state, + get_seed, + normal, + normal_like, + set_rng_state, + set_seed, + uniform, + uniform_like, +) + +__all__ = [ + "absolute", + "add", + "all", + "any", + "argmax", + "argmin", + "astype", + "autodecorate_cost_method", + "choice", + "copy", + "derive_seed", + "device_of", + "device_to_native", + "diag", + "div", + "dot", + "eye", + "eye_like", + "from_numpy", + "get_item", + "get_rng_state", + "get_seed", + "iadd", + "idiv", + "imul", + "isub", + "matmul", + "max", + "maximum", + "mean", + "min", + "mul", + "ndim", + "negative", + "norm", + "normal", + "normal_like", + "ones", + "ones_like", + "pow", + "reshape", + "set_backend", + "set_item", + "set_rng_state", + "set_seed", + "shape", + "sign", + "size", + "sqrt", + "squeeze", + "stack", + "sub", + "sum", + "to_array", + "to_numpy", + "transpose", + "uniform", + "uniform_like", + "unsqueeze", + "zeros", + "zeros_like", +] diff --git a/decent_array/interoperability/_abstracts/__init__.py b/decent_array/interoperability/_abstracts/__init__.py new file mode 100644 index 0000000..b49360e --- /dev/null +++ b/decent_array/interoperability/_abstracts/__init__.py @@ -0,0 +1,3 @@ +from .backend import Backend + +__all__ = ["Backend"] diff --git a/decent_array/interoperability/abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py similarity index 99% rename from decent_array/interoperability/abstracts/backend.py rename to decent_array/interoperability/_abstracts/backend.py index 99d3ecc..8229d6a 100644 --- a/decent_array/interoperability/abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -1,5 +1,5 @@ """ -Abstract :class:`_Backend` contract. +Abstract :class:`Backend` contract. All abstract methods live in this single class rather than across six mixin ABCs. The flat layout is mypyc-compatible: when this module is included in the same compilation @@ -27,7 +27,7 @@ from decent_array.types import ArrayKey -class _Backend(ABC): # noqa: PLR0904 +class Backend(ABC): # noqa: PLR0904 """ Abstract base class for a backend. diff --git a/decent_array/interoperability/backend_manager.py b/decent_array/interoperability/_backend_manager.py similarity index 83% rename from decent_array/interoperability/backend_manager.py rename to decent_array/interoperability/_backend_manager.py index 7a743d3..634bf74 100644 --- a/decent_array/interoperability/backend_manager.py +++ b/decent_array/interoperability/_backend_manager.py @@ -6,13 +6,13 @@ from decent_array.types import SupportedDevices, SupportedFrameworks -from .abstracts import _Backend +from ._abstracts import Backend -_BACKEND_REGISTRY: dict[SupportedFrameworks, type[_Backend]] = {} -_BACKEND_INSTANCES: dict[SupportedFrameworks, _Backend] = {} +_BACKEND_REGISTRY: dict[SupportedFrameworks, type[Backend]] = {} +_BACKEND_INSTANCES: dict[SupportedFrameworks, Backend] = {} _ACTIVE_BACKEND: ContextVar[SupportedFrameworks | None] = ContextVar("decent_bench.iop2.active_backend", default=None) -_BACKEND_LISTENERS: list[Callable[[_Backend | None], None]] = [] -_BACKEND_INSTANCE: _Backend | None = None +_BACKEND_LISTENERS: list[Callable[[Backend | None], None]] = [] +_BACKEND_INSTANCE: Backend | None = None def set_backend( @@ -28,22 +28,20 @@ def set_backend( skip framework dispatch and isinstance checks, and lets backends construct array creation routines bound to a specific accelerator. - Backend modules are auto-imported on demand: the first call to ``set_backend("pytorch")`` - triggers import of ``decent_bench.utils.interoperability_2._pytorch``, whose ``__init__`` - is expected to register the backend via :func:`register_backend`. + Backend modules are auto-imported on demand. Args: - backend: A :class:`SupportedFrameworks` value, its canonical string (e.g. + backend: A :class:`~decent_array.types.SupportedFrameworks` value, its canonical string (e.g. ``"numpy"``, ``"pytorch"``), or any alias declared by the backend at registration time. Aliases are only resolvable after the backend module has been loaded; pass the canonical name on the first call to trigger autoload. - device: Target accelerator. Accepts a :class:`SupportedDevices` value or its + device: Target accelerator. Accepts a :class:`~decent_array.types.SupportedDevices` value or its string equivalent (``"cpu"``, ``"gpu"``, ``"mps"``). Defaults to CPU. The backend's array-creation methods produce arrays on this device by default. Note: Raises :class:`ImportError` if the backend module cannot be imported (e.g. due to - a missing optional dependency); the failure originates from :func:`_auto_import`. + a missing optional dependency). Raises: RuntimeError: If a different backend (or the same backend with a different device) @@ -75,7 +73,7 @@ def set_backend( listener(_BACKEND_INSTANCE) -def register_backend_listener(listener: Callable[[_Backend | None], None]) -> None: +def register_backend_listener(listener: Callable[[Backend | None], None]) -> None: """ Register a callback to be invoked on backend activation. @@ -83,7 +81,7 @@ def register_backend_listener(listener: Callable[[_Backend | None], None]) -> No is already active, the callback is invoked immediately with the current backend. Args: - listener: A callable that accepts a single :class:`_Backend` instance argument. + listener: A callable that accepts a single :class:`Backend` instance argument. """ _BACKEND_LISTENERS.append(listener) @@ -93,7 +91,7 @@ def register_backend_listener(listener: Callable[[_Backend | None], None]) -> No def register_backend( backend: SupportedFrameworks, - cls: type[_Backend], + cls: type[Backend], ) -> None: """ Register a backend class under a :class:`SupportedFrameworks` value. @@ -110,14 +108,14 @@ class decorator). Decorator-based registration would mark the decorated class as Args: backend: Canonical backend identifier. - cls: A concrete subclass of :class:`_Backend`. + cls: A concrete subclass of :class:`Backend`. Raises: - TypeError: If ``cls`` is not a subclass of :class:`_Backend`. + TypeError: If ``cls`` is not a subclass of :class:`Backend`. """ - if not issubclass(cls, _Backend): - raise TypeError(f"Registered backend must be a subclass of _Backend, got {cls}") + if not issubclass(cls, Backend): + raise TypeError(f"Registered backend must be a subclass of Backend, got {cls}") _BACKEND_REGISTRY[backend] = cls _BACKEND_INSTANCES.pop(backend, None) @@ -147,7 +145,7 @@ def _normalize(backend: SupportedFrameworks | str) -> SupportedFrameworks: raise KeyError(f"Unknown backend '{backend}'. Valid backends: {valid}.") from exc -def _instantiate(backend: SupportedFrameworks, device: SupportedDevices) -> _Backend: +def _instantiate(backend: SupportedFrameworks, device: SupportedDevices) -> Backend: if backend in _BACKEND_INSTANCES: return _BACKEND_INSTANCES[backend] diff --git a/decent_array/interoperability/decorators.py b/decent_array/interoperability/_decorators.py similarity index 62% rename from decent_array/interoperability/decorators.py rename to decent_array/interoperability/_decorators.py index 97a6ec5..c50c0b2 100644 --- a/decent_array/interoperability/decorators.py +++ b/decent_array/interoperability/_decorators.py @@ -3,7 +3,7 @@ Single-backend semantics make this decorator dramatically simpler than the v1 version: no framework dispatch, no cross-framework conversion, no ``to_array_like`` magic — just -unwrap input :class:`Array` values to their native form, call the subclass method, and +unwrap input :class:`~decent_array.Array` values to their native form, call the subclass method, and re-wrap the return if the superclass declared ``-> Array``. """ @@ -18,9 +18,9 @@ def autodecorate_cost_method[T: Callable[..., Any]](superclass_method: T) -> Cal """ Decorate a Cost method override so its body can use raw framework arrays. - Each :class:`Array` argument is unwrapped to its underlying value before the call. - If the *superclass* method's return annotation is :class:`Array`, the return value - is re-wrapped in :class:`Array` (unless already wrapped). All other arguments and + Each :class:`~decent_array.Array` argument is unwrapped to its underlying value before the call. + If the *superclass* method's return annotation is :class:`~decent_array.Array`, the return value + is re-wrapped in :class:`~decent_array.Array` (unless already wrapped). All other arguments and return values pass through unchanged. Args: @@ -28,13 +28,15 @@ def autodecorate_cost_method[T: Callable[..., Any]](superclass_method: T) -> Cal Used solely to look up the declared return type at decoration time. Example: - class LinearRegressionCost(EmpiricalRiskCost): - @autodecorate_cost_method(EmpiricalRiskCost.gradient) - def gradient(self, x: NDArray[float64], indices: ...) -> NDArray[float64]: - # ``x`` arrives as a numpy ndarray; the wrapper unwraps the caller's Array. - return self.A.T @ (self.A @ x - self.b) / self.n_samples - # Return value is wrapped back into Array because EmpiricalRiskCost.gradient - # is annotated ``-> Array``. + .. code-block:: python + + class LinearRegressionCost(EmpiricalRiskCost): + @autodecorate_cost_method(EmpiricalRiskCost.gradient) + def gradient(self, x: NDArray[float64], indices: ...) -> NDArray[float64]: + # ``x`` arrives as a numpy ndarray; the wrapper unwraps the caller's Array. + return self.A.T @ (self.A @ x - self.b) / self.n_samples + # Return value is wrapped back into Array because EmpiricalRiskCost.gradient + # is annotated ``-> Array``. """ from decent_array.array import Array # noqa: PLC0415 diff --git a/decent_array/interoperability/iop/__init__.py b/decent_array/interoperability/_iop/__init__.py similarity index 100% rename from decent_array/interoperability/iop/__init__.py rename to decent_array/interoperability/_iop/__init__.py diff --git a/decent_array/interoperability/iop/functions.py b/decent_array/interoperability/_iop/functions.py similarity index 94% rename from decent_array/interoperability/iop/functions.py rename to decent_array/interoperability/_iop/functions.py index efb637e..8944e53 100644 --- a/decent_array/interoperability/iop/functions.py +++ b/decent_array/interoperability/_iop/functions.py @@ -6,7 +6,7 @@ via :func:`_set_active_backend`. Calling any of these before ``set_backend`` raises :class:`RuntimeError` via the sentinel's ``__getattr__``. -When this module and ``_Backend`` are mypyc-compiled in the same group, +When this module and ``Backend`` are mypyc-compiled in the same group, ``_BACKEND.add(...)`` dispatches as a native compiled-to-compiled call — no Python attribute lookup, no bound-method allocation per call. """ @@ -16,20 +16,20 @@ from collections.abc import Sequence from typing import TYPE_CHECKING, Any -from decent_array.interoperability.backend_manager import register_backend_listener +from decent_array.interoperability._backend_manager import register_backend_listener if TYPE_CHECKING: from numpy.typing import NDArray from decent_array.array import Array - from decent_array.interoperability.abstracts import _Backend + from decent_array.interoperability._abstracts import Backend from decent_array.types import ArrayKey, SupportedDevices -_BACKEND_INSTANCE: _Backend | None = None +_BACKEND_INSTANCE: Backend | None = None _error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") -def _update_backend(backend: _Backend | None) -> None: +def _update_backend(backend: Backend | None) -> None: global _BACKEND_INSTANCE # noqa: PLW0603 _BACKEND_INSTANCE = backend @@ -82,14 +82,14 @@ def eye_like(array: Array) -> Array: def device_to_native(device: SupportedDevices) -> Any: # noqa: ANN401 - """Convert :class:`SupportedDevices` to the active backend's native device.""" + """Convert :class:`~decent_array.types.SupportedDevices` to the active backend's native device.""" if _BACKEND_INSTANCE is None: raise _error return _BACKEND_INSTANCE.device_to_native(device) def device_of(array: Array) -> SupportedDevices: - """Return the :class:`SupportedDevices` of ``array``.""" + """Return the :class:`~decent_array.types.SupportedDevices` of ``array``.""" if _BACKEND_INSTANCE is None: raise _error return _BACKEND_INSTANCE.device_of(array) @@ -113,14 +113,14 @@ def to_numpy(array: Array) -> NDArray[Any]: def from_numpy(array: NDArray[Any]) -> Array: - """Convert a NumPy array on CPU to an :class:`Array` on the active backend.""" + """Convert a NumPy array on CPU to an :class:`~decent_array.Array` on the active backend.""" if _BACKEND_INSTANCE is None: raise _error return _BACKEND_INSTANCE.from_numpy(array) def to_array(array: float | bool) -> Array: - """Convert a Python scalar to an :class:`Array` on the active backend.""" + """Convert a Python scalar to an :class:`~decent_array.Array` on the active backend.""" if _BACKEND_INSTANCE is None: raise _error return _BACKEND_INSTANCE.to_array(array) diff --git a/decent_array/interoperability/iop/rng.py b/decent_array/interoperability/_iop/rng.py similarity index 95% rename from decent_array/interoperability/iop/rng.py rename to decent_array/interoperability/_iop/rng.py index a472bad..1043c8b 100644 --- a/decent_array/interoperability/iop/rng.py +++ b/decent_array/interoperability/_iop/rng.py @@ -20,21 +20,21 @@ import random from typing import TYPE_CHECKING, Any -from decent_array.interoperability.backend_manager import _instantiate, register_backend_listener +from decent_array.interoperability._backend_manager import _instantiate, register_backend_listener from decent_array.types import SupportedDevices, SupportedFrameworks if TYPE_CHECKING: from decent_array.array import Array - from decent_array.interoperability.abstracts import _Backend + from decent_array.interoperability._abstracts import Backend _NUMPY_STATE_KEY = "__numpy_rng_state__" _PYTHON_RANDOM_KEY = "__python_random_state__" -_BACKEND_INSTANCE: _Backend | None = None +_BACKEND_INSTANCE: Backend | None = None _error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") -def _update_backend(backend: _Backend | None) -> None: +def _update_backend(backend: Backend | None) -> None: global _BACKEND_INSTANCE # noqa: PLW0603 _BACKEND_INSTANCE = backend @@ -114,7 +114,7 @@ def set_rng_state(self, state: dict[str, Any]) -> None: numpy_backend.set_rng_state(numpy_state) active.set_rng_state(state) - def _numpy_backend(self) -> _Backend: + def _numpy_backend(self) -> Backend: return _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU) diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index b5eceba..256fda5 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -20,8 +20,8 @@ from numpy.typing import NDArray from decent_array.array import Array -from decent_array.interoperability.abstracts import _Backend -from decent_array.interoperability.backend_manager import register_backend +from decent_array.interoperability._abstracts import Backend +from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks @@ -30,8 +30,8 @@ def _unwrap(array: Any) -> Any: # noqa: ANN401 return array.value if type(array) is Array else array -class JaxBackend(_Backend): # noqa: PLR0904 - """JAX implementation of :class:`_Backend`.""" +class JaxBackend(Backend): # noqa: PLR0904 + """JAX implementation of :class:`Backend`.""" def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: super().__init__(device) diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index 5555192..a9b2efd 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -15,8 +15,8 @@ from numpy.typing import NDArray from decent_array.array import Array -from decent_array.interoperability.abstracts import _Backend -from decent_array.interoperability.backend_manager import register_backend +from decent_array.interoperability._abstracts import Backend +from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks @@ -31,8 +31,8 @@ def _unwrap(array: Any) -> Any: # noqa: ANN401 return array.value if type(array) is Array else array -class NumpyBackend(_Backend): # noqa: PLR0904 - """NumPy implementation of :class:`_Backend`.""" +class NumpyBackend(Backend): # noqa: PLR0904 + """NumPy implementation of :class:`Backend`.""" def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: if device != SupportedDevices.CPU: diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index f3a8730..8d92df3 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -15,8 +15,8 @@ from numpy.typing import NDArray from decent_array.array import Array -from decent_array.interoperability.abstracts import _Backend -from decent_array.interoperability.backend_manager import register_backend +from decent_array.interoperability._abstracts import Backend +from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks @@ -25,8 +25,8 @@ def _unwrap(array: Any) -> Any: # noqa: ANN401 return array.value if type(array) is Array else array -class PyTorchBackend(_Backend): # noqa: PLR0904 - """PyTorch implementation of :class:`_Backend`.""" +class PyTorchBackend(Backend): # noqa: PLR0904 + """PyTorch implementation of :class:`Backend`.""" def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: super().__init__(device) diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index f153ed3..e31e3e9 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -18,8 +18,8 @@ from numpy.typing import NDArray from decent_array.array import Array -from decent_array.interoperability.abstracts import _Backend -from decent_array.interoperability.backend_manager import register_backend +from decent_array.interoperability._abstracts import Backend +from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks @@ -28,8 +28,8 @@ def _unwrap(array: Any) -> Any: # noqa: ANN401 return array.value if type(array) is Array else array -class TensorflowBackend(_Backend): # noqa: PLR0904 - """TensorFlow implementation of :class:`_Backend`.""" +class TensorflowBackend(Backend): # noqa: PLR0904 + """TensorFlow implementation of :class:`Backend`.""" def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: super().__init__(device) diff --git a/decent_array/interoperability/abstracts/__init__.py b/decent_array/interoperability/abstracts/__init__.py deleted file mode 100644 index d8b79e9..0000000 --- a/decent_array/interoperability/abstracts/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .backend import _Backend - -__all__ = ["_Backend"] diff --git a/docs/source/api/decent_array.array.rst b/docs/source/api/decent_array.array.rst new file mode 100644 index 0000000..ab02904 --- /dev/null +++ b/docs/source/api/decent_array.array.rst @@ -0,0 +1,7 @@ +decent\_array.Array +=================== + +.. automodule:: decent_array + :members: + :show-inheritance: + :undoc-members: \ No newline at end of file diff --git a/docs/source/api/decent_array.interoperability.rst b/docs/source/api/decent_array.interoperability.rst new file mode 100644 index 0000000..00ead3d --- /dev/null +++ b/docs/source/api/decent_array.interoperability.rst @@ -0,0 +1,7 @@ +decent\_array.interoperability +============================== + +.. automodule:: decent_array.interoperability + :members: + :show-inheritance: + :undoc-members: diff --git a/docs/source/api/decent_array.rst b/docs/source/api/decent_array.rst new file mode 100644 index 0000000..66c4fcd --- /dev/null +++ b/docs/source/api/decent_array.rst @@ -0,0 +1,14 @@ +decent\_array +============= + +.. toctree:: + :maxdepth: 2 + + decent_array.interoperability + + +.. toctree:: + :maxdepth: 2 + + decent_array.types + decent_array.array \ No newline at end of file diff --git a/docs/source/api/decent_array.types.rst b/docs/source/api/decent_array.types.rst new file mode 100644 index 0000000..6a29483 --- /dev/null +++ b/docs/source/api/decent_array.types.rst @@ -0,0 +1,7 @@ +decent\_array.types +=================== + +.. automodule:: decent_array.types + :members: + :show-inheritance: + :undoc-members: \ No newline at end of file diff --git a/tests/test_backend_manager.py b/tests/test_backend_manager.py index 3c656f6..8842812 100644 --- a/tests/test_backend_manager.py +++ b/tests/test_backend_manager.py @@ -7,7 +7,7 @@ import pytest from decent_array.interoperability import backend_manager -from decent_array.interoperability.abstracts import _Backend +from decent_array.interoperability.abstracts import Backend from decent_array.interoperability.backend_manager import ( _instantiate, _normalize, @@ -117,34 +117,34 @@ def test_register_backend_replaces_cached_instance() -> None: def test_listener_called_on_activation() -> None: - received: list[_Backend | None] = [] + received: list[Backend | None] = [] - def listener(backend: _Backend | None) -> None: + def listener(backend: Backend | None) -> None: received.append(backend) register_backend_listener(listener) set_backend("numpy") assert len(received) == 1 - assert isinstance(received[0], _Backend) + assert isinstance(received[0], Backend) def test_listener_called_immediately_when_backend_already_active() -> None: set_backend("numpy") - received: list[_Backend | None] = [] + received: list[Backend | None] = [] - def listener(backend: _Backend | None) -> None: + def listener(backend: Backend | None) -> None: received.append(backend) register_backend_listener(listener) assert len(received) == 1 - assert isinstance(received[0], _Backend) + assert isinstance(received[0], Backend) def test_listener_called_with_none_on_reset() -> None: set_backend("numpy") - received: list[_Backend | None] = [] + received: list[Backend | None] = [] - def listener(backend: _Backend | None) -> None: + def listener(backend: Backend | None) -> None: received.append(backend) register_backend_listener(listener) From ce7473928fa5887531ae5b36dc89472f7b46e3f2 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 04:06:21 +0200 Subject: [PATCH 03/11] fix broken links --- decent_array/_array.py | 2 +- decent_array/interoperability/_abstracts/backend.py | 2 +- decent_array/interoperability/_decorators.py | 2 +- decent_array/interoperability/_iop/functions.py | 2 +- decent_array/interoperability/_iop/rng.py | 2 +- decent_array/interoperability/_jax/jax_backend.py | 2 +- decent_array/interoperability/_numpy/numpy_backend.py | 2 +- decent_array/interoperability/_pytorch/pytorch_backend.py | 2 +- decent_array/interoperability/_tensorflow/tensorflow_backend.py | 2 +- 9 files changed, 9 insertions(+), 9 deletions(-) diff --git a/decent_array/_array.py b/decent_array/_array.py index a4c1662..8d70614 100644 --- a/decent_array/_array.py +++ b/decent_array/_array.py @@ -177,7 +177,7 @@ def __getitem__(self, key: ArrayKey) -> Array: def __setitem__(self, key: ArrayKey, value: Array | float) -> None: """Set the item at ``key`` to ``value``.""" - if type(value) is not Array: + if not isinstance(value, Array): value = Array(value) self._backend.set_item(self, key, value) diff --git a/decent_array/interoperability/_abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py index 8229d6a..5557b88 100644 --- a/decent_array/interoperability/_abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -23,7 +23,7 @@ if TYPE_CHECKING: from numpy.typing import NDArray - from decent_array.array import Array + from decent_array import Array from decent_array.types import ArrayKey diff --git a/decent_array/interoperability/_decorators.py b/decent_array/interoperability/_decorators.py index c50c0b2..bd0df3f 100644 --- a/decent_array/interoperability/_decorators.py +++ b/decent_array/interoperability/_decorators.py @@ -39,7 +39,7 @@ def gradient(self, x: NDArray[float64], indices: ...) -> NDArray[float64]: # is annotated ``-> Array``. """ - from decent_array.array import Array # noqa: PLC0415 + from decent_array import Array # noqa: PLC0415 return_is_array = superclass_method.__annotations__.get("return") is Array diff --git a/decent_array/interoperability/_iop/functions.py b/decent_array/interoperability/_iop/functions.py index 8944e53..6b57e91 100644 --- a/decent_array/interoperability/_iop/functions.py +++ b/decent_array/interoperability/_iop/functions.py @@ -21,7 +21,7 @@ if TYPE_CHECKING: from numpy.typing import NDArray - from decent_array.array import Array + from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.types import ArrayKey, SupportedDevices diff --git a/decent_array/interoperability/_iop/rng.py b/decent_array/interoperability/_iop/rng.py index 1043c8b..91abdc9 100644 --- a/decent_array/interoperability/_iop/rng.py +++ b/decent_array/interoperability/_iop/rng.py @@ -24,7 +24,7 @@ from decent_array.types import SupportedDevices, SupportedFrameworks if TYPE_CHECKING: - from decent_array.array import Array + from decent_array import Array from decent_array.interoperability._abstracts import Backend diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index 256fda5..62a39e4 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -19,7 +19,7 @@ import numpy as np from numpy.typing import NDArray -from decent_array.array import Array +from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index a9b2efd..0bae7f4 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -14,7 +14,7 @@ import numpy as np from numpy.typing import NDArray -from decent_array.array import Array +from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index 8d92df3..56d9359 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -14,7 +14,7 @@ import torch from numpy.typing import NDArray -from decent_array.array import Array +from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index e31e3e9..f8e9b65 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -17,7 +17,7 @@ import tensorflow as tf from numpy.typing import NDArray -from decent_array.array import Array +from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks From 7ff035252ef7bbbe820a941e8b30d1e3fd827fe6 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 04:24:39 +0200 Subject: [PATCH 04/11] fix pytest --- benchmarks/bench_common.py | 2 +- benchmarks/profile_hotpath.py | 2 +- tests/conftest.py | 4 +- tests/test_array.py | 110 ++++++------ tests/test_backend_manager.py | 10 +- tests/test_decorators.py | 26 +-- tests/test_iop_functions.py | 311 +++++++++++++++++----------------- tests/test_iop_rng.py | 131 +++++++------- 8 files changed, 298 insertions(+), 298 deletions(-) diff --git a/benchmarks/bench_common.py b/benchmarks/bench_common.py index ebe1659..13b350b 100644 --- a/benchmarks/bench_common.py +++ b/benchmarks/bench_common.py @@ -133,7 +133,7 @@ def parse_backends_arg() -> list[str] | None: def is_compiled() -> tuple[bool, str]: """Return ``(True, path)`` if the Array module loaded from a ``.so``/``.pyd``, else ``(False, .py path)``.""" - module = importlib.import_module("decent_array.array.array") + module = importlib.import_module("decent_array.Array") path = module.__file__ or "" return path.endswith((".so", ".pyd")), path diff --git a/benchmarks/profile_hotpath.py b/benchmarks/profile_hotpath.py index 70e6d8c..588e494 100644 --- a/benchmarks/profile_hotpath.py +++ b/benchmarks/profile_hotpath.py @@ -39,7 +39,7 @@ def _is_compiled() -> tuple[bool, str]: - module = importlib.import_module("decent_array.array") + module = importlib.import_module("decent_array._array") path = module.__file__ or "" return path.endswith((".so", ".pyd")), path diff --git a/tests/conftest.py b/tests/conftest.py index 6810e44..1ca38bf 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -14,7 +14,7 @@ import pytest -from decent_array.interoperability.backend_manager import reset_backends +from decent_array.interoperability._backend_manager import reset_backends from decent_array.types import SupportedDevices, SupportedFrameworks if TYPE_CHECKING: @@ -106,7 +106,7 @@ def _backend_params() -> list[pytest.ParameterSet]: @pytest.fixture(params=BACKEND_PARAMS) def backend(request: FixtureRequest) -> Iterator[tuple[SupportedFrameworks, SupportedDevices]]: """Activate the (framework, device) backend for this test, then reset on teardown.""" - from decent_array.interoperability.backend_manager import set_backend # noqa: PLC0415 + from decent_array.interoperability import set_backend # noqa: PLC0415 framework, device = request.param set_backend(framework, device) diff --git a/tests/test_array.py b/tests/test_array.py index 02afb4a..3653c2b 100644 --- a/tests/test_array.py +++ b/tests/test_array.py @@ -1,4 +1,4 @@ -"""Tests for :class:`decent_array.array.Array` operators, properties, and dunders.""" +"""Tests for :class:`decent_array.Array` operators, properties, and dunders.""" from __future__ import annotations @@ -7,14 +7,14 @@ import numpy as np import pytest -import decent_array as da -from decent_array.array import Array -from decent_array.interoperability.backend_manager import reset_backends +import decent_array.interoperability as iop +from decent_array import Array +from decent_array.interoperability._backend_manager import reset_backends def _np(arr: Array) -> np.ndarray: """Convert a backend-native ``Array`` to a numpy array for assertions.""" - return da.to_numpy(arr) + return iop.to_numpy(arr) # Construction ------------------------------------------------------------ @@ -27,7 +27,7 @@ def test_init_requires_active_backend() -> None: def test_init_records_active_backend(backend: tuple) -> None: - arr = da.zeros((3,)) + arr = iop.zeros((3,)) assert arr._backend is not None assert isinstance(arr, Array) @@ -36,72 +36,72 @@ def test_init_records_active_backend(backend: tuple) -> None: def test_add_array(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) - b = da.from_numpy(np.array([4.0, 5.0, 6.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([4.0, 5.0, 6.0])) np.testing.assert_allclose(_np(a + b), [5.0, 7.0, 9.0]) def test_add_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(a + 2), [3.0, 4.0, 5.0]) def test_radd_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(2 + a), [3.0, 4.0, 5.0]) def test_sub_array(backend: tuple) -> None: - a = da.from_numpy(np.array([4.0, 5.0, 6.0])) - b = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([4.0, 5.0, 6.0])) + b = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(a - b), [3.0, 3.0, 3.0]) def test_sub_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([4.0, 5.0, 6.0])) + a = iop.from_numpy(np.array([4.0, 5.0, 6.0])) np.testing.assert_allclose(_np(a - 1), [3.0, 4.0, 5.0]) def test_rsub_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(10 - a), [9.0, 8.0, 7.0]) def test_mul_array(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) - b = da.from_numpy(np.array([2.0, 3.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([2.0, 3.0, 4.0])) np.testing.assert_allclose(_np(a * b), [2.0, 6.0, 12.0]) def test_mul_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(a * 3), [3.0, 6.0, 9.0]) def test_rmul_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(3 * a), [3.0, 6.0, 9.0]) def test_truediv_array(backend: tuple) -> None: - a = da.from_numpy(np.array([4.0, 9.0, 16.0])) - b = da.from_numpy(np.array([2.0, 3.0, 4.0])) + a = iop.from_numpy(np.array([4.0, 9.0, 16.0])) + b = iop.from_numpy(np.array([2.0, 3.0, 4.0])) np.testing.assert_allclose(_np(a / b), [2.0, 3.0, 4.0]) def test_truediv_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([2.0, 4.0, 6.0])) + a = iop.from_numpy(np.array([2.0, 4.0, 6.0])) np.testing.assert_allclose(_np(a / 2), [1.0, 2.0, 3.0]) def test_rtruediv_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 4.0])) np.testing.assert_allclose(_np(8 / a), [8.0, 4.0, 2.0]) def test_matmul_array(backend: tuple) -> None: - a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - b = da.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) expected = np.array([[19.0, 22.0], [43.0, 50.0]]) np.testing.assert_allclose(_np(a @ b), expected) @@ -109,13 +109,13 @@ def test_matmul_array(backend: tuple) -> None: def test_rmatmul_explicit_call(backend: tuple) -> None: # Python dispatch never picks Array.__rmatmul__ when both operands are Array, # so call it directly to exercise the code path. - a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - b = da.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) np.testing.assert_allclose(_np(a.__rmatmul__(b)), _np(b @ a)) def test_pow_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) np.testing.assert_allclose(_np(a**2), [1.0, 4.0, 9.0]) @@ -123,33 +123,33 @@ def test_pow_scalar(backend: tuple) -> None: def test_iadd_array(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) - b = da.from_numpy(np.array([4.0, 5.0, 6.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([4.0, 5.0, 6.0])) a += b np.testing.assert_allclose(_np(a), [5.0, 7.0, 9.0]) def test_iadd_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) a += 10 np.testing.assert_allclose(_np(a), [11.0, 12.0, 13.0]) def test_isub_array(backend: tuple) -> None: - a = da.from_numpy(np.array([5.0, 6.0, 7.0])) - b = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([5.0, 6.0, 7.0])) + b = iop.from_numpy(np.array([1.0, 2.0, 3.0])) a -= b np.testing.assert_allclose(_np(a), [4.0, 4.0, 4.0]) def test_imul_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) a *= 2 np.testing.assert_allclose(_np(a), [2.0, 4.0, 6.0]) def test_itruediv_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([2.0, 4.0, 6.0])) + a = iop.from_numpy(np.array([2.0, 4.0, 6.0])) a /= 2 np.testing.assert_allclose(_np(a), [1.0, 2.0, 3.0]) @@ -158,12 +158,12 @@ def test_itruediv_scalar(backend: tuple) -> None: def test_neg(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, -2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, -2.0, 3.0])) np.testing.assert_allclose(_np(-a), [-1.0, 2.0, -3.0]) def test_abs(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, -2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, -2.0, 3.0])) np.testing.assert_allclose(_np(abs(a)), [1.0, 2.0, 3.0]) @@ -171,29 +171,29 @@ def test_abs(backend: tuple) -> None: def test_getitem_int(backend: tuple) -> None: - a = da.from_numpy(np.array([10.0, 20.0, 30.0])) + a = iop.from_numpy(np.array([10.0, 20.0, 30.0])) np.testing.assert_allclose(_np(a[1]), 20.0) def test_getitem_slice(backend: tuple) -> None: - a = da.from_numpy(np.array([10.0, 20.0, 30.0, 40.0])) + a = iop.from_numpy(np.array([10.0, 20.0, 30.0, 40.0])) np.testing.assert_allclose(_np(a[1:3]), [20.0, 30.0]) def test_getitem_tuple(backend: tuple) -> None: - a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) np.testing.assert_allclose(_np(a[1, 0]), 3.0) def test_setitem_with_array(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) - a[1] = da.from_numpy(np.array(99.0)) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a[1] = iop.from_numpy(np.array(99.0)) np.testing.assert_allclose(_np(a), [1.0, 99.0, 3.0]) def test_setitem_with_scalar(backend: tuple) -> None: # __setitem__ wraps a non-Array value in Array internally. - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) a[2] = 99.0 np.testing.assert_allclose(_np(a), [1.0, 2.0, 99.0]) @@ -202,24 +202,24 @@ def test_setitem_with_scalar(backend: tuple) -> None: def test_len(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) assert len(a) == 4 def test_float_coercion(backend: tuple) -> None: - a = da.from_numpy(np.array(2.5)) + a = iop.from_numpy(np.array(2.5)) assert float(a) == pytest.approx(2.5) def test_repr(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0])) text = repr(a) assert text.startswith("Array(") assert text.endswith(")") def test_str(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0])) # ``str(arr)`` delegates to the wrapped value's stringifier; just check it succeeds # and is non-empty rather than pin per-backend formatting. assert isinstance(str(a), str) @@ -230,45 +230,45 @@ def test_str(backend: tuple) -> None: def test_shape(backend: tuple) -> None: - a = da.from_numpy(np.zeros((2, 3, 4))) + a = iop.from_numpy(np.zeros((2, 3, 4))) assert a.shape == (2, 3, 4) def test_size(backend: tuple) -> None: - a = da.from_numpy(np.zeros((2, 3, 4))) + a = iop.from_numpy(np.zeros((2, 3, 4))) assert a.size == 24 def test_ndim(backend: tuple) -> None: - a = da.from_numpy(np.zeros((2, 3, 4))) + a = iop.from_numpy(np.zeros((2, 3, 4))) assert a.ndim == 3 def test_transpose_property(backend: tuple) -> None: - a = da.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) + a = iop.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) np.testing.assert_allclose(_np(a.transpose), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]) def test_T_alias(backend: tuple) -> None: - a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) np.testing.assert_allclose(_np(a.T), _np(a.transpose)) def test_any_true(backend: tuple) -> None: - a = da.from_numpy(np.array([0.0, 0.0, 1.0])) + a = iop.from_numpy(np.array([0.0, 0.0, 1.0])) assert a.any is True def test_any_false(backend: tuple) -> None: - a = da.from_numpy(np.array([0.0, 0.0, 0.0])) + a = iop.from_numpy(np.array([0.0, 0.0, 0.0])) assert a.any is False def test_all_true(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) assert a.all is True def test_all_false(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 0.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 0.0, 3.0])) assert a.all is False diff --git a/tests/test_backend_manager.py b/tests/test_backend_manager.py index 8842812..982812d 100644 --- a/tests/test_backend_manager.py +++ b/tests/test_backend_manager.py @@ -1,4 +1,4 @@ -"""Tests for :mod:`decent_array.interoperability.backend_manager`.""" +"""Tests for :mod:`decent_array.interoperability._backend_manager`.""" from __future__ import annotations @@ -6,9 +6,9 @@ import pytest -from decent_array.interoperability import backend_manager -from decent_array.interoperability.abstracts import Backend -from decent_array.interoperability.backend_manager import ( +from decent_array.interoperability import _backend_manager as backend_manager +from decent_array.interoperability._abstracts import Backend +from decent_array.interoperability._backend_manager import ( _instantiate, _normalize, register_backend, @@ -95,7 +95,7 @@ def test_register_backend_rejects_non_subclass() -> None: class NotABackend: pass - with pytest.raises(TypeError, match=r"subclass of _Backend"): + with pytest.raises(TypeError, match=r"subclass of Backend"): register_backend(SupportedFrameworks.NUMPY, NotABackend) # type: ignore[arg-type] diff --git a/tests/test_decorators.py b/tests/test_decorators.py index 123893f..2a5e157 100644 --- a/tests/test_decorators.py +++ b/tests/test_decorators.py @@ -10,9 +10,9 @@ import numpy as np -import decent_array as da -from decent_array.array import Array -from decent_array.interoperability.decorators import autodecorate_cost_method +import decent_array.interoperability as iop +from decent_array import Array +from decent_array.interoperability._decorators import autodecorate_cost_method class _Base: @@ -38,13 +38,13 @@ def returns_array(self, x: Any) -> Any: seen.append(x) return x * 2 - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) result = Impl().returns_array(arr) # The decorator should have unwrapped the Array to its underlying value. assert not isinstance(seen[0], Array) # Annotated `-> Array`, so the return is re-wrapped. assert isinstance(result, Array) - np.testing.assert_allclose(da.to_numpy(result), [2.0, 4.0, 6.0]) + np.testing.assert_allclose(iop.to_numpy(result), [2.0, 4.0, 6.0]) def test_does_not_rewrap_when_return_not_array(backend: tuple) -> None: @@ -57,7 +57,7 @@ def returns_float(self, x: Any) -> float: assert not isinstance(x, Array) return 42.0 - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) result = Impl().returns_float(arr) assert isinstance(result, float) assert result == 42.0 @@ -71,11 +71,11 @@ def takes_kwarg(self, x: Any, *, scale: Any) -> Any: assert not isinstance(scale, Array) return x * scale - arr = da.from_numpy(np.array([1.0, 2.0])) - scale = da.from_numpy(np.array([10.0, 100.0])) + arr = iop.from_numpy(np.array([1.0, 2.0])) + scale = iop.from_numpy(np.array([10.0, 100.0])) result = Impl().takes_kwarg(arr, scale=scale) assert isinstance(result, Array) - np.testing.assert_allclose(da.to_numpy(result), [10.0, 200.0]) + np.testing.assert_allclose(iop.to_numpy(result), [10.0, 200.0]) def test_passes_non_array_args_unchanged(backend: tuple) -> None: @@ -85,10 +85,10 @@ def passes_through_non_array(self, x: Any, n: int) -> Any: assert isinstance(n, int) return x * n - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) result = Impl().passes_through_non_array(arr, 4) assert isinstance(result, Array) - np.testing.assert_allclose(da.to_numpy(result), [4.0, 8.0, 12.0]) + np.testing.assert_allclose(iop.to_numpy(result), [4.0, 8.0, 12.0]) def test_does_not_double_wrap_when_impl_returns_array(backend: tuple) -> None: @@ -99,9 +99,9 @@ class Impl(_Base): def returns_array(self, x: Any) -> Array: return Array(x * 3) - arr = da.from_numpy(np.array([1.0, 2.0])) + arr = iop.from_numpy(np.array([1.0, 2.0])) result = Impl().returns_array(arr) assert isinstance(result, Array) # If the wrapper double-wrapped, ``result.value`` would itself be an Array. assert not isinstance(result.value, Array) - np.testing.assert_allclose(da.to_numpy(result), [3.0, 6.0]) + np.testing.assert_allclose(iop.to_numpy(result), [3.0, 6.0]) diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py index 1e2af5c..9dc42dd 100644 --- a/tests/test_iop_functions.py +++ b/tests/test_iop_functions.py @@ -5,72 +5,71 @@ import numpy as np import pytest -import decent_array as da -from decent_array.array import Array -from decent_array.interoperability.backend_manager import reset_backends -from decent_array.interoperability.iop import functions as iop_functions +import decent_array.interoperability as iop +from decent_array import Array +from decent_array.interoperability._backend_manager import reset_backends from decent_array.types import SupportedDevices def _np(arr: Array) -> np.ndarray: - return da.to_numpy(arr) + return iop.to_numpy(arr) # Array creation --------------------------------------------------------- def test_zeros(backend: tuple) -> None: - arr = da.zeros((2, 3)) + arr = iop.zeros((2, 3)) np.testing.assert_allclose(_np(arr), np.zeros((2, 3))) def test_zeros_like(backend: tuple) -> None: - src = da.from_numpy(np.ones((2, 3))) - arr = da.zeros_like(src) + src = iop.from_numpy(np.ones((2, 3))) + arr = iop.zeros_like(src) np.testing.assert_allclose(_np(arr), np.zeros((2, 3))) def test_ones(backend: tuple) -> None: - arr = da.ones((2, 3)) + arr = iop.ones((2, 3)) np.testing.assert_allclose(_np(arr), np.ones((2, 3))) def test_ones_like(backend: tuple) -> None: - src = da.from_numpy(np.zeros((2, 3))) - arr = da.ones_like(src) + src = iop.from_numpy(np.zeros((2, 3))) + arr = iop.ones_like(src) np.testing.assert_allclose(_np(arr), np.ones((2, 3))) def test_eye(backend: tuple) -> None: - arr = da.eye(3) + arr = iop.eye(3) np.testing.assert_allclose(_np(arr), np.eye(3)) def test_eye_like(backend: tuple) -> None: - src = da.from_numpy(np.zeros((4, 4))) - arr = da.eye_like(src) + src = iop.from_numpy(np.zeros((4, 4))) + arr = iop.eye_like(src) np.testing.assert_allclose(_np(arr), np.eye(4)) def test_device_to_native(backend: tuple) -> None: framework, device = backend - native = da.device_to_native(device) + native = iop.device_to_native(device) # Just verify the call succeeds and returns a non-None value (varies per backend). assert native is not None def test_device_of(backend: tuple) -> None: _framework, device = backend - arr = da.zeros((3,)) - assert da.device_of(arr) == device + arr = iop.zeros((3,)) + assert iop.device_of(arr) == device # Array manipulation ----------------------------------------------------- def test_copy_independent(backend: tuple) -> None: - src = da.from_numpy(np.array([1.0, 2.0, 3.0])) - dst = da.copy(src) + src = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + dst = iop.copy(src) np.testing.assert_allclose(_np(dst), [1.0, 2.0, 3.0]) # Mutating the copy shouldn't affect the original. dst[0] = 99.0 @@ -78,117 +77,119 @@ def test_copy_independent(backend: tuple) -> None: def test_to_numpy(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) - out = da.to_numpy(arr) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + out = iop.to_numpy(arr) assert isinstance(out, np.ndarray) np.testing.assert_allclose(out, [1.0, 2.0, 3.0]) def test_from_numpy_roundtrip(backend: tuple) -> None: raw = np.array([[1.0, 2.0], [3.0, 4.0]]) - arr = da.from_numpy(raw) + arr = iop.from_numpy(raw) np.testing.assert_allclose(_np(arr), raw) def test_to_array_from_scalar(backend: tuple) -> None: - arr = da.to_array(2.5) + arr = iop.to_array(2.5) np.testing.assert_allclose(_np(arr), 2.5) def test_stack(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) - b = da.from_numpy(np.array([3.0, 4.0])) - arr = da.stack([a, b]) + a = iop.from_numpy(np.array([1.0, 2.0])) + b = iop.from_numpy(np.array([3.0, 4.0])) + arr = iop.stack([a, b]) np.testing.assert_allclose(_np(arr), [[1.0, 2.0], [3.0, 4.0]]) def test_stack_dim(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) - b = da.from_numpy(np.array([3.0, 4.0])) - arr = da.stack([a, b], dim=1) + a = iop.from_numpy(np.array([1.0, 2.0])) + b = iop.from_numpy(np.array([3.0, 4.0])) + arr = iop.stack([a, b], dim=1) np.testing.assert_allclose(_np(arr), [[1.0, 3.0], [2.0, 4.0]]) def test_stack_empty_raises(backend: tuple) -> None: with pytest.raises(ValueError, match=r"empty sequence"): - da.stack([]) + iop.stack([]) def test_reshape(backend: tuple) -> None: - arr = da.from_numpy(np.arange(6, dtype=np.float32)) - out = da.reshape(arr, (2, 3)) + arr = iop.from_numpy(np.arange(6, dtype=np.float32)) + out = iop.reshape(arr, (2, 3)) np.testing.assert_allclose(_np(out), np.arange(6, dtype=np.float32).reshape(2, 3)) def test_transpose_default(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) - np.testing.assert_allclose(_np(da.transpose(arr)), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]) + arr = iop.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) + np.testing.assert_allclose( + _np(iop.transpose(arr)), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]] + ) def test_transpose_explicit_dim(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) - out = da.transpose(arr, dim=(1, 0, 2)) - assert da.shape(out) == (3, 2, 4) + arr = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) + out = iop.transpose(arr, dim=(1, 0, 2)) + assert iop.shape(out) == (3, 2, 4) def test_shape_function(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((2, 3, 4))) - assert da.shape(arr) == (2, 3, 4) + arr = iop.from_numpy(np.zeros((2, 3, 4))) + assert iop.shape(arr) == (2, 3, 4) def test_size_function(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((2, 3, 4))) - assert da.size(arr) == 24 + arr = iop.from_numpy(np.zeros((2, 3, 4))) + assert iop.size(arr) == 24 def test_ndim_function(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((2, 3, 4))) - assert da.ndim(arr) == 3 + arr = iop.from_numpy(np.zeros((2, 3, 4))) + assert iop.ndim(arr) == 3 def test_squeeze_default(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((1, 3, 1))) - assert da.shape(da.squeeze(arr)) == (3,) + arr = iop.from_numpy(np.zeros((1, 3, 1))) + assert iop.shape(iop.squeeze(arr)) == (3,) def test_squeeze_specific_dim(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((1, 3, 1))) - assert da.shape(da.squeeze(arr, dim=0)) == (3, 1) + arr = iop.from_numpy(np.zeros((1, 3, 1))) + assert iop.shape(iop.squeeze(arr, dim=0)) == (3, 1) def test_unsqueeze(backend: tuple) -> None: - arr = da.from_numpy(np.zeros((3,))) - assert da.shape(da.unsqueeze(arr, dim=0)) == (1, 3) - assert da.shape(da.unsqueeze(arr, dim=1)) == (3, 1) + arr = iop.from_numpy(np.zeros((3,))) + assert iop.shape(iop.unsqueeze(arr, dim=0)) == (1, 3) + assert iop.shape(iop.unsqueeze(arr, dim=1)) == (3, 1) def test_diag_from_vector(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) - np.testing.assert_allclose(_np(da.diag(arr)), np.diag([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(iop.diag(arr)), np.diag([1.0, 2.0, 3.0])) def test_diag_from_matrix(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - np.testing.assert_allclose(_np(da.diag(arr)), [1.0, 4.0]) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(iop.diag(arr)), [1.0, 4.0]) def test_astype_to_float(backend: tuple) -> None: - arr = da.to_array(3.0) - out = da.astype(arr, float) + arr = iop.to_array(3.0) + out = iop.astype(arr, float) assert isinstance(out, float) assert out == pytest.approx(3.0) def test_astype_to_int(backend: tuple) -> None: - arr = da.to_array(3.0) - out = da.astype(arr, int) + arr = iop.to_array(3.0) + out = iop.astype(arr, int) assert isinstance(out, int) assert out == 3 def test_astype_to_bool(backend: tuple) -> None: - arr = da.to_array(1.0) - out = da.astype(arr, bool) + arr = iop.to_array(1.0) + out = iop.astype(arr, bool) assert isinstance(out, bool) assert out is True @@ -197,32 +198,32 @@ def test_astype_to_bool(backend: tuple) -> None: def test_dot(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0, 3.0])) - b = da.from_numpy(np.array([4.0, 5.0, 6.0])) - np.testing.assert_allclose(_np(da.dot(a, b)), 32.0) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([4.0, 5.0, 6.0])) + np.testing.assert_allclose(_np(iop.dot(a, b)), 32.0) def test_matmul(backend: tuple) -> None: - a = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - b = da.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) expected = np.array([[19.0, 22.0], [43.0, 50.0]]) - np.testing.assert_allclose(_np(da.matmul(a, b)), expected) + np.testing.assert_allclose(_np(iop.matmul(a, b)), expected) def test_norm_default_l2(backend: tuple) -> None: - arr = da.from_numpy(np.array([3.0, 4.0])) - np.testing.assert_allclose(_np(da.norm(arr)), 5.0) + arr = iop.from_numpy(np.array([3.0, 4.0])) + np.testing.assert_allclose(_np(iop.norm(arr)), 5.0) def test_norm_p1(backend: tuple) -> None: - arr = da.from_numpy(np.array([3.0, -4.0])) - np.testing.assert_allclose(_np(da.norm(arr, p=1)), 7.0) + arr = iop.from_numpy(np.array([3.0, -4.0])) + np.testing.assert_allclose(_np(iop.norm(arr, p=1)), 7.0) def test_norm_dim_keepdims(backend: tuple) -> None: - arr = da.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]])) - out = da.norm(arr, p=2, dim=1, keepdims=True) - assert da.shape(out) == (2, 1) + arr = iop.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]])) + out = iop.norm(arr, p=2, dim=1, keepdims=True) + assert iop.shape(out) == (2, 1) np.testing.assert_allclose(_np(out).reshape(-1), [5.0, 10.0]) @@ -230,207 +231,207 @@ def test_norm_dim_keepdims(backend: tuple) -> None: def test_sum_all(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - np.testing.assert_allclose(_np(da.sum(arr)), 10.0) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(iop.sum(arr)), 10.0) def test_sum_dim(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - np.testing.assert_allclose(_np(da.sum(arr, dim=0)), [4.0, 6.0]) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(iop.sum(arr, dim=0)), [4.0, 6.0]) def test_sum_dim_keepdims(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - out = da.sum(arr, dim=0, keepdims=True) - assert da.shape(out) == (1, 2) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + out = iop.sum(arr, dim=0, keepdims=True) + assert iop.shape(out) == (1, 2) def test_mean_all(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) - np.testing.assert_allclose(_np(da.mean(arr)), 2.5) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + np.testing.assert_allclose(_np(iop.mean(arr)), 2.5) def test_mean_dim(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - np.testing.assert_allclose(_np(da.mean(arr, dim=1)), [1.5, 3.5]) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + np.testing.assert_allclose(_np(iop.mean(arr, dim=1)), [1.5, 3.5]) def test_min_all(backend: tuple) -> None: - arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) - np.testing.assert_allclose(_np(da.min(arr)), 1.0) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) + np.testing.assert_allclose(_np(iop.min(arr)), 1.0) def test_min_dim(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) - np.testing.assert_allclose(_np(da.min(arr, dim=0)), [1.0, 2.0]) + arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) + np.testing.assert_allclose(_np(iop.min(arr, dim=0)), [1.0, 2.0]) def test_max_all(backend: tuple) -> None: - arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) - np.testing.assert_allclose(_np(da.max(arr)), 5.0) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) + np.testing.assert_allclose(_np(iop.max(arr)), 5.0) def test_max_dim(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) - np.testing.assert_allclose(_np(da.max(arr, dim=0)), [3.0, 5.0]) + arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) + np.testing.assert_allclose(_np(iop.max(arr, dim=0)), [3.0, 5.0]) def test_any_true(backend: tuple) -> None: - arr = da.from_numpy(np.array([0.0, 1.0, 0.0])) - assert da.any(arr) is True + arr = iop.from_numpy(np.array([0.0, 1.0, 0.0])) + assert iop.any(arr) is True def test_any_false(backend: tuple) -> None: - arr = da.from_numpy(np.array([0.0, 0.0, 0.0])) - assert da.any(arr) is False + arr = iop.from_numpy(np.array([0.0, 0.0, 0.0])) + assert iop.any(arr) is False def test_all_true(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) - assert da.all(arr) is True + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + assert iop.all(arr) is True def test_all_false(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 0.0, 3.0])) - assert da.all(arr) is False + arr = iop.from_numpy(np.array([1.0, 0.0, 3.0])) + assert iop.all(arr) is False # Math elementwise ------------------------------------------------------- def test_add_two_arrays(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) - b = da.from_numpy(np.array([3.0, 4.0])) - np.testing.assert_allclose(_np(da.add(a, b)), [4.0, 6.0]) + a = iop.from_numpy(np.array([1.0, 2.0])) + b = iop.from_numpy(np.array([3.0, 4.0])) + np.testing.assert_allclose(_np(iop.add(a, b)), [4.0, 6.0]) def test_add_array_and_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) - np.testing.assert_allclose(_np(da.add(a, 10.0)), [11.0, 12.0]) + a = iop.from_numpy(np.array([1.0, 2.0])) + np.testing.assert_allclose(_np(iop.add(a, 10.0)), [11.0, 12.0]) def test_sub(backend: tuple) -> None: - a = da.from_numpy(np.array([5.0, 6.0])) - b = da.from_numpy(np.array([1.0, 2.0])) - np.testing.assert_allclose(_np(da.sub(a, b)), [4.0, 4.0]) + a = iop.from_numpy(np.array([5.0, 6.0])) + b = iop.from_numpy(np.array([1.0, 2.0])) + np.testing.assert_allclose(_np(iop.sub(a, b)), [4.0, 4.0]) def test_mul(backend: tuple) -> None: - a = da.from_numpy(np.array([2.0, 3.0])) - b = da.from_numpy(np.array([4.0, 5.0])) - np.testing.assert_allclose(_np(da.mul(a, b)), [8.0, 15.0]) + a = iop.from_numpy(np.array([2.0, 3.0])) + b = iop.from_numpy(np.array([4.0, 5.0])) + np.testing.assert_allclose(_np(iop.mul(a, b)), [8.0, 15.0]) def test_div(backend: tuple) -> None: - a = da.from_numpy(np.array([8.0, 10.0])) - b = da.from_numpy(np.array([2.0, 5.0])) - np.testing.assert_allclose(_np(da.div(a, b)), [4.0, 2.0]) + a = iop.from_numpy(np.array([8.0, 10.0])) + b = iop.from_numpy(np.array([2.0, 5.0])) + np.testing.assert_allclose(_np(iop.div(a, b)), [4.0, 2.0]) def test_iadd_func(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 2.0])) - out = da.iadd(a, 10.0) + a = iop.from_numpy(np.array([1.0, 2.0])) + out = iop.iadd(a, 10.0) # Returned wrapper is the same instance. assert out is a np.testing.assert_allclose(_np(a), [11.0, 12.0]) def test_isub_func(backend: tuple) -> None: - a = da.from_numpy(np.array([5.0, 6.0])) - out = da.isub(a, 1.0) + a = iop.from_numpy(np.array([5.0, 6.0])) + out = iop.isub(a, 1.0) assert out is a np.testing.assert_allclose(_np(a), [4.0, 5.0]) def test_imul_func(backend: tuple) -> None: - a = da.from_numpy(np.array([2.0, 3.0])) - out = da.imul(a, 4.0) + a = iop.from_numpy(np.array([2.0, 3.0])) + out = iop.imul(a, 4.0) assert out is a np.testing.assert_allclose(_np(a), [8.0, 12.0]) def test_idiv_func(backend: tuple) -> None: - a = da.from_numpy(np.array([8.0, 12.0])) - out = da.idiv(a, 4.0) + a = iop.from_numpy(np.array([8.0, 12.0])) + out = iop.idiv(a, 4.0) assert out is a np.testing.assert_allclose(_np(a), [2.0, 3.0]) def test_pow_function(backend: tuple) -> None: - arr = da.from_numpy(np.array([2.0, 3.0, 4.0])) - np.testing.assert_allclose(_np(da.pow(arr, 2)), [4.0, 9.0, 16.0]) + arr = iop.from_numpy(np.array([2.0, 3.0, 4.0])) + np.testing.assert_allclose(_np(iop.pow(arr, 2)), [4.0, 9.0, 16.0]) def test_negative(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, -2.0, 3.0])) - np.testing.assert_allclose(_np(da.negative(arr)), [-1.0, 2.0, -3.0]) + arr = iop.from_numpy(np.array([1.0, -2.0, 3.0])) + np.testing.assert_allclose(_np(iop.negative(arr)), [-1.0, 2.0, -3.0]) def test_absolute(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, -2.0, 3.0])) - np.testing.assert_allclose(_np(da.absolute(arr)), [1.0, 2.0, 3.0]) + arr = iop.from_numpy(np.array([1.0, -2.0, 3.0])) + np.testing.assert_allclose(_np(iop.absolute(arr)), [1.0, 2.0, 3.0]) def test_sqrt(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 4.0, 9.0])) - np.testing.assert_allclose(_np(da.sqrt(arr)), [1.0, 2.0, 3.0]) + arr = iop.from_numpy(np.array([1.0, 4.0, 9.0])) + np.testing.assert_allclose(_np(iop.sqrt(arr)), [1.0, 2.0, 3.0]) # Operators -------------------------------------------------------------- def test_sign(backend: tuple) -> None: - arr = da.from_numpy(np.array([-2.0, 0.0, 3.0])) - np.testing.assert_allclose(_np(da.sign(arr)), [-1.0, 0.0, 1.0]) + arr = iop.from_numpy(np.array([-2.0, 0.0, 3.0])) + np.testing.assert_allclose(_np(iop.sign(arr)), [-1.0, 0.0, 1.0]) def test_maximum_arrays(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 5.0, 3.0])) - b = da.from_numpy(np.array([4.0, 2.0, 6.0])) - np.testing.assert_allclose(_np(da.maximum(a, b)), [4.0, 5.0, 6.0]) + a = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + b = iop.from_numpy(np.array([4.0, 2.0, 6.0])) + np.testing.assert_allclose(_np(iop.maximum(a, b)), [4.0, 5.0, 6.0]) def test_maximum_array_and_scalar(backend: tuple) -> None: - a = da.from_numpy(np.array([1.0, 5.0, 3.0])) - np.testing.assert_allclose(_np(da.maximum(a, 4.0)), [4.0, 5.0, 4.0]) + a = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + np.testing.assert_allclose(_np(iop.maximum(a, 4.0)), [4.0, 5.0, 4.0]) def test_argmax_default(backend: tuple) -> None: - arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) - np.testing.assert_allclose(_np(da.argmax(arr)), 5) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) + np.testing.assert_allclose(_np(iop.argmax(arr)), 5) def test_argmax_dim(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) - np.testing.assert_allclose(_np(da.argmax(arr, dim=1)), [1, 0]) + arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + np.testing.assert_allclose(_np(iop.argmax(arr, dim=1)), [1, 0]) def test_argmin_default(backend: tuple) -> None: - arr = da.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) # First occurrence of minimum is index 1. - np.testing.assert_allclose(_np(da.argmin(arr)), 1) + np.testing.assert_allclose(_np(iop.argmin(arr)), 1) def test_argmin_dim(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) - np.testing.assert_allclose(_np(da.argmin(arr, dim=1)), [0, 1]) + arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + np.testing.assert_allclose(_np(iop.argmin(arr, dim=1)), [0, 1]) def test_argmax_keepdims(backend: tuple) -> None: - arr = da.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) - out = da.argmax(arr, dim=1, keepdims=True) - assert da.shape(out) == (2, 1) + arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + out = iop.argmax(arr, dim=1, keepdims=True) + assert iop.shape(out) == (2, 1) def test_set_item_function(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) - da.set_item(arr, 0, da.from_numpy(np.array(99.0))) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + iop.set_item(arr, 0, iop.from_numpy(np.array(99.0))) np.testing.assert_allclose(_np(arr), [99.0, 2.0, 3.0]) def test_get_item_function(backend: tuple) -> None: - arr = da.from_numpy(np.array([1.0, 2.0, 3.0])) - np.testing.assert_allclose(_np(da.get_item(arr, 1)), 2.0) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_allclose(_np(iop.get_item(arr, 1)), 2.0) # No-backend errors ------------------------------------------------------ @@ -439,10 +440,10 @@ def test_get_item_function(backend: tuple) -> None: def test_function_raises_when_no_backend() -> None: reset_backends() with pytest.raises(RuntimeError, match=r"No backend active"): - iop_functions.zeros((3,)) + iop.zeros((3,)) def test_to_array_round_trip_with_bool(backend: tuple) -> None: - arr = da.to_array(True) - out = da.astype(arr, bool) + arr = iop.to_array(True) + out = iop.astype(arr, bool) assert out is True diff --git a/tests/test_iop_rng.py b/tests/test_iop_rng.py index 0b56e12..f941e04 100644 --- a/tests/test_iop_rng.py +++ b/tests/test_iop_rng.py @@ -7,91 +7,90 @@ import numpy as np import pytest -import decent_array as da -from decent_array.array import Array -from decent_array.interoperability.backend_manager import reset_backends -from decent_array.interoperability.iop import rng as iop_rng -from decent_array.interoperability.iop.rng import _set_seed_without_global +import decent_array.interoperability as iop +from decent_array import Array +from decent_array.interoperability._backend_manager import reset_backends +from decent_array.interoperability._iop import rng as iop_rng def _np(arr: Array) -> np.ndarray: - return da.to_numpy(arr) + return iop.to_numpy(arr) # Seed management -------------------------------------------------------- def test_set_seed_records_global(backend: tuple) -> None: - da.set_seed(123) - assert da.get_seed() == 123 + iop.set_seed(123) + assert iop.get_seed() == 123 def test_set_seed_makes_normal_reproducible(backend: tuple) -> None: - da.set_seed(7) - first = _np(da.normal(shape=(4,))) - da.set_seed(7) - second = _np(da.normal(shape=(4,))) + iop.set_seed(7) + first = _np(iop.normal(shape=(4,))) + iop.set_seed(7) + second = _np(iop.normal(shape=(4,))) np.testing.assert_allclose(first, second) def test_set_seed_makes_uniform_reproducible(backend: tuple) -> None: - da.set_seed(7) - first = _np(da.uniform(shape=(4,))) - da.set_seed(7) - second = _np(da.uniform(shape=(4,))) + iop.set_seed(7) + first = _np(iop.uniform(shape=(4,))) + iop.set_seed(7) + second = _np(iop.uniform(shape=(4,))) np.testing.assert_allclose(first, second) def test_set_seed_seeds_python_random(backend: tuple) -> None: - da.set_seed(11) + iop.set_seed(11) a = random.random() - da.set_seed(11) + iop.set_seed(11) b = random.random() assert a == b def test_set_seed_without_global_keeps_seed(backend: tuple) -> None: - da.set_seed(42) - _set_seed_without_global(99) + iop.set_seed(42) + iop_rng._set_seed_without_global(99) # The "global" seed observable via get_seed() must be unchanged. - assert da.get_seed() == 42 + assert iop.get_seed() == 42 def test_get_seed_initially_none(backend: tuple) -> None: # Fresh activation via the fixture: nothing has called set_seed yet on this # coordinator instance, but the coordinator is process-singleton and may have # state from earlier tests. Call set_seed/then-clear to assert via reseed instead. - da.set_seed(0) - assert da.get_seed() == 0 + iop.set_seed(0) + assert iop.get_seed() == 0 # RNG state snapshot/restore -------------------------------------------- def test_rng_state_round_trip_normal(backend: tuple) -> None: - da.set_seed(123) - state = da.get_rng_state() - first = _np(da.normal(shape=(4,))) - da.set_rng_state(state) - second = _np(da.normal(shape=(4,))) + iop.set_seed(123) + state = iop.get_rng_state() + first = _np(iop.normal(shape=(4,))) + iop.set_rng_state(state) + second = _np(iop.normal(shape=(4,))) np.testing.assert_allclose(first, second) def test_rng_state_includes_python_random(backend: tuple) -> None: - da.set_seed(7) - state = da.get_rng_state() + iop.set_seed(7) + state = iop.get_rng_state() a = random.random() - da.set_rng_state(state) + iop.set_rng_state(state) b = random.random() assert a == b def test_rng_state_round_trip_uniform(backend: tuple) -> None: - da.set_seed(456) - state = da.get_rng_state() - first = _np(da.uniform(shape=(3,))) - da.set_rng_state(state) - second = _np(da.uniform(shape=(3,))) + iop.set_seed(456) + state = iop.get_rng_state() + first = _np(iop.uniform(shape=(3,))) + iop.set_rng_state(state) + second = _np(iop.uniform(shape=(3,))) np.testing.assert_allclose(first, second) @@ -99,16 +98,16 @@ def test_rng_state_round_trip_uniform(backend: tuple) -> None: def test_derive_seed_when_seed_set_is_reproducible(backend: tuple) -> None: - da.set_seed(123) - a = da.derive_seed() - da.set_seed(123) - b = da.derive_seed() + iop.set_seed(123) + a = iop.derive_seed() + iop.set_seed(123) + b = iop.derive_seed() assert a == b def test_derive_seed_returns_int_in_range(backend: tuple) -> None: - da.set_seed(0) - seed = da.derive_seed() + iop.set_seed(0) + seed = iop.derive_seed() assert isinstance(seed, int) assert 0 <= seed < 2**32 @@ -117,19 +116,19 @@ def test_derive_seed_returns_int_in_range(backend: tuple) -> None: def test_normal_shape(backend: tuple) -> None: - arr = da.normal(shape=(2, 3)) - assert da.shape(arr) == (2, 3) + arr = iop.normal(shape=(2, 3)) + assert iop.shape(arr) == (2, 3) def test_normal_default_scalar(backend: tuple) -> None: - da.set_seed(1) - arr = da.normal() - assert da.shape(arr) == () + iop.set_seed(1) + arr = iop.normal() + assert iop.shape(arr) == () def test_uniform_shape_and_range(backend: tuple) -> None: - da.set_seed(1) - arr = da.uniform(low=0.0, high=1.0, shape=(50,)) + iop.set_seed(1) + arr = iop.uniform(low=0.0, high=1.0, shape=(50,)) samples = _np(arr) assert samples.shape == (50,) assert (samples >= 0.0).all() @@ -137,46 +136,46 @@ def test_uniform_shape_and_range(backend: tuple) -> None: def test_uniform_custom_range(backend: tuple) -> None: - da.set_seed(1) - samples = _np(da.uniform(low=-2.0, high=-1.0, shape=(50,))) + iop.set_seed(1) + samples = _np(iop.uniform(low=-2.0, high=-1.0, shape=(50,))) assert (samples >= -2.0).all() assert (samples < -1.0).all() def test_normal_like(backend: tuple) -> None: - src = da.from_numpy(np.zeros((3, 4))) - arr = da.normal_like(src) - assert da.shape(arr) == (3, 4) + src = iop.from_numpy(np.zeros((3, 4))) + arr = iop.normal_like(src) + assert iop.shape(arr) == (3, 4) def test_uniform_like(backend: tuple) -> None: - src = da.from_numpy(np.zeros((3, 4))) - arr = da.uniform_like(src, low=0.0, high=1.0) - assert da.shape(arr) == (3, 4) + src = iop.from_numpy(np.zeros((3, 4))) + arr = iop.uniform_like(src, low=0.0, high=1.0) + assert iop.shape(arr) == (3, 4) samples = _np(arr) assert (samples >= 0.0).all() assert (samples < 1.0).all() def test_choice_shape(backend: tuple) -> None: - da.set_seed(1) - population = da.from_numpy(np.array([10.0, 20.0, 30.0, 40.0, 50.0])) - sample = da.choice(population, size=3) - assert da.shape(sample) == (3,) + iop.set_seed(1) + population = iop.from_numpy(np.array([10.0, 20.0, 30.0, 40.0, 50.0])) + sample = iop.choice(population, size=3) + assert iop.shape(sample) == (3,) def test_choice_values_in_population(backend: tuple) -> None: - da.set_seed(1) + iop.set_seed(1) pop_np = np.array([10.0, 20.0, 30.0, 40.0, 50.0]) - sample = da.choice(da.from_numpy(pop_np), size=10) + sample = iop.choice(iop.from_numpy(pop_np), size=10) drawn = _np(sample).reshape(-1) assert all(v in pop_np for v in drawn) def test_choice_no_replace_unique(backend: tuple) -> None: - da.set_seed(1) - pop = da.from_numpy(np.arange(20, dtype=np.float32)) - sample = da.choice(pop, size=5, replace=False) + iop.set_seed(1) + pop = iop.from_numpy(np.arange(20, dtype=np.float32)) + sample = iop.choice(pop, size=5, replace=False) drawn = _np(sample).reshape(-1) assert len(set(drawn.tolist())) == 5 From 6c617e70bb239aabaf5b6163348fbb21e10e2763 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 16:27:28 +0200 Subject: [PATCH 05/11] update ci --- .github/workflows/ci.yaml | 54 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 44b5982..24ea582 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -115,3 +115,57 @@ jobs: - name: Check git diff run: git diff --exit-code || { echo 'Error - Docs are stale, please regenerate with `tox -e sphinx`.'; exit 1; } + + mypyc-macos-latest: + runs-on: "macos-latest" + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run mypyc + run: tox -e mypyc + + mypyc-ubuntu-latest: + runs-on: "ubuntu-latest" + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run mypyc + run: tox -e mypyc + + mypyc-windows-latest: + runs-on: "windows-latest" + + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - name: Install tox + run: pip install tox + + - name: Run mypyc + run: tox -e mypyc \ No newline at end of file From 46334894c90cefe996b6c0ee5a591775e0aa63a5 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 18:29:48 +0200 Subject: [PATCH 06/11] add logical operators --- decent_array/_array.py | 68 ++++++++++- decent_array/interoperability/__init__.py | 14 +++ .../interoperability/_abstracts/backend.py | 70 ++++++++--- .../interoperability/_iop/functions.py | 113 ++++++++++++----- .../interoperability/_jax/jax_backend.py | 69 +++++++---- .../interoperability/_numpy/numpy_backend.py | 69 +++++++---- .../_pytorch/pytorch_backend.py | 79 ++++++++---- .../_tensorflow/tensorflow_backend.py | 80 ++++++++---- tests/test_array.py | 110 +++++++++++++++++ tests/test_iop_functions.py | 115 +++++++++++++++--- 10 files changed, 625 insertions(+), 162 deletions(-) diff --git a/decent_array/_array.py b/decent_array/_array.py index 8d70614..87a5788 100644 --- a/decent_array/_array.py +++ b/decent_array/_array.py @@ -13,12 +13,17 @@ Hot-path notes: -* ``__add__``/``__sub__``/``__mul__``/``__truediv__``/``__matmul__`` and the unary - ``__neg__``/``__abs__``/``__pow__`` are inlined: every supported framework's tensor - implements the equivalent operator natively with numpy-equivalent semantics, so - routing through the backend saves nothing. +* ``__add__``/``__sub__``/``__mul__``/``__truediv__``/``__matmul__``, the unary + ``__neg__``/``__abs__``/``__pow__``, the comparisons ``__eq__``/``__ne__``/``__lt__``/ + ``__le__``/``__gt__``/``__ge__`` and the bitwise ``__and__``/``__rand__`` are + inlined: every supported framework's tensor implements the equivalent operator + natively with numpy-equivalent semantics, so routing through the backend saves + nothing. * Operators that *do* go through the backend (in-place math, indexing, properties like ``shape``/``transpose``) read the cached ``_backend`` slot. +* Overriding ``__eq__`` makes :class:`Array` unhashable (Python clears ``__hash__`` + automatically). This matches numpy/torch/jax/tf, where element-wise equality is + more useful than identity-based hashing. """ from __future__ import annotations @@ -129,6 +134,61 @@ def __pow__(self, other: float) -> Array: # call for no behavioral difference. return Array(self.value**other) + # Comparisons ---------------------------------------------------------- + # + # Element-wise comparisons return an :class:`Array` of bools. The ``__eq__`` and + # ``__ne__`` parameters are typed ``object`` to match the LSP signature inherited + # from :class:`object`; the body still enforces the strict ``Array | scalar`` + # contract via the underlying framework's operator (incompatible operands raise + # from the backend's native comparison, matching ``__add__``). + # + # Overriding ``__eq__`` makes instances unhashable; ``__hash__ = None`` makes that + # explicit (and silences the lint that flags the dropped ``__hash__``). + + __hash__ = None # type: ignore[assignment] + + def __eq__(self, other: object) -> Array: # type: ignore[override] + """Element-wise equality.""" + return Array(self.value == (other.value if type(other) is Array else other)) + + def __ne__(self, other: object) -> Array: # type: ignore[override] + """Element-wise inequality.""" + return Array(self.value != (other.value if type(other) is Array else other)) + + def __lt__(self, other: Array | float) -> Array: + """Element-wise less-than.""" + return Array(self.value < (other.value if type(other) is Array else other)) + + def __le__(self, other: Array | float) -> Array: + """Element-wise less-than-or-equal.""" + return Array(self.value <= (other.value if type(other) is Array else other)) + + def __gt__(self, other: Array | float) -> Array: + """Element-wise greater-than.""" + return Array(self.value > (other.value if type(other) is Array else other)) + + def __ge__(self, other: Array | float) -> Array: + """Element-wise greater-than-or-equal.""" + return Array(self.value >= (other.value if type(other) is Array else other)) + + # Bitwise -------------------------------------------------------------- + # + # Bitwise AND is only defined for integer/boolean dtypes. ``__and__``'s ``Array + # | int`` is a Union (mypyc keeps Union operands boxed, so a ``bool`` operand + # stays a ``bool`` and TF's strict dtype check accepts it). ``__rand__``'s + # operand is typed ``Any`` for the same reason: a single-primitive annotation + # like ``int`` causes mypyc to unbox a ``True`` to ``1`` before the call body, + # which fails TF's ``1 & bool_tensor`` rejection. Native operator semantics on + # the wrapped tensor enforce the actual dtype contract. + + def __and__(self, other: Array | int) -> Array: + """Element-wise bitwise/logical AND.""" + return Array(self.value & (other.value if type(other) is Array else other)) + + def __rand__(self, other: Any) -> Array: # noqa: ANN401 + """Element-wise bitwise/logical AND with the array on the right.""" + return Array(other & self.value) + # In-place arithmetic -------------------------------------------------- # # The backend handles the framework's mutability semantics: numpy/pytorch mutate diff --git a/decent_array/interoperability/__init__.py b/decent_array/interoperability/__init__.py index 7893d88..5301fb2 100644 --- a/decent_array/interoperability/__init__.py +++ b/decent_array/interoperability/__init__.py @@ -22,20 +22,26 @@ argmax, argmin, astype, + bitwise_and, copy, device_of, device_to_native, diag, div, dot, + eq, eye, eye_like, from_numpy, + ge, get_item, + gt, iadd, idiv, imul, isub, + le, + lt, matmul, max, # noqa: A004 maximum, @@ -43,6 +49,7 @@ min, # noqa: A004 mul, ndim, + ne, negative, norm, ones, @@ -87,6 +94,7 @@ "argmin", "astype", "autodecorate_cost_method", + "bitwise_and", "choice", "copy", "derive_seed", @@ -95,16 +103,21 @@ "diag", "div", "dot", + "eq", "eye", "eye_like", "from_numpy", + "ge", "get_item", "get_rng_state", "get_seed", + "gt", "iadd", "idiv", "imul", "isub", + "le", + "lt", "matmul", "max", "maximum", @@ -112,6 +125,7 @@ "min", "mul", "ndim", + "ne", "negative", "norm", "normal", diff --git a/decent_array/interoperability/_abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py index 5557b88..04bdf82 100644 --- a/decent_array/interoperability/_abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -91,7 +91,7 @@ def to_array(self, array: float | bool) -> Array: """Convert a Python scalar to an :class:`Array` on this backend.""" @abstractmethod - def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: """Stack a sequence of arrays along a new dimension.""" @abstractmethod @@ -99,7 +99,7 @@ def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: """Reshape ``array`` to ``shape``.""" @abstractmethod - def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: """Transpose ``array``; ``None`` reverses the dimensions.""" @abstractmethod @@ -115,12 +115,12 @@ def ndim(self, array: Array) -> int: """Return the number of dimensions of ``array``.""" @abstractmethod - def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: """Remove single-dimensional entries from ``array``.""" @abstractmethod - def unsqueeze(self, array: Array, dim: int) -> Array: - """Insert a singleton dimension at ``dim``.""" + def unsqueeze(self, array: Array, axis: int) -> Array: + """Insert a singleton dimension at ``axis``.""" @abstractmethod def diag(self, array: Array) -> Array: @@ -145,7 +145,7 @@ def norm( self, array: Array, p: float = 2, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: """Compute the norm of ``array``.""" @@ -153,20 +153,20 @@ def norm( # Math reductions ----------------------------------------------------- @abstractmethod - def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Sum elements of ``array`` along ``dim``.""" + def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Sum elements of ``array`` along ``axis``.""" @abstractmethod - def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Mean of ``array`` along ``dim``.""" + def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Mean of ``array`` along ``axis``.""" @abstractmethod - def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Minimum of ``array`` along ``dim``.""" + def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Minimum of ``array`` along ``axis``.""" @abstractmethod - def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Maximum of ``array`` along ``dim``.""" + def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Maximum of ``array`` along ``axis``.""" @abstractmethod def any(self, array: Array) -> bool: @@ -228,6 +228,40 @@ def absolute(self, array: Array) -> Array: def sqrt(self, array: Array) -> Array: """Element-wise square root.""" + # Comparisons — both operands may be Array or scalar. + + @abstractmethod + def eq(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise equality. Returns an :class:`Array` of bools.""" + + @abstractmethod + def ne(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise inequality. Returns an :class:`Array` of bools.""" + + @abstractmethod + def lt(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise less-than. Returns an :class:`Array` of bools.""" + + @abstractmethod + def le(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise less-than-or-equal. Returns an :class:`Array` of bools.""" + + @abstractmethod + def gt(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise greater-than. Returns an :class:`Array` of bools.""" + + @abstractmethod + def ge(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise greater-than-or-equal. Returns an :class:`Array` of bools.""" + + # Bitwise — operands may be int/bool arrays or scalars. Mirrors Python's ``&``, + # which dispatches to ``logical_and`` on bool tensors and ``bitwise_and`` on int + # tensors in every supported framework. + + @abstractmethod + def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: + """Element-wise bitwise/logical AND.""" + # Operators ----------------------------------------------------------- @abstractmethod @@ -239,12 +273,12 @@ def maximum(self, array1: Array | float, array2: Array | float) -> Array: """Element-wise maximum.""" @abstractmethod - def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - """Index of maximum value along ``dim``.""" + def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + """Index of maximum value along ``axis``.""" @abstractmethod - def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - """Index of minimum value along ``dim``.""" + def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + """Index of minimum value along ``axis``.""" @abstractmethod def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: diff --git a/decent_array/interoperability/_iop/functions.py b/decent_array/interoperability/_iop/functions.py index 6b57e91..e7115f8 100644 --- a/decent_array/interoperability/_iop/functions.py +++ b/decent_array/interoperability/_iop/functions.py @@ -126,11 +126,11 @@ def to_array(array: float | bool) -> Array: return _BACKEND_INSTANCE.to_array(array) -def stack(arrays: Sequence[Array], dim: int = 0) -> Array: +def stack(arrays: Sequence[Array], axis: int = 0) -> Array: """Stack a sequence of arrays along a new dimension.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.stack(arrays, dim) + return _BACKEND_INSTANCE.stack(arrays, axis) def reshape(array: Array, shape: tuple[int, ...]) -> Array: @@ -140,11 +140,11 @@ def reshape(array: Array, shape: tuple[int, ...]) -> Array: return _BACKEND_INSTANCE.reshape(array, shape) -def transpose(array: Array, dim: tuple[int, ...] | None = None) -> Array: +def transpose(array: Array, axis: tuple[int, ...] | None = None) -> Array: """Transpose ``array``; ``None`` reverses dimensions.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.transpose(array, dim) + return _BACKEND_INSTANCE.transpose(array, axis) def shape(array: Array) -> tuple[int, ...]: @@ -168,18 +168,18 @@ def ndim(array: Array) -> int: return _BACKEND_INSTANCE.ndim(array) -def squeeze(array: Array, dim: int | tuple[int, ...] | None = None) -> Array: +def squeeze(array: Array, axis: int | tuple[int, ...] | None = None) -> Array: """Remove single-dimensional entries from ``array``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.squeeze(array, dim) + return _BACKEND_INSTANCE.squeeze(array, axis) -def unsqueeze(array: Array, dim: int) -> Array: - """Insert a singleton dimension at ``dim``.""" +def unsqueeze(array: Array, axis: int) -> Array: + """Insert a singleton dimension at ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.unsqueeze(array, dim) + return _BACKEND_INSTANCE.unsqueeze(array, axis) def diag(array: Array) -> Array: @@ -216,13 +216,13 @@ def matmul(array1: Array, array2: Array) -> Array: def norm( array: Array, p: float = 2, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: """Norm of ``array``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.norm(array, p, dim, keepdims) + return _BACKEND_INSTANCE.norm(array, p, axis, keepdims) # Math reductions @@ -230,46 +230,46 @@ def norm( def sum( # noqa: A001 array: Array, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - """Sum elements of ``array`` along ``dim``.""" + """Sum elements of ``array`` along ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.sum(array, dim, keepdims) + return _BACKEND_INSTANCE.sum(array, axis, keepdims) def mean( array: Array, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - """Mean of ``array`` along ``dim``.""" + """Mean of ``array`` along ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.mean(array, dim, keepdims) + return _BACKEND_INSTANCE.mean(array, axis, keepdims) def min( # noqa: A001 array: Array, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - """Minimum of ``array`` along ``dim``.""" + """Minimum of ``array`` along ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.min(array, dim, keepdims) + return _BACKEND_INSTANCE.min(array, axis, keepdims) def max( # noqa: A001 array: Array, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - """Maximum of ``array`` along ``dim``.""" + """Maximum of ``array`` along ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.max(array, dim, keepdims) + return _BACKEND_INSTANCE.max(array, axis, keepdims) def any(array: Array) -> bool: # noqa: A001 @@ -373,6 +373,61 @@ def sqrt(array: Array) -> Array: return _BACKEND_INSTANCE.sqrt(array) +# Comparisons + + +def eq(array1: Array | float, array2: Array | float) -> Array: + """Element-wise equality. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.eq(array1, array2) + + +def ne(array1: Array | float, array2: Array | float) -> Array: + """Element-wise inequality. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ne(array1, array2) + + +def lt(array1: Array | float, array2: Array | float) -> Array: + """Element-wise less-than. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.lt(array1, array2) + + +def le(array1: Array | float, array2: Array | float) -> Array: + """Element-wise less-than-or-equal. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.le(array1, array2) + + +def gt(array1: Array | float, array2: Array | float) -> Array: + """Element-wise greater-than. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.gt(array1, array2) + + +def ge(array1: Array | float, array2: Array | float) -> Array: + """Element-wise greater-than-or-equal. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ge(array1, array2) + + +# Bitwise + + +def bitwise_and(array1: Array | float, array2: Array | float) -> Array: + """Element-wise bitwise/logical AND.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.bitwise_and(array1, array2) + + # Operators @@ -390,18 +445,18 @@ def maximum(array1: Array | float, array2: Array | float) -> Array: return _BACKEND_INSTANCE.maximum(array1, array2) -def argmax(array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - """Index of maximum value along ``dim``.""" +def argmax(array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + """Index of maximum value along ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.argmax(array, dim, keepdims) + return _BACKEND_INSTANCE.argmax(array, axis, keepdims) -def argmin(array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - """Index of minimum value along ``dim``.""" +def argmin(array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + """Index of minimum value along ``axis``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.argmin(array, dim, keepdims) + return _BACKEND_INSTANCE.argmin(array, axis, keepdims) def set_item(array: Array, key: ArrayKey, value: Array) -> None: diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index 62a39e4..b7048a5 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -89,16 +89,16 @@ def from_numpy(self, array: NDArray[Any]) -> Array: def to_array(self, array: float | bool) -> Array: return Array(jnp.array(array, device=self._native_device)) - def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") - return Array(jnp.stack([a.value for a in arrays], axis=dim)) + return Array(jnp.stack([a.value for a in arrays], axis=axis)) def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: return Array(jnp.reshape(array.value, shape)) - def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: - return Array(jnp.transpose(array.value, axes=dim)) + def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: + return Array(jnp.transpose(array.value, axes=axis)) def shape(self, array: Array) -> tuple[int, ...]: return tuple(array.value.shape) @@ -109,11 +109,11 @@ def size(self, array: Array) -> int: def ndim(self, array: Array) -> int: return int(array.value.ndim) - def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: - return Array(jnp.squeeze(array.value, axis=dim)) + def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: + return Array(jnp.squeeze(array.value, axis=axis)) - def unsqueeze(self, array: Array, dim: int) -> Array: - return Array(jnp.expand_dims(array.value, axis=dim)) + def unsqueeze(self, array: Array, axis: int) -> Array: + return Array(jnp.expand_dims(array.value, axis=axis)) def diag(self, array: Array) -> Array: return Array(jnp.diag(array.value)) @@ -133,24 +133,24 @@ def norm( self, array: Array, p: float = 2, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - return Array(jnp.linalg.norm(array.value, ord=p, axis=dim, keepdims=keepdims)) + return Array(jnp.linalg.norm(array.value, ord=p, axis=axis, keepdims=keepdims)) # Math reductions - def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.sum(array.value, axis=dim, keepdims=keepdims)) + def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.sum(array.value, axis=axis, keepdims=keepdims)) - def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.mean(array.value, axis=dim, keepdims=keepdims)) + def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.mean(array.value, axis=axis, keepdims=keepdims)) - def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.min(array.value, axis=dim, keepdims=keepdims)) + def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.min(array.value, axis=axis, keepdims=keepdims)) - def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.max(array.value, axis=dim, keepdims=keepdims)) + def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.max(array.value, axis=axis, keepdims=keepdims)) def any(self, array: Array) -> bool: return bool(jnp.any(array.value)) @@ -202,6 +202,31 @@ def absolute(self, array: Array) -> Array: def sqrt(self, array: Array) -> Array: return Array(jnp.sqrt(array.value)) + # Comparisons + + def eq(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.equal(_unwrap(array1), _unwrap(array2))) + + def ne(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.not_equal(_unwrap(array1), _unwrap(array2))) + + def lt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.less(_unwrap(array1), _unwrap(array2))) + + def le(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.less_equal(_unwrap(array1), _unwrap(array2))) + + def gt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.greater(_unwrap(array1), _unwrap(array2))) + + def ge(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.greater_equal(_unwrap(array1), _unwrap(array2))) + + # Bitwise + + def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: + return Array(jnp.bitwise_and(_unwrap(array1), _unwrap(array2))) + # Operators def sign(self, array: Array) -> Array: @@ -210,11 +235,11 @@ def sign(self, array: Array) -> Array: def maximum(self, array1: Array | float, array2: Array | float) -> Array: return Array(jnp.maximum(_unwrap(array1), _unwrap(array2))) - def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - return Array(jnp.argmax(array.value, axis=dim, keepdims=keepdims)) + def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(jnp.argmax(array.value, axis=axis, keepdims=keepdims)) - def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - return Array(jnp.argmin(array.value, axis=dim, keepdims=keepdims)) + def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(jnp.argmin(array.value, axis=axis, keepdims=keepdims)) def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: # JAX arrays are immutable; rebind the wrapper to a new array with `key` updated. diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index 0bae7f4..8c6d3aa 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -89,16 +89,16 @@ def from_numpy(self, array: NDArray[Any]) -> Array: def to_array(self, array: float | bool) -> Array: return Array(np.array(array)) - def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") - return Array(np.stack([a.value for a in arrays], axis=dim)) + return Array(np.stack([a.value for a in arrays], axis=axis)) def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: return Array(np.reshape(array.value, shape)) - def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: - return Array(np.transpose(array.value, axes=dim)) + def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: + return Array(np.transpose(array.value, axes=axis)) def shape(self, array: Array) -> tuple[int, ...]: return tuple(array.value.shape) @@ -109,11 +109,11 @@ def size(self, array: Array) -> int: def ndim(self, array: Array) -> int: return int(array.value.ndim) - def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: - return Array(np.squeeze(array.value, axis=dim)) + def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: + return Array(np.squeeze(array.value, axis=axis)) - def unsqueeze(self, array: Array, dim: int) -> Array: - return Array(np.expand_dims(array.value, axis=dim)) + def unsqueeze(self, array: Array, axis: int) -> Array: + return Array(np.expand_dims(array.value, axis=axis)) def diag(self, array: Array) -> Array: return Array(np.diag(array.value)) @@ -135,24 +135,24 @@ def norm( self, array: Array, p: float = 2, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - return Array(np.linalg.norm(array.value, ord=p, axis=dim, keepdims=keepdims)) + return Array(np.linalg.norm(array.value, ord=p, axis=axis, keepdims=keepdims)) # Math reductions - def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.sum(array.value, axis=dim, keepdims=keepdims)) + def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.sum(array.value, axis=axis, keepdims=keepdims)) - def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.mean(array.value, axis=dim, keepdims=keepdims)) + def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.mean(array.value, axis=axis, keepdims=keepdims)) - def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.min(array.value, axis=dim, keepdims=keepdims)) + def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.min(array.value, axis=axis, keepdims=keepdims)) - def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.max(array.value, axis=dim, keepdims=keepdims)) + def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.max(array.value, axis=axis, keepdims=keepdims)) def any(self, array: Array) -> bool: return bool(np.any(array.value)) @@ -203,6 +203,31 @@ def absolute(self, array: Array) -> Array: def sqrt(self, array: Array) -> Array: return Array(np.sqrt(array.value)) + # Comparisons + + def eq(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.equal(_unwrap(array1), _unwrap(array2))) + + def ne(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.not_equal(_unwrap(array1), _unwrap(array2))) + + def lt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.less(_unwrap(array1), _unwrap(array2))) + + def le(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.less_equal(_unwrap(array1), _unwrap(array2))) + + def gt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.greater(_unwrap(array1), _unwrap(array2))) + + def ge(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.greater_equal(_unwrap(array1), _unwrap(array2))) + + # Bitwise + + def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: + return Array(np.bitwise_and(_unwrap(array1), _unwrap(array2))) + # Operators def sign(self, array: Array) -> Array: @@ -211,11 +236,11 @@ def sign(self, array: Array) -> Array: def maximum(self, array1: Array | float, array2: Array | float) -> Array: return Array(np.maximum(_unwrap(array1), _unwrap(array2))) - def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - return Array(np.argmax(array.value, axis=dim, keepdims=keepdims)) + def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(np.argmax(array.value, axis=axis, keepdims=keepdims)) - def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - return Array(np.argmin(array.value, axis=dim, keepdims=keepdims)) + def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(np.argmin(array.value, axis=axis, keepdims=keepdims)) def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: array.value[key] = value.value diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index 56d9359..c315adb 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -93,17 +93,17 @@ def from_numpy(self, array: NDArray[Any]) -> Array: def to_array(self, array: float | bool) -> Array: return Array(torch.tensor(array, device=self._native_device)) - def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") - return Array(torch.stack([a.value for a in arrays], dim=dim)) + return Array(torch.stack([a.value for a in arrays], dim=axis)) def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: return Array(torch.reshape(array.value, shape)) - def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: + def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: v = array.value - dims = dim if dim is not None else tuple(reversed(range(v.ndim))) + dims = axis if axis is not None else tuple(reversed(range(v.ndim))) return Array(torch.permute(v, dims=dims)) def shape(self, array: Array) -> tuple[int, ...]: @@ -115,14 +115,14 @@ def size(self, array: Array) -> int: def ndim(self, array: Array) -> int: return int(array.value.ndim) - def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: + def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: v = array.value - if dim is None: + if axis is None: return Array(torch.squeeze(v)) - return Array(torch.squeeze(v, dim=dim)) + return Array(torch.squeeze(v, dim=axis)) - def unsqueeze(self, array: Array, dim: int) -> Array: - return Array(torch.unsqueeze(array.value, dim=dim)) + def unsqueeze(self, array: Array, axis: int) -> Array: + return Array(torch.unsqueeze(array.value, dim=axis)) def diag(self, array: Array) -> Array: return Array(torch.diag(array.value)) @@ -142,36 +142,36 @@ def norm( self, array: Array, p: float = 2, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - return Array(torch.linalg.norm(array.value, ord=p, dim=dim, keepdim=keepdims)) + return Array(torch.linalg.norm(array.value, ord=p, axis=axis, keepdim=keepdims)) # Math reductions - def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: v = array.value - if dim is None: + if axis is None: return Array(torch.sum(v)) - return Array(torch.sum(v, dim=dim, keepdim=keepdims)) + return Array(torch.sum(v, dim=axis, keepdim=keepdims)) - def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: v = array.value - if dim is None: + if axis is None: return Array(torch.mean(v)) - return Array(torch.mean(v, dim=dim, keepdim=keepdims)) + return Array(torch.mean(v, dim=axis, keepdim=keepdims)) - def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: v = array.value - if dim is None: + if axis is None: return Array(torch.min(v)) - return Array(torch.amin(v, dim=dim, keepdim=keepdims)) + return Array(torch.amin(v, dim=axis, keepdim=keepdims)) - def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: v = array.value - if dim is None: + if axis is None: return Array(torch.max(v)) - return Array(torch.amax(v, dim=dim, keepdim=keepdims)) + return Array(torch.amax(v, dim=axis, keepdim=keepdims)) def any(self, array: Array) -> bool: return bool(torch.any(array.value).item()) @@ -222,6 +222,31 @@ def absolute(self, array: Array) -> Array: def sqrt(self, array: Array) -> Array: return Array(torch.sqrt(array.value)) + # Comparisons + + def eq(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.eq(_unwrap(array1), _unwrap(array2))) + + def ne(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.ne(_unwrap(array1), _unwrap(array2))) + + def lt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.lt(_unwrap(array1), _unwrap(array2))) + + def le(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.le(_unwrap(array1), _unwrap(array2))) + + def gt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.gt(_unwrap(array1), _unwrap(array2))) + + def ge(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.ge(_unwrap(array1), _unwrap(array2))) + + # Bitwise + + def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: + return Array(torch.bitwise_and(_unwrap(array1), _unwrap(array2))) + # Operators def sign(self, array: Array) -> Array: @@ -238,11 +263,11 @@ def maximum(self, array1: Array | float, array2: Array | float) -> Array: b = torch.tensor(b, dtype=a.dtype, device=a.device) return Array(torch.maximum(a, b)) - def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - return Array(torch.argmax(array.value, dim=dim, keepdim=keepdims)) + def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(torch.argmax(array.value, dim=axis, keepdim=keepdims)) - def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: - return Array(torch.argmin(array.value, dim=dim, keepdim=keepdims)) + def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(torch.argmin(array.value, dim=axis, keepdim=keepdims)) def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: array.value[key] = value.value diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index f8e9b65..f6cf51e 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -96,16 +96,16 @@ def to_array(self, array: float | bool) -> Array: with tf.device(self._native_device): return Array(tf.convert_to_tensor(array)) - def stack(self, arrays: Sequence[Array], dim: int = 0) -> Array: + def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") - return Array(tf.stack([a.value for a in arrays], axis=dim)) + return Array(tf.stack([a.value for a in arrays], axis=axis)) def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: return Array(tf.reshape(array.value, shape)) - def transpose(self, array: Array, dim: tuple[int, ...] | None = None) -> Array: - return Array(tf.transpose(array.value, perm=dim)) + def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: + return Array(tf.transpose(array.value, perm=axis)) def shape(self, array: Array) -> tuple[int, ...]: return cast("tuple[int, ...]", tuple(array.value.shape)) @@ -116,11 +116,11 @@ def size(self, array: Array) -> int: def ndim(self, array: Array) -> int: return len(array.value.shape) - def squeeze(self, array: Array, dim: int | tuple[int, ...] | None = None) -> Array: - return Array(tf.squeeze(array.value, axis=dim)) + def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: + return Array(tf.squeeze(array.value, axis=axis)) - def unsqueeze(self, array: Array, dim: int) -> Array: - return Array(tf.expand_dims(array.value, axis=dim)) + def unsqueeze(self, array: Array, axis: int) -> Array: + return Array(tf.expand_dims(array.value, axis=axis)) def diag(self, array: Array) -> Array: v = array.value @@ -151,28 +151,28 @@ def norm( self, array: Array, p: float = 2, - dim: int | tuple[int, ...] | None = None, + axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: v = array.value # tf.norm defaults differ from np.linalg.norm on 2-D inputs (operator vs. # Frobenius); match numpy's flat default by reducing over both trailing axes. - axis = dim if dim is not None else (-2, -1) if v.ndim == 2 else None + axis = axis if axis is not None else (-2, -1) if v.ndim == 2 else None return Array(tf.norm(v, ord=p, axis=axis, keepdims=keepdims)) # Math reductions - def sum(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_sum(array.value, axis=dim, keepdims=keepdims)) + def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_sum(array.value, axis=axis, keepdims=keepdims)) - def mean(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_mean(array.value, axis=dim, keepdims=keepdims)) + def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_mean(array.value, axis=axis, keepdims=keepdims)) - def min(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_min(array.value, axis=dim, keepdims=keepdims)) + def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_min(array.value, axis=axis, keepdims=keepdims)) - def max(self, array: Array, dim: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_max(array.value, axis=dim, keepdims=keepdims)) + def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_max(array.value, axis=axis, keepdims=keepdims)) def any(self, array: Array) -> bool: return bool(tf.reduce_any(tf.cast(array.value, tf.bool)).numpy()) @@ -224,6 +224,34 @@ def absolute(self, array: Array) -> Array: def sqrt(self, array: Array) -> Array: return Array(tf.sqrt(array.value)) + # Comparisons + + def eq(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.equal(_unwrap(array1), _unwrap(array2))) + + def ne(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.not_equal(_unwrap(array1), _unwrap(array2))) + + def lt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.less(_unwrap(array1), _unwrap(array2))) + + def le(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.less_equal(_unwrap(array1), _unwrap(array2))) + + def gt(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.greater(_unwrap(array1), _unwrap(array2))) + + def ge(self, array1: Array | float, array2: Array | float) -> Array: + return Array(tf.greater_equal(_unwrap(array1), _unwrap(array2))) + + # Bitwise — TF's native ``&`` dispatches to ``tf.math.logical_and`` for bool + # tensors and ``tf.bitwise.bitwise_and`` for int tensors, matching numpy/torch/jax + # operator semantics. Calling either named function directly here would constrain + # us to one dtype family. + + def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: + return Array(_unwrap(array1) & _unwrap(array2)) + # Operators def sign(self, array: Array) -> Array: @@ -232,30 +260,30 @@ def sign(self, array: Array) -> Array: def maximum(self, array1: Array | float, array2: Array | float) -> Array: return Array(tf.maximum(_unwrap(array1), _unwrap(array2))) - def argmax(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: v = array.value - if dim is None: + if axis is None: flat = tf.argmax(tf.reshape(v, [-1]), axis=0) if keepdims: ndim = v.shape.ndims or 0 return Array(tf.reshape(flat, [1] * ndim)) return Array(flat) - out = tf.argmax(v, axis=dim) + out = tf.argmax(v, axis=axis) if keepdims: - out = tf.expand_dims(out, axis=dim) + out = tf.expand_dims(out, axis=axis) return Array(out) - def argmin(self, array: Array, dim: int | None = None, keepdims: bool = False) -> Array: + def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: v = array.value - if dim is None: + if axis is None: flat = tf.argmin(tf.reshape(v, [-1]), axis=0) if keepdims: ndim = v.shape.ndims or 0 return Array(tf.reshape(flat, [1] * ndim)) return Array(flat) - out = tf.argmin(v, axis=dim) + out = tf.argmin(v, axis=axis) if keepdims: - out = tf.expand_dims(out, axis=dim) + out = tf.expand_dims(out, axis=axis) return Array(out) def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: diff --git a/tests/test_array.py b/tests/test_array.py index 3653c2b..5919933 100644 --- a/tests/test_array.py +++ b/tests/test_array.py @@ -119,6 +119,116 @@ def test_pow_scalar(backend: tuple) -> None: np.testing.assert_allclose(_np(a**2), [1.0, 4.0, 9.0]) +# Comparisons ------------------------------------------------------------ + + +def test_eq_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + result = a == b + assert isinstance(result, Array) + np.testing.assert_array_equal(_np(result), [True, False, True]) + + +def test_eq_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(a == 2.0), [False, True, False]) + + +def test_ne_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + np.testing.assert_array_equal(_np(a != b), [False, True, False]) + + +def test_ne_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(a != 2.0), [True, False, True]) + + +def test_lt_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + np.testing.assert_array_equal(_np(a < b), [False, True, False]) + + +def test_lt_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(a < 2.5), [True, True, False]) + + +def test_le_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + np.testing.assert_array_equal(_np(a <= b), [True, True, False]) + + +def test_le_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(a <= 2.0), [True, True, False]) + + +def test_gt_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + np.testing.assert_array_equal(_np(a > b), [False, False, True]) + + +def test_gt_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(a > 1.5), [False, True, True]) + + +def test_ge_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + np.testing.assert_array_equal(_np(a >= b), [True, False, True]) + + +def test_ge_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(a >= 2.0), [False, True, True]) + + +def test_array_is_unhashable(backend: tuple) -> None: # noqa: ARG001 + """ + Overriding ``__eq__`` makes Array unhashable, matching numpy/torch/jax/tf. + + The check is on ``hash(arr)`` rather than ``Array.__hash__ is None`` because + mypyc realizes unhashability via a type-error-raising slot descriptor while + pure Python sets the attribute to ``None``; ``hash()`` raises ``TypeError`` + in either case. + """ + arr = iop.from_numpy(np.array([1.0])) + with pytest.raises(TypeError, match=re.compile(r"unhashable", re.IGNORECASE)): + hash(arr) + + +# Bitwise ---------------------------------------------------------------- + + +def test_and_array(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + mask1 = a > 1.0 + mask2 = a < 4.0 + np.testing.assert_array_equal(_np(mask1 & mask2), [False, True, True, False]) + + +def test_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + mask = a > 1.0 + np.testing.assert_array_equal(_np(mask & True), [False, True, True]) # noqa: E712 + np.testing.assert_array_equal(_np(mask & False), [False, False, False]) # noqa: E712 + + +def test_rand_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + mask = a > 1.0 + # Python evaluates ``True & mask`` via ``mask.__rand__(True)`` since bool's + # ``__and__`` doesn't accept Array. + np.testing.assert_array_equal(_np(True & mask), [False, True, True]) # noqa: E712 + + # In-place arithmetic ----------------------------------------------------- diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py index 9dc42dd..c19e88a 100644 --- a/tests/test_iop_functions.py +++ b/tests/test_iop_functions.py @@ -104,7 +104,7 @@ def test_stack(backend: tuple) -> None: def test_stack_dim(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0])) b = iop.from_numpy(np.array([3.0, 4.0])) - arr = iop.stack([a, b], dim=1) + arr = iop.stack([a, b], axis=1) np.testing.assert_allclose(_np(arr), [[1.0, 3.0], [2.0, 4.0]]) @@ -128,7 +128,7 @@ def test_transpose_default(backend: tuple) -> None: def test_transpose_explicit_dim(backend: tuple) -> None: arr = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) - out = iop.transpose(arr, dim=(1, 0, 2)) + out = iop.transpose(arr, axis=(1, 0, 2)) assert iop.shape(out) == (3, 2, 4) @@ -154,13 +154,13 @@ def test_squeeze_default(backend: tuple) -> None: def test_squeeze_specific_dim(backend: tuple) -> None: arr = iop.from_numpy(np.zeros((1, 3, 1))) - assert iop.shape(iop.squeeze(arr, dim=0)) == (3, 1) + assert iop.shape(iop.squeeze(arr, axis=0)) == (3, 1) def test_unsqueeze(backend: tuple) -> None: arr = iop.from_numpy(np.zeros((3,))) - assert iop.shape(iop.unsqueeze(arr, dim=0)) == (1, 3) - assert iop.shape(iop.unsqueeze(arr, dim=1)) == (3, 1) + assert iop.shape(iop.unsqueeze(arr, axis=0)) == (1, 3) + assert iop.shape(iop.unsqueeze(arr, axis=1)) == (3, 1) def test_diag_from_vector(backend: tuple) -> None: @@ -222,7 +222,7 @@ def test_norm_p1(backend: tuple) -> None: def test_norm_dim_keepdims(backend: tuple) -> None: arr = iop.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]])) - out = iop.norm(arr, p=2, dim=1, keepdims=True) + out = iop.norm(arr, p=2, axis=1, keepdims=True) assert iop.shape(out) == (2, 1) np.testing.assert_allclose(_np(out).reshape(-1), [5.0, 10.0]) @@ -237,12 +237,12 @@ def test_sum_all(backend: tuple) -> None: def test_sum_dim(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - np.testing.assert_allclose(_np(iop.sum(arr, dim=0)), [4.0, 6.0]) + np.testing.assert_allclose(_np(iop.sum(arr, axis=0)), [4.0, 6.0]) def test_sum_dim_keepdims(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - out = iop.sum(arr, dim=0, keepdims=True) + out = iop.sum(arr, axis=0, keepdims=True) assert iop.shape(out) == (1, 2) @@ -253,7 +253,7 @@ def test_mean_all(backend: tuple) -> None: def test_mean_dim(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - np.testing.assert_allclose(_np(iop.mean(arr, dim=1)), [1.5, 3.5]) + np.testing.assert_allclose(_np(iop.mean(arr, axis=1)), [1.5, 3.5]) def test_min_all(backend: tuple) -> None: @@ -263,7 +263,7 @@ def test_min_all(backend: tuple) -> None: def test_min_dim(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) - np.testing.assert_allclose(_np(iop.min(arr, dim=0)), [1.0, 2.0]) + np.testing.assert_allclose(_np(iop.min(arr, axis=0)), [1.0, 2.0]) def test_max_all(backend: tuple) -> None: @@ -273,7 +273,7 @@ def test_max_all(backend: tuple) -> None: def test_max_dim(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) - np.testing.assert_allclose(_np(iop.max(arr, dim=0)), [3.0, 5.0]) + np.testing.assert_allclose(_np(iop.max(arr, axis=0)), [3.0, 5.0]) def test_any_true(backend: tuple) -> None: @@ -396,6 +396,93 @@ def test_maximum_array_and_scalar(backend: tuple) -> None: np.testing.assert_allclose(_np(iop.maximum(a, 4.0)), [4.0, 5.0, 4.0]) +# Comparisons ------------------------------------------------------------ + + +def test_eq_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + np.testing.assert_array_equal(_np(iop.eq(a, b)), [True, False, True]) + + +def test_eq_array_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(iop.eq(a, 2.0)), [False, True, False]) + + +def test_ne_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + np.testing.assert_array_equal(_np(iop.ne(a, b)), [False, True, False]) + + +def test_ne_array_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(iop.ne(a, 2.0)), [True, False, True]) + + +def test_lt_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + np.testing.assert_array_equal(_np(iop.lt(a, b)), [True, False, False]) + + +def test_lt_array_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(iop.lt(a, 2.5)), [True, True, False]) + + +def test_le_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + np.testing.assert_array_equal(_np(iop.le(a, b)), [True, True, False]) + + +def test_le_array_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(iop.le(a, 2.0)), [True, True, False]) + + +def test_gt_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + np.testing.assert_array_equal(_np(iop.gt(a, b)), [False, False, True]) + + +def test_gt_array_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(iop.gt(a, 1.5)), [False, True, True]) + + +def test_ge_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + np.testing.assert_array_equal(_np(iop.ge(a, b)), [False, True, True]) + + +def test_ge_array_and_scalar(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + np.testing.assert_array_equal(_np(iop.ge(a, 2.0)), [False, True, True]) + + +# Bitwise ---------------------------------------------------------------- + + +def test_bitwise_and_bool_arrays(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + mask1 = iop.gt(a, 1.0) + mask2 = iop.lt(a, 4.0) + np.testing.assert_array_equal(_np(iop.bitwise_and(mask1, mask2)), [False, True, True, False]) + + +def test_bitwise_and_int_arrays(backend: tuple) -> None: + # Bitwise on int dtypes is well-defined across all backends; bool tensors are + # tested separately because TF dispatches them to ``logical_and``. + a = iop.from_numpy(np.array([0b1100, 0b1010], dtype=np.int32)) + b = iop.from_numpy(np.array([0b1010, 0b0110], dtype=np.int32)) + np.testing.assert_array_equal(_np(iop.bitwise_and(a, b)), [0b1000, 0b0010]) + + def test_argmax_default(backend: tuple) -> None: arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) np.testing.assert_allclose(_np(iop.argmax(arr)), 5) @@ -403,7 +490,7 @@ def test_argmax_default(backend: tuple) -> None: def test_argmax_dim(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) - np.testing.assert_allclose(_np(iop.argmax(arr, dim=1)), [1, 0]) + np.testing.assert_allclose(_np(iop.argmax(arr, axis=1)), [1, 0]) def test_argmin_default(backend: tuple) -> None: @@ -414,12 +501,12 @@ def test_argmin_default(backend: tuple) -> None: def test_argmin_dim(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) - np.testing.assert_allclose(_np(iop.argmin(arr, dim=1)), [0, 1]) + np.testing.assert_allclose(_np(iop.argmin(arr, axis=1)), [0, 1]) def test_argmax_keepdims(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) - out = iop.argmax(arr, dim=1, keepdims=True) + out = iop.argmax(arr, axis=1, keepdims=True) assert iop.shape(out) == (2, 1) From 8852fdb4e984c48e719f62c130a4b0c9bfa9df40 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 21:22:25 +0200 Subject: [PATCH 07/11] fix(PR): PR comments and fix MPS tests --- benchmarks/bench_common.py | 4 +- benchmarks/bench_iop.py | 22 +- decent_array/_array.py | 6 +- decent_array/interoperability/__init__.py | 2 + .../interoperability/_abstracts/backend.py | 4 + .../interoperability/_backend_manager.py | 4 +- .../interoperability/_iop/functions.py | 17 +- decent_array/interoperability/_iop/rng.py | 6 + .../interoperability/_jax/jax_backend.py | 4 + .../interoperability/_numpy/numpy_backend.py | 4 + .../_pytorch/pytorch_backend.py | 4 + .../_tensorflow/tensorflow_backend.py | 6 + decent_array/types.py | 8 +- docs/source/author.rst | 5 +- docs/source/developer.rst | 6 +- tests/test_array.py | 153 +++++++------- tests/test_decorators.py | 12 +- tests/test_iop_functions.py | 196 ++++++++++-------- tests/test_iop_rng.py | 4 + 19 files changed, 269 insertions(+), 198 deletions(-) diff --git a/benchmarks/bench_common.py b/benchmarks/bench_common.py index 13b350b..d67726e 100644 --- a/benchmarks/bench_common.py +++ b/benchmarks/bench_common.py @@ -56,7 +56,7 @@ def activate_backend(name: str) -> None: ``decent_array`` enforces a single-active-backend invariant per execution context; swapping between frameworks within one process requires resetting first. """ - from decent_array.interoperability.backend_manager import reset_backends, set_backend # noqa: PLC0415 + from decent_array.interoperability._backend_manager import reset_backends, set_backend # noqa: PLC0415 reset_backends() set_backend(name) @@ -133,7 +133,7 @@ def parse_backends_arg() -> list[str] | None: def is_compiled() -> tuple[bool, str]: """Return ``(True, path)`` if the Array module loaded from a ``.so``/``.pyd``, else ``(False, .py path)``.""" - module = importlib.import_module("decent_array.Array") + module = importlib.import_module("decent_array._array") path = module.__file__ or "" return path.endswith((".so", ".pyd")), path diff --git a/benchmarks/bench_iop.py b/benchmarks/bench_iop.py index 5991f2c..5127b0a 100644 --- a/benchmarks/bench_iop.py +++ b/benchmarks/bench_iop.py @@ -35,7 +35,7 @@ time_us_safe, ) -import decent_array as iop +import decent_array.interoperability as iop from decent_array import Array @@ -43,6 +43,7 @@ def _native_ops(backend: str) -> dict[str, Callable[..., Any]]: """Return the native-framework equivalents of each ``iop.`` for ``backend``.""" if backend == "numpy": import numpy as np # noqa: PLC0415 + return { "add": np.add, "mul": np.multiply, @@ -55,6 +56,7 @@ def _native_ops(backend: str) -> dict[str, Callable[..., Any]]: } if backend == "pytorch": import torch # noqa: PLC0415 + return { "add": torch.add, "mul": torch.mul, @@ -67,6 +69,7 @@ def _native_ops(backend: str) -> dict[str, Callable[..., Any]]: } if backend == "jax": import jax.numpy as jnp # noqa: PLC0415 + return { "add": jnp.add, "mul": jnp.multiply, @@ -79,6 +82,7 @@ def _native_ops(backend: str) -> dict[str, Callable[..., Any]]: } if backend == "tensorflow": import tensorflow as tf # noqa: PLC0415 + return { "add": tf.add, "mul": tf.multiply, @@ -103,14 +107,14 @@ def _bench_case(case: BackendCase) -> None: print_size_header(n) rows = ( - ("add", lambda a=a, b=b: native["add"](a, b), lambda d_a=d_a, d_b=d_b: iop.add(d_a, d_b)), - ("mul", lambda a=a, b=b: native["mul"](a, b), lambda d_a=d_a, d_b=d_b: iop.mul(d_a, d_b)), - ("dot", lambda a=a, b=b: native["dot"](a, b), lambda d_a=d_a, d_b=d_b: iop.dot(d_a, d_b)), - ("sum", lambda a=a: native["sum"](a), lambda d_a=d_a: iop.sum(d_a)), - ("mean", lambda a=a: native["mean"](a), lambda d_a=d_a: iop.mean(d_a)), - ("norm", lambda a=a: native["norm"](a), lambda d_a=d_a: iop.norm(d_a)), - ("sqrt", lambda a=a: native["sqrt"](a), lambda d_a=d_a: iop.sqrt(d_a)), - ("sign", lambda a=a: native["sign"](a), lambda d_a=d_a: iop.sign(d_a)), + ("add", lambda a=a, b=b: native["add"](a, b), lambda d_a=d_a, d_b=d_b: iop.add(d_a, d_b)), + ("mul", lambda a=a, b=b: native["mul"](a, b), lambda d_a=d_a, d_b=d_b: iop.mul(d_a, d_b)), + ("dot", lambda a=a, b=b: native["dot"](a, b), lambda d_a=d_a, d_b=d_b: iop.dot(d_a, d_b)), + ("sum", lambda a=a: native["sum"](a), lambda d_a=d_a: iop.sum(d_a)), + ("mean", lambda a=a: native["mean"](a), lambda d_a=d_a: iop.mean(d_a)), + ("norm", lambda a=a: native["norm"](a), lambda d_a=d_a: iop.norm(d_a)), + ("sqrt", lambda a=a: native["sqrt"](a), lambda d_a=d_a: iop.sqrt(d_a)), + ("sign", lambda a=a: native["sign"](a), lambda d_a=d_a: iop.sign(d_a)), ) for op, native_fn, wrapped_fn in rows: n_us = time_us_safe(case, native_fn) diff --git a/decent_array/_array.py b/decent_array/_array.py index 87a5788..9c554f5 100644 --- a/decent_array/_array.py +++ b/decent_array/_array.py @@ -2,9 +2,9 @@ Lightweight wrapper around backend-native arrays. The :class:`Array` class wraps a single value of the active backend's framework type. -Under the single-active-backend invariant maintained by, every :class:`Array` at runtime -holds a value from the same framework, so operators dispatch directly to the active -backend without per-call isinstance dispatch. +Under the single-active-backend invariant maintained by the backend manager, every +:class:`Array` at runtime holds a value from the same framework, so operators dispatch +directly to the active backend without per-call isinstance dispatch. Operator contract is *strict*: binary arithmetic and indexing accept either another :class:`Array` or a Python scalar (``int``/``float``). Pass other framework-native diff --git a/decent_array/interoperability/__init__.py b/decent_array/interoperability/__init__.py index 5301fb2..a1b96ed 100644 --- a/decent_array/interoperability/__init__.py +++ b/decent_array/interoperability/__init__.py @@ -33,6 +33,7 @@ eye, eye_like, from_numpy, + from_numpy_like, ge, get_item, gt, @@ -107,6 +108,7 @@ "eye", "eye_like", "from_numpy", + "from_numpy_like", "ge", "get_item", "get_rng_state", diff --git a/decent_array/interoperability/_abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py index 04bdf82..72b0b5e 100644 --- a/decent_array/interoperability/_abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -86,6 +86,10 @@ def to_numpy(self, array: Array) -> NDArray[Any]: def from_numpy(self, array: NDArray[Any]) -> Array: """Convert a NumPy array on the CPU to an :class:`Array` on this backend.""" + @abstractmethod + def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + """Convert a Numpy array to an :class:`Array` on this backend, matching shape and type of ``like``.""" + @abstractmethod def to_array(self, array: float | bool) -> Array: """Convert a Python scalar to an :class:`Array` on this backend.""" diff --git a/decent_array/interoperability/_backend_manager.py b/decent_array/interoperability/_backend_manager.py index 634bf74..3092958 100644 --- a/decent_array/interoperability/_backend_manager.py +++ b/decent_array/interoperability/_backend_manager.py @@ -10,7 +10,9 @@ _BACKEND_REGISTRY: dict[SupportedFrameworks, type[Backend]] = {} _BACKEND_INSTANCES: dict[SupportedFrameworks, Backend] = {} -_ACTIVE_BACKEND: ContextVar[SupportedFrameworks | None] = ContextVar("decent_bench.iop2.active_backend", default=None) +_ACTIVE_BACKEND: ContextVar[SupportedFrameworks | None] = ContextVar( + "decent_array.interoperability.active_backend", default=None +) _BACKEND_LISTENERS: list[Callable[[Backend | None], None]] = [] _BACKEND_INSTANCE: Backend | None = None diff --git a/decent_array/interoperability/_iop/functions.py b/decent_array/interoperability/_iop/functions.py index e7115f8..9239a3f 100644 --- a/decent_array/interoperability/_iop/functions.py +++ b/decent_array/interoperability/_iop/functions.py @@ -1,13 +1,13 @@ """ Module-level interoperability functions. -Each function delegates to the active backend cached in this module's ``_BACKEND`` -slot. The slot is rebound by :func:`decent_bench.utils.interoperability_2.set_backend` -via :func:`_set_active_backend`. Calling any of these before ``set_backend`` raises -:class:`RuntimeError` via the sentinel's ``__getattr__``. +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. When this module and ``Backend`` are mypyc-compiled in the same group, -``_BACKEND.add(...)`` dispatches as a native compiled-to-compiled call — no Python +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python attribute lookup, no bound-method allocation per call. """ @@ -119,6 +119,13 @@ def from_numpy(array: NDArray[Any]) -> Array: return _BACKEND_INSTANCE.from_numpy(array) +def from_numpy_like(array: NDArray[Any], like: Array) -> Array: + """Convert a NumPy array to an :class:`~decent_array.Array` matching ``like``'s dtype and device.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.from_numpy_like(array, like) + + def to_array(array: float | bool) -> Array: """Convert a Python scalar to an :class:`~decent_array.Array` on the active backend.""" if _BACKEND_INSTANCE is None: diff --git a/decent_array/interoperability/_iop/rng.py b/decent_array/interoperability/_iop/rng.py index 91abdc9..706bf1e 100644 --- a/decent_array/interoperability/_iop/rng.py +++ b/decent_array/interoperability/_iop/rng.py @@ -135,6 +135,12 @@ def _set_seed_without_global(seed: int) -> None: _COORDINATOR.set_seed(seed, set_global_seed=False) +def _reset_rng() -> None: + """Reset RNG state to a fresh state.""" + global _COORDINATOR # noqa: PLW0603 + _COORDINATOR = _RngCoordinator() + + def get_seed() -> int | None: """Return the most recently set global seed, or ``None`` if unset.""" return _COORDINATOR.get_seed() diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index b7048a5..4dbd187 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -86,6 +86,10 @@ def to_numpy(self, array: Array) -> NDArray[Any]: def from_numpy(self, array: NDArray[Any]) -> Array: return Array(jnp.array(array, device=self._native_device)) + def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + v = like.value + return Array(jnp.asarray(array, dtype=v.dtype, device=v.device)) + def to_array(self, array: float | bool) -> Array: return Array(jnp.array(array, device=self._native_device)) diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index 8c6d3aa..f3e0dfb 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -86,6 +86,10 @@ def to_numpy(self, array: Array) -> NDArray[Any]: def from_numpy(self, array: NDArray[Any]) -> Array: return Array(array) + def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + # NumPy has no device dimension, so only the dtype of ``like`` matters. + return Array(np.asarray(array, dtype=like.value.dtype)) + def to_array(self, array: float | bool) -> Array: return Array(np.array(array)) diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index c315adb..39dfc31 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -90,6 +90,10 @@ def to_numpy(self, array: Array) -> NDArray[Any]: def from_numpy(self, array: NDArray[Any]) -> Array: return Array(torch.from_numpy(array).to(device=self._native_device)) + def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + v = like.value + return Array(torch.from_numpy(array).to(dtype=v.dtype, device=v.device)) + def to_array(self, array: float | bool) -> Array: return Array(torch.tensor(array, device=self._native_device)) diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index f6cf51e..1026701 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -91,6 +91,12 @@ def from_numpy(self, array: NDArray[Any]) -> Array: with tf.device(self._native_device): return Array(tf.convert_to_tensor(array)) + def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + """Create an :class:`Array` from a NumPy array, on ``like``'s device with ``like``'s dtype.""" + v = like.value + with tf.device(v.device): + return Array(tf.convert_to_tensor(array, dtype=v.dtype)) + def to_array(self, array: float | bool) -> Array: """Convert a Python scalar to an :class:`Array` on this backend.""" with tf.device(self._native_device): diff --git a/decent_array/types.py b/decent_array/types.py index 3e359aa..6d62fcb 100644 --- a/decent_array/types.py +++ b/decent_array/types.py @@ -13,13 +13,13 @@ ArrayLike: TypeAlias = Union["numpy.ndarray", "torch.Tensor", "tf.Tensor", "jax.Array"] # noqa: UP040 """ -Type alias for array-like types supported in decent-bench, including NumPy arrays, +Type alias for array-like types supported in decent-array, including NumPy arrays, PyTorch tensors, TensorFlow tensors, and JAX arrays. """ SupportedArrayTypes: TypeAlias = ArrayLike | float | int # noqa: UP040 """ -Type alias for supported types for optimization variables in decent-bench, +Type alias for supported types for optimization variables in decent-array, including array-like types and scalars. """ @@ -33,7 +33,7 @@ # Its important that the enum values correspond to the folder names of the backends, # since those are used for dynamic imports in _backend_manager.py class SupportedFrameworks(Enum): - """Enum for supported frameworks in decent-bench.""" + """Enum for supported frameworks in decent-array.""" NUMPY = "numpy" PYTORCH = "pytorch" @@ -42,7 +42,7 @@ class SupportedFrameworks(Enum): class SupportedDevices(Enum): - """Enum for supported devices in decent-bench.""" + """Enum for supported devices in decent-array.""" CPU = "cpu" GPU = "gpu" diff --git a/docs/source/author.rst b/docs/source/author.rst index 688188b..0506444 100644 --- a/docs/source/author.rst +++ b/docs/source/author.rst @@ -1,7 +1,6 @@ Contributors ============ -decent-bench is developed by `Elias Ram `_, -`Simon Granström `_, -`Adriana Rodriguez `_ under the supervision of +decent-array is developed by `Simon Granström `_ and +`Adriana Rodriguez `_, under the supervision of `Dr. Nicola Bastianello `_. diff --git a/docs/source/developer.rst b/docs/source/developer.rst index bfb018e..053f9ec 100644 --- a/docs/source/developer.rst +++ b/docs/source/developer.rst @@ -1,6 +1,6 @@ Developer Guide =============== -Want to contribute to decent-bench? That's great! This guide contains useful information +Want to contribute to decent-array? That's great! This guide contains useful information about development tools, processes, and rules. @@ -55,12 +55,12 @@ Tools can also be used directly (instead of via tox) after activating the dev en ruff check decent_array --fix # find and fix style issues ruff format decent_array # format code mypy decent_array --strict # find typing issues - pytest test # run tests + pytest tests # run tests sphinx-build -W -E -b html docs/source docs/build/html # rebuild html doc files To verify that doc changes look good, use an html previewer such as `Live Preview `_. -If you are running :code:`pytest test` while using ``WSL`` on Windows and it starts to randomly fail (or if its really slow), restart your ``WSL`` instance. +If you are running :code:`pytest tests` while using ``WSL`` on Windows and it starts to randomly fail (or if its really slow), restart your ``WSL`` instance. diff --git a/tests/test_array.py b/tests/test_array.py index 5919933..164e223 100644 --- a/tests/test_array.py +++ b/tests/test_array.py @@ -17,6 +17,11 @@ def _np(arr: Array) -> np.ndarray: return iop.to_numpy(arr) +def _create_array(data: float | list[float] | list[list[float]]) -> Array: + """Create an Array from a list of floats for testing.""" + return iop.from_numpy(np.array(data, dtype=np.float32)) + + # Construction ------------------------------------------------------------ @@ -36,72 +41,72 @@ def test_init_records_active_backend(backend: tuple) -> None: def test_add_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([4.0, 5.0, 6.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([4.0, 5.0, 6.0]) np.testing.assert_allclose(_np(a + b), [5.0, 7.0, 9.0]) def test_add_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(a + 2), [3.0, 4.0, 5.0]) def test_radd_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(2 + a), [3.0, 4.0, 5.0]) def test_sub_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([4.0, 5.0, 6.0])) - b = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([4.0, 5.0, 6.0]) + b = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(a - b), [3.0, 3.0, 3.0]) def test_sub_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([4.0, 5.0, 6.0])) + a = _create_array([4.0, 5.0, 6.0]) np.testing.assert_allclose(_np(a - 1), [3.0, 4.0, 5.0]) def test_rsub_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(10 - a), [9.0, 8.0, 7.0]) def test_mul_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([2.0, 3.0, 4.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([2.0, 3.0, 4.0]) np.testing.assert_allclose(_np(a * b), [2.0, 6.0, 12.0]) def test_mul_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(a * 3), [3.0, 6.0, 9.0]) def test_rmul_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(3 * a), [3.0, 6.0, 9.0]) def test_truediv_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([4.0, 9.0, 16.0])) - b = iop.from_numpy(np.array([2.0, 3.0, 4.0])) + a = _create_array([4.0, 9.0, 16.0]) + b = _create_array([2.0, 3.0, 4.0]) np.testing.assert_allclose(_np(a / b), [2.0, 3.0, 4.0]) def test_truediv_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([2.0, 4.0, 6.0])) + a = _create_array([2.0, 4.0, 6.0]) np.testing.assert_allclose(_np(a / 2), [1.0, 2.0, 3.0]) def test_rtruediv_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 4.0])) + a = _create_array([1.0, 2.0, 4.0]) np.testing.assert_allclose(_np(8 / a), [8.0, 4.0, 2.0]) def test_matmul_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + a = _create_array([[1.0, 2.0], [3.0, 4.0]]) + b = _create_array([[5.0, 6.0], [7.0, 8.0]]) expected = np.array([[19.0, 22.0], [43.0, 50.0]]) np.testing.assert_allclose(_np(a @ b), expected) @@ -109,13 +114,13 @@ def test_matmul_array(backend: tuple) -> None: def test_rmatmul_explicit_call(backend: tuple) -> None: # Python dispatch never picks Array.__rmatmul__ when both operands are Array, # so call it directly to exercise the code path. - a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) + a = _create_array([[1.0, 2.0], [3.0, 4.0]]) + b = _create_array([[5.0, 6.0], [7.0, 8.0]]) np.testing.assert_allclose(_np(a.__rmatmul__(b)), _np(b @ a)) def test_pow_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_allclose(_np(a**2), [1.0, 4.0, 9.0]) @@ -123,70 +128,70 @@ def test_pow_scalar(backend: tuple) -> None: def test_eq_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([1.0, 5.0, 3.0]) result = a == b assert isinstance(result, Array) np.testing.assert_array_equal(_np(result), [True, False, True]) def test_eq_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_array_equal(_np(a == 2.0), [False, True, False]) def test_ne_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([1.0, 5.0, 3.0]) np.testing.assert_array_equal(_np(a != b), [False, True, False]) def test_ne_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_array_equal(_np(a != 2.0), [True, False, True]) def test_lt_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([1.0, 5.0, 0.0]) np.testing.assert_array_equal(_np(a < b), [False, True, False]) def test_lt_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_array_equal(_np(a < 2.5), [True, True, False]) def test_le_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([1.0, 5.0, 0.0]) np.testing.assert_array_equal(_np(a <= b), [True, True, False]) def test_le_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_array_equal(_np(a <= 2.0), [True, True, False]) def test_gt_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([1.0, 5.0, 0.0]) np.testing.assert_array_equal(_np(a > b), [False, False, True]) def test_gt_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_array_equal(_np(a > 1.5), [False, True, True]) def test_ge_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 0.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([1.0, 5.0, 0.0]) np.testing.assert_array_equal(_np(a >= b), [True, False, True]) def test_ge_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) np.testing.assert_array_equal(_np(a >= 2.0), [False, True, True]) @@ -199,7 +204,7 @@ def test_array_is_unhashable(backend: tuple) -> None: # noqa: ARG001 pure Python sets the attribute to ``None``; ``hash()`` raises ``TypeError`` in either case. """ - arr = iop.from_numpy(np.array([1.0])) + arr = _create_array([1.0]) with pytest.raises(TypeError, match=re.compile(r"unhashable", re.IGNORECASE)): hash(arr) @@ -208,58 +213,58 @@ def test_array_is_unhashable(backend: tuple) -> None: # noqa: ARG001 def test_and_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + a = _create_array([1.0, 2.0, 3.0, 4.0]) mask1 = a > 1.0 mask2 = a < 4.0 np.testing.assert_array_equal(_np(mask1 & mask2), [False, True, True, False]) def test_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) mask = a > 1.0 - np.testing.assert_array_equal(_np(mask & True), [False, True, True]) # noqa: E712 - np.testing.assert_array_equal(_np(mask & False), [False, False, False]) # noqa: E712 + np.testing.assert_array_equal(_np(mask & True), [False, True, True]) + np.testing.assert_array_equal(_np(mask & False), [False, False, False]) def test_rand_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) mask = a > 1.0 # Python evaluates ``True & mask`` via ``mask.__rand__(True)`` since bool's # ``__and__`` doesn't accept Array. - np.testing.assert_array_equal(_np(True & mask), [False, True, True]) # noqa: E712 + np.testing.assert_array_equal(_np(True & mask), [False, True, True]) # In-place arithmetic ----------------------------------------------------- def test_iadd_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([4.0, 5.0, 6.0])) + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([4.0, 5.0, 6.0]) a += b np.testing.assert_allclose(_np(a), [5.0, 7.0, 9.0]) def test_iadd_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) a += 10 np.testing.assert_allclose(_np(a), [11.0, 12.0, 13.0]) def test_isub_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([5.0, 6.0, 7.0])) - b = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([5.0, 6.0, 7.0]) + b = _create_array([1.0, 2.0, 3.0]) a -= b np.testing.assert_allclose(_np(a), [4.0, 4.0, 4.0]) def test_imul_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) a *= 2 np.testing.assert_allclose(_np(a), [2.0, 4.0, 6.0]) def test_itruediv_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([2.0, 4.0, 6.0])) + a = _create_array([2.0, 4.0, 6.0]) a /= 2 np.testing.assert_allclose(_np(a), [1.0, 2.0, 3.0]) @@ -268,12 +273,12 @@ def test_itruediv_scalar(backend: tuple) -> None: def test_neg(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, -2.0, 3.0])) + a = _create_array([1.0, -2.0, 3.0]) np.testing.assert_allclose(_np(-a), [-1.0, 2.0, -3.0]) def test_abs(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, -2.0, 3.0])) + a = _create_array([1.0, -2.0, 3.0]) np.testing.assert_allclose(_np(abs(a)), [1.0, 2.0, 3.0]) @@ -281,29 +286,29 @@ def test_abs(backend: tuple) -> None: def test_getitem_int(backend: tuple) -> None: - a = iop.from_numpy(np.array([10.0, 20.0, 30.0])) + a = _create_array([10.0, 20.0, 30.0]) np.testing.assert_allclose(_np(a[1]), 20.0) def test_getitem_slice(backend: tuple) -> None: - a = iop.from_numpy(np.array([10.0, 20.0, 30.0, 40.0])) + a = _create_array([10.0, 20.0, 30.0, 40.0]) np.testing.assert_allclose(_np(a[1:3]), [20.0, 30.0]) def test_getitem_tuple(backend: tuple) -> None: - a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + a = _create_array([[1.0, 2.0], [3.0, 4.0]]) np.testing.assert_allclose(_np(a[1, 0]), 3.0) def test_setitem_with_array(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - a[1] = iop.from_numpy(np.array(99.0)) + a = _create_array([1.0, 2.0, 3.0]) + a[1] = _create_array(99.0) np.testing.assert_allclose(_np(a), [1.0, 99.0, 3.0]) def test_setitem_with_scalar(backend: tuple) -> None: # __setitem__ wraps a non-Array value in Array internally. - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) a[2] = 99.0 np.testing.assert_allclose(_np(a), [1.0, 2.0, 99.0]) @@ -312,24 +317,24 @@ def test_setitem_with_scalar(backend: tuple) -> None: def test_len(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + a = _create_array([1.0, 2.0, 3.0, 4.0]) assert len(a) == 4 def test_float_coercion(backend: tuple) -> None: - a = iop.from_numpy(np.array(2.5)) + a = _create_array([2.5]) assert float(a) == pytest.approx(2.5) def test_repr(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) + a = _create_array([1.0, 2.0]) text = repr(a) assert text.startswith("Array(") assert text.endswith(")") def test_str(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) + a = _create_array([1.0, 2.0]) # ``str(arr)`` delegates to the wrapped value's stringifier; just check it succeeds # and is non-empty rather than pin per-backend formatting. assert isinstance(str(a), str) @@ -340,45 +345,45 @@ def test_str(backend: tuple) -> None: def test_shape(backend: tuple) -> None: - a = iop.from_numpy(np.zeros((2, 3, 4))) + a = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) assert a.shape == (2, 3, 4) def test_size(backend: tuple) -> None: - a = iop.from_numpy(np.zeros((2, 3, 4))) + a = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) assert a.size == 24 def test_ndim(backend: tuple) -> None: - a = iop.from_numpy(np.zeros((2, 3, 4))) + a = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) assert a.ndim == 3 def test_transpose_property(backend: tuple) -> None: - a = iop.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) + a = _create_array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) np.testing.assert_allclose(_np(a.transpose), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]) def test_T_alias(backend: tuple) -> None: - a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + a = _create_array([[1.0, 2.0], [3.0, 4.0]]) np.testing.assert_allclose(_np(a.T), _np(a.transpose)) def test_any_true(backend: tuple) -> None: - a = iop.from_numpy(np.array([0.0, 0.0, 1.0])) + a = _create_array([0.0, 0.0, 1.0]) assert a.any is True def test_any_false(backend: tuple) -> None: - a = iop.from_numpy(np.array([0.0, 0.0, 0.0])) + a = _create_array([0.0, 0.0, 0.0]) assert a.any is False def test_all_true(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = _create_array([1.0, 2.0, 3.0]) assert a.all is True def test_all_false(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 0.0, 3.0])) + a = _create_array([1.0, 0.0, 3.0]) assert a.all is False diff --git a/tests/test_decorators.py b/tests/test_decorators.py index 2a5e157..3c75137 100644 --- a/tests/test_decorators.py +++ b/tests/test_decorators.py @@ -38,7 +38,7 @@ def returns_array(self, x: Any) -> Any: seen.append(x) return x * 2 - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) result = Impl().returns_array(arr) # The decorator should have unwrapped the Array to its underlying value. assert not isinstance(seen[0], Array) @@ -57,7 +57,7 @@ def returns_float(self, x: Any) -> float: assert not isinstance(x, Array) return 42.0 - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) result = Impl().returns_float(arr) assert isinstance(result, float) assert result == 42.0 @@ -71,8 +71,8 @@ def takes_kwarg(self, x: Any, *, scale: Any) -> Any: assert not isinstance(scale, Array) return x * scale - arr = iop.from_numpy(np.array([1.0, 2.0])) - scale = iop.from_numpy(np.array([10.0, 100.0])) + arr = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) + scale = iop.from_numpy(np.array([10.0, 100.0], dtype=np.float32)) result = Impl().takes_kwarg(arr, scale=scale) assert isinstance(result, Array) np.testing.assert_allclose(iop.to_numpy(result), [10.0, 200.0]) @@ -85,7 +85,7 @@ def passes_through_non_array(self, x: Any, n: int) -> Any: assert isinstance(n, int) return x * n - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) result = Impl().passes_through_non_array(arr, 4) assert isinstance(result, Array) np.testing.assert_allclose(iop.to_numpy(result), [4.0, 8.0, 12.0]) @@ -99,7 +99,7 @@ class Impl(_Base): def returns_array(self, x: Any) -> Array: return Array(x * 3) - arr = iop.from_numpy(np.array([1.0, 2.0])) + arr = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) result = Impl().returns_array(arr) assert isinstance(result, Array) # If the wrapper double-wrapped, ``result.value`` would itself be an Array. diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py index c19e88a..117daac 100644 --- a/tests/test_iop_functions.py +++ b/tests/test_iop_functions.py @@ -24,7 +24,7 @@ def test_zeros(backend: tuple) -> None: def test_zeros_like(backend: tuple) -> None: - src = iop.from_numpy(np.ones((2, 3))) + src = iop.from_numpy(np.ones((2, 3), dtype=np.float32)) arr = iop.zeros_like(src) np.testing.assert_allclose(_np(arr), np.zeros((2, 3))) @@ -35,7 +35,7 @@ def test_ones(backend: tuple) -> None: def test_ones_like(backend: tuple) -> None: - src = iop.from_numpy(np.zeros((2, 3))) + src = iop.from_numpy(np.zeros((2, 3), dtype=np.float32)) arr = iop.ones_like(src) np.testing.assert_allclose(_np(arr), np.ones((2, 3))) @@ -46,7 +46,7 @@ def test_eye(backend: tuple) -> None: def test_eye_like(backend: tuple) -> None: - src = iop.from_numpy(np.zeros((4, 4))) + src = iop.from_numpy(np.zeros((4, 4), dtype=np.float32)) arr = iop.eye_like(src) np.testing.assert_allclose(_np(arr), np.eye(4)) @@ -68,7 +68,7 @@ def test_device_of(backend: tuple) -> None: def test_copy_independent(backend: tuple) -> None: - src = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + src = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) dst = iop.copy(src) np.testing.assert_allclose(_np(dst), [1.0, 2.0, 3.0]) # Mutating the copy shouldn't affect the original. @@ -77,33 +77,53 @@ def test_copy_independent(backend: tuple) -> None: def test_to_numpy(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) out = iop.to_numpy(arr) assert isinstance(out, np.ndarray) np.testing.assert_allclose(out, [1.0, 2.0, 3.0]) def test_from_numpy_roundtrip(backend: tuple) -> None: - raw = np.array([[1.0, 2.0], [3.0, 4.0]]) + raw = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32) arr = iop.from_numpy(raw) np.testing.assert_allclose(_np(arr), raw) +def test_from_numpy_like_matches_dtype(backend: tuple) -> None: + # ``like`` is int32 so the resulting Array should be int32 even though the + # source numpy array is float32. (Avoids float64, which torch MPS rejects.) + like = iop.from_numpy(np.array([0, 0], dtype=np.int32)) + raw = np.array([1.5, 2.5], dtype=np.float32) + arr = iop.from_numpy_like(raw, like) + out_np = _np(arr) + assert out_np.dtype == np.int32 + np.testing.assert_array_equal(out_np, [1, 2]) + + +def test_from_numpy_like_matches_device(backend: tuple) -> None: + # ``like`` lives on whichever device the active backend uses; the result of + # from_numpy_like must report the same device. + like = iop.from_numpy(np.array([0.0, 0.0], dtype=np.float32)) + raw = np.array([3.0, 4.0], dtype=np.float32) + arr = iop.from_numpy_like(raw, like) + assert iop.device_of(arr) == iop.device_of(like) + + def test_to_array_from_scalar(backend: tuple) -> None: arr = iop.to_array(2.5) np.testing.assert_allclose(_np(arr), 2.5) def test_stack(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) - b = iop.from_numpy(np.array([3.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) + b = iop.from_numpy(np.array([3.0, 4.0], dtype=np.float32)) arr = iop.stack([a, b]) np.testing.assert_allclose(_np(arr), [[1.0, 2.0], [3.0, 4.0]]) def test_stack_dim(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) - b = iop.from_numpy(np.array([3.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) + b = iop.from_numpy(np.array([3.0, 4.0], dtype=np.float32)) arr = iop.stack([a, b], axis=1) np.testing.assert_allclose(_np(arr), [[1.0, 3.0], [2.0, 4.0]]) @@ -120,7 +140,7 @@ def test_reshape(backend: tuple) -> None: def test_transpose_default(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])) + arr = iop.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)) np.testing.assert_allclose( _np(iop.transpose(arr)), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]] ) @@ -133,43 +153,43 @@ def test_transpose_explicit_dim(backend: tuple) -> None: def test_shape_function(backend: tuple) -> None: - arr = iop.from_numpy(np.zeros((2, 3, 4))) + arr = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) assert iop.shape(arr) == (2, 3, 4) def test_size_function(backend: tuple) -> None: - arr = iop.from_numpy(np.zeros((2, 3, 4))) + arr = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) assert iop.size(arr) == 24 def test_ndim_function(backend: tuple) -> None: - arr = iop.from_numpy(np.zeros((2, 3, 4))) + arr = iop.from_numpy(np.zeros((2, 3, 4), dtype=np.float32)) assert iop.ndim(arr) == 3 def test_squeeze_default(backend: tuple) -> None: - arr = iop.from_numpy(np.zeros((1, 3, 1))) + arr = iop.from_numpy(np.zeros((1, 3, 1), dtype=np.float32)) assert iop.shape(iop.squeeze(arr)) == (3,) def test_squeeze_specific_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.zeros((1, 3, 1))) + arr = iop.from_numpy(np.zeros((1, 3, 1), dtype=np.float32)) assert iop.shape(iop.squeeze(arr, axis=0)) == (3, 1) def test_unsqueeze(backend: tuple) -> None: - arr = iop.from_numpy(np.zeros((3,))) + arr = iop.from_numpy(np.zeros((3,), dtype=np.float32)) assert iop.shape(iop.unsqueeze(arr, axis=0)) == (1, 3) assert iop.shape(iop.unsqueeze(arr, axis=1)) == (3, 1) def test_diag_from_vector(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.diag(arr)), np.diag([1.0, 2.0, 3.0])) def test_diag_from_matrix(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.diag(arr)), [1.0, 4.0]) @@ -198,30 +218,30 @@ def test_astype_to_bool(backend: tuple) -> None: def test_dot(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([4.0, 5.0, 6.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([4.0, 5.0, 6.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.dot(a, b)), 32.0) def test_matmul(backend: tuple) -> None: - a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) - b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]])) - expected = np.array([[19.0, 22.0], [43.0, 50.0]]) + a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) + b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]], dtype=np.float32)) + expected = np.array([[19.0, 22.0], [43.0, 50.0]], dtype=np.float32) np.testing.assert_allclose(_np(iop.matmul(a, b)), expected) def test_norm_default_l2(backend: tuple) -> None: - arr = iop.from_numpy(np.array([3.0, 4.0])) + arr = iop.from_numpy(np.array([3.0, 4.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.norm(arr)), 5.0) def test_norm_p1(backend: tuple) -> None: - arr = iop.from_numpy(np.array([3.0, -4.0])) + arr = iop.from_numpy(np.array([3.0, -4.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.norm(arr, p=1)), 7.0) def test_norm_dim_keepdims(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]])) + arr = iop.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)) out = iop.norm(arr, p=2, axis=1, keepdims=True) assert iop.shape(out) == (2, 1) np.testing.assert_allclose(_np(out).reshape(-1), [5.0, 10.0]) @@ -231,68 +251,68 @@ def test_norm_dim_keepdims(backend: tuple) -> None: def test_sum_all(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.sum(arr)), 10.0) def test_sum_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.sum(arr, axis=0)), [4.0, 6.0]) def test_sum_dim_keepdims(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) out = iop.sum(arr, axis=0, keepdims=True) assert iop.shape(out) == (1, 2) def test_mean_all(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.mean(arr)), 2.5) def test_mean_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]])) + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.mean(arr, axis=1)), [1.5, 3.5]) def test_min_all(backend: tuple) -> None: - arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.min(arr)), 1.0) def test_min_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) + arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.min(arr, axis=0)), [1.0, 2.0]) def test_max_all(backend: tuple) -> None: - arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0])) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.max(arr)), 5.0) def test_max_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]])) + arr = iop.from_numpy(np.array([[1.0, 5.0], [3.0, 2.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.max(arr, axis=0)), [3.0, 5.0]) def test_any_true(backend: tuple) -> None: - arr = iop.from_numpy(np.array([0.0, 1.0, 0.0])) + arr = iop.from_numpy(np.array([0.0, 1.0, 0.0], dtype=np.float32)) assert iop.any(arr) is True def test_any_false(backend: tuple) -> None: - arr = iop.from_numpy(np.array([0.0, 0.0, 0.0])) + arr = iop.from_numpy(np.array([0.0, 0.0, 0.0], dtype=np.float32)) assert iop.any(arr) is False def test_all_true(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) assert iop.all(arr) is True def test_all_false(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 0.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 0.0, 3.0], dtype=np.float32)) assert iop.all(arr) is False @@ -300,36 +320,36 @@ def test_all_false(backend: tuple) -> None: def test_add_two_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) - b = iop.from_numpy(np.array([3.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) + b = iop.from_numpy(np.array([3.0, 4.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.add(a, b)), [4.0, 6.0]) def test_add_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.add(a, 10.0)), [11.0, 12.0]) def test_sub(backend: tuple) -> None: - a = iop.from_numpy(np.array([5.0, 6.0])) - b = iop.from_numpy(np.array([1.0, 2.0])) + a = iop.from_numpy(np.array([5.0, 6.0], dtype=np.float32)) + b = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.sub(a, b)), [4.0, 4.0]) def test_mul(backend: tuple) -> None: - a = iop.from_numpy(np.array([2.0, 3.0])) - b = iop.from_numpy(np.array([4.0, 5.0])) + a = iop.from_numpy(np.array([2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([4.0, 5.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.mul(a, b)), [8.0, 15.0]) def test_div(backend: tuple) -> None: - a = iop.from_numpy(np.array([8.0, 10.0])) - b = iop.from_numpy(np.array([2.0, 5.0])) + a = iop.from_numpy(np.array([8.0, 10.0], dtype=np.float32)) + b = iop.from_numpy(np.array([2.0, 5.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.div(a, b)), [4.0, 2.0]) def test_iadd_func(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) out = iop.iadd(a, 10.0) # Returned wrapper is the same instance. assert out is a @@ -337,43 +357,43 @@ def test_iadd_func(backend: tuple) -> None: def test_isub_func(backend: tuple) -> None: - a = iop.from_numpy(np.array([5.0, 6.0])) + a = iop.from_numpy(np.array([5.0, 6.0], dtype=np.float32)) out = iop.isub(a, 1.0) assert out is a np.testing.assert_allclose(_np(a), [4.0, 5.0]) def test_imul_func(backend: tuple) -> None: - a = iop.from_numpy(np.array([2.0, 3.0])) + a = iop.from_numpy(np.array([2.0, 3.0], dtype=np.float32)) out = iop.imul(a, 4.0) assert out is a np.testing.assert_allclose(_np(a), [8.0, 12.0]) def test_idiv_func(backend: tuple) -> None: - a = iop.from_numpy(np.array([8.0, 12.0])) + a = iop.from_numpy(np.array([8.0, 12.0], dtype=np.float32)) out = iop.idiv(a, 4.0) assert out is a np.testing.assert_allclose(_np(a), [2.0, 3.0]) def test_pow_function(backend: tuple) -> None: - arr = iop.from_numpy(np.array([2.0, 3.0, 4.0])) + arr = iop.from_numpy(np.array([2.0, 3.0, 4.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.pow(arr, 2)), [4.0, 9.0, 16.0]) def test_negative(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, -2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, -2.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.negative(arr)), [-1.0, 2.0, -3.0]) def test_absolute(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, -2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, -2.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.absolute(arr)), [1.0, 2.0, 3.0]) def test_sqrt(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 4.0, 9.0])) + arr = iop.from_numpy(np.array([1.0, 4.0, 9.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.sqrt(arr)), [1.0, 2.0, 3.0]) @@ -381,18 +401,18 @@ def test_sqrt(backend: tuple) -> None: def test_sign(backend: tuple) -> None: - arr = iop.from_numpy(np.array([-2.0, 0.0, 3.0])) + arr = iop.from_numpy(np.array([-2.0, 0.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.sign(arr)), [-1.0, 0.0, 1.0]) def test_maximum_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 5.0, 3.0])) - b = iop.from_numpy(np.array([4.0, 2.0, 6.0])) + a = iop.from_numpy(np.array([1.0, 5.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([4.0, 2.0, 6.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.maximum(a, b)), [4.0, 5.0, 6.0]) def test_maximum_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 5.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.maximum(a, 4.0)), [4.0, 5.0, 4.0]) @@ -400,68 +420,68 @@ def test_maximum_array_and_scalar(backend: tuple) -> None: def test_eq_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([1.0, 5.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.eq(a, b)), [True, False, True]) def test_eq_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.eq(a, 2.0)), [False, True, False]) def test_ne_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([1.0, 5.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([1.0, 5.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.ne(a, b)), [False, True, False]) def test_ne_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.ne(a, 2.0)), [True, False, True]) def test_lt_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.lt(a, b)), [True, False, False]) def test_lt_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.lt(a, 2.5)), [True, True, False]) def test_le_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.le(a, b)), [True, True, False]) def test_le_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.le(a, 2.0)), [True, True, False]) def test_gt_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.gt(a, b)), [False, False, True]) def test_gt_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.gt(a, 1.5)), [False, True, True]) def test_ge_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - b = iop.from_numpy(np.array([2.0, 2.0, 2.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.ge(a, b)), [False, True, True]) def test_ge_array_and_scalar(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_array_equal(_np(iop.ge(a, 2.0)), [False, True, True]) @@ -469,7 +489,7 @@ def test_ge_array_and_scalar(backend: tuple) -> None: def test_bitwise_and_bool_arrays(backend: tuple) -> None: - a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0])) + a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)) mask1 = iop.gt(a, 1.0) mask2 = iop.lt(a, 4.0) np.testing.assert_array_equal(_np(iop.bitwise_and(mask1, mask2)), [False, True, True, False]) @@ -484,40 +504,40 @@ def test_bitwise_and_int_arrays(backend: tuple) -> None: def test_argmax_default(backend: tuple) -> None: - arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.argmax(arr)), 5) def test_argmax_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.argmax(arr, axis=1)), [1, 0]) def test_argmin_default(backend: tuple) -> None: - arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0])) + arr = iop.from_numpy(np.array([3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0], dtype=np.float32)) # First occurrence of minimum is index 1. np.testing.assert_allclose(_np(iop.argmin(arr)), 1) def test_argmin_dim(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]], dtype=np.float32)) np.testing.assert_allclose(_np(iop.argmin(arr, axis=1)), [0, 1]) def test_argmax_keepdims(backend: tuple) -> None: - arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]])) + arr = iop.from_numpy(np.array([[1.0, 5.0, 2.0], [4.0, 0.0, 3.0]], dtype=np.float32)) out = iop.argmax(arr, axis=1, keepdims=True) assert iop.shape(out) == (2, 1) def test_set_item_function(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) - iop.set_item(arr, 0, iop.from_numpy(np.array(99.0))) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + iop.set_item(arr, 0, iop.from_numpy(np.array(99.0, dtype=np.float32))) np.testing.assert_allclose(_np(arr), [99.0, 2.0, 3.0]) def test_get_item_function(backend: tuple) -> None: - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0])) + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.get_item(arr, 1)), 2.0) diff --git a/tests/test_iop_rng.py b/tests/test_iop_rng.py index f941e04..b36c340 100644 --- a/tests/test_iop_rng.py +++ b/tests/test_iop_rng.py @@ -60,6 +60,10 @@ def test_get_seed_initially_none(backend: tuple) -> None: # Fresh activation via the fixture: nothing has called set_seed yet on this # coordinator instance, but the coordinator is process-singleton and may have # state from earlier tests. Call set_seed/then-clear to assert via reseed instead. + from decent_array.interoperability._iop.rng import _reset_rng # noqa: PLC0415, PLC2701 + + _reset_rng() + assert iop.get_seed() is None iop.set_seed(0) assert iop.get_seed() == 0 From 609b939c792ca9d690b547be30bc2aaf6ed62394 Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 10 May 2026 21:33:50 +0200 Subject: [PATCH 08/11] fix(tests): Fix float64 error on MPS for torch --- tests/test_iop_rng.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/test_iop_rng.py b/tests/test_iop_rng.py index b36c340..10bca67 100644 --- a/tests/test_iop_rng.py +++ b/tests/test_iop_rng.py @@ -147,13 +147,13 @@ def test_uniform_custom_range(backend: tuple) -> None: def test_normal_like(backend: tuple) -> None: - src = iop.from_numpy(np.zeros((3, 4))) + src = iop.from_numpy(np.zeros((3, 4), dtype=np.float32)) arr = iop.normal_like(src) assert iop.shape(arr) == (3, 4) def test_uniform_like(backend: tuple) -> None: - src = iop.from_numpy(np.zeros((3, 4))) + src = iop.from_numpy(np.zeros((3, 4), dtype=np.float32)) arr = iop.uniform_like(src, low=0.0, high=1.0) assert iop.shape(arr) == (3, 4) samples = _np(arr) @@ -163,14 +163,14 @@ def test_uniform_like(backend: tuple) -> None: def test_choice_shape(backend: tuple) -> None: iop.set_seed(1) - population = iop.from_numpy(np.array([10.0, 20.0, 30.0, 40.0, 50.0])) + population = iop.from_numpy(np.array([10.0, 20.0, 30.0, 40.0, 50.0], dtype=np.float32)) sample = iop.choice(population, size=3) assert iop.shape(sample) == (3,) def test_choice_values_in_population(backend: tuple) -> None: iop.set_seed(1) - pop_np = np.array([10.0, 20.0, 30.0, 40.0, 50.0]) + pop_np = np.array([10.0, 20.0, 30.0, 40.0, 50.0], dtype=np.float32) sample = iop.choice(iop.from_numpy(pop_np), size=10) drawn = _np(sample).reshape(-1) assert all(v in pop_np for v in drawn) From 8d779163e2da6b32cee8e5b9817bbc04cdce704e Mon Sep 17 00:00:00 2001 From: simpag Date: Sun, 24 May 2026 21:11:45 +0200 Subject: [PATCH 09/11] PR comments --- .gitignore | 4 +- benchmarks/bench_iop.py | 2 +- benchmarks/profile_hotpath.py | 4 +- decent_array/_array.py | 75 +-- decent_array/interoperability/__init__.py | 95 ++-- .../interoperability/_abstracts/backend.py | 178 ++++--- .../interoperability/_backend_manager.py | 50 +- decent_array/interoperability/_decorators.py | 58 --- .../interoperability/_iop/bit_operators.py | 40 ++ .../interoperability/_iop/comparasion.py | 75 +++ .../interoperability/_iop/creation.py | 68 +++ .../interoperability/_iop/functions.py | 480 ------------------ decent_array/interoperability/_iop/linalg.py | 65 +++ .../interoperability/_iop/manipulations.py | 149 ++++++ decent_array/interoperability/_iop/math.py | 128 +++++ .../interoperability/_iop/operators.py | 61 +++ .../interoperability/_iop/reductions.py | 91 ++++ decent_array/interoperability/_iop/rng.py | 39 +- decent_array/interoperability/_iop/utils.py | 62 +++ .../interoperability/_jax/jax_backend.py | 264 +++++----- .../interoperability/_numpy/numpy_backend.py | 263 +++++----- .../_pytorch/pytorch_backend.py | 263 +++++----- .../_tensorflow/tensorflow_backend.py | 268 +++++----- decent_array/types.py | 27 +- docs/source/api/decent_array.rst | 9 +- docs/source/author.rst | 4 +- docs/source/background.rst | 3 - docs/source/conf.py | 24 - docs/source/developer.rst | 9 +- docs/source/index.rst | 1 - docs/source/user.rst | 2 - pyproject.toml | 20 +- tests/test_array.py | 32 ++ tests/test_backend_manager.py | 15 + tests/test_decorators.py | 107 ---- tests/test_iop_functions.py | 122 +++-- tests/test_iop_rng.py | 17 + 37 files changed, 1700 insertions(+), 1474 deletions(-) delete mode 100644 decent_array/interoperability/_decorators.py create mode 100644 decent_array/interoperability/_iop/bit_operators.py create mode 100644 decent_array/interoperability/_iop/comparasion.py create mode 100644 decent_array/interoperability/_iop/creation.py delete mode 100644 decent_array/interoperability/_iop/functions.py create mode 100644 decent_array/interoperability/_iop/linalg.py create mode 100644 decent_array/interoperability/_iop/manipulations.py create mode 100644 decent_array/interoperability/_iop/math.py create mode 100644 decent_array/interoperability/_iop/operators.py create mode 100644 decent_array/interoperability/_iop/reductions.py create mode 100644 decent_array/interoperability/_iop/utils.py delete mode 100644 docs/source/background.rst delete mode 100644 tests/test_decorators.py diff --git a/.gitignore b/.gitignore index db3da45..bc4b1e5 100644 --- a/.gitignore +++ b/.gitignore @@ -8,4 +8,6 @@ .vscode dist pyrightconfig.json -.claude \ No newline at end of file +.claude +*.py[codz] +*$py.class \ No newline at end of file diff --git a/benchmarks/bench_iop.py b/benchmarks/bench_iop.py index 5127b0a..fa8b6b3 100644 --- a/benchmarks/bench_iop.py +++ b/benchmarks/bench_iop.py @@ -108,7 +108,7 @@ def _bench_case(case: BackendCase) -> None: print_size_header(n) rows = ( ("add", lambda a=a, b=b: native["add"](a, b), lambda d_a=d_a, d_b=d_b: iop.add(d_a, d_b)), - ("mul", lambda a=a, b=b: native["mul"](a, b), lambda d_a=d_a, d_b=d_b: iop.mul(d_a, d_b)), + ("mul", lambda a=a, b=b: native["mul"](a, b), lambda d_a=d_a, d_b=d_b: iop.multiply(d_a, d_b)), ("dot", lambda a=a, b=b: native["dot"](a, b), lambda d_a=d_a, d_b=d_b: iop.dot(d_a, d_b)), ("sum", lambda a=a: native["sum"](a), lambda d_a=d_a: iop.sum(d_a)), ("mean", lambda a=a: native["mean"](a), lambda d_a=d_a: iop.mean(d_a)), diff --git a/benchmarks/profile_hotpath.py b/benchmarks/profile_hotpath.py index 588e494..9d53477 100644 --- a/benchmarks/profile_hotpath.py +++ b/benchmarks/profile_hotpath.py @@ -58,9 +58,9 @@ def hot_loop(a: Array, b: Array, iterations: int) -> None: _ = a**2.0 # Function surface (iop dispatch) _ = iop.add(a, b) - _ = iop.mul(a, b) + _ = iop.multiply(a, b) _ = iop.sum(a) - _ = iop.norm(a) + _ = iop.vector_norm(a) _ = iop.dot(a, b) _ = iop.sqrt(a) diff --git a/decent_array/_array.py b/decent_array/_array.py index 9c554f5..3bb29ba 100644 --- a/decent_array/_array.py +++ b/decent_array/_array.py @@ -7,9 +7,7 @@ directly to the active backend without per-call isinstance dispatch. Operator contract is *strict*: binary arithmetic and indexing accept either another -:class:`Array` or a Python scalar (``int``/``float``). Pass other framework-native -arrays through :func:`decent_array.interoperability.get_item` and friends, not through the -operator path. +:class:`Array` or a Python scalar (``int``/``float``). Hot-path notes: @@ -17,8 +15,8 @@ ``__neg__``/``__abs__``/``__pow__``, the comparisons ``__eq__``/``__ne__``/``__lt__``/ ``__le__``/``__gt__``/``__ge__`` and the bitwise ``__and__``/``__rand__`` are inlined: every supported framework's tensor implements the equivalent operator - natively with numpy-equivalent semantics, so routing through the backend saves - nothing. + natively with numpy-equivalent semantics, so routing through the interoperability layer + introduces unnecessary overhead. * Operators that *do* go through the backend (in-place math, indexing, properties like ``shape``/``transpose``) read the cached ``_backend`` slot. * Overriding ``__eq__`` makes :class:`Array` unhashable (Python clears ``__hash__`` @@ -34,7 +32,7 @@ if TYPE_CHECKING: from decent_array.interoperability._abstracts import Backend - from decent_array.types import ArrayKey, SupportedArrayTypes + from decent_array.types import ArrayKey, SupportedArrayTypes, SupportedDevices _BACKEND_INSTANCE: Backend | None = None @@ -87,52 +85,52 @@ def __init__(self, value: SupportedArrayTypes) -> None: # Binary arithmetic ---------------------------------------------------- - def __add__(self, other: Array | float) -> Array: + def __add__(self, other: int | float | complex | Array, /) -> Array: """Return the sum of the array and another array or a scalar.""" return Array(self.value + (other.value if type(other) is Array else other)) - def __radd__(self, other: float) -> Array: + def __radd__(self, other: int | float | complex | Array, /) -> Array: """Return the sum of the array and a scalar.""" return Array(other + self.value) - def __sub__(self, other: Array | float) -> Array: + def __sub__(self, other: int | float | complex | Array, /) -> Array: """Return the subtraction of another array or a scalar from the array.""" return Array(self.value - (other.value if type(other) is Array else other)) - def __rsub__(self, other: float) -> Array: + def __rsub__(self, other: int | float | complex | Array, /) -> Array: """Return the subtraction of the array from a scalar.""" return Array(other - self.value) - def __mul__(self, other: Array | float) -> Array: + def __mul__(self, other: int | float | complex | Array, /) -> Array: """Return the product of the array and another array or a scalar.""" return Array(self.value * (other.value if type(other) is Array else other)) - def __rmul__(self, other: float) -> Array: + def __rmul__(self, other: int | float | complex | Array, /) -> Array: """Return the product of the array and a scalar.""" return Array(other * self.value) - def __truediv__(self, other: Array | float) -> Array: + def __truediv__(self, other: int | float | complex | Array, /) -> Array: """Return the true division of the array by ``other``.""" return Array(self.value / (other.value if type(other) is Array else other)) - def __rtruediv__(self, other: float) -> Array: + def __rtruediv__(self, other: int | float | complex | Array, /) -> Array: """Return the true division of ``other`` by the array.""" return Array(other / self.value) - def __matmul__(self, other: Array) -> Array: + def __matmul__(self, other: Array, /) -> Array: """Return the matrix multiplication of the array with ``other``.""" return Array(self.value @ other.value) - def __rmatmul__(self, other: Array) -> Array: + def __rmatmul__(self, other: Array, /) -> Array: """Return the matrix multiplication of ``other`` with the array.""" return Array(other.value @ self.value) - def __pow__(self, other: float) -> Array: + def __pow__(self, other: int | float | complex | Array, /) -> Array: """Exponentiate the array by a scalar power.""" # numpy/torch/jax/tf all implement ``tensor ** p`` with semantics matching the # backend's ``pow``; routing through the backend would cost an extra method # call for no behavioral difference. - return Array(self.value**other) + return Array(self.value ** (other.value if type(other) is Array else other)) # Comparisons ---------------------------------------------------------- # @@ -147,27 +145,27 @@ def __pow__(self, other: float) -> Array: __hash__ = None # type: ignore[assignment] - def __eq__(self, other: object) -> Array: # type: ignore[override] + def __eq__(self, other: bool | int | float | complex | Array, /) -> Array: # type: ignore[override] """Element-wise equality.""" return Array(self.value == (other.value if type(other) is Array else other)) - def __ne__(self, other: object) -> Array: # type: ignore[override] + def __ne__(self, other: bool | int | float | complex | Array, /) -> Array: # type: ignore[override] """Element-wise inequality.""" return Array(self.value != (other.value if type(other) is Array else other)) - def __lt__(self, other: Array | float) -> Array: + def __lt__(self, other: int | float | Array, /) -> Array: """Element-wise less-than.""" return Array(self.value < (other.value if type(other) is Array else other)) - def __le__(self, other: Array | float) -> Array: + def __le__(self, other: int | float | Array, /) -> Array: """Element-wise less-than-or-equal.""" return Array(self.value <= (other.value if type(other) is Array else other)) - def __gt__(self, other: Array | float) -> Array: + def __gt__(self, other: int | float | Array, /) -> Array: """Element-wise greater-than.""" return Array(self.value > (other.value if type(other) is Array else other)) - def __ge__(self, other: Array | float) -> Array: + def __ge__(self, other: int | float | Array, /) -> Array: """Element-wise greater-than-or-equal.""" return Array(self.value >= (other.value if type(other) is Array else other)) @@ -181,11 +179,11 @@ def __ge__(self, other: Array | float) -> Array: # which fails TF's ``1 & bool_tensor`` rejection. Native operator semantics on # the wrapped tensor enforce the actual dtype contract. - def __and__(self, other: Array | int) -> Array: + def __and__(self, other: bool | int | Array, /) -> Array: """Element-wise bitwise/logical AND.""" return Array(self.value & (other.value if type(other) is Array else other)) - def __rand__(self, other: Any) -> Array: # noqa: ANN401 + def __rand__(self, other: bool | int | Array, /) -> Array: """Element-wise bitwise/logical AND with the array on the right.""" return Array(other & self.value) @@ -195,24 +193,24 @@ def __rand__(self, other: Any) -> Array: # noqa: ANN401 # `value` in place, jax/tensorflow rebind it. In every case the returned object is # the same wrapper instance, so we just discard the return and yield ``self``. - def __iadd__(self, other: Array | float) -> Self: + def __iadd__(self, other: int | float | complex | Array, /) -> Self: """In-place addition.""" self._backend.iadd(self, other) return self - def __isub__(self, other: Array | float) -> Self: + def __isub__(self, other: int | float | complex | Array, /) -> Self: """In-place subtraction.""" - self._backend.isub(self, other) + self._backend.isubtract(self, other) return self - def __imul__(self, other: Array | float) -> Self: + def __imul__(self, other: int | float | complex | Array, /) -> Self: """In-place multiplication.""" - self._backend.imul(self, other) + self._backend.imultiply(self, other) return self - def __itruediv__(self, other: Array | float) -> Self: + def __itruediv__(self, other: int | float | complex | Array, /) -> Self: """In-place true division.""" - self._backend.idiv(self, other) + self._backend.idivide(self, other) return self # Unary ---------------------------------------------------------------- @@ -231,11 +229,11 @@ def __abs__(self) -> Array: # Indexing ------------------------------------------------------------- - def __getitem__(self, key: ArrayKey) -> Array: + def __getitem__(self, key: ArrayKey, /) -> Array: """Return the item at ``key``.""" return self._backend.get_item(self, key) - def __setitem__(self, key: ArrayKey, value: Array | float) -> None: + def __setitem__(self, key: ArrayKey, value: bool | int | float | complex | Array, /) -> None: """Set the item at ``key`` to ``value``.""" if not isinstance(value, Array): value = Array(value) @@ -251,7 +249,7 @@ def __len__(self) -> int: def __float__(self) -> float: """Coerce a scalar array to a Python float.""" - return float(self._backend.astype(self, float)) + return float(self._backend.squeeze(self).value) # Repr ----------------------------------------------------------------- @@ -299,3 +297,8 @@ def any(self) -> bool: def all(self) -> bool: """Return True if all elements of the array are truthy.""" return self._backend.all(self) + + @property + def device(self) -> SupportedDevices: + """Return the device of the array.""" + return self._backend.device_of(self) diff --git a/decent_array/interoperability/__init__.py b/decent_array/interoperability/__init__.py index a1b96ed..e27b0b0 100644 --- a/decent_array/interoperability/__init__.py +++ b/decent_array/interoperability/__init__.py @@ -12,70 +12,36 @@ """ -from ._backend_manager import set_backend -from ._decorators import autodecorate_cost_method -from ._iop.functions import ( - absolute, - add, - all, # noqa: A004 - any, # noqa: A004 - argmax, - argmin, +from ._backend_manager import default_device, set_backend +from ._iop.bit_operators import bitwise_and +from ._iop.comparasion import equal, greater, greater_equal, less, less_equal, not_equal +from ._iop.creation import eye, ones, ones_like, zeros, zeros_like +from ._iop.linalg import dot, matmul, vecdot, vector_norm +from ._iop.manipulations import ( + asarray, astype, - bitwise_and, copy, - device_of, - device_to_native, diag, - div, - dot, - eq, - eye, - eye_like, + expand_dims, from_numpy, from_numpy_like, - ge, - get_item, - gt, - iadd, - idiv, - imul, - isub, - le, - lt, - matmul, - max, # noqa: A004 - maximum, - mean, - min, # noqa: A004 - mul, ndim, - ne, - negative, - norm, - ones, - ones_like, - pow, # noqa: A004 reshape, - set_item, shape, - sign, size, - sqrt, squeeze, stack, - sub, - sum, # noqa: A004 - to_array, to_numpy, transpose, unsqueeze, - zeros, - zeros_like, ) +from ._iop.math import abs, absolute, add, divide, multiply, negative, pow, sqrt, subtract # noqa: A004 +from ._iop.operators import argmax, argmin, maximum, sign +from ._iop.reductions import all, any, max, mean, min, sum # noqa: A004 from ._iop.rng import ( choice, derive_seed, + get_numpy_rng, get_rng_state, get_seed, normal, @@ -85,59 +51,55 @@ uniform, uniform_like, ) +from ._iop.utils import device_of __all__ = [ + "abs", "absolute", "add", "all", "any", "argmax", "argmin", + "asarray", "astype", - "autodecorate_cost_method", "bitwise_and", "choice", "copy", + "default_device", "derive_seed", "device_of", - "device_to_native", "diag", - "div", + "divide", "dot", - "eq", + "equal", + "expand_dims", "eye", - "eye_like", "from_numpy", "from_numpy_like", - "ge", - "get_item", + "get_numpy_rng", "get_rng_state", "get_seed", - "gt", - "iadd", - "idiv", - "imul", - "isub", - "le", - "lt", + "greater", + "greater_equal", + "less", + "less_equal", "matmul", "max", "maximum", "mean", "min", - "mul", + "multiply", "ndim", - "ne", "negative", - "norm", "normal", "normal_like", + "not_equal", "ones", "ones_like", "pow", "reshape", "set_backend", - "set_item", "set_rng_state", "set_seed", "shape", @@ -146,14 +108,15 @@ "sqrt", "squeeze", "stack", - "sub", + "subtract", "sum", - "to_array", "to_numpy", "transpose", "uniform", "uniform_like", "unsqueeze", + "vecdot", + "vector_norm", "zeros", "zeros_like", ] diff --git a/decent_array/interoperability/_abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py index 72b0b5e..2337b4f 100644 --- a/decent_array/interoperability/_abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -1,11 +1,11 @@ """ Abstract :class:`Backend` contract. -All abstract methods live in this single class rather than across six mixin ABCs. The -flat layout is mypyc-compatible: when this module is included in the same compilation -group as the concrete backends, ``_BACKEND.add(self, other)`` becomes a native -compiled-to-compiled call (no Python attribute lookup, no bound-method allocation), -which removes the need for a ``raw_ops`` escape hatch on the hot path. +All abstract methods live in this single class. The flat layout is mypyc-compatible: +when this module is included in the same compilation group as the concrete backends, +``_BACKEND.add(self, other)`` becomes a native compiled-to-compiled call (no Python +attribute lookup, no bound-method allocation), which removes the need for a ``raw_ops`` +escape hatch on the hot path. Section dividers in this file group related operations the way the legacy split files did (creation, manipulation, linalg, math, operators, RNG); the only thing that @@ -24,7 +24,7 @@ from numpy.typing import NDArray from decent_array import Array - from decent_array.types import ArrayKey + from decent_array.types import ArrayKey, DTypes, SupportedArrayTypes class Backend(ABC): # noqa: PLR0904 @@ -41,57 +41,53 @@ def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: # Array creation ------------------------------------------------------ @abstractmethod - def zeros(self, shape: tuple[int, ...]) -> Array: + def zeros(self, shape: int | tuple[int, ...]) -> Array: """Create an array of zeros with the given shape.""" @abstractmethod - def zeros_like(self, array: Array) -> Array: - """Create an array of zeros matching the shape and type of ``array``.""" + def zeros_like(self, x: Array) -> Array: + """Create an array of zeros matching the shape and type of ``x``.""" @abstractmethod - def ones(self, shape: tuple[int, ...]) -> Array: + def ones(self, shape: int | tuple[int, ...]) -> Array: """Create an array of ones with the given shape.""" @abstractmethod - def ones_like(self, array: Array) -> Array: - """Create an array of ones matching the shape and type of ``array``.""" + def ones_like(self, x: Array) -> Array: + """Create an array of ones matching the shape and type of ``x``.""" @abstractmethod def eye(self, n: int) -> Array: """Create an ``n x n`` identity matrix.""" - @abstractmethod - def eye_like(self, array: Array) -> Array: - """Create an identity matrix matching the trailing two dims of ``array``.""" - @abstractmethod def device_to_native(self, device: SupportedDevices) -> Any: # noqa: ANN401 """Convert :class:`SupportedDevices` to the backend's native device representation.""" @abstractmethod - def device_of(self, array: Array) -> SupportedDevices: + def device_of(self, x: Array) -> SupportedDevices: """Return the :class:`SupportedDevices` of the given array.""" # Array manipulation -------------------------------------------------- @abstractmethod - def copy(self, array: Array) -> Array: - """Return a copy of ``array``.""" + def copy(self, x: Array) -> Array: + """Return a copy of ``x``.""" @abstractmethod - def to_numpy(self, array: Array) -> NDArray[Any]: - """Convert ``array`` to a NumPy array on the CPU.""" + def to_numpy(self, x: SupportedArrayTypes | Array) -> NDArray[Any]: + """Convert ``x`` to a NumPy array on the CPU.""" @abstractmethod - def from_numpy(self, array: NDArray[Any]) -> Array: + def from_numpy(self, x: NDArray[Any]) -> Array: """Convert a NumPy array on the CPU to an :class:`Array` on this backend.""" @abstractmethod - def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + def from_numpy_like(self, x: NDArray[Any], like: Array) -> Array: """Convert a Numpy array to an :class:`Array` on this backend, matching shape and type of ``like``.""" @abstractmethod - def to_array(self, array: float | bool) -> Array: + def asarray(self, x: bool | int | float | complex) -> Array: """Convert a Python scalar to an :class:`Array` on this backend.""" @abstractmethod @@ -99,163 +95,163 @@ def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: """Stack a sequence of arrays along a new dimension.""" @abstractmethod - def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: - """Reshape ``array`` to ``shape``.""" + def reshape(self, x: Array, shape: tuple[int, ...]) -> Array: + """Reshape ``x`` to ``shape``.""" @abstractmethod - def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: - """Transpose ``array``; ``None`` reverses the dimensions.""" + def transpose(self, x: Array, axis: tuple[int, ...] | None = None) -> Array: + """Transpose ``x``; ``None`` reverses the dimensions.""" @abstractmethod - def shape(self, array: Array) -> tuple[int, ...]: - """Return the shape of ``array``.""" + def shape(self, x: Array) -> tuple[int, ...]: + """Return the shape of ``x``.""" @abstractmethod - def size(self, array: Array) -> int: - """Return the total number of elements in ``array``.""" + def size(self, x: Array) -> int: + """Return the total number of elements in ``x``.""" @abstractmethod - def ndim(self, array: Array) -> int: - """Return the number of dimensions of ``array``.""" + def ndim(self, x: Array) -> int: + """Return the number of dimensions of ``x``.""" @abstractmethod - def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: - """Remove single-dimensional entries from ``array``.""" + def squeeze(self, x: Array, axis: int | tuple[int, ...] | None = None) -> Array: + """Remove single-dimensional entries from ``x``.""" @abstractmethod - def unsqueeze(self, array: Array, axis: int) -> Array: + def unsqueeze(self, x: Array, axis: int) -> Array: """Insert a singleton dimension at ``axis``.""" @abstractmethod - def diag(self, array: Array) -> Array: + def diag(self, x: Array) -> Array: """Diagonal: build from a vector or extract from a matrix.""" @abstractmethod - def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: - """Cast a single-element ``array`` to a Python scalar of ``dtype``.""" + def astype(self, x: Array, dtype: DTypes) -> Array: + """Cast ``x`` to a different dtype.""" # Linalg -------------------------------------------------------------- @abstractmethod - def dot(self, array1: Array, array2: Array) -> Array: + def dot(self, x1: Array, x2: Array) -> Array: """Dot product of two arrays.""" @abstractmethod - def matmul(self, array1: Array, array2: Array) -> Array: + def matmul(self, x1: Array, x2: Array) -> Array: """Matrix multiplication of two arrays.""" @abstractmethod - def norm( + def vector_norm( self, - array: Array, + x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - """Compute the norm of ``array``.""" + """Compute the norm of ``x``.""" # Math reductions ----------------------------------------------------- @abstractmethod - def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Sum elements of ``array`` along ``axis``.""" + def sum(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Sum elements of ``x`` along ``axis``.""" @abstractmethod - def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Mean of ``array`` along ``axis``.""" + def mean(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Mean of ``x`` along ``axis``.""" @abstractmethod - def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Minimum of ``array`` along ``axis``.""" + def min(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Minimum of ``x`` along ``axis``.""" @abstractmethod - def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - """Maximum of ``array`` along ``axis``.""" + def max(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Maximum of ``x`` along ``axis``.""" @abstractmethod - def any(self, array: Array) -> bool: - """Return True if any element of ``array`` is truthy.""" + def any(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + """Return True if any element of ``x`` is truthy.""" @abstractmethod - def all(self, array: Array) -> bool: - """Return True if all elements of ``array`` are truthy.""" + def all(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + """Return True if all elements of ``x`` are truthy.""" # Math elementwise — both operands may be Array or scalar (operator dunders pass # either). ``Array | float`` covers both because PEP 484's numeric tower implicitly # admits ``int``. @abstractmethod - def add(self, array1: Array | float, array2: Array | float) -> Array: + def add(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise addition.""" @abstractmethod - def iadd[T: Array](self, array1: T, array2: Array | float) -> T: + def iadd[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: """In-place element-wise addition.""" @abstractmethod - def sub(self, array1: Array | float, array2: Array | float) -> Array: + def subtract(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise subtraction.""" @abstractmethod - def isub[T: Array](self, array1: T, array2: Array | float) -> T: + def isubtract[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: """In-place element-wise subtraction.""" @abstractmethod - def mul(self, array1: Array | float, array2: Array | float) -> Array: + def multiply(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise multiplication.""" @abstractmethod - def imul[T: Array](self, array1: T, array2: Array | float) -> T: + def imultiply[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: """In-place element-wise multiplication.""" @abstractmethod - def div(self, array1: Array | float, array2: Array | float) -> Array: + def divide(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise division.""" @abstractmethod - def idiv[T: Array](self, array1: T, array2: Array | float) -> T: + def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: """In-place element-wise division.""" @abstractmethod - def pow(self, array: Array, p: float) -> Array: - """Raise ``array`` to power ``p``.""" + def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: + """Raise ``x`` to power ``p``.""" @abstractmethod - def negative(self, array: Array) -> Array: + def negative(self, x: Array) -> Array: """Element-wise negation.""" @abstractmethod - def absolute(self, array: Array) -> Array: + def absolute(self, x: Array) -> Array: """Element-wise absolute value.""" @abstractmethod - def sqrt(self, array: Array) -> Array: + def sqrt(self, x: Array) -> Array: """Element-wise square root.""" # Comparisons — both operands may be Array or scalar. @abstractmethod - def eq(self, array1: Array | float, array2: Array | float) -> Array: + def equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise equality. Returns an :class:`Array` of bools.""" @abstractmethod - def ne(self, array1: Array | float, array2: Array | float) -> Array: + def not_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise inequality. Returns an :class:`Array` of bools.""" @abstractmethod - def lt(self, array1: Array | float, array2: Array | float) -> Array: + def less(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise less-than. Returns an :class:`Array` of bools.""" @abstractmethod - def le(self, array1: Array | float, array2: Array | float) -> Array: + def less_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise less-than-or-equal. Returns an :class:`Array` of bools.""" @abstractmethod - def gt(self, array1: Array | float, array2: Array | float) -> Array: + def greater(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise greater-than. Returns an :class:`Array` of bools.""" @abstractmethod - def ge(self, array1: Array | float, array2: Array | float) -> Array: + def greater_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: """Element-wise greater-than-or-equal. Returns an :class:`Array` of bools.""" # Bitwise — operands may be int/bool arrays or scalars. Mirrors Python's ``&``, @@ -263,34 +259,34 @@ def ge(self, array1: Array | float, array2: Array | float) -> Array: # tensors in every supported framework. @abstractmethod - def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: + def bitwise_and(self, x1: bool | int | Array, x2: bool | int | Array) -> Array: """Element-wise bitwise/logical AND.""" # Operators ----------------------------------------------------------- @abstractmethod - def sign(self, array: Array) -> Array: + def sign(self, x: Array) -> Array: """Element-wise sign.""" @abstractmethod - def maximum(self, array1: Array | float, array2: Array | float) -> Array: + def maximum(self, x1: int | float | Array, x2: int | float | Array) -> Array: """Element-wise maximum.""" @abstractmethod - def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: """Index of maximum value along ``axis``.""" @abstractmethod - def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: + def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: """Index of minimum value along ``axis``.""" @abstractmethod - def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: - """Set ``array[key] = value``.""" + def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: + """Set ``x[key] = value``.""" @abstractmethod - def get_item(self, array: Array, key: ArrayKey) -> Array: - """Return ``array[key]``.""" + def get_item(self, x: Array, key: ArrayKey) -> Array: + """Return ``x[key]``.""" # RNG ----------------------------------------------------------------- @@ -315,13 +311,13 @@ def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = """Draw uniformly distributed samples from ``[low, high)``.""" @abstractmethod - def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: - """Draw normally distributed samples shaped like ``array``.""" + def normal_like(self, x: Array, mean: float = 0.0, std: float = 1.0) -> Array: + """Draw normally distributed samples shaped like ``x`` with same dtype.""" @abstractmethod - def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: - """Draw uniformly distributed samples shaped like ``array``.""" + def uniform_like(self, x: Array, low: float = 0.0, high: float = 1.0) -> Array: + """Draw uniformly distributed samples shaped like ``x`` with same dtype.""" @abstractmethod - def choice(self, array: Array, size: int, replace: bool = True) -> Array: - """Sample ``size`` elements from ``array``.""" + def choice(self, x: Array, size: int, replace: bool = True) -> Array: + """Sample ``size`` elements from ``x``.""" diff --git a/decent_array/interoperability/_backend_manager.py b/decent_array/interoperability/_backend_manager.py index 3092958..a359a67 100644 --- a/decent_array/interoperability/_backend_manager.py +++ b/decent_array/interoperability/_backend_manager.py @@ -34,22 +34,17 @@ def set_backend( Args: backend: A :class:`~decent_array.types.SupportedFrameworks` value, its canonical string (e.g. - ``"numpy"``, ``"pytorch"``), or any alias declared by the backend at - registration time. Aliases are only resolvable after the backend module has - been loaded; pass the canonical name on the first call to trigger autoload. + ``"numpy"``, ``"pytorch"``). device: Target accelerator. Accepts a :class:`~decent_array.types.SupportedDevices` value or its string equivalent (``"cpu"``, ``"gpu"``, ``"mps"``). Defaults to CPU. The backend's array-creation methods produce arrays on this device by default. - Note: - Raises :class:`ImportError` if the backend module cannot be imported (e.g. due to - a missing optional dependency). - Raises: RuntimeError: If a different backend (or the same backend with a different device) is already active in this context. + ImportError: If the backend module cannot be imported (e.g. due to a missing optional dependency). - """ + """ # noqa: DOC502 requested = _normalize(backend) requested_device = device if isinstance(device, SupportedDevices) else SupportedDevices(device) @@ -98,12 +93,7 @@ def register_backend( """ Register a backend class under a :class:`SupportedFrameworks` value. - Called once per backend module *after* the class definition (rather than as a - class decorator). Decorator-based registration would mark the decorated class as - non-extension under mypyc, blocking native compiled-to-compiled dispatch on - ``_BACKEND.add(...)`` and friends — the call-form keeps concrete backends as - extension classes. - + Called once per backend module *after* the class definition. Backends are instantiated lazily on first use. Re-registering replaces the previous class and discards any cached instance, but keeps existing aliases (which still point to the same canonical name). @@ -137,7 +127,30 @@ def reset_backends() -> None: listener(None) +def default_device() -> SupportedDevices: + """ + Return the default device for the active backend. + + Raises: + RuntimeError: If no backend is currently active. + + """ + backend = _BACKEND_INSTANCE + if backend is None: + raise RuntimeError( + "No active backend. Call set_backend() to initialize a backend before querying the default device." + ) + return backend.device + + def _normalize(backend: SupportedFrameworks | str) -> SupportedFrameworks: + """ + Convert a backend identifier to its canonical :class:`SupportedFrameworks` value. + + Raises: + KeyError: If the input is not a valid backend identifier. + + """ if isinstance(backend, SupportedFrameworks): return backend try: @@ -148,11 +161,18 @@ def _normalize(backend: SupportedFrameworks | str) -> SupportedFrameworks: def _instantiate(backend: SupportedFrameworks, device: SupportedDevices) -> Backend: + """ + Get or create a backend instance for the given backend and device. + + Raises: + KeyError: If the backend is not registered and cannot be auto-imported. + + """ if backend in _BACKEND_INSTANCES: return _BACKEND_INSTANCES[backend] if backend not in _BACKEND_REGISTRY: - _auto_import(backend) + _auto_import(backend) # Attempt to load the backend module, which should register the backend as a side-effect. cls = _BACKEND_REGISTRY.get(backend) if cls is None: diff --git a/decent_array/interoperability/_decorators.py b/decent_array/interoperability/_decorators.py deleted file mode 100644 index bd0df3f..0000000 --- a/decent_array/interoperability/_decorators.py +++ /dev/null @@ -1,58 +0,0 @@ -""" -Decorator that bridges :class:`Cost` superclass signatures with framework-native subclass implementations. - -Single-backend semantics make this decorator dramatically simpler than the v1 version: no -framework dispatch, no cross-framework conversion, no ``to_array_like`` magic — just -unwrap input :class:`~decent_array.Array` values to their native form, call the subclass method, and -re-wrap the return if the superclass declared ``-> Array``. -""" - -from __future__ import annotations - -from collections.abc import Callable -from functools import wraps -from typing import Any, cast - - -def autodecorate_cost_method[T: Callable[..., Any]](superclass_method: T) -> Callable[[Callable[..., Any]], T]: - """ - Decorate a Cost method override so its body can use raw framework arrays. - - Each :class:`~decent_array.Array` argument is unwrapped to its underlying value before the call. - If the *superclass* method's return annotation is :class:`~decent_array.Array`, the return value - is re-wrapped in :class:`~decent_array.Array` (unless already wrapped). All other arguments and - return values pass through unchanged. - - Args: - superclass_method: The base-class method being overridden (e.g. ``Cost.function``). - Used solely to look up the declared return type at decoration time. - - Example: - .. code-block:: python - - class LinearRegressionCost(EmpiricalRiskCost): - @autodecorate_cost_method(EmpiricalRiskCost.gradient) - def gradient(self, x: NDArray[float64], indices: ...) -> NDArray[float64]: - # ``x`` arrives as a numpy ndarray; the wrapper unwraps the caller's Array. - return self.A.T @ (self.A @ x - self.b) / self.n_samples - # Return value is wrapped back into Array because EmpiricalRiskCost.gradient - # is annotated ``-> Array``. - - """ - from decent_array import Array # noqa: PLC0415 - - return_is_array = superclass_method.__annotations__.get("return") is Array - - def decorator(func: Callable[..., Any]) -> T: - @wraps(func) - def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any: # noqa: ANN401 - new_args = [a.value if isinstance(a, Array) else a for a in args] - new_kwargs = {k: (v.value if isinstance(v, Array) else v) for k, v in kwargs.items()} - result = func(self, *new_args, **new_kwargs) - if return_is_array and not isinstance(result, Array): - return Array(result) - return result - - return cast("T", wrapper) - - return decorator diff --git a/decent_array/interoperability/_iop/bit_operators.py b/decent_array/interoperability/_iop/bit_operators.py new file mode 100644 index 0000000..aa58334 --- /dev/null +++ b/decent_array/interoperability/_iop/bit_operators.py @@ -0,0 +1,40 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def bitwise_and(x1: bool | int | Array, x2: bool | int | Array) -> Array: + """Element-wise bitwise/logical AND.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.bitwise_and(x1, x2) diff --git a/decent_array/interoperability/_iop/comparasion.py b/decent_array/interoperability/_iop/comparasion.py new file mode 100644 index 0000000..64d176c --- /dev/null +++ b/decent_array/interoperability/_iop/comparasion.py @@ -0,0 +1,75 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def equal(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise equality. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.equal(x1, x2) + + +def not_equal(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise inequality. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.not_equal(x1, x2) + + +def less(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise less-than. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.less(x1, x2) + + +def less_equal(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise less-than-or-equal. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.less_equal(x1, x2) + + +def greater(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise greater-than. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.greater(x1, x2) + + +def greater_equal(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise greater-than-or-equal. Returns an :class:`~decent_array.Array` of bools.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.greater_equal(x1, x2) diff --git a/decent_array/interoperability/_iop/creation.py b/decent_array/interoperability/_iop/creation.py new file mode 100644 index 0000000..1ebcc74 --- /dev/null +++ b/decent_array/interoperability/_iop/creation.py @@ -0,0 +1,68 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def zeros(shape: int | tuple[int, ...]) -> Array: + """Create an array of zeros with the given shape.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.zeros(shape) + + +def zeros_like(x: Array) -> Array: + """Create an array of zeros matching the shape and type of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.zeros_like(x) + + +def ones(shape: int | tuple[int, ...]) -> Array: + """Create an array of ones with the given shape.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ones(shape) + + +def ones_like(x: Array) -> Array: + """Create an array of ones matching the shape and type of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ones_like(x) + + +def eye(n: int) -> Array: + """Create an ``n x n`` identity matrix.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.eye(n) diff --git a/decent_array/interoperability/_iop/functions.py b/decent_array/interoperability/_iop/functions.py deleted file mode 100644 index 9239a3f..0000000 --- a/decent_array/interoperability/_iop/functions.py +++ /dev/null @@ -1,480 +0,0 @@ -""" -Module-level interoperability functions. - -Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` -slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. -Calling any of these before ``set_backend`` raises -:class:`RuntimeError`. - -When this module and ``Backend`` are mypyc-compiled in the same group, -``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python -attribute lookup, no bound-method allocation per call. -""" - -from __future__ import annotations - -from collections.abc import Sequence -from typing import TYPE_CHECKING, Any - -from decent_array.interoperability._backend_manager import register_backend_listener - -if TYPE_CHECKING: - from numpy.typing import NDArray - - from decent_array import Array - from decent_array.interoperability._abstracts import Backend - from decent_array.types import ArrayKey, SupportedDevices - -_BACKEND_INSTANCE: Backend | None = None -_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") - - -def _update_backend(backend: Backend | None) -> None: - global _BACKEND_INSTANCE # noqa: PLW0603 - _BACKEND_INSTANCE = backend - - -register_backend_listener(_update_backend) - -# Array creation - - -def zeros(shape: tuple[int, ...]) -> Array: - """Create an array of zeros with the given shape.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.zeros(shape) - - -def zeros_like(array: Array) -> Array: - """Create an array of zeros matching the shape and type of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.zeros_like(array) - - -def ones(shape: tuple[int, ...]) -> Array: - """Create an array of ones with the given shape.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.ones(shape) - - -def ones_like(array: Array) -> Array: - """Create an array of ones matching the shape and type of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.ones_like(array) - - -def eye(n: int) -> Array: - """Create an ``n x n`` identity matrix.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.eye(n) - - -def eye_like(array: Array) -> Array: - """Create an identity matrix matching the trailing 2 dims of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.eye_like(array) - - -def device_to_native(device: SupportedDevices) -> Any: # noqa: ANN401 - """Convert :class:`~decent_array.types.SupportedDevices` to the active backend's native device.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.device_to_native(device) - - -def device_of(array: Array) -> SupportedDevices: - """Return the :class:`~decent_array.types.SupportedDevices` of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.device_of(array) - - -# Array manipulation - - -def copy(array: Array) -> Array: - """Return a copy of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.copy(array) - - -def to_numpy(array: Array) -> NDArray[Any]: - """Convert ``array`` to a NumPy array on CPU.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.to_numpy(array) - - -def from_numpy(array: NDArray[Any]) -> Array: - """Convert a NumPy array on CPU to an :class:`~decent_array.Array` on the active backend.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.from_numpy(array) - - -def from_numpy_like(array: NDArray[Any], like: Array) -> Array: - """Convert a NumPy array to an :class:`~decent_array.Array` matching ``like``'s dtype and device.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.from_numpy_like(array, like) - - -def to_array(array: float | bool) -> Array: - """Convert a Python scalar to an :class:`~decent_array.Array` on the active backend.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.to_array(array) - - -def stack(arrays: Sequence[Array], axis: int = 0) -> Array: - """Stack a sequence of arrays along a new dimension.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.stack(arrays, axis) - - -def reshape(array: Array, shape: tuple[int, ...]) -> Array: - """Reshape ``array`` to ``shape``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.reshape(array, shape) - - -def transpose(array: Array, axis: tuple[int, ...] | None = None) -> Array: - """Transpose ``array``; ``None`` reverses dimensions.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.transpose(array, axis) - - -def shape(array: Array) -> tuple[int, ...]: - """Return the shape of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.shape(array) - - -def size(array: Array) -> int: - """Return the total number of elements in ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.size(array) - - -def ndim(array: Array) -> int: - """Return the number of dimensions of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.ndim(array) - - -def squeeze(array: Array, axis: int | tuple[int, ...] | None = None) -> Array: - """Remove single-dimensional entries from ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.squeeze(array, axis) - - -def unsqueeze(array: Array, axis: int) -> Array: - """Insert a singleton dimension at ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.unsqueeze(array, axis) - - -def diag(array: Array) -> Array: - """Diagonal: build from a vector or extract from a matrix.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.diag(array) - - -def astype(array: Array, dtype: type[float | int | bool]) -> float | int | bool: - """Cast a single-element ``array`` to a Python scalar of ``dtype``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.astype(array, dtype) - - -# Linalg - - -def dot(array1: Array, array2: Array) -> Array: - """Dot product of two arrays.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.dot(array1, array2) - - -def matmul(array1: Array, array2: Array) -> Array: - """Matrix multiplication of two arrays.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.matmul(array1, array2) - - -def norm( - array: Array, - p: float = 2, - axis: int | tuple[int, ...] | None = None, - keepdims: bool = False, -) -> Array: - """Norm of ``array``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.norm(array, p, axis, keepdims) - - -# Math reductions - - -def sum( # noqa: A001 - array: Array, - axis: int | tuple[int, ...] | None = None, - keepdims: bool = False, -) -> Array: - """Sum elements of ``array`` along ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.sum(array, axis, keepdims) - - -def mean( - array: Array, - axis: int | tuple[int, ...] | None = None, - keepdims: bool = False, -) -> Array: - """Mean of ``array`` along ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.mean(array, axis, keepdims) - - -def min( # noqa: A001 - array: Array, - axis: int | tuple[int, ...] | None = None, - keepdims: bool = False, -) -> Array: - """Minimum of ``array`` along ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.min(array, axis, keepdims) - - -def max( # noqa: A001 - array: Array, - axis: int | tuple[int, ...] | None = None, - keepdims: bool = False, -) -> Array: - """Maximum of ``array`` along ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.max(array, axis, keepdims) - - -def any(array: Array) -> bool: # noqa: A001 - """Return True if any element of ``array`` is truthy.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.any(array) - - -def all(array: Array) -> bool: # noqa: A001 - """Return True if all elements of ``array`` are truthy.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.all(array) - - -# Math elementwise - - -def add(array1: Array | float, array2: Array | float) -> Array: - """Element-wise addition.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.add(array1, array2) - - -def iadd[T: Array](array1: T, array2: Array | float) -> T: - """In-place element-wise addition.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.iadd(array1, array2) - - -def sub(array1: Array | float, array2: Array | float) -> Array: - """Element-wise subtraction.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.sub(array1, array2) - - -def isub[T: Array](array1: T, array2: Array | float) -> T: - """In-place element-wise subtraction.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.isub(array1, array2) - - -def mul(array1: Array | float, array2: Array | float) -> Array: - """Element-wise multiplication.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.mul(array1, array2) - - -def imul[T: Array](array1: T, array2: Array | float) -> T: - """In-place element-wise multiplication.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.imul(array1, array2) - - -def div(array1: Array | float, array2: Array | float) -> Array: - """Element-wise division.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.div(array1, array2) - - -def idiv[T: Array](array1: T, array2: Array | float) -> T: - """In-place element-wise division.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.idiv(array1, array2) - - -def pow(array: Array, p: float) -> Array: # noqa: A001 - """Raise ``array`` to power ``p``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.pow(array, p) - - -def negative(array: Array) -> Array: - """Element-wise negation.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.negative(array) - - -def absolute(array: Array) -> Array: - """Element-wise absolute value.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.absolute(array) - - -def sqrt(array: Array) -> Array: - """Element-wise square root.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.sqrt(array) - - -# Comparisons - - -def eq(array1: Array | float, array2: Array | float) -> Array: - """Element-wise equality. Returns an :class:`~decent_array.Array` of bools.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.eq(array1, array2) - - -def ne(array1: Array | float, array2: Array | float) -> Array: - """Element-wise inequality. Returns an :class:`~decent_array.Array` of bools.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.ne(array1, array2) - - -def lt(array1: Array | float, array2: Array | float) -> Array: - """Element-wise less-than. Returns an :class:`~decent_array.Array` of bools.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.lt(array1, array2) - - -def le(array1: Array | float, array2: Array | float) -> Array: - """Element-wise less-than-or-equal. Returns an :class:`~decent_array.Array` of bools.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.le(array1, array2) - - -def gt(array1: Array | float, array2: Array | float) -> Array: - """Element-wise greater-than. Returns an :class:`~decent_array.Array` of bools.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.gt(array1, array2) - - -def ge(array1: Array | float, array2: Array | float) -> Array: - """Element-wise greater-than-or-equal. Returns an :class:`~decent_array.Array` of bools.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.ge(array1, array2) - - -# Bitwise - - -def bitwise_and(array1: Array | float, array2: Array | float) -> Array: - """Element-wise bitwise/logical AND.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.bitwise_and(array1, array2) - - -# Operators - - -def sign(array: Array) -> Array: - """Element-wise sign.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.sign(array) - - -def maximum(array1: Array | float, array2: Array | float) -> Array: - """Element-wise maximum.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.maximum(array1, array2) - - -def argmax(array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - """Index of maximum value along ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.argmax(array, axis, keepdims) - - -def argmin(array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - """Index of minimum value along ``axis``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.argmin(array, axis, keepdims) - - -def set_item(array: Array, key: ArrayKey, value: Array) -> None: - """Set ``array[key] = value`` in place.""" - if _BACKEND_INSTANCE is None: - raise _error - _BACKEND_INSTANCE.set_item(array, key, value) - - -def get_item(array: Array, key: ArrayKey) -> Array: - """Return ``array[key]``.""" - if _BACKEND_INSTANCE is None: - raise _error - return _BACKEND_INSTANCE.get_item(array, key) diff --git a/decent_array/interoperability/_iop/linalg.py b/decent_array/interoperability/_iop/linalg.py new file mode 100644 index 0000000..4c74963 --- /dev/null +++ b/decent_array/interoperability/_iop/linalg.py @@ -0,0 +1,65 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def vecdot(x1: Array, x2: Array) -> Array: + """Vector dot product of two arrays.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.dot(x1, x2) + + +def dot(x1: Array, x2: Array) -> Array: + """ + Vector dot product of two arrays. + + Alias for :func:`vecdot`. + """ + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.dot(x1, x2) + + +def matmul(x1: Array, x2: Array) -> Array: + """Matrix multiplication of two arrays.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.matmul(x1, x2) + + +def vector_norm(x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """Vector norm of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.vector_norm(x, p, axis, keepdims) diff --git a/decent_array/interoperability/_iop/manipulations.py b/decent_array/interoperability/_iop/manipulations.py new file mode 100644 index 0000000..8dcf8d4 --- /dev/null +++ b/decent_array/interoperability/_iop/manipulations.py @@ -0,0 +1,149 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from typing import TYPE_CHECKING, Any + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from numpy.typing import NDArray + + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + from decent_array.types import DTypes, SupportedArrayTypes + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def copy(x: Array) -> Array: + """Return a copy of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.copy(x) + + +def to_numpy(x: SupportedArrayTypes | Array) -> NDArray[Any]: + """Convert ``x`` to a NumPy array on CPU.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.to_numpy(x) + + +def from_numpy(x: NDArray[Any]) -> Array: + """Convert a NumPy array on CPU to an :class:`~decent_array.Array` on the active backend.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.from_numpy(x) + + +def from_numpy_like(x: NDArray[Any], like: Array) -> Array: + """Convert a NumPy array to an :class:`~decent_array.Array` matching ``like``'s dtype and device.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.from_numpy_like(x, like) + + +def asarray(x: float | bool) -> Array: + """Convert a Python scalar to an :class:`~decent_array.Array` on the active backend.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.asarray(x) + + +def stack(arrays: Sequence[Array], axis: int = 0) -> Array: + """Stack a sequence of arrays along a new dimension.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.stack(arrays, axis) + + +def reshape(x: Array, shape: tuple[int, ...]) -> Array: + """Reshape ``x`` to ``shape``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.reshape(x, shape) + + +def transpose(x: Array, axis: tuple[int, ...] | None = None) -> Array: + """Transpose ``x``; ``None`` reverses dimensions.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.transpose(x, axis) + + +def shape(x: Array) -> tuple[int, ...]: + """Return the shape of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.shape(x) + + +def size(x: Array) -> int: + """Return the total number of elements in ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.size(x) + + +def ndim(x: Array) -> int: + """Return the number of dimensions of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.ndim(x) + + +def squeeze(x: Array, axis: int | tuple[int, ...] | None = None) -> Array: + """Remove single-dimensional entries from ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.squeeze(x, axis) + + +def expand_dims(x: Array, axis: int) -> Array: + """Insert a singleton dimension at ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.unsqueeze(x, axis) + + +def unsqueeze(x: Array, axis: int) -> Array: + """Insert a singleton dimension at ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.unsqueeze(x, axis) + + +def diag(x: Array) -> Array: + """Diagonal: build from a vector or extract from a matrix.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.diag(x) + + +def astype(x: Array, dtype: DTypes) -> Array: + """Cast ``x`` to a different dtype.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.astype(x, dtype) diff --git a/decent_array/interoperability/_iop/math.py b/decent_array/interoperability/_iop/math.py new file mode 100644 index 0000000..3894989 --- /dev/null +++ b/decent_array/interoperability/_iop/math.py @@ -0,0 +1,128 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def add(x1: Array | float, x2: Array | float) -> Array: + """Element-wise addition.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.add(x1, x2) + + +def iadd[T: Array](x1: T, x2: Array | float) -> T: + """In-place element-wise addition.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.iadd(x1, x2) + + +def subtract(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Element-wise subtraction.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.subtract(x1, x2) + + +def isubtract[T: Array](x1: T, x2: int | float | complex | Array) -> T: + """In-place element-wise subtraction.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.isubtract(x1, x2) + + +def multiply(x1: Array | float, x2: int | float | complex | Array) -> Array: + """Element-wise multiplication.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.multiply(x1, x2) + + +def imultiply[T: Array](x1: T, x2: int | float | complex | Array) -> T: + """In-place element-wise multiplication.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.imultiply(x1, x2) + + +def divide(x1: Array | float, x2: int | float | complex | Array) -> Array: + """Element-wise division.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.divide(x1, x2) + + +def idivide[T: Array](x1: T, x2: int | float | complex | Array) -> T: + """In-place element-wise division.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.idivide(x1, x2) + + +def pow(x: Array, p: int | float | complex) -> Array: # noqa: A001 + """Raise ``x`` to power ``p``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.pow(x, p) + + +def negative(x: Array) -> Array: + """Element-wise negation.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.negative(x) + + +def absolute(x: Array) -> Array: + """Element-wise absolute value.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.absolute(x) + + +def abs(x: Array) -> Array: # noqa: A001 + """ + Element-wise absolute value. + + Alias for :func:`absolute`. + """ + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.absolute(x) + + +def sqrt(x: Array) -> Array: + """Element-wise square root.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sqrt(x) diff --git a/decent_array/interoperability/_iop/operators.py b/decent_array/interoperability/_iop/operators.py new file mode 100644 index 0000000..b72c6ab --- /dev/null +++ b/decent_array/interoperability/_iop/operators.py @@ -0,0 +1,61 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def sign(x: Array) -> Array: + """Element-wise sign.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sign(x) + + +def maximum(x1: Array | float, x2: Array | float) -> Array: + """Element-wise maximum.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.maximum(x1, x2) + + +def argmax(x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + """Index of maximum value along ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.argmax(x, axis, keepdims) + + +def argmin(x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + """Index of minimum value along ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.argmin(x, axis, keepdims) diff --git a/decent_array/interoperability/_iop/reductions.py b/decent_array/interoperability/_iop/reductions.py new file mode 100644 index 0000000..7c81125 --- /dev/null +++ b/decent_array/interoperability/_iop/reductions.py @@ -0,0 +1,91 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def sum( # noqa: A001 + x: Array, + axis: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Sum elements of ``x`` along ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.sum(x, axis, keepdims) + + +def mean( + x: Array, + axis: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Mean of ``x`` along ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.mean(x, axis, keepdims) + + +def min( # noqa: A001 + x: Array, + axis: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Minimum of ``x`` along ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.min(x, axis, keepdims) + + +def max( # noqa: A001 + x: Array, + axis: int | tuple[int, ...] | None = None, + keepdims: bool = False, +) -> Array: + """Maximum of ``x`` along ``axis``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.max(x, axis, keepdims) + + +def any(x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: # noqa: A001 + """Return True if any element of ``x`` is truthy.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.any(x, axis, keepdims) + + +def all(x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: # noqa: A001 + """Return True if all elements of ``x`` are truthy.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.all(x, axis, keepdims) diff --git a/decent_array/interoperability/_iop/rng.py b/decent_array/interoperability/_iop/rng.py index 706bf1e..6968ddb 100644 --- a/decent_array/interoperability/_iop/rng.py +++ b/decent_array/interoperability/_iop/rng.py @@ -18,14 +18,17 @@ from __future__ import annotations import random -from typing import TYPE_CHECKING, Any +from typing import TYPE_CHECKING, Any, cast from decent_array.interoperability._backend_manager import _instantiate, register_backend_listener from decent_array.types import SupportedDevices, SupportedFrameworks if TYPE_CHECKING: + import numpy + from decent_array import Array from decent_array.interoperability._abstracts import Backend + from decent_array.interoperability._numpy import NumpyBackend _NUMPY_STATE_KEY = "__numpy_rng_state__" @@ -65,7 +68,7 @@ def set_seed(self, seed: int, *, set_global_seed: bool = True) -> None: random.seed(seed) active = _BACKEND_INSTANCE active.set_seed(seed) - numpy_backend = self._numpy_backend() + numpy_backend = self.numpy_backend() if numpy_backend is not active: numpy_backend.set_seed(seed) if set_global_seed: @@ -91,7 +94,7 @@ def get_rng_state(self) -> dict[str, Any]: active = _BACKEND_INSTANCE state = active.get_rng_state() state[_PYTHON_RANDOM_KEY] = random.getstate() - numpy_backend = self._numpy_backend() + numpy_backend = self.numpy_backend() if numpy_backend is not active: state[_NUMPY_STATE_KEY] = numpy_backend.get_rng_state() return state @@ -107,15 +110,15 @@ def set_rng_state(self, state: dict[str, Any]) -> None: if python_state is not None: random.setstate(python_state) active = _BACKEND_INSTANCE - numpy_backend = self._numpy_backend() + numpy_backend = self.numpy_backend() if numpy_backend is not active: numpy_state = state.pop(_NUMPY_STATE_KEY, None) if numpy_state is not None: numpy_backend.set_rng_state(numpy_state) active.set_rng_state(state) - def _numpy_backend(self) -> Backend: - return _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU) + def numpy_backend(self) -> NumpyBackend: + return cast("NumpyBackend", _instantiate(SupportedFrameworks.NUMPY, SupportedDevices.CPU)) _COORDINATOR = _RngCoordinator() @@ -141,6 +144,12 @@ def _reset_rng() -> None: _COORDINATOR = _RngCoordinator() +def get_numpy_rng() -> numpy.random.Generator: + """Return a NumPy Generator seeded from the current state.""" + np_backend = _COORDINATOR.numpy_backend() + return np_backend._rng # noqa: SLF001 + + def get_seed() -> int | None: """Return the most recently set global seed, or ``None`` if unset.""" return _COORDINATOR.get_seed() @@ -190,22 +199,22 @@ def uniform(low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> return _BACKEND_INSTANCE.uniform(low, high, shape) -def normal_like(array: Array, mean: float = 0.0, std: float = 1.0) -> Array: - """Draw normally distributed samples shaped like ``array``.""" +def normal_like(x: Array, mean: float = 0.0, std: float = 1.0) -> Array: + """Draw normally distributed samples shaped like ``x`` with same dtype.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.normal_like(array, mean, std) + return _BACKEND_INSTANCE.normal_like(x, mean, std) -def uniform_like(array: Array, low: float = 0.0, high: float = 1.0) -> Array: - """Draw uniformly distributed samples shaped like ``array``.""" +def uniform_like(x: Array, low: float = 0.0, high: float = 1.0) -> Array: + """Draw uniformly distributed samples shaped like ``x`` with same dtype.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.uniform_like(array, low, high) + return _BACKEND_INSTANCE.uniform_like(x, low, high) -def choice(array: Array, size: int, replace: bool = True) -> Array: - """Sample ``size`` elements from ``array``.""" +def choice(x: Array, size: int, replace: bool = True) -> Array: + """Sample ``size`` elements from ``x``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.choice(array, size, replace) + return _BACKEND_INSTANCE.choice(x, size, replace) diff --git a/decent_array/interoperability/_iop/utils.py b/decent_array/interoperability/_iop/utils.py new file mode 100644 index 0000000..7632e9d --- /dev/null +++ b/decent_array/interoperability/_iop/utils.py @@ -0,0 +1,62 @@ +""" +Module-level interoperability functions. + +Each function delegates to the active backend cached in this module's ``_BACKEND_INSTANCE`` +slot. The slot is rebound by :func:`decent_array.interoperability.set_backend`. +Calling any of these before ``set_backend`` raises +:class:`RuntimeError`. + +When this module and ``Backend`` are mypyc-compiled in the same group, +``_BACKEND_INSTANCE.add(...)`` dispatches as a native compiled-to-compiled call — no Python +attribute lookup, no bound-method allocation per call. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +from decent_array.interoperability._backend_manager import register_backend_listener + +if TYPE_CHECKING: + from decent_array import Array + from decent_array.interoperability._abstracts import Backend + from decent_array.types import ArrayKey, SupportedDevices + +_BACKEND_INSTANCE: Backend | None = None +_error = RuntimeError("No backend active: call 'set_backend' with a supported framework to activate one.") + + +def _update_backend(backend: Backend | None) -> None: + global _BACKEND_INSTANCE # noqa: PLW0603 + _BACKEND_INSTANCE = backend + + +register_backend_listener(_update_backend) + + +def device_to_native(device: SupportedDevices) -> Any: # noqa: ANN401 + """Convert :class:`~decent_array.types.SupportedDevices` to the active backend's native device.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.device_to_native(device) + + +def device_of(x: Array) -> SupportedDevices: + """Return the :class:`~decent_array.types.SupportedDevices` of ``x``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.device_of(x) + + +def set_item(x: Array, key: ArrayKey, value: Array) -> None: + """Set ``x[key] = value`` in place.""" + if _BACKEND_INSTANCE is None: + raise _error + _BACKEND_INSTANCE.set_item(x, key, value) + + +def get_item(x: Array, key: ArrayKey) -> Array: + """Return ``x[key]``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.get_item(x, key) diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index 4dbd187..85e58ef 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -1,5 +1,5 @@ """ -JAX backend for interoperability_2. +JAX backend. Importing this module registers the backend via :func:`register_backend`, so the package can be auto-loaded on the first ``set_backend("jax")`` call. @@ -22,12 +22,29 @@ from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend -from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks +from decent_array.types import ArrayKey, DTypes, SupportedArrayTypes, SupportedDevices, SupportedFrameworks -def _unwrap(array: Any) -> Any: # noqa: ANN401 - """Return the underlying value of an :class:`Array`, or pass ``array`` through.""" - return array.value if type(array) is Array else array +def _unwrap(x: Any) -> Any: # noqa: ANN401 + """Return the underlying value of an :class:`Array`, or pass ``x`` through.""" + return x.value if type(x) is Array else x + + +_DTYPE_MAP = { + DTypes.BOOL: jnp.bool_, + DTypes.UINT8: jnp.uint8, + DTypes.UINT16: jnp.uint16, + DTypes.UINT32: jnp.uint32, + DTypes.UINT64: jnp.uint64, + DTypes.INT8: jnp.int8, + DTypes.INT16: jnp.int16, + DTypes.INT32: jnp.int32, + DTypes.INT64: jnp.int64, + DTypes.FLOAT32: jnp.float32, + DTypes.FLOAT64: jnp.float64, + DTypes.COMPLEX64: jnp.complex64, + DTypes.COMPLEX128: jnp.complex128, +} class JaxBackend(Backend): # noqa: PLR0904 @@ -40,26 +57,21 @@ def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: # Array creation - def zeros(self, shape: tuple[int, ...]) -> Array: + def zeros(self, shape: int | tuple[int, ...]) -> Array: return Array(jnp.zeros(shape, device=self._native_device)) - def zeros_like(self, array: Array) -> Array: - return Array(jnp.zeros_like(array.value)) + def zeros_like(self, x: Array) -> Array: + return Array(jnp.zeros_like(x.value)) - def ones(self, shape: tuple[int, ...]) -> Array: + def ones(self, shape: int | tuple[int, ...]) -> Array: return Array(jnp.ones(shape, device=self._native_device)) - def ones_like(self, array: Array) -> Array: - return Array(jnp.ones_like(array.value)) + def ones_like(self, x: Array) -> Array: + return Array(jnp.ones_like(x.value)) def eye(self, n: int) -> Array: return Array(jnp.eye(n, device=self._native_device)) - def eye_like(self, array: Array) -> Array: - v = array.value - rows, cols = v.shape[-2:] - return Array(jnp.eye(rows, cols, dtype=v.dtype, device=v.device)) - def device_to_native(self, device: SupportedDevices) -> jax.Device: if device == SupportedDevices.CPU: return jax.devices("cpu")[0] @@ -67,8 +79,8 @@ def device_to_native(self, device: SupportedDevices) -> jax.Device: return jax.devices("gpu")[0] raise ValueError(f"Unsupported device for JAX: {device}") - def device_of(self, array: Array) -> SupportedDevices: - platform = array.value.device.platform + def device_of(self, x: Array) -> SupportedDevices: + platform = x.value.device.platform if platform == "gpu": return SupportedDevices.GPU if platform == "cpu": @@ -77,180 +89,182 @@ def device_of(self, array: Array) -> SupportedDevices: # Array manipulation - def copy(self, array: Array) -> Array: - return Array(jnp.array(array.value, copy=True)) + def copy(self, x: Array) -> Array: + return Array(jnp.array(x.value, copy=True)) - def to_numpy(self, array: Array) -> NDArray[Any]: - return np.array(array.value) + def to_numpy(self, x: SupportedArrayTypes | Array) -> NDArray[Any]: + return np.array(x.value if type(x) is Array else x) - def from_numpy(self, array: NDArray[Any]) -> Array: - return Array(jnp.array(array, device=self._native_device)) + def from_numpy(self, x: NDArray[Any]) -> Array: + return Array(jnp.array(x, device=self._native_device)) - def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + def from_numpy_like(self, x: NDArray[Any], like: Array) -> Array: v = like.value - return Array(jnp.asarray(array, dtype=v.dtype, device=v.device)) + return Array(jnp.asarray(x, dtype=v.dtype, device=v.device)) - def to_array(self, array: float | bool) -> Array: - return Array(jnp.array(array, device=self._native_device)) + def asarray(self, x: bool | int | float | complex) -> Array: + return Array(jnp.array(x, device=self._native_device)) def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") return Array(jnp.stack([a.value for a in arrays], axis=axis)) - def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: - return Array(jnp.reshape(array.value, shape)) + def reshape(self, x: Array, shape: tuple[int, ...]) -> Array: + return Array(jnp.reshape(x.value, shape)) - def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: - return Array(jnp.transpose(array.value, axes=axis)) + def transpose(self, x: Array, axis: tuple[int, ...] | None = None) -> Array: + return Array(jnp.transpose(x.value, axes=axis)) - def shape(self, array: Array) -> tuple[int, ...]: - return tuple(array.value.shape) + def shape(self, x: Array) -> tuple[int, ...]: + return tuple(x.value.shape) - def size(self, array: Array) -> int: - return int(array.value.size) + def size(self, x: Array) -> int: + return int(x.value.size) - def ndim(self, array: Array) -> int: - return int(array.value.ndim) + def ndim(self, x: Array) -> int: + return int(x.value.ndim) - def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: - return Array(jnp.squeeze(array.value, axis=axis)) + def squeeze(self, x: Array, axis: int | tuple[int, ...] | None = None) -> Array: + return Array(jnp.squeeze(x.value, axis=axis)) - def unsqueeze(self, array: Array, axis: int) -> Array: - return Array(jnp.expand_dims(array.value, axis=axis)) + def unsqueeze(self, x: Array, axis: int) -> Array: + return Array(jnp.expand_dims(x.value, axis=axis)) - def diag(self, array: Array) -> Array: - return Array(jnp.diag(array.value)) + def diag(self, x: Array) -> Array: + return Array(jnp.diag(x.value)) - def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: - return dtype(array.value.item()) + def astype(self, x: Array, dtype: DTypes) -> Array: + if dtype not in _DTYPE_MAP: + raise ValueError(f"Unsupported dtype '{dtype.value}' for NumPy backend.") + return Array(jnp.asarray(x.value, dtype=_DTYPE_MAP[dtype])) # Linalg - def dot(self, array1: Array, array2: Array) -> Array: - return Array(jnp.dot(array1.value, array2.value)) + def dot(self, x1: Array, x2: Array) -> Array: + return Array(jnp.dot(x1.value, x2.value)) - def matmul(self, array1: Array, array2: Array) -> Array: - return Array(array1.value @ array2.value) + def matmul(self, x1: Array, x2: Array) -> Array: + return Array(x1.value @ x2.value) - def norm( + def vector_norm( self, - array: Array, + x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - return Array(jnp.linalg.norm(array.value, ord=p, axis=axis, keepdims=keepdims)) + return Array(jnp.linalg.norm(x.value, ord=p, axis=axis, keepdims=keepdims)) # Math reductions - def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.sum(array.value, axis=axis, keepdims=keepdims)) + def sum(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.sum(x.value, axis=axis, keepdims=keepdims)) - def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.mean(array.value, axis=axis, keepdims=keepdims)) + def mean(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.mean(x.value, axis=axis, keepdims=keepdims)) - def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.min(array.value, axis=axis, keepdims=keepdims)) + def min(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.min(x.value, axis=axis, keepdims=keepdims)) - def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(jnp.max(array.value, axis=axis, keepdims=keepdims)) + def max(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(jnp.max(x.value, axis=axis, keepdims=keepdims)) - def any(self, array: Array) -> bool: - return bool(jnp.any(array.value)) + def any(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(jnp.any(x.value, axis=axis, keepdims=keepdims)) - def all(self, array: Array) -> bool: - return bool(jnp.all(array.value)) + def all(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(jnp.all(x.value, axis=axis, keepdims=keepdims)) # Math elementwise — JAX arrays are immutable; "in-place" ops rebind the wrapper. # Operands may be Array or scalar (operator dunders pass either); ``Array | float`` # covers both because PEP 484's numeric tower implicitly admits ``int``. - def add(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.add(_unwrap(array1), _unwrap(array2))) + def add(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.add(_unwrap(x1), _unwrap(x2))) - def iadd[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = jnp.add(array1.value, _unwrap(array2)) - return array1 + def iadd[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = jnp.add(x1.value, _unwrap(x2)) + return x1 - def sub(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.subtract(_unwrap(array1), _unwrap(array2))) + def subtract(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.subtract(_unwrap(x1), _unwrap(x2))) - def isub[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = jnp.subtract(array1.value, _unwrap(array2)) - return array1 + def isubtract[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = jnp.subtract(x1.value, _unwrap(x2)) + return x1 - def mul(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.multiply(_unwrap(array1), _unwrap(array2))) + def multiply(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.multiply(_unwrap(x1), _unwrap(x2))) - def imul[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = jnp.multiply(array1.value, _unwrap(array2)) - return array1 + def imultiply[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = jnp.multiply(x1.value, _unwrap(x2)) + return x1 - def div(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.divide(_unwrap(array1), _unwrap(array2))) + def divide(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.divide(_unwrap(x1), _unwrap(x2))) - def idiv[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = jnp.divide(array1.value, _unwrap(array2)) - return array1 + def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = jnp.divide(x1.value, _unwrap(x2)) + return x1 - def pow(self, array: Array, p: float) -> Array: - return Array(jnp.power(array.value, p)) + def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: + return Array(jnp.power(_unwrap(x), _unwrap(p))) - def negative(self, array: Array) -> Array: - return Array(jnp.negative(array.value)) + def negative(self, x: Array) -> Array: + return Array(jnp.negative(x.value)) - def absolute(self, array: Array) -> Array: - return Array(jnp.abs(array.value)) + def absolute(self, x: Array) -> Array: + return Array(jnp.abs(x.value)) - def sqrt(self, array: Array) -> Array: - return Array(jnp.sqrt(array.value)) + def sqrt(self, x: Array) -> Array: + return Array(jnp.sqrt(x.value)) # Comparisons - def eq(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.equal(_unwrap(array1), _unwrap(array2))) + def equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.equal(_unwrap(x1), _unwrap(x2))) - def ne(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.not_equal(_unwrap(array1), _unwrap(array2))) + def not_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.not_equal(_unwrap(x1), _unwrap(x2))) - def lt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.less(_unwrap(array1), _unwrap(array2))) + def less(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.less(_unwrap(x1), _unwrap(x2))) - def le(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.less_equal(_unwrap(array1), _unwrap(array2))) + def less_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.less_equal(_unwrap(x1), _unwrap(x2))) - def gt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.greater(_unwrap(array1), _unwrap(array2))) + def greater(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.greater(_unwrap(x1), _unwrap(x2))) - def ge(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.greater_equal(_unwrap(array1), _unwrap(array2))) + def greater_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.greater_equal(_unwrap(x1), _unwrap(x2))) # Bitwise - def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.bitwise_and(_unwrap(array1), _unwrap(array2))) + def bitwise_and(self, x1: int | Array, x2: int | Array) -> Array: + return Array(jnp.bitwise_and(_unwrap(x1), _unwrap(x2))) # Operators - def sign(self, array: Array) -> Array: - return Array(jnp.sign(array.value)) + def sign(self, x: Array) -> Array: + return Array(jnp.sign(x.value)) - def maximum(self, array1: Array | float, array2: Array | float) -> Array: - return Array(jnp.maximum(_unwrap(array1), _unwrap(array2))) + def maximum(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.maximum(_unwrap(x1), _unwrap(x2))) - def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - return Array(jnp.argmax(array.value, axis=axis, keepdims=keepdims)) + def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(jnp.argmax(x.value, axis=axis, keepdims=keepdims)) - def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - return Array(jnp.argmin(array.value, axis=axis, keepdims=keepdims)) + def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(jnp.argmin(x.value, axis=axis, keepdims=keepdims)) - def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: # JAX arrays are immutable; rebind the wrapper to a new array with `key` updated. - array.value = array.value.at[key].set(value.value) + x.value = x.value.at[key].set(value.value) - def get_item(self, array: Array, key: ArrayKey) -> Array: - return Array(array.value[key]) + def get_item(self, x: Array, key: ArrayKey) -> Array: + return Array(x.value[key]) # RNG @@ -273,19 +287,19 @@ def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = sub = self._next_key() return Array(jax.random.uniform(sub, shape=shape, minval=low, maxval=high).to_device(self._native_device)) - def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: - v = array.value + def normal_like(self, x: Array, mean: float = 0.0, std: float = 1.0) -> Array: + v = x.value sub = self._next_key() sample = jax.random.normal(sub, shape=v.shape, dtype=v.dtype) return Array(mean + std * sample) - def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: - v = array.value + def uniform_like(self, x: Array, low: float = 0.0, high: float = 1.0) -> Array: + v = x.value sub = self._next_key() return Array(jax.random.uniform(sub, shape=v.shape, dtype=v.dtype, minval=low, maxval=high)) - def choice(self, array: Array, size: int, replace: bool = True) -> Array: - v = array.value + def choice(self, x: Array, size: int, replace: bool = True) -> Array: + v = x.value sub = self._next_key() indices = jax.random.choice(sub, a=v.shape[0], shape=(size,), replace=replace) return Array(v[indices]) diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index f3e0dfb..f160780 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -1,5 +1,5 @@ """ -NumPy backend for interoperability_2. +NumPy backend. Importing this module registers the backend via :func:`register_backend`, so the package can be auto-loaded on the first ``set_backend("numpy")`` call. @@ -17,18 +17,35 @@ from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend -from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks +from decent_array.types import ArrayKey, DTypes, SupportedArrayTypes, SupportedDevices, SupportedFrameworks -def _unwrap(array: Any) -> Any: # noqa: ANN401 +def _unwrap(x: Any) -> Any: # noqa: ANN401 """ - Return the underlying value of an :class:`Array`, or pass ``array`` through. + Return the underlying value of an :class:`Array`, or pass ``x`` through. Typed as ``Any`` because operator dunders may pass either an :class:`Array` or a Python scalar; the strict abstract signature would force a ``cast`` at every call site without runtime benefit. """ - return array.value if type(array) is Array else array + return x.value if type(x) is Array else x + + +_DTYPE_MAP = { + DTypes.BOOL: np.bool_, + DTypes.UINT8: np.uint8, + DTypes.UINT16: np.uint16, + DTypes.UINT32: np.uint32, + DTypes.UINT64: np.uint64, + DTypes.INT8: np.int8, + DTypes.INT16: np.int16, + DTypes.INT32: np.int32, + DTypes.INT64: np.int64, + DTypes.FLOAT32: np.float32, + DTypes.FLOAT64: np.float64, + DTypes.COMPLEX64: np.complex64, + DTypes.COMPLEX128: np.complex128, +} class NumpyBackend(Backend): # noqa: PLR0904 @@ -42,215 +59,211 @@ def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: # Array creation - def zeros(self, shape: tuple[int, ...]) -> Array: + def zeros(self, shape: int | tuple[int, ...]) -> Array: return Array(np.zeros(shape)) - def zeros_like(self, array: Array) -> Array: - return Array(np.zeros_like(array.value)) + def zeros_like(self, x: Array) -> Array: + return Array(np.zeros_like(x.value)) - def ones(self, shape: tuple[int, ...]) -> Array: + def ones(self, shape: int | tuple[int, ...]) -> Array: return Array(np.ones(shape)) - def ones_like(self, array: Array) -> Array: - return Array(np.ones_like(array.value)) + def ones_like(self, x: Array) -> Array: + return Array(np.ones_like(x.value)) def eye(self, n: int) -> Array: return Array(np.eye(n)) - def eye_like(self, array: Array) -> Array: - v = array.value - return Array(np.eye(*v.shape[-2:], dtype=v.dtype)) - def device_to_native(self, device: SupportedDevices) -> Any: # noqa: ANN401 # NumPy has no explicit device management; surface the request unchanged. return device - def device_of(self, array: Array) -> SupportedDevices: # noqa: ARG002 + def device_of(self, x: Array) -> SupportedDevices: # noqa: ARG002 return SupportedDevices.CPU # Array manipulation - def copy(self, array: Array) -> Array: - v = array.value + def copy(self, x: Array) -> Array: + v = x.value if isinstance(v, np.ndarray | np.generic): return Array(np.copy(v)) return Array(deepcopy(v)) - def to_numpy(self, array: Array) -> NDArray[Any]: + def to_numpy(self, x: SupportedArrayTypes | Array) -> NDArray[Any]: """Return the value of an :class:`Array` as a NumPy array.""" - v = array.value + v = x.value if type(x) is Array else x if isinstance(v, np.ndarray): return v return np.asarray(v) - def from_numpy(self, array: NDArray[Any]) -> Array: - return Array(array) + def from_numpy(self, x: NDArray[Any]) -> Array: + return Array(x) - def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + def from_numpy_like(self, x: NDArray[Any], like: Array) -> Array: # NumPy has no device dimension, so only the dtype of ``like`` matters. - return Array(np.asarray(array, dtype=like.value.dtype)) + return Array(np.asarray(x, dtype=like.value.dtype)) - def to_array(self, array: float | bool) -> Array: - return Array(np.array(array)) + def asarray(self, x: bool | int | float | complex) -> Array: + return Array(np.array(x)) def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") return Array(np.stack([a.value for a in arrays], axis=axis)) - def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: - return Array(np.reshape(array.value, shape)) + def reshape(self, x: Array, shape: tuple[int, ...]) -> Array: + return Array(np.reshape(x.value, shape)) - def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: - return Array(np.transpose(array.value, axes=axis)) + def transpose(self, x: Array, axis: tuple[int, ...] | None = None) -> Array: + return Array(np.transpose(x.value, axes=axis)) - def shape(self, array: Array) -> tuple[int, ...]: - return tuple(array.value.shape) + def shape(self, x: Array) -> tuple[int, ...]: + return tuple(x.value.shape) - def size(self, array: Array) -> int: - return int(array.value.size) + def size(self, x: Array) -> int: + return int(x.value.size) - def ndim(self, array: Array) -> int: - return int(array.value.ndim) + def ndim(self, x: Array) -> int: + return int(x.value.ndim) - def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: - return Array(np.squeeze(array.value, axis=axis)) + def squeeze(self, x: Array, axis: int | tuple[int, ...] | None = None) -> Array: + return Array(np.squeeze(x.value, axis=axis)) - def unsqueeze(self, array: Array, axis: int) -> Array: - return Array(np.expand_dims(array.value, axis=axis)) + def unsqueeze(self, x: Array, axis: int) -> Array: + return Array(np.expand_dims(x.value, axis=axis)) - def diag(self, array: Array) -> Array: - return Array(np.diag(array.value)) + def diag(self, x: Array) -> Array: + return Array(np.diag(x.value)) - def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: - v = array.value - scalar = v.item() if hasattr(v, "item") else v - return dtype(scalar) + def astype(self, x: Array, dtype: DTypes) -> Array: + if dtype not in _DTYPE_MAP: + raise ValueError(f"Unsupported dtype '{dtype.value}' for NumPy backend.") + return Array(np.asarray(x.value, dtype=_DTYPE_MAP[dtype])) # Linalg - def dot(self, array1: Array, array2: Array) -> Array: - return Array(np.dot(array1.value, array2.value)) + def dot(self, x1: Array, x2: Array) -> Array: + return Array(np.dot(x1.value, x2.value)) - def matmul(self, array1: Array, array2: Array) -> Array: - return Array(array1.value @ array2.value) + def matmul(self, x1: Array, x2: Array) -> Array: + return Array(x1.value @ x2.value) - def norm( + def vector_norm( self, - array: Array, + x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - return Array(np.linalg.norm(array.value, ord=p, axis=axis, keepdims=keepdims)) + return Array(np.linalg.norm(x.value, ord=p, axis=axis, keepdims=keepdims)) # Math reductions - def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.sum(array.value, axis=axis, keepdims=keepdims)) + def sum(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.sum(x.value, axis=axis, keepdims=keepdims)) - def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.mean(array.value, axis=axis, keepdims=keepdims)) + def mean(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.mean(x.value, axis=axis, keepdims=keepdims)) - def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.min(array.value, axis=axis, keepdims=keepdims)) + def min(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.min(x.value, axis=axis, keepdims=keepdims)) - def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(np.max(array.value, axis=axis, keepdims=keepdims)) + def max(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(np.max(x.value, axis=axis, keepdims=keepdims)) - def any(self, array: Array) -> bool: - return bool(np.any(array.value)) + def any(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(np.any(x.value, axis=axis, keepdims=keepdims)) - def all(self, array: Array) -> bool: - return bool(np.all(array.value)) + def all(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(np.all(x.value, axis=axis, keepdims=keepdims)) # Math elementwise — operands may be Array or scalar (operator dunders pass either). # ``Array | float`` covers both: PEP 484's numeric tower implicitly admits ``int``. - def add(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.add(_unwrap(array1), _unwrap(array2))) + def add(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.add(_unwrap(x1), _unwrap(x2))) - def iadd[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value += _unwrap(array2) - return array1 + def iadd[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value += _unwrap(x2) + return x1 - def sub(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.subtract(_unwrap(array1), _unwrap(array2))) + def subtract(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.subtract(_unwrap(x1), _unwrap(x2))) - def isub[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value -= _unwrap(array2) - return array1 + def isubtract[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value -= _unwrap(x2) + return x1 - def mul(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.multiply(_unwrap(array1), _unwrap(array2))) + def multiply(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.multiply(_unwrap(x1), _unwrap(x2))) - def imul[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value *= _unwrap(array2) - return array1 + def imultiply[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value *= _unwrap(x2) + return x1 - def div(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.divide(_unwrap(array1), _unwrap(array2))) + def divide(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.divide(_unwrap(x1), _unwrap(x2))) - def idiv[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value /= _unwrap(array2) - return array1 + def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value /= _unwrap(x2) + return x1 - def pow(self, array: Array, p: float) -> Array: - return Array(np.power(array.value, p)) + def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: + return Array(np.power(_unwrap(x), _unwrap(p))) - def negative(self, array: Array) -> Array: - return Array(np.negative(array.value)) + def negative(self, x: Array) -> Array: + return Array(np.negative(x.value)) - def absolute(self, array: Array) -> Array: - return Array(np.abs(array.value)) + def absolute(self, x: Array) -> Array: + return Array(np.abs(x.value)) - def sqrt(self, array: Array) -> Array: - return Array(np.sqrt(array.value)) + def sqrt(self, x: Array) -> Array: + return Array(np.sqrt(x.value)) # Comparisons - def eq(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.equal(_unwrap(array1), _unwrap(array2))) + def equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.equal(_unwrap(x1), _unwrap(x2))) - def ne(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.not_equal(_unwrap(array1), _unwrap(array2))) + def not_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.not_equal(_unwrap(x1), _unwrap(x2))) - def lt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.less(_unwrap(array1), _unwrap(array2))) + def less(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.less(_unwrap(x1), _unwrap(x2))) - def le(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.less_equal(_unwrap(array1), _unwrap(array2))) + def less_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.less_equal(_unwrap(x1), _unwrap(x2))) - def gt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.greater(_unwrap(array1), _unwrap(array2))) + def greater(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.greater(_unwrap(x1), _unwrap(x2))) - def ge(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.greater_equal(_unwrap(array1), _unwrap(array2))) + def greater_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.greater_equal(_unwrap(x1), _unwrap(x2))) # Bitwise - def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.bitwise_and(_unwrap(array1), _unwrap(array2))) + def bitwise_and(self, x1: int | Array, x2: int | Array) -> Array: + return Array(np.bitwise_and(_unwrap(x1), _unwrap(x2))) # Operators - def sign(self, array: Array) -> Array: - return Array(np.sign(array.value)) + def sign(self, x: Array) -> Array: + return Array(np.sign(x.value)) - def maximum(self, array1: Array | float, array2: Array | float) -> Array: - return Array(np.maximum(_unwrap(array1), _unwrap(array2))) + def maximum(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.maximum(_unwrap(x1), _unwrap(x2))) - def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - return Array(np.argmax(array.value, axis=axis, keepdims=keepdims)) + def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(np.argmax(x.value, axis=axis, keepdims=keepdims)) - def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - return Array(np.argmin(array.value, axis=axis, keepdims=keepdims)) + def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(np.argmin(x.value, axis=axis, keepdims=keepdims)) - def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: - array.value[key] = value.value + def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: + x.value[key] = value.value - def get_item(self, array: Array, key: ArrayKey) -> Array: - return Array(array.value[key]) + def get_item(self, x: Array, key: ArrayKey) -> Array: + return Array(x.value[key]) # RNG @@ -283,14 +296,14 @@ def normal(self, mean: float = 0.0, std: float = 1.0, shape: tuple[int, ...] = ( def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = ()) -> Array: return Array(self._rng.uniform(low=low, high=high, size=shape)) - def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: - return Array(self._rng.normal(loc=mean, scale=std, size=array.value.shape)) + def normal_like(self, x: Array, mean: float = 0.0, std: float = 1.0) -> Array: + return Array(self._rng.normal(loc=mean, scale=std, size=x.value.shape).astype(x.value.dtype)) - def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: - return Array(self._rng.uniform(low=low, high=high, size=array.value.shape)) + def uniform_like(self, x: Array, low: float = 0.0, high: float = 1.0) -> Array: + return Array(self._rng.uniform(low=low, high=high, size=x.value.shape).astype(x.value.dtype)) - def choice(self, array: Array, size: int, replace: bool = True) -> Array: - return Array(self._rng.choice(array.value, size=size, replace=replace)) + def choice(self, x: Array, size: int, replace: bool = True) -> Array: + return Array(self._rng.choice(x.value, size=size, replace=replace)) register_backend(SupportedFrameworks.NUMPY, NumpyBackend) diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index 39dfc31..8875675 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -1,5 +1,5 @@ """ -PyTorch backend for interoperability_2. +PyTorch backend. Importing this module registers the backend via :func:`register_backend`, so the package can be auto-loaded on the first ``set_backend("pytorch")`` call. @@ -17,12 +17,29 @@ from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend -from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks +from decent_array.types import ArrayKey, DTypes, SupportedArrayTypes, SupportedDevices, SupportedFrameworks -def _unwrap(array: Any) -> Any: # noqa: ANN401 - """Return the underlying value of an :class:`Array`, or pass ``array`` through.""" - return array.value if type(array) is Array else array +def _unwrap(x: Any) -> Any: # noqa: ANN401 + """Return the underlying value of an :class:`Array`, or pass ``x`` through.""" + return x.value if type(x) is Array else x + + +_DTYPE_MAP = { + DTypes.BOOL: torch.bool, + DTypes.UINT8: torch.uint8, + DTypes.UINT16: torch.uint16, + DTypes.UINT32: torch.uint32, + DTypes.UINT64: torch.uint64, + DTypes.INT8: torch.int8, + DTypes.INT16: torch.int16, + DTypes.INT32: torch.int32, + DTypes.INT64: torch.int64, + DTypes.FLOAT32: torch.float32, + DTypes.FLOAT64: torch.float64, + DTypes.COMPLEX64: torch.complex64, + DTypes.COMPLEX128: torch.complex128, +} class PyTorchBackend(Backend): # noqa: PLR0904 @@ -35,25 +52,21 @@ def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: # Array creation - def zeros(self, shape: tuple[int, ...]) -> Array: + def zeros(self, shape: int | tuple[int, ...]) -> Array: return Array(torch.zeros(shape, device=self._native_device)) - def zeros_like(self, array: Array) -> Array: - return Array(torch.zeros_like(array.value)) + def zeros_like(self, x: Array) -> Array: + return Array(torch.zeros_like(x.value)) - def ones(self, shape: tuple[int, ...]) -> Array: + def ones(self, shape: int | tuple[int, ...]) -> Array: return Array(torch.ones(shape, device=self._native_device)) - def ones_like(self, array: Array) -> Array: - return Array(torch.ones_like(array.value)) + def ones_like(self, x: Array) -> Array: + return Array(torch.ones_like(x.value)) def eye(self, n: int) -> Array: return Array(torch.eye(n, device=self._native_device)) - def eye_like(self, array: Array) -> Array: - v = array.value - return Array(torch.eye(*v.shape[-2:], dtype=v.dtype, device=v.device)) - def device_to_native(self, device: SupportedDevices) -> str: if device == SupportedDevices.CPU: return "cpu" @@ -63,8 +76,8 @@ def device_to_native(self, device: SupportedDevices) -> str: return "mps" raise ValueError(f"Unsupported device: {device}") - def device_of(self, array: Array) -> SupportedDevices: - kind = array.value.device.type + def device_of(self, x: Array) -> SupportedDevices: + kind = x.value.device.type if kind == "cpu": return SupportedDevices.CPU if kind == "cuda": @@ -75,189 +88,191 @@ def device_of(self, array: Array) -> SupportedDevices: # Array manipulation - def copy(self, array: Array) -> Array: - return Array(array.value.detach().clone()) + def copy(self, x: Array) -> Array: + return Array(x.value.detach().clone()) - def to_numpy(self, array: Array) -> NDArray[Any]: + def to_numpy(self, x: SupportedArrayTypes | Array) -> NDArray[Any]: """Return the value of an :class:`Array` as a NumPy array.""" - v = array.value + v = x.value if type(x) is Array else x if isinstance(v, torch.Tensor): ret: NDArray[Any] = v.cpu().numpy() else: ret = np.asarray(v) return ret - def from_numpy(self, array: NDArray[Any]) -> Array: - return Array(torch.from_numpy(array).to(device=self._native_device)) + def from_numpy(self, x: NDArray[Any]) -> Array: + return Array(torch.from_numpy(x).to(device=self._native_device)) - def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + def from_numpy_like(self, x: NDArray[Any], like: Array) -> Array: v = like.value - return Array(torch.from_numpy(array).to(dtype=v.dtype, device=v.device)) + return Array(torch.from_numpy(x).to(dtype=v.dtype, device=v.device)) - def to_array(self, array: float | bool) -> Array: - return Array(torch.tensor(array, device=self._native_device)) + def asarray(self, x: bool | int | float | complex) -> Array: + return Array(torch.tensor(x, device=self._native_device)) def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") return Array(torch.stack([a.value for a in arrays], dim=axis)) - def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: - return Array(torch.reshape(array.value, shape)) + def reshape(self, x: Array, shape: tuple[int, ...]) -> Array: + return Array(torch.reshape(x.value, shape)) - def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: - v = array.value + def transpose(self, x: Array, axis: tuple[int, ...] | None = None) -> Array: + v = x.value dims = axis if axis is not None else tuple(reversed(range(v.ndim))) return Array(torch.permute(v, dims=dims)) - def shape(self, array: Array) -> tuple[int, ...]: - return tuple(array.value.shape) + def shape(self, x: Array) -> tuple[int, ...]: + return tuple(x.value.shape) - def size(self, array: Array) -> int: - return int(array.value.numel()) + def size(self, x: Array) -> int: + return int(x.value.numel()) - def ndim(self, array: Array) -> int: - return int(array.value.ndim) + def ndim(self, x: Array) -> int: + return int(x.value.ndim) - def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: - v = array.value + def squeeze(self, x: Array, axis: int | tuple[int, ...] | None = None) -> Array: + v = x.value if axis is None: return Array(torch.squeeze(v)) return Array(torch.squeeze(v, dim=axis)) - def unsqueeze(self, array: Array, axis: int) -> Array: - return Array(torch.unsqueeze(array.value, dim=axis)) + def unsqueeze(self, x: Array, axis: int) -> Array: + return Array(torch.unsqueeze(x.value, dim=axis)) - def diag(self, array: Array) -> Array: - return Array(torch.diag(array.value)) + def diag(self, x: Array) -> Array: + return Array(torch.diag(x.value)) - def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: - return dtype(array.value.item()) + def astype(self, x: Array, dtype: DTypes) -> Array: + if dtype not in _DTYPE_MAP: + raise ValueError(f"Unsupported dtype '{dtype.value}' for PyTorch backend.") + return Array(x.value.to(dtype=_DTYPE_MAP[dtype])) # Linalg - def dot(self, array1: Array, array2: Array) -> Array: - return Array(torch.dot(array1.value, array2.value)) + def dot(self, x1: Array, x2: Array) -> Array: + return Array(torch.dot(x1.value, x2.value)) - def matmul(self, array1: Array, array2: Array) -> Array: - return Array(array1.value @ array2.value) + def matmul(self, x1: Array, x2: Array) -> Array: + return Array(x1.value @ x2.value) - def norm( + def vector_norm( self, - array: Array, + x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - return Array(torch.linalg.norm(array.value, ord=p, axis=axis, keepdim=keepdims)) + return Array(torch.linalg.norm(x.value, ord=p, axis=axis, keepdim=keepdims)) # Math reductions - def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - v = array.value + def sum(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = x.value if axis is None: return Array(torch.sum(v)) return Array(torch.sum(v, dim=axis, keepdim=keepdims)) - def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - v = array.value + def mean(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = x.value if axis is None: return Array(torch.mean(v)) return Array(torch.mean(v, dim=axis, keepdim=keepdims)) - def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - v = array.value + def min(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = x.value if axis is None: return Array(torch.min(v)) return Array(torch.amin(v, dim=axis, keepdim=keepdims)) - def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - v = array.value + def max(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + v = x.value if axis is None: return Array(torch.max(v)) return Array(torch.amax(v, dim=axis, keepdim=keepdims)) - def any(self, array: Array) -> bool: - return bool(torch.any(array.value).item()) + def any(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(torch.any(x.value, dim=axis, keepdim=keepdims).item()) - def all(self, array: Array) -> bool: - return bool(torch.all(array.value).item()) + def all(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(torch.all(x.value, dim=axis, keepdim=keepdims).item()) # Math elementwise — operands may be Array or scalar (operator dunders pass either). # ``Array | float`` covers both: PEP 484's numeric tower implicitly admits ``int``. - def add(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.add(_unwrap(array1), _unwrap(array2))) + def add(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.add(_unwrap(x1), _unwrap(x2))) - def iadd[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value.add_(_unwrap(array2)) - return array1 + def iadd[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value.add_(_unwrap(x2)) + return x1 - def sub(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.sub(_unwrap(array1), _unwrap(array2))) + def subtract(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.sub(_unwrap(x1), _unwrap(x2))) - def isub[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value.sub_(_unwrap(array2)) - return array1 + def isubtract[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value.sub_(_unwrap(x2)) + return x1 - def mul(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.mul(_unwrap(array1), _unwrap(array2))) + def multiply(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.mul(_unwrap(x1), _unwrap(x2))) - def imul[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value.mul_(_unwrap(array2)) - return array1 + def imultiply[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value.mul_(_unwrap(x2)) + return x1 - def div(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.div(_unwrap(array1), _unwrap(array2))) + def divide(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.div(_unwrap(x1), _unwrap(x2))) - def idiv[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value.div_(_unwrap(array2)) - return array1 + def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value.div_(_unwrap(x2)) + return x1 - def pow(self, array: Array, p: float) -> Array: - return Array(torch.pow(array.value, p)) + def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: + return Array(torch.pow(_unwrap(x), _unwrap(p))) - def negative(self, array: Array) -> Array: - return Array(torch.neg(array.value)) + def negative(self, x: Array) -> Array: + return Array(torch.neg(x.value)) - def absolute(self, array: Array) -> Array: - return Array(torch.abs(array.value)) + def absolute(self, x: Array) -> Array: + return Array(torch.abs(x.value)) - def sqrt(self, array: Array) -> Array: - return Array(torch.sqrt(array.value)) + def sqrt(self, x: Array) -> Array: + return Array(torch.sqrt(x.value)) # Comparisons - def eq(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.eq(_unwrap(array1), _unwrap(array2))) + def equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.eq(_unwrap(x1), _unwrap(x2))) - def ne(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.ne(_unwrap(array1), _unwrap(array2))) + def not_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.ne(_unwrap(x1), _unwrap(x2))) - def lt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.lt(_unwrap(array1), _unwrap(array2))) + def less(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.lt(_unwrap(x1), _unwrap(x2))) - def le(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.le(_unwrap(array1), _unwrap(array2))) + def less_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.le(_unwrap(x1), _unwrap(x2))) - def gt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.gt(_unwrap(array1), _unwrap(array2))) + def greater(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.gt(_unwrap(x1), _unwrap(x2))) - def ge(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.ge(_unwrap(array1), _unwrap(array2))) + def greater_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.ge(_unwrap(x1), _unwrap(x2))) # Bitwise - def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: - return Array(torch.bitwise_and(_unwrap(array1), _unwrap(array2))) + def bitwise_and(self, x1: int | Array, x2: int | Array) -> Array: + return Array(torch.bitwise_and(_unwrap(x1), _unwrap(x2))) # Operators - def sign(self, array: Array) -> Array: - return Array(torch.sign(array.value)) + def sign(self, x: Array) -> Array: + return Array(torch.sign(x.value)) - def maximum(self, array1: Array | float, array2: Array | float) -> Array: - a, b = _unwrap(array1), _unwrap(array2) + def maximum(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + a, b = _unwrap(x1), _unwrap(x2) # torch.maximum requires both operands to be Tensors; lift Python scalars to # match the dtype/device of the tensor operand so the contract matches numpy. if not isinstance(a, torch.Tensor): @@ -267,17 +282,17 @@ def maximum(self, array1: Array | float, array2: Array | float) -> Array: b = torch.tensor(b, dtype=a.dtype, device=a.device) return Array(torch.maximum(a, b)) - def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - return Array(torch.argmax(array.value, dim=axis, keepdim=keepdims)) + def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(torch.argmax(x.value, dim=axis, keepdim=keepdims)) - def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - return Array(torch.argmin(array.value, dim=axis, keepdim=keepdims)) + def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + return Array(torch.argmin(x.value, dim=axis, keepdim=keepdims)) - def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: - array.value[key] = value.value + def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: + x.value[key] = value.value - def get_item(self, array: Array, key: ArrayKey) -> Array: - return Array(array.value[key]) + def get_item(self, x: Array, key: ArrayKey) -> Array: + return Array(x.value[key]) # RNG @@ -313,8 +328,8 @@ def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = rand = torch.rand(size=shape, device=self._native_device, generator=self._generator) return Array((high - low) * rand + low) - def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: - v = array.value + def normal_like(self, x: Array, mean: float = 0.0, std: float = 1.0) -> Array: + v = x.value return Array( torch.normal( mean=mean, @@ -326,13 +341,13 @@ def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Arra ) ) - def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: - v = array.value + def uniform_like(self, x: Array, low: float = 0.0, high: float = 1.0) -> Array: + v = x.value rand = torch.rand(size=tuple(v.shape), dtype=v.dtype, device=v.device, generator=self._generator) return Array((high - low) * rand + low) - def choice(self, array: Array, size: int, replace: bool = True) -> Array: - v = array.value + def choice(self, x: Array, size: int, replace: bool = True) -> Array: + v = x.value weights = torch.ones(v.shape[0], device=v.device) indices = weights.multinomial(num_samples=size, replacement=replace, generator=self._generator) return Array(v[indices]) diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index 1026701..9da64c8 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -1,5 +1,5 @@ """ -TensorFlow backend for interoperability_2. +TensorFlow backend. Importing this module registers the backend via :func:`register_backend`, so the package can be auto-loaded on the first ``set_backend("tensorflow")`` call. @@ -20,12 +20,30 @@ from decent_array import Array from decent_array.interoperability._abstracts import Backend from decent_array.interoperability._backend_manager import register_backend -from decent_array.types import ArrayKey, SupportedDevices, SupportedFrameworks +from decent_array.types import ArrayKey, DTypes, SupportedArrayTypes, SupportedDevices, SupportedFrameworks -def _unwrap(array: Any) -> Any: # noqa: ANN401 - """Return the underlying value of an :class:`Array`, or pass ``array`` through.""" - return array.value if type(array) is Array else array +def _unwrap(x: Any) -> Any: # noqa: ANN401 + """Return the underlying value of an :class:`Array`, or pass ``x`` through.""" + return x.value if type(x) is Array else x + + +_DTYPE_MAP = { + DTypes.BOOL: tf.bool, + DTypes.UINT8: tf.uint8, + DTypes.INT8: tf.int8, + DTypes.UINT16: tf.uint16, + DTypes.INT16: tf.int16, + DTypes.UINT32: tf.uint32, + DTypes.INT32: tf.int32, + DTypes.UINT64: tf.uint64, + DTypes.INT64: tf.int64, + DTypes.FLOAT16: tf.float16, + DTypes.FLOAT32: tf.float32, + DTypes.FLOAT64: tf.float64, + DTypes.COMPLEX64: tf.complex64, + DTypes.COMPLEX128: tf.complex128, +} class TensorflowBackend(Backend): # noqa: PLR0904 @@ -38,98 +56,94 @@ def __init__(self, device: SupportedDevices = SupportedDevices.CPU) -> None: # Array creation - def zeros(self, shape: tuple[int, ...]) -> Array: + def zeros(self, shape: int | tuple[int, ...]) -> Array: with tf.device(self._native_device): return Array(tf.zeros(shape)) - def zeros_like(self, array: Array) -> Array: - return Array(tf.zeros_like(array.value)) + def zeros_like(self, x: Array) -> Array: + return Array(tf.zeros_like(x.value)) - def ones(self, shape: tuple[int, ...]) -> Array: + def ones(self, shape: int | tuple[int, ...]) -> Array: with tf.device(self._native_device): return Array(tf.ones(shape)) - def ones_like(self, array: Array) -> Array: - return Array(tf.ones_like(array.value)) + def ones_like(self, x: Array) -> Array: + return Array(tf.ones_like(x.value)) def eye(self, n: int) -> Array: with tf.device(self._native_device): return Array(tf.eye(n)) - def eye_like(self, array: Array) -> Array: - v = array.value - rows, cols = v.shape[-2:] - return Array(tf.eye(rows, cols, dtype=v.dtype)) - def device_to_native(self, device: SupportedDevices) -> str: if device in {SupportedDevices.CPU, SupportedDevices.GPU}: return f"/{device.value}:0" raise ValueError(f"Unsupported device for TensorFlow: {device}") - def device_of(self, array: Array) -> SupportedDevices: - device_str = array.value.device.lower() + def device_of(self, x: Array) -> SupportedDevices: + device_str = x.value.device.lower() if "gpu" in device_str or "cuda" in device_str: return SupportedDevices.GPU return SupportedDevices.CPU # Array manipulation - def copy(self, array: Array) -> Array: - return Array(tf.identity(array.value)) + def copy(self, x: Array) -> Array: + return Array(tf.identity(x.value)) - def to_numpy(self, array: Array) -> NDArray[Any]: + def to_numpy(self, x: SupportedArrayTypes | Array) -> NDArray[Any]: """Return the value of an :class:`Array` as a NumPy array.""" - v = array.value + v = x.value if type(x) is Array else x if isinstance(v, tf.Tensor): ret: NDArray[Any] = v.numpy() else: ret = np.asarray(v) return ret - def from_numpy(self, array: NDArray[Any]) -> Array: + def from_numpy(self, x: NDArray[Any]) -> Array: """Create an :class:`Array` from a NumPy array.""" with tf.device(self._native_device): - return Array(tf.convert_to_tensor(array)) + return Array(tf.convert_to_tensor(x)) - def from_numpy_like(self, array: NDArray[Any], like: Array) -> Array: + def from_numpy_like(self, x: NDArray[Any], like: Array) -> Array: """Create an :class:`Array` from a NumPy array, on ``like``'s device with ``like``'s dtype.""" v = like.value with tf.device(v.device): - return Array(tf.convert_to_tensor(array, dtype=v.dtype)) + return Array(tf.convert_to_tensor(x, dtype=v.dtype)) - def to_array(self, array: float | bool) -> Array: + def asarray(self, x: bool | int | float | complex) -> Array: """Convert a Python scalar to an :class:`Array` on this backend.""" with tf.device(self._native_device): - return Array(tf.convert_to_tensor(array)) + # Its not a tf tensor but mypyc doesn't import tf so it complains about unsude type-ignores + return Array(tf.convert_to_tensor(cast("tf.Tensor", x))) def stack(self, arrays: Sequence[Array], axis: int = 0) -> Array: if len(arrays) == 0: raise ValueError("Cannot stack an empty sequence of arrays.") return Array(tf.stack([a.value for a in arrays], axis=axis)) - def reshape(self, array: Array, shape: tuple[int, ...]) -> Array: - return Array(tf.reshape(array.value, shape)) + def reshape(self, x: Array, shape: tuple[int, ...]) -> Array: + return Array(tf.reshape(x.value, shape)) - def transpose(self, array: Array, axis: tuple[int, ...] | None = None) -> Array: - return Array(tf.transpose(array.value, perm=axis)) + def transpose(self, x: Array, axis: tuple[int, ...] | None = None) -> Array: + return Array(tf.transpose(x.value, perm=axis)) - def shape(self, array: Array) -> tuple[int, ...]: - return cast("tuple[int, ...]", tuple(array.value.shape)) + def shape(self, x: Array) -> tuple[int, ...]: + return cast("tuple[int, ...]", tuple(x.value.shape)) - def size(self, array: Array) -> int: - return int(tf.size(array.value).numpy()) + def size(self, x: Array) -> int: + return int(tf.size(x.value).numpy()) - def ndim(self, array: Array) -> int: - return len(array.value.shape) + def ndim(self, x: Array) -> int: + return len(x.value.shape) - def squeeze(self, array: Array, axis: int | tuple[int, ...] | None = None) -> Array: - return Array(tf.squeeze(array.value, axis=axis)) + def squeeze(self, x: Array, axis: int | tuple[int, ...] | None = None) -> Array: + return Array(tf.squeeze(x.value, axis=axis)) - def unsqueeze(self, array: Array, axis: int) -> Array: - return Array(tf.expand_dims(array.value, axis=axis)) + def unsqueeze(self, x: Array, axis: int) -> Array: + return Array(tf.expand_dims(x.value, axis=axis)) - def diag(self, array: Array) -> Array: - v = array.value + def diag(self, x: Array) -> Array: + v = x.value rank = v.shape.ndims if rank == 1: return Array(tf.linalg.diag(v)) @@ -137,30 +151,32 @@ def diag(self, array: Array) -> Array: return Array(tf.linalg.diag_part(v)) raise ValueError(f"diag requires a 1- or 2-D tensor, got rank {rank}") - def astype(self, array: Array, dtype: type[float | int | bool]) -> float | int | bool: - return dtype(array.value.numpy().item()) + def astype(self, x: Array, dtype: DTypes) -> Array: + if dtype not in _DTYPE_MAP: + raise ValueError(f"Unsupported dtype '{dtype.value}' for TensorFlow backend.") + return Array(tf.cast(x.value, dtype=_DTYPE_MAP[dtype])) # Linalg - def dot(self, array1: Array, array2: Array) -> Array: - return Array(tf.tensordot(array1.value, array2.value, axes=1)) + def dot(self, x1: Array, x2: Array) -> Array: + return Array(tf.tensordot(x1.value, x2.value, axes=1)) - def matmul(self, array1: Array, array2: Array) -> Array: + def matmul(self, x1: Array, x2: Array) -> Array: # tf.matmul requires both operands to have ndim >= 2; fall back to tensordot # for the vector cases so semantics match numpy / torch / jax matmul. - a, b = array1.value, array2.value + a, b = x1.value, x2.value if a.shape.ndims is None or b.shape.ndims is None or a.shape.ndims < 2 or b.shape.ndims < 2: return Array(tf.tensordot(a, b, axes=1)) return Array(a @ b) - def norm( + def vector_norm( self, - array: Array, + x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, ) -> Array: - v = array.value + v = x.value # tf.norm defaults differ from np.linalg.norm on 2-D inputs (operator vs. # Frobenius); match numpy's flat default by reducing over both trailing axes. axis = axis if axis is not None else (-2, -1) if v.ndim == 2 else None @@ -168,106 +184,106 @@ def norm( # Math reductions - def sum(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_sum(array.value, axis=axis, keepdims=keepdims)) + def sum(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_sum(x.value, axis=axis, keepdims=keepdims)) - def mean(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_mean(array.value, axis=axis, keepdims=keepdims)) + def mean(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_mean(x.value, axis=axis, keepdims=keepdims)) - def min(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_min(array.value, axis=axis, keepdims=keepdims)) + def min(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_min(x.value, axis=axis, keepdims=keepdims)) - def max(self, array: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: - return Array(tf.reduce_max(array.value, axis=axis, keepdims=keepdims)) + def max(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + return Array(tf.reduce_max(x.value, axis=axis, keepdims=keepdims)) - def any(self, array: Array) -> bool: - return bool(tf.reduce_any(tf.cast(array.value, tf.bool)).numpy()) + def any(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(tf.reduce_any(tf.cast(x.value, tf.bool), axis=axis, keepdims=keepdims).numpy()) - def all(self, array: Array) -> bool: - return bool(tf.reduce_all(tf.cast(array.value, tf.bool)).numpy()) + def all(self, x: Array, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> bool: + return bool(tf.reduce_all(tf.cast(x.value, tf.bool), axis=axis, keepdims=keepdims).numpy()) # Math elementwise — TF Tensors are immutable; "in-place" ops rebind the wrapper. # Operands may be Array or scalar (operator dunders pass either); ``Array | float`` # covers both because PEP 484's numeric tower implicitly admits ``int``. - def add(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.add(_unwrap(array1), _unwrap(array2))) + def add(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.add(_unwrap(x1), _unwrap(x2))) - def iadd[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = tf.add(array1.value, _unwrap(array2)) - return array1 + def iadd[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = tf.add(x1.value, _unwrap(x2)) + return x1 - def sub(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.subtract(_unwrap(array1), _unwrap(array2))) + def subtract(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.subtract(_unwrap(x1), _unwrap(x2))) - def isub[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = tf.subtract(array1.value, _unwrap(array2)) - return array1 + def isubtract[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = tf.subtract(x1.value, _unwrap(x2)) + return x1 - def mul(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.multiply(_unwrap(array1), _unwrap(array2))) + def multiply(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.multiply(_unwrap(x1), _unwrap(x2))) - def imul[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = tf.multiply(array1.value, _unwrap(array2)) - return array1 + def imultiply[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = tf.multiply(x1.value, _unwrap(x2)) + return x1 - def div(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.divide(_unwrap(array1), _unwrap(array2))) + def divide(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.divide(_unwrap(x1), _unwrap(x2))) - def idiv[T: Array](self, array1: T, array2: Array | float) -> T: - array1.value = tf.divide(array1.value, _unwrap(array2)) - return array1 + def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: + x1.value = tf.divide(x1.value, _unwrap(x2)) + return x1 - def pow(self, array: Array, p: float) -> Array: - return Array(tf.pow(array.value, p)) + def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: + return Array(tf.pow(_unwrap(x), _unwrap(p))) - def negative(self, array: Array) -> Array: - return Array(tf.negative(array.value)) + def negative(self, x: Array) -> Array: + return Array(tf.negative(x.value)) - def absolute(self, array: Array) -> Array: - return Array(tf.abs(array.value)) + def absolute(self, x: Array) -> Array: + return Array(tf.abs(x.value)) - def sqrt(self, array: Array) -> Array: - return Array(tf.sqrt(array.value)) + def sqrt(self, x: Array) -> Array: + return Array(tf.sqrt(x.value)) # Comparisons - def eq(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.equal(_unwrap(array1), _unwrap(array2))) + def equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.equal(_unwrap(x1), _unwrap(x2))) - def ne(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.not_equal(_unwrap(array1), _unwrap(array2))) + def not_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.not_equal(_unwrap(x1), _unwrap(x2))) - def lt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.less(_unwrap(array1), _unwrap(array2))) + def less(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.less(_unwrap(x1), _unwrap(x2))) - def le(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.less_equal(_unwrap(array1), _unwrap(array2))) + def less_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.less_equal(_unwrap(x1), _unwrap(x2))) - def gt(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.greater(_unwrap(array1), _unwrap(array2))) + def greater(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.greater(_unwrap(x1), _unwrap(x2))) - def ge(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.greater_equal(_unwrap(array1), _unwrap(array2))) + def greater_equal(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.greater_equal(_unwrap(x1), _unwrap(x2))) # Bitwise — TF's native ``&`` dispatches to ``tf.math.logical_and`` for bool # tensors and ``tf.bitwise.bitwise_and`` for int tensors, matching numpy/torch/jax # operator semantics. Calling either named function directly here would constrain # us to one dtype family. - def bitwise_and(self, array1: Array | float, array2: Array | float) -> Array: - return Array(_unwrap(array1) & _unwrap(array2)) + def bitwise_and(self, x1: int | Array, x2: int | Array) -> Array: + return Array(_unwrap(x1) & _unwrap(x2)) # Operators - def sign(self, array: Array) -> Array: - return Array(tf.sign(array.value)) + def sign(self, x: Array) -> Array: + return Array(tf.sign(x.value)) - def maximum(self, array1: Array | float, array2: Array | float) -> Array: - return Array(tf.maximum(_unwrap(array1), _unwrap(array2))) + def maximum(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.maximum(_unwrap(x1), _unwrap(x2))) - def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - v = array.value + def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + v = x.value if axis is None: flat = tf.argmax(tf.reshape(v, [-1]), axis=0) if keepdims: @@ -279,8 +295,8 @@ def argmax(self, array: Array, axis: int | None = None, keepdims: bool = False) out = tf.expand_dims(out, axis=axis) return Array(out) - def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) -> Array: - v = array.value + def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: + v = x.value if axis is None: flat = tf.argmin(tf.reshape(v, [-1]), axis=0) if keepdims: @@ -292,19 +308,19 @@ def argmin(self, array: Array, axis: int | None = None, keepdims: bool = False) out = tf.expand_dims(out, axis=axis) return Array(out) - def set_item(self, array: Array, key: ArrayKey, value: Array) -> None: + def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: # TF eager tensors are immutable; round-trip through numpy so arbitrary indexing # patterns (slices, fancy indexing) Just Work. The wrapper is rebound to a fresh # tensor on the configured device. This is correct but allocates — algorithms # that hammer set_item in tight loops should consider numpy or pytorch. - original = array.value + original = x.value np_array = original.numpy().copy() np_array[key] = np.asarray(value.value) with tf.device(self._native_device): - array.value = tf.convert_to_tensor(np_array, dtype=original.dtype) + x.value = tf.convert_to_tensor(np_array, dtype=original.dtype) - def get_item(self, array: Array, key: ArrayKey) -> Array: - return Array(array.value[key]) + def get_item(self, x: Array, key: ArrayKey) -> Array: + return Array(x.value[key]) # RNG @@ -327,16 +343,16 @@ def uniform(self, low: float = 0.0, high: float = 1.0, shape: tuple[int, ...] = with tf.device(self._native_device): return Array(self._generator.uniform(shape=shape, minval=low, maxval=high)) - def normal_like(self, array: Array, mean: float = 0.0, std: float = 1.0) -> Array: - v = array.value + def normal_like(self, x: Array, mean: float = 0.0, std: float = 1.0) -> Array: + v = x.value return Array(self._generator.normal(shape=tf.shape(v), mean=mean, stddev=std, dtype=v.dtype)) - def uniform_like(self, array: Array, low: float = 0.0, high: float = 1.0) -> Array: - v = array.value + def uniform_like(self, x: Array, low: float = 0.0, high: float = 1.0) -> Array: + v = x.value return Array(self._generator.uniform(shape=tf.shape(v), minval=low, maxval=high, dtype=v.dtype)) - def choice(self, array: Array, size: int, replace: bool = True) -> Array: - v = array.value + def choice(self, x: Array, size: int, replace: bool = True) -> Array: + v = x.value n = v.shape[0] if replace: indices = self._generator.uniform(shape=(size,), minval=0, maxval=n, dtype=tf.int32) diff --git a/decent_array/types.py b/decent_array/types.py index 6d62fcb..7e39af0 100644 --- a/decent_array/types.py +++ b/decent_array/types.py @@ -11,19 +11,23 @@ import tensorflow as tf import torch + from decent_array._array import Array + ArrayLike: TypeAlias = Union["numpy.ndarray", "torch.Tensor", "tf.Tensor", "jax.Array"] # noqa: UP040 """ Type alias for array-like types supported in decent-array, including NumPy arrays, PyTorch tensors, TensorFlow tensors, and JAX arrays. """ -SupportedArrayTypes: TypeAlias = ArrayLike | float | int # noqa: UP040 +SupportedArrayTypes: TypeAlias = bool | int | float | complex | ArrayLike # noqa: UP040 """ Type alias for supported types for optimization variables in decent-array, including array-like types and scalars. """ -ArrayKey: TypeAlias = SupportsIndex | slice | tuple[SupportsIndex | slice, ...] # noqa: UP040 +ArrayKey: TypeAlias = ( # noqa: UP040 + "int | SupportsIndex | slice | Array | tuple[int | SupportsIndex | slice | Array | None, ...] | None" +) """ Type alias for valid keys used to index into supported array types. Includes single indices, tuples of indices, slices, and tuples of slices. @@ -47,3 +51,22 @@ class SupportedDevices(Enum): CPU = "cpu" GPU = "gpu" MPS = "mps" + + +class DTypes(Enum): + """Enum for supported dtypes in decent-array.""" + + BOOL = "bool" + UINT8 = "uint8" + UINT16 = "uint16" + UINT32 = "uint32" + UINT64 = "uint64" + INT8 = "int8" + INT16 = "int16" + INT32 = "int32" + INT64 = "int64" + FLOAT16 = "float16" + FLOAT32 = "float32" + FLOAT64 = "float64" + COMPLEX64 = "complex64" + COMPLEX128 = "complex128" diff --git a/docs/source/api/decent_array.rst b/docs/source/api/decent_array.rst index 66c4fcd..ba5e129 100644 --- a/docs/source/api/decent_array.rst +++ b/docs/source/api/decent_array.rst @@ -4,11 +4,6 @@ decent\_array .. toctree:: :maxdepth: 2 + decent_array.array decent_array.interoperability - - -.. toctree:: - :maxdepth: 2 - - decent_array.types - decent_array.array \ No newline at end of file + decent_array.types \ No newline at end of file diff --git a/docs/source/author.rst b/docs/source/author.rst index 0506444..f29baf0 100644 --- a/docs/source/author.rst +++ b/docs/source/author.rst @@ -1,6 +1,4 @@ Contributors ============ -decent-array is developed by `Simon Granström `_ and -`Adriana Rodriguez `_, under the supervision of -`Dr. Nicola Bastianello `_. +decent-array is developed by `Simon Granström `_, under the supervision of `Dr. Nicola Bastianello `_. diff --git a/docs/source/background.rst b/docs/source/background.rst deleted file mode 100644 index 7370504..0000000 --- a/docs/source/background.rst +++ /dev/null @@ -1,3 +0,0 @@ -Background -========== - diff --git a/docs/source/conf.py b/docs/source/conf.py index f95654f..4c33da5 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -89,30 +89,6 @@ def _fix_missing_ref(app, env, node, contnode): "TensorflowGenerator", refuri="https://www.tensorflow.org/api_docs/python/tf/random/Generator", ) - if target in {"TorchGenerator"}: - return nodes.reference( - "", - "TorchGenerator", - refuri="https://pytorch.org/docs/stable/generated/torch.Generator.html#torch.Generator", - ) - if target in {"JaxArray"}: - return nodes.reference( - "", - "JaxArray", - refuri="https://docs.jax.dev/en/latest/_autosummary/jax.Array.html#jax.Array", - ) - if target in {"TorchTensor"}: - return nodes.reference( - "", - "TorchTensor", - refuri="https://docs.pytorch.org/docs/stable/tensors.html#torch-tensor", - ) - if target in {"TensorflowTensor"}: - return nodes.reference( - "", - "TensorflowTensor", - refuri="https://www.tensorflow.org/api_docs/python/tf/Tensor", - ) return None diff --git a/docs/source/developer.rst b/docs/source/developer.rst index 053f9ec..797dba5 100644 --- a/docs/source/developer.rst +++ b/docs/source/developer.rst @@ -15,6 +15,12 @@ Prerequisites Installation for Development ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +A compatible C compiler is required to build the mypyc extensions. On Windows, install +`Build Tools for Visual Studio 2022 `_ or +`C++ Build Tools `_. +and select the "C++ build tools" workload. On Mac, install Xcode Command Line Tools by running :code:`xcode-select --install` in the terminal. +On Linux, install the appropriate build tools for your distribution, see the `Mypyc documentation `_ for details. + .. code-block:: git clone https://github.com/team-decent/decent-array.git @@ -40,9 +46,10 @@ To make sure all GitHub status checks pass, simply run :code:`tox`. You can also .. code-block:: tox -e mypy # find typing issues - tox -e pytest # run tests tox -e ruff # find formatting and style issues + tox -e pytest # run tests tox -e sphinx # rebuild documentation + tox -m lint # run all linters (ruff + mypy) Note: Running :code:`tox` commands can take several minutes and may require admin privileges. If you have mypy addon installed in your IDE, you can use it to get instant feedback on typing issues while coding. diff --git a/docs/source/index.rst b/docs/source/index.rst index f9ec474..7e0b11f 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -8,7 +8,6 @@ With Decent-Array, you can write code that is portable and optimized for perform .. toctree:: :maxdepth: 1 - background user API Reference developer diff --git a/docs/source/user.rst b/docs/source/user.rst index 735989b..9c08874 100644 --- a/docs/source/user.rst +++ b/docs/source/user.rst @@ -1,7 +1,5 @@ User Guide ========== -This user guide shows you different examples of how to use decent-array. - Installation ------------ diff --git a/pyproject.toml b/pyproject.toml index 38542cc..398c054 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [project] name = "decent-array" version = "0.1.0" -authors = [{name = "Elias Ram"}, {name = "Simon Granström"}, {name = "Adriana Rodriguez"}, {name = "Nicola Bastianello"}] +authors = [{name = "Simon Granström"}, {name = "Nicola Bastianello"}] maintainers = [{name = "Team Decent"}] description = "A library of array operations and linear algebra primitives for interoperability across ML frameworks." readme = "README.md" @@ -26,9 +26,6 @@ dev = [ "mypy", "pytest", "ruff", - "scipy-stubs", - "types-networkx", - "types-tabulate", "torch", "torchvision", "types-tensorflow", @@ -71,7 +68,8 @@ include = [ mypy-args = ["--ignore-missing-imports"] [tool.tox] -envlist = ["dev", "mypy", "pytest", "ruff", "sphinx"] +envlist = ["dev", "mypy", "mypyc", "pytest", "ruff", "sphinx"] +package = "editable" [tool.tox.env.dev] description = "Generate dev venv with all dependencies, active with `source .tox/dev/bin/activate`" @@ -82,6 +80,7 @@ deps = [ ".[sphinx-tools]", "git+https://github.com/microsoft/python-type-stubs.git@main" ] +package = "editable" [tool.tox.env.dev-gpu] description = "Generate dev venv with all dependencies including GPU support, active with `source .tox/dev-gpu/bin/activate`" @@ -92,12 +91,16 @@ deps = [ ".[sphinx-tools]", "git+https://github.com/microsoft/python-type-stubs.git@main" ] +package = "editable" [tool.tox.env.sphinx] description = "Generate rst and html files using sphinx" set_env = { HATCH_BUILD_NO_HOOKS = "true" } +skip_install = true +allowlist_externals = ["tox"] deps = [".[sphinx-tools]"] commands = [ + ["tox", "-e", "clean-mypyc"], # ensure .py source files are used for doc generation, not mypyc-compiled .so ["sphinx-apidoc", "-o", "docs/source/api", "decent_array", "--separate", "--no-toc", "--templatedir=docs/source/_templates"], ["sphinx-build", "-W", "-E", "-b", "html", "docs/source", "docs/build/html"] ] @@ -121,13 +124,14 @@ commands = [ description = "Compile hot-path modules in place with mypyc (drops .so files alongside the .py source)" deps = ["mypy", "numpy", "setuptools"] skip_install = true +allowlist_externals = ["tox"] # First command clears any stale shared-runtime ``.so`` at the project root from a # previous compile (its name is hash-derived from the file list, so changing inputs # leaves orphans); second command compiles the Array module + entire iop2 package # (including ``_abstracts``) as one group so cross-module dispatch (Array → # _Backend.add → concrete backend method) is native compiled-to-compiled. commands = [ - ["python", "-c", "import pathlib; [p.unlink() for p in pathlib.Path('.').glob('*__mypyc.cpython-*.so')]"], + ["tox", "-e", "clean-mypyc"], # ensure we're compiling from a clean slate with no stale .so files ["python", "-m", "mypyc", "--ignore-missing-imports", "decent_array/", @@ -149,6 +153,9 @@ commands = [ ["ruff", "format", "decent_array", "--check"] ] +[tool.tox.labels] +lint = ["ruff", "mypy"] + [tool.pytest.ini_options] addopts = "-q -W error" testpaths = ["tests"] @@ -185,6 +192,7 @@ lint.ignore = [ "FBT001", # boolean-type-hint-positional-argument, complains about bool args with default values in functions "FBT002", # boolean-default-value-positional-argument, complains about bool args with default values in functions "ICN001", # unconventional-import-alias, complains about common import aliases like `import numpy as np` but it doesn't work for most libraries + "PYI041", # Removes warning for redundant types in cases like int | float | complex where complex already covers int and float, but we want to keep the union for readability and explicitness about supported types. ] preview = true line-length = 120 diff --git a/tests/test_array.py b/tests/test_array.py index 164e223..de0d72f 100644 --- a/tests/test_array.py +++ b/tests/test_array.py @@ -124,6 +124,12 @@ def test_pow_scalar(backend: tuple) -> None: np.testing.assert_allclose(_np(a**2), [1.0, 4.0, 9.0]) +def test_pow_array(backend: tuple) -> None: + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([3.0, 2.0, 1.0]) + np.testing.assert_allclose(_np(a**b), [1.0, 4.0, 3.0]) + + # Comparisons ------------------------------------------------------------ @@ -257,12 +263,32 @@ def test_isub_array(backend: tuple) -> None: np.testing.assert_allclose(_np(a), [4.0, 4.0, 4.0]) +def test_isub_scalar(backend: tuple) -> None: + a = _create_array([5.0, 6.0, 7.0]) + a -= 1 + np.testing.assert_allclose(_np(a), [4.0, 5.0, 6.0]) + + +def test_imul_array(backend: tuple) -> None: + a = _create_array([1.0, 2.0, 3.0]) + b = _create_array([4.0, 5.0, 6.0]) + a *= b + np.testing.assert_allclose(_np(a), [4.0, 10.0, 18.0]) + + def test_imul_scalar(backend: tuple) -> None: a = _create_array([1.0, 2.0, 3.0]) a *= 2 np.testing.assert_allclose(_np(a), [2.0, 4.0, 6.0]) +def test_itruediv_array(backend: tuple) -> None: + a = _create_array([2.0, 6.0, 12.0]) + b = _create_array([2.0, 3.0, 4.0]) + a /= b + np.testing.assert_allclose(_np(a), [1.0, 2.0, 3.0]) + + def test_itruediv_scalar(backend: tuple) -> None: a = _create_array([2.0, 4.0, 6.0]) a /= 2 @@ -387,3 +413,9 @@ def test_all_true(backend: tuple) -> None: def test_all_false(backend: tuple) -> None: a = _create_array([1.0, 0.0, 3.0]) assert a.all is False + + +def test_device_property(backend: tuple) -> None: + _framework, device = backend + a = iop.zeros((3,)) + assert a.device == device diff --git a/tests/test_backend_manager.py b/tests/test_backend_manager.py index 982812d..a0eaf4c 100644 --- a/tests/test_backend_manager.py +++ b/tests/test_backend_manager.py @@ -11,6 +11,7 @@ from decent_array.interoperability._backend_manager import ( _instantiate, _normalize, + default_device, register_backend, register_backend_listener, reset_backends, @@ -187,3 +188,17 @@ def test_set_backend_device_mismatch_raises() -> None: with pytest.raises((RuntimeError, ValueError)): # The same backend cannot be reconfigured to a different device. set_backend("numpy", "gpu") + + +# default_device -------------------------------------------------------- + + +def test_default_device_returns_active_device() -> None: + set_backend("numpy", SupportedDevices.CPU) + assert default_device() == SupportedDevices.CPU + + +def test_default_device_raises_when_no_backend() -> None: + reset_backends() + with pytest.raises(RuntimeError, match=r"No active backend"): + default_device() diff --git a/tests/test_decorators.py b/tests/test_decorators.py deleted file mode 100644 index 3c75137..0000000 --- a/tests/test_decorators.py +++ /dev/null @@ -1,107 +0,0 @@ -"""Tests for :mod:`decent_array.interoperability.decorators`. - -Note: this file deliberately omits ``from __future__ import annotations``. The -:func:`autodecorate_cost_method` decorator inspects ``__annotations__["return"] is Array`` -on the superclass method, and PEP 563-style stringified annotations would break that -identity check. -""" - -from typing import Any - -import numpy as np - -import decent_array.interoperability as iop -from decent_array import Array -from decent_array.interoperability._decorators import autodecorate_cost_method - - -class _Base: - def returns_array(self, x: Array) -> Array: - raise NotImplementedError - - def returns_float(self, x: Array) -> float: - raise NotImplementedError - - def takes_kwarg(self, x: Array, *, scale: Array) -> Array: - raise NotImplementedError - - def passes_through_non_array(self, x: Array, n: int) -> Array: - raise NotImplementedError - - -def test_unwraps_array_args(backend: tuple) -> None: - seen: list[Any] = [] - - class Impl(_Base): - @autodecorate_cost_method(_Base.returns_array) - def returns_array(self, x: Any) -> Any: - seen.append(x) - return x * 2 - - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - result = Impl().returns_array(arr) - # The decorator should have unwrapped the Array to its underlying value. - assert not isinstance(seen[0], Array) - # Annotated `-> Array`, so the return is re-wrapped. - assert isinstance(result, Array) - np.testing.assert_allclose(iop.to_numpy(result), [2.0, 4.0, 6.0]) - - -def test_does_not_rewrap_when_return_not_array(backend: tuple) -> None: - class Impl(_Base): - @autodecorate_cost_method(_Base.returns_float) - def returns_float(self, x: Any) -> float: - # Use a fixed value so the test doesn't depend on framework-specific tensor - # methods (e.g. TF eager tensors don't expose ``.sum()`` without enabling - # the numpy compatibility shim). - assert not isinstance(x, Array) - return 42.0 - - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - result = Impl().returns_float(arr) - assert isinstance(result, float) - assert result == 42.0 - - -def test_unwraps_kwargs(backend: tuple) -> None: - class Impl(_Base): - @autodecorate_cost_method(_Base.takes_kwarg) - def takes_kwarg(self, x: Any, *, scale: Any) -> Any: - assert not isinstance(x, Array) - assert not isinstance(scale, Array) - return x * scale - - arr = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) - scale = iop.from_numpy(np.array([10.0, 100.0], dtype=np.float32)) - result = Impl().takes_kwarg(arr, scale=scale) - assert isinstance(result, Array) - np.testing.assert_allclose(iop.to_numpy(result), [10.0, 200.0]) - - -def test_passes_non_array_args_unchanged(backend: tuple) -> None: - class Impl(_Base): - @autodecorate_cost_method(_Base.passes_through_non_array) - def passes_through_non_array(self, x: Any, n: int) -> Any: - assert isinstance(n, int) - return x * n - - arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - result = Impl().passes_through_non_array(arr, 4) - assert isinstance(result, Array) - np.testing.assert_allclose(iop.to_numpy(result), [4.0, 8.0, 12.0]) - - -def test_does_not_double_wrap_when_impl_returns_array(backend: tuple) -> None: - """If the decorated impl already returns an :class:`Array`, the wrapper should not double-wrap.""" - - class Impl(_Base): - @autodecorate_cost_method(_Base.returns_array) - def returns_array(self, x: Any) -> Array: - return Array(x * 3) - - arr = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) - result = Impl().returns_array(arr) - assert isinstance(result, Array) - # If the wrapper double-wrapped, ``result.value`` would itself be an Array. - assert not isinstance(result.value, Array) - np.testing.assert_allclose(iop.to_numpy(result), [3.0, 6.0]) diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py index 117daac..f2d7391 100644 --- a/tests/test_iop_functions.py +++ b/tests/test_iop_functions.py @@ -8,7 +8,9 @@ import decent_array.interoperability as iop from decent_array import Array from decent_array.interoperability._backend_manager import reset_backends -from decent_array.types import SupportedDevices +from decent_array.interoperability._iop.math import iadd, idivide, imultiply, isubtract +from decent_array.interoperability._iop.utils import device_to_native, get_item, set_item +from decent_array.types import DTypes def _np(arr: Array) -> np.ndarray: @@ -45,15 +47,9 @@ def test_eye(backend: tuple) -> None: np.testing.assert_allclose(_np(arr), np.eye(3)) -def test_eye_like(backend: tuple) -> None: - src = iop.from_numpy(np.zeros((4, 4), dtype=np.float32)) - arr = iop.eye_like(src) - np.testing.assert_allclose(_np(arr), np.eye(4)) - - def test_device_to_native(backend: tuple) -> None: framework, device = backend - native = iop.device_to_native(device) + native = device_to_native(device) # Just verify the call succeeds and returns a non-None value (varies per backend). assert native is not None @@ -110,7 +106,7 @@ def test_from_numpy_like_matches_device(backend: tuple) -> None: def test_to_array_from_scalar(backend: tuple) -> None: - arr = iop.to_array(2.5) + arr = iop.asarray(2.5) np.testing.assert_allclose(_np(arr), 2.5) @@ -141,9 +137,7 @@ def test_reshape(backend: tuple) -> None: def test_transpose_default(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)) - np.testing.assert_allclose( - _np(iop.transpose(arr)), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]] - ) + np.testing.assert_allclose(_np(iop.transpose(arr)), [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]]) def test_transpose_explicit_dim(backend: tuple) -> None: @@ -177,6 +171,12 @@ def test_squeeze_specific_dim(backend: tuple) -> None: assert iop.shape(iop.squeeze(arr, axis=0)) == (3, 1) +def test_expand_dims(backend: tuple) -> None: + arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + out = iop.expand_dims(arr, axis=0) + assert iop.shape(out) == (1, 3) + + def test_unsqueeze(backend: tuple) -> None: arr = iop.from_numpy(np.zeros((3,), dtype=np.float32)) assert iop.shape(iop.unsqueeze(arr, axis=0)) == (1, 3) @@ -194,24 +194,27 @@ def test_diag_from_matrix(backend: tuple) -> None: def test_astype_to_float(backend: tuple) -> None: - arr = iop.to_array(3.0) - out = iop.astype(arr, float) - assert isinstance(out, float) - assert out == pytest.approx(3.0) + arr = iop.asarray(3.0) + out = iop.astype(arr, DTypes.FLOAT32) + np_out = _np(out) + assert np_out.dtype == np.float32 + assert np_out == pytest.approx(3.0) def test_astype_to_int(backend: tuple) -> None: - arr = iop.to_array(3.0) - out = iop.astype(arr, int) - assert isinstance(out, int) - assert out == 3 + arr = iop.asarray(3.0) + out = iop.astype(arr, DTypes.INT32) + np_out = _np(out) + assert np_out.dtype == np.int32 + assert int(np_out) == 3 def test_astype_to_bool(backend: tuple) -> None: - arr = iop.to_array(1.0) - out = iop.astype(arr, bool) - assert isinstance(out, bool) - assert out is True + arr = iop.asarray(1.0) + out = iop.astype(arr, DTypes.BOOL) + np_out = _np(out) + assert np_out.dtype == np.bool_ + assert bool(np_out) is True # Linalg ----------------------------------------------------------------- @@ -223,6 +226,12 @@ def test_dot(backend: tuple) -> None: np.testing.assert_allclose(_np(iop.dot(a, b)), 32.0) +def test_vecdot(backend: tuple) -> None: + a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + b = iop.from_numpy(np.array([4.0, 5.0, 6.0], dtype=np.float32)) + np.testing.assert_allclose(_np(iop.vecdot(a, b)), 32.0) + + def test_matmul(backend: tuple) -> None: a = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) b = iop.from_numpy(np.array([[5.0, 6.0], [7.0, 8.0]], dtype=np.float32)) @@ -232,17 +241,17 @@ def test_matmul(backend: tuple) -> None: def test_norm_default_l2(backend: tuple) -> None: arr = iop.from_numpy(np.array([3.0, 4.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.norm(arr)), 5.0) + np.testing.assert_allclose(_np(iop.vector_norm(arr)), 5.0) def test_norm_p1(backend: tuple) -> None: arr = iop.from_numpy(np.array([3.0, -4.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.norm(arr, p=1)), 7.0) + np.testing.assert_allclose(_np(iop.vector_norm(arr, p=1)), 7.0) def test_norm_dim_keepdims(backend: tuple) -> None: arr = iop.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)) - out = iop.norm(arr, p=2, axis=1, keepdims=True) + out = iop.vector_norm(arr, p=2, axis=1, keepdims=True) assert iop.shape(out) == (2, 1) np.testing.assert_allclose(_np(out).reshape(-1), [5.0, 10.0]) @@ -333,24 +342,24 @@ def test_add_array_and_scalar(backend: tuple) -> None: def test_sub(backend: tuple) -> None: a = iop.from_numpy(np.array([5.0, 6.0], dtype=np.float32)) b = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.sub(a, b)), [4.0, 4.0]) + np.testing.assert_allclose(_np(iop.subtract(a, b)), [4.0, 4.0]) def test_mul(backend: tuple) -> None: a = iop.from_numpy(np.array([2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([4.0, 5.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.mul(a, b)), [8.0, 15.0]) + np.testing.assert_allclose(_np(iop.multiply(a, b)), [8.0, 15.0]) def test_div(backend: tuple) -> None: a = iop.from_numpy(np.array([8.0, 10.0], dtype=np.float32)) b = iop.from_numpy(np.array([2.0, 5.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.div(a, b)), [4.0, 2.0]) + np.testing.assert_allclose(_np(iop.divide(a, b)), [4.0, 2.0]) def test_iadd_func(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0], dtype=np.float32)) - out = iop.iadd(a, 10.0) + out = iadd(a, 10.0) # Returned wrapper is the same instance. assert out is a np.testing.assert_allclose(_np(a), [11.0, 12.0]) @@ -358,21 +367,21 @@ def test_iadd_func(backend: tuple) -> None: def test_isub_func(backend: tuple) -> None: a = iop.from_numpy(np.array([5.0, 6.0], dtype=np.float32)) - out = iop.isub(a, 1.0) + out = isubtract(a, 1.0) assert out is a np.testing.assert_allclose(_np(a), [4.0, 5.0]) def test_imul_func(backend: tuple) -> None: a = iop.from_numpy(np.array([2.0, 3.0], dtype=np.float32)) - out = iop.imul(a, 4.0) + out = imultiply(a, 4.0) assert out is a np.testing.assert_allclose(_np(a), [8.0, 12.0]) def test_idiv_func(backend: tuple) -> None: a = iop.from_numpy(np.array([8.0, 12.0], dtype=np.float32)) - out = iop.idiv(a, 4.0) + out = idivide(a, 4.0) assert out is a np.testing.assert_allclose(_np(a), [2.0, 3.0]) @@ -387,6 +396,11 @@ def test_negative(backend: tuple) -> None: np.testing.assert_allclose(_np(iop.negative(arr)), [-1.0, 2.0, -3.0]) +def test_abs(backend: tuple) -> None: + arr = iop.from_numpy(np.array([-1.0, 2.0, -3.0], dtype=np.float32)) + np.testing.assert_allclose(_np(iop.abs(arr)), [1.0, 2.0, 3.0]) + + def test_absolute(backend: tuple) -> None: arr = iop.from_numpy(np.array([1.0, -2.0, 3.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.absolute(arr)), [1.0, 2.0, 3.0]) @@ -422,67 +436,67 @@ def test_maximum_array_and_scalar(backend: tuple) -> None: def test_eq_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([1.0, 5.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.eq(a, b)), [True, False, True]) + np.testing.assert_array_equal(_np(iop.equal(a, b)), [True, False, True]) def test_eq_array_and_scalar(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.eq(a, 2.0)), [False, True, False]) + np.testing.assert_array_equal(_np(iop.equal(a, 2.0)), [False, True, False]) def test_ne_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([1.0, 5.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.ne(a, b)), [False, True, False]) + np.testing.assert_array_equal(_np(iop.not_equal(a, b)), [False, True, False]) def test_ne_array_and_scalar(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.ne(a, 2.0)), [True, False, True]) + np.testing.assert_array_equal(_np(iop.not_equal(a, 2.0)), [True, False, True]) def test_lt_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.lt(a, b)), [True, False, False]) + np.testing.assert_array_equal(_np(iop.less(a, b)), [True, False, False]) def test_lt_array_and_scalar(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.lt(a, 2.5)), [True, True, False]) + np.testing.assert_array_equal(_np(iop.less(a, 2.5)), [True, True, False]) def test_le_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.le(a, b)), [True, True, False]) + np.testing.assert_array_equal(_np(iop.less_equal(a, b)), [True, True, False]) def test_le_array_and_scalar(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.le(a, 2.0)), [True, True, False]) + np.testing.assert_array_equal(_np(iop.less_equal(a, 2.0)), [True, True, False]) def test_gt_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.gt(a, b)), [False, False, True]) + np.testing.assert_array_equal(_np(iop.greater(a, b)), [False, False, True]) def test_gt_array_and_scalar(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.gt(a, 1.5)), [False, True, True]) + np.testing.assert_array_equal(_np(iop.greater(a, 1.5)), [False, True, True]) def test_ge_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) b = iop.from_numpy(np.array([2.0, 2.0, 2.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.ge(a, b)), [False, True, True]) + np.testing.assert_array_equal(_np(iop.greater_equal(a, b)), [False, True, True]) def test_ge_array_and_scalar(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_array_equal(_np(iop.ge(a, 2.0)), [False, True, True]) + np.testing.assert_array_equal(_np(iop.greater_equal(a, 2.0)), [False, True, True]) # Bitwise ---------------------------------------------------------------- @@ -490,8 +504,8 @@ def test_ge_array_and_scalar(backend: tuple) -> None: def test_bitwise_and_bool_arrays(backend: tuple) -> None: a = iop.from_numpy(np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)) - mask1 = iop.gt(a, 1.0) - mask2 = iop.lt(a, 4.0) + mask1 = iop.greater(a, 1.0) + mask2 = iop.less(a, 4.0) np.testing.assert_array_equal(_np(iop.bitwise_and(mask1, mask2)), [False, True, True, False]) @@ -532,13 +546,13 @@ def test_argmax_keepdims(backend: tuple) -> None: def test_set_item_function(backend: tuple) -> None: arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - iop.set_item(arr, 0, iop.from_numpy(np.array(99.0, dtype=np.float32))) + set_item(arr, 0, iop.from_numpy(np.array(99.0, dtype=np.float32))) np.testing.assert_allclose(_np(arr), [99.0, 2.0, 3.0]) def test_get_item_function(backend: tuple) -> None: arr = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.get_item(arr, 1)), 2.0) + np.testing.assert_allclose(_np(get_item(arr, 1)), 2.0) # No-backend errors ------------------------------------------------------ @@ -551,6 +565,8 @@ def test_function_raises_when_no_backend() -> None: def test_to_array_round_trip_with_bool(backend: tuple) -> None: - arr = iop.to_array(True) - out = iop.astype(arr, bool) - assert out is True + arr = iop.asarray(True) + out = iop.astype(arr, DTypes.BOOL) + np_out = _np(out) + assert np_out.dtype == np.bool_ + assert bool(np_out) is True diff --git a/tests/test_iop_rng.py b/tests/test_iop_rng.py index 10bca67..1021239 100644 --- a/tests/test_iop_rng.py +++ b/tests/test_iop_rng.py @@ -116,6 +116,23 @@ def test_derive_seed_returns_int_in_range(backend: tuple) -> None: assert 0 <= seed < 2**32 +# get_numpy_rng --------------------------------------------------------- + + +def test_get_numpy_rng_returns_generator(backend: tuple) -> None: + iop.set_seed(42) + rng = iop.get_numpy_rng() + assert isinstance(rng, np.random.Generator) + + +def test_get_numpy_rng_is_seeded(backend: tuple) -> None: + iop.set_seed(42) + first = iop.get_numpy_rng().standard_normal(4) + iop.set_seed(42) + second = iop.get_numpy_rng().standard_normal(4) + np.testing.assert_array_equal(first, second) + + # Distribution shape checks --------------------------------------------- From e4e9ea5c5ef0e29db95c6eb2eb2937e8630d37b5 Mon Sep 17 00:00:00 2001 From: MyNameIsSimon Date: Mon, 25 May 2026 20:04:58 +0200 Subject: [PATCH 10/11] PR comments --- decent_array/_array.py | 11 ++++++++--- decent_array/interoperability/__init__.py | 5 ++++- .../interoperability/_abstracts/backend.py | 8 ++++++-- decent_array/interoperability/_iop/linalg.py | 11 +++++++++++ .../interoperability/_iop/manipulations.py | 9 ++++++++- decent_array/interoperability/_iop/utils.py | 2 +- .../interoperability/_jax/jax_backend.py | 11 +++++++++-- .../interoperability/_numpy/numpy_backend.py | 11 +++++++++-- .../_pytorch/pytorch_backend.py | 11 +++++++++-- .../_tensorflow/tensorflow_backend.py | 19 ++++++++++++------- tests/test_iop_functions.py | 10 ++++++++-- 11 files changed, 85 insertions(+), 23 deletions(-) diff --git a/decent_array/_array.py b/decent_array/_array.py index 3bb29ba..2799ad7 100644 --- a/decent_array/_array.py +++ b/decent_array/_array.py @@ -31,6 +31,8 @@ from decent_array.interoperability._backend_manager import register_backend_listener if TYPE_CHECKING: + from numpy.typing import NDArray + from decent_array.interoperability._abstracts import Backend from decent_array.types import ArrayKey, SupportedArrayTypes, SupportedDevices @@ -185,7 +187,7 @@ def __and__(self, other: bool | int | Array, /) -> Array: def __rand__(self, other: bool | int | Array, /) -> Array: """Element-wise bitwise/logical AND with the array on the right.""" - return Array(other & self.value) + return Array((other.value if type(other) is Array else other) & self.value) # In-place arithmetic -------------------------------------------------- # @@ -235,8 +237,6 @@ def __getitem__(self, key: ArrayKey, /) -> Array: def __setitem__(self, key: ArrayKey, value: bool | int | float | complex | Array, /) -> None: """Set the item at ``key`` to ``value``.""" - if not isinstance(value, Array): - value = Array(value) self._backend.set_item(self, key, value) # Containers / iteration ---------------------------------------------- @@ -302,3 +302,8 @@ def all(self) -> bool: def device(self) -> SupportedDevices: """Return the device of the array.""" return self._backend.device_of(self) + + @property + def numpy(self) -> NDArray[Any]: + """Return a NumPy array view of the array's data.""" + return self._backend.to_numpy(self) diff --git a/decent_array/interoperability/__init__.py b/decent_array/interoperability/__init__.py index e27b0b0..a837416 100644 --- a/decent_array/interoperability/__init__.py +++ b/decent_array/interoperability/__init__.py @@ -16,12 +16,13 @@ from ._iop.bit_operators import bitwise_and from ._iop.comparasion import equal, greater, greater_equal, less, less_equal, not_equal from ._iop.creation import eye, ones, ones_like, zeros, zeros_like -from ._iop.linalg import dot, matmul, vecdot, vector_norm +from ._iop.linalg import dot, matmul, norm, vecdot, vector_norm from ._iop.manipulations import ( asarray, astype, copy, diag, + diagonal, expand_dims, from_numpy, from_numpy_like, @@ -70,6 +71,7 @@ "derive_seed", "device_of", "diag", + "diagonal", "divide", "dot", "equal", @@ -92,6 +94,7 @@ "multiply", "ndim", "negative", + "norm", "normal", "normal_like", "not_equal", diff --git a/decent_array/interoperability/_abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py index 2337b4f..02e5a45 100644 --- a/decent_array/interoperability/_abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -124,7 +124,11 @@ def unsqueeze(self, x: Array, axis: int) -> Array: @abstractmethod def diag(self, x: Array) -> Array: - """Diagonal: build from a vector or extract from a matrix.""" + """Build a diagonal matrix from a 1-D vector.""" + + @abstractmethod + def diagonal(self, x: Array, offset: int = 0) -> Array: + """Extract the diagonal entries from a 2-D matrix at the given ``offset``.""" @abstractmethod def astype(self, x: Array, dtype: DTypes) -> Array: @@ -281,7 +285,7 @@ def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> A """Index of minimum value along ``axis``.""" @abstractmethod - def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: + def set_item(self, x: Array, key: ArrayKey, value: bool | int | float | complex | Array) -> None: """Set ``x[key] = value``.""" @abstractmethod diff --git a/decent_array/interoperability/_iop/linalg.py b/decent_array/interoperability/_iop/linalg.py index 4c74963..1556ed9 100644 --- a/decent_array/interoperability/_iop/linalg.py +++ b/decent_array/interoperability/_iop/linalg.py @@ -63,3 +63,14 @@ def vector_norm(x: Array, p: float = 2, axis: int | tuple[int, ...] | None = Non if _BACKEND_INSTANCE is None: raise _error return _BACKEND_INSTANCE.vector_norm(x, p, axis, keepdims) + + +def norm(x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: + """ + Vector norm of ``x``. + + Alias for :func:`vector_norm`. + """ + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.vector_norm(x, p, axis, keepdims) diff --git a/decent_array/interoperability/_iop/manipulations.py b/decent_array/interoperability/_iop/manipulations.py index 8dcf8d4..55b4e89 100644 --- a/decent_array/interoperability/_iop/manipulations.py +++ b/decent_array/interoperability/_iop/manipulations.py @@ -136,12 +136,19 @@ def unsqueeze(x: Array, axis: int) -> Array: def diag(x: Array) -> Array: - """Diagonal: build from a vector or extract from a matrix.""" + """Build a diagonal matrix from a 1-D vector.""" if _BACKEND_INSTANCE is None: raise _error return _BACKEND_INSTANCE.diag(x) +def diagonal(x: Array, offset: int = 0) -> Array: + """Extract the diagonal entries from a 2-D matrix at the given ``offset``.""" + if _BACKEND_INSTANCE is None: + raise _error + return _BACKEND_INSTANCE.diagonal(x, offset) + + def astype(x: Array, dtype: DTypes) -> Array: """Cast ``x`` to a different dtype.""" if _BACKEND_INSTANCE is None: diff --git a/decent_array/interoperability/_iop/utils.py b/decent_array/interoperability/_iop/utils.py index 7632e9d..e1b737a 100644 --- a/decent_array/interoperability/_iop/utils.py +++ b/decent_array/interoperability/_iop/utils.py @@ -48,7 +48,7 @@ def device_of(x: Array) -> SupportedDevices: return _BACKEND_INSTANCE.device_of(x) -def set_item(x: Array, key: ArrayKey, value: Array) -> None: +def set_item(x: Array, key: ArrayKey, value: bool | int | float | complex | Array) -> None: """Set ``x[key] = value`` in place.""" if _BACKEND_INSTANCE is None: raise _error diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index 85e58ef..7cf4759 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -132,8 +132,15 @@ def unsqueeze(self, x: Array, axis: int) -> Array: return Array(jnp.expand_dims(x.value, axis=axis)) def diag(self, x: Array) -> Array: + if x.value.ndim != 1: + raise ValueError(f"diag requires a 1-D array, got {x.value.ndim}-D") return Array(jnp.diag(x.value)) + def diagonal(self, x: Array, offset: int = 0) -> Array: + if x.value.ndim != 2: + raise ValueError(f"diagonal requires a 2-D array, got {x.value.ndim}-D") + return Array(jnp.diagonal(x.value, offset=offset)) + def astype(self, x: Array, dtype: DTypes) -> Array: if dtype not in _DTYPE_MAP: raise ValueError(f"Unsupported dtype '{dtype.value}' for NumPy backend.") @@ -259,9 +266,9 @@ def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> A def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: return Array(jnp.argmin(x.value, axis=axis, keepdims=keepdims)) - def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: + def set_item(self, x: Array, key: ArrayKey, value: bool | int | float | complex | Array) -> None: # JAX arrays are immutable; rebind the wrapper to a new array with `key` updated. - x.value = x.value.at[key].set(value.value) + x.value = x.value.at[key].set(_unwrap(value)) def get_item(self, x: Array, key: ArrayKey) -> Array: return Array(x.value[key]) diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index f160780..292d12c 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -133,8 +133,15 @@ def unsqueeze(self, x: Array, axis: int) -> Array: return Array(np.expand_dims(x.value, axis=axis)) def diag(self, x: Array) -> Array: + if x.value.ndim != 1: + raise ValueError(f"diag requires a 1-D array, got {x.value.ndim}-D") return Array(np.diag(x.value)) + def diagonal(self, x: Array, offset: int = 0) -> Array: + if x.value.ndim != 2: + raise ValueError(f"diagonal requires a 2-D array, got {x.value.ndim}-D") + return Array(np.diagonal(x.value, offset=offset)) + def astype(self, x: Array, dtype: DTypes) -> Array: if dtype not in _DTYPE_MAP: raise ValueError(f"Unsupported dtype '{dtype.value}' for NumPy backend.") @@ -259,8 +266,8 @@ def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> A def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: return Array(np.argmin(x.value, axis=axis, keepdims=keepdims)) - def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: - x.value[key] = value.value + def set_item(self, x: Array, key: ArrayKey, value: bool | int | float | complex | Array) -> None: + x.value[key] = _unwrap(value) def get_item(self, x: Array, key: ArrayKey) -> Array: return Array(x.value[key]) diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index 8875675..9b7c475 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -142,8 +142,15 @@ def unsqueeze(self, x: Array, axis: int) -> Array: return Array(torch.unsqueeze(x.value, dim=axis)) def diag(self, x: Array) -> Array: + if x.value.ndim != 1: + raise ValueError(f"diag requires a 1-D array, got {x.value.ndim}-D") return Array(torch.diag(x.value)) + def diagonal(self, x: Array, offset: int = 0) -> Array: + if x.value.ndim != 2: + raise ValueError(f"diagonal requires a 2-D array, got {x.value.ndim}-D") + return Array(torch.diagonal(x.value, offset=offset)) + def astype(self, x: Array, dtype: DTypes) -> Array: if dtype not in _DTYPE_MAP: raise ValueError(f"Unsupported dtype '{dtype.value}' for PyTorch backend.") @@ -288,8 +295,8 @@ def argmax(self, x: Array, axis: int | None = None, keepdims: bool = False) -> A def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> Array: return Array(torch.argmin(x.value, dim=axis, keepdim=keepdims)) - def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: - x.value[key] = value.value + def set_item(self, x: Array, key: ArrayKey, value: bool | int | float | complex | Array) -> None: + x.value[key] = _unwrap(value) def get_item(self, x: Array, key: ArrayKey) -> Array: return Array(x.value[key]) diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index 9da64c8..83eb018 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -145,11 +145,16 @@ def unsqueeze(self, x: Array, axis: int) -> Array: def diag(self, x: Array) -> Array: v = x.value rank = v.shape.ndims - if rank == 1: - return Array(tf.linalg.diag(v)) - if rank == 2: - return Array(tf.linalg.diag_part(v)) - raise ValueError(f"diag requires a 1- or 2-D tensor, got rank {rank}") + if rank != 1: + raise ValueError(f"diag requires a 1-D tensor, got rank {rank}") + return Array(tf.linalg.diag(v)) + + def diagonal(self, x: Array, offset: int = 0) -> Array: + v = x.value + rank = v.shape.ndims + if rank != 2: + raise ValueError(f"diagonal requires a 2-D tensor, got rank {rank}") + return Array(tf.linalg.diag_part(v, k=offset)) def astype(self, x: Array, dtype: DTypes) -> Array: if dtype not in _DTYPE_MAP: @@ -308,14 +313,14 @@ def argmin(self, x: Array, axis: int | None = None, keepdims: bool = False) -> A out = tf.expand_dims(out, axis=axis) return Array(out) - def set_item(self, x: Array, key: ArrayKey, value: Array) -> None: + def set_item(self, x: Array, key: ArrayKey, value: bool | int | float | complex | Array) -> None: # TF eager tensors are immutable; round-trip through numpy so arbitrary indexing # patterns (slices, fancy indexing) Just Work. The wrapper is rebound to a fresh # tensor on the configured device. This is correct but allocates — algorithms # that hammer set_item in tight loops should consider numpy or pytorch. original = x.value np_array = original.numpy().copy() - np_array[key] = np.asarray(value.value) + np_array[key] = np.asarray(_unwrap(value)) with tf.device(self._native_device): x.value = tf.convert_to_tensor(np_array, dtype=original.dtype) diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py index f2d7391..cf42df1 100644 --- a/tests/test_iop_functions.py +++ b/tests/test_iop_functions.py @@ -188,9 +188,15 @@ def test_diag_from_vector(backend: tuple) -> None: np.testing.assert_allclose(_np(iop.diag(arr)), np.diag([1.0, 2.0, 3.0])) -def test_diag_from_matrix(backend: tuple) -> None: +def test_diagonal_from_matrix(backend: tuple) -> None: arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.diag(arr)), [1.0, 4.0]) + np.testing.assert_allclose(_np(iop.diagonal(arr)), [1.0, 4.0]) + + +def test_diagonal_with_offset(backend: tuple) -> None: + arr = iop.from_numpy(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)) + np.testing.assert_allclose(_np(iop.diagonal(arr, offset=1)), [2.0]) + np.testing.assert_allclose(_np(iop.diagonal(arr, offset=-1)), [3.0]) def test_astype_to_float(backend: tuple) -> None: From 6c95a2fc34cbd148607bd9585c890f837836c369 Mon Sep 17 00:00:00 2001 From: MyNameIsSimon Date: Tue, 26 May 2026 20:20:13 +0200 Subject: [PATCH 11/11] pr changes --- .../interoperability/_abstracts/backend.py | 8 +++---- decent_array/interoperability/_iop/linalg.py | 22 ++++++++++++++----- decent_array/interoperability/_iop/math.py | 4 ++-- .../interoperability/_jax/jax_backend.py | 10 ++++----- .../interoperability/_numpy/numpy_backend.py | 10 ++++----- .../_pytorch/pytorch_backend.py | 10 ++++----- .../_tensorflow/tensorflow_backend.py | 10 ++++----- tests/test_iop_functions.py | 6 +++-- 8 files changed, 46 insertions(+), 34 deletions(-) diff --git a/decent_array/interoperability/_abstracts/backend.py b/decent_array/interoperability/_abstracts/backend.py index 02e5a45..cfa17b8 100644 --- a/decent_array/interoperability/_abstracts/backend.py +++ b/decent_array/interoperability/_abstracts/backend.py @@ -137,7 +137,7 @@ def astype(self, x: Array, dtype: DTypes) -> Array: # Linalg -------------------------------------------------------------- @abstractmethod - def dot(self, x1: Array, x2: Array) -> Array: + def vecdot(self, x1: Array, x2: Array) -> Array: """Dot product of two arrays.""" @abstractmethod @@ -148,9 +148,9 @@ def matmul(self, x1: Array, x2: Array) -> Array: def vector_norm( self, x: Array, - p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, + ord: int | float = 2, # noqa: A002 ) -> Array: """Compute the norm of ``x``.""" @@ -217,8 +217,8 @@ def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: """In-place element-wise division.""" @abstractmethod - def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: - """Raise ``x`` to power ``p``.""" + def pow(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + """Raise ``x1`` to power ``x2``.""" @abstractmethod def negative(self, x: Array) -> Array: diff --git a/decent_array/interoperability/_iop/linalg.py b/decent_array/interoperability/_iop/linalg.py index 1556ed9..c10e0f0 100644 --- a/decent_array/interoperability/_iop/linalg.py +++ b/decent_array/interoperability/_iop/linalg.py @@ -37,7 +37,7 @@ def vecdot(x1: Array, x2: Array) -> Array: """Vector dot product of two arrays.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.dot(x1, x2) + return _BACKEND_INSTANCE.vecdot(x1, x2) def dot(x1: Array, x2: Array) -> Array: @@ -48,7 +48,7 @@ def dot(x1: Array, x2: Array) -> Array: """ if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.dot(x1, x2) + return _BACKEND_INSTANCE.vecdot(x1, x2) def matmul(x1: Array, x2: Array) -> Array: @@ -58,14 +58,24 @@ def matmul(x1: Array, x2: Array) -> Array: return _BACKEND_INSTANCE.matmul(x1, x2) -def vector_norm(x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: +def vector_norm( + x: Array, + axis: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ord: int | float = 2, # noqa: A002 +) -> Array: """Vector norm of ``x``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.vector_norm(x, p, axis, keepdims) + return _BACKEND_INSTANCE.vector_norm(x, axis, keepdims, ord) -def norm(x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False) -> Array: +def norm( + x: Array, + axis: int | tuple[int, ...] | None = None, + keepdims: bool = False, + ord: int | float = 2, # noqa: A002 +) -> Array: """ Vector norm of ``x``. @@ -73,4 +83,4 @@ def norm(x: Array, p: float = 2, axis: int | tuple[int, ...] | None = None, keep """ if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.vector_norm(x, p, axis, keepdims) + return _BACKEND_INSTANCE.vector_norm(x, axis, keepdims, ord) diff --git a/decent_array/interoperability/_iop/math.py b/decent_array/interoperability/_iop/math.py index 3894989..f9dd2bf 100644 --- a/decent_array/interoperability/_iop/math.py +++ b/decent_array/interoperability/_iop/math.py @@ -89,11 +89,11 @@ def idivide[T: Array](x1: T, x2: int | float | complex | Array) -> T: return _BACKEND_INSTANCE.idivide(x1, x2) -def pow(x: Array, p: int | float | complex) -> Array: # noqa: A001 +def pow(x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: # noqa: A001 """Raise ``x`` to power ``p``.""" if _BACKEND_INSTANCE is None: raise _error - return _BACKEND_INSTANCE.pow(x, p) + return _BACKEND_INSTANCE.pow(x1, x2) def negative(x: Array) -> Array: diff --git a/decent_array/interoperability/_jax/jax_backend.py b/decent_array/interoperability/_jax/jax_backend.py index 7cf4759..734b634 100644 --- a/decent_array/interoperability/_jax/jax_backend.py +++ b/decent_array/interoperability/_jax/jax_backend.py @@ -148,7 +148,7 @@ def astype(self, x: Array, dtype: DTypes) -> Array: # Linalg - def dot(self, x1: Array, x2: Array) -> Array: + def vecdot(self, x1: Array, x2: Array) -> Array: return Array(jnp.dot(x1.value, x2.value)) def matmul(self, x1: Array, x2: Array) -> Array: @@ -157,11 +157,11 @@ def matmul(self, x1: Array, x2: Array) -> Array: def vector_norm( self, x: Array, - p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, + ord: int | float = 2, # noqa: A002 ) -> Array: - return Array(jnp.linalg.norm(x.value, ord=p, axis=axis, keepdims=keepdims)) + return Array(jnp.linalg.norm(x.value, ord=ord, axis=axis, keepdims=keepdims)) # Math reductions @@ -215,8 +215,8 @@ def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: x1.value = jnp.divide(x1.value, _unwrap(x2)) return x1 - def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: - return Array(jnp.power(_unwrap(x), _unwrap(p))) + def pow(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(jnp.power(_unwrap(x1), _unwrap(x2))) def negative(self, x: Array) -> Array: return Array(jnp.negative(x.value)) diff --git a/decent_array/interoperability/_numpy/numpy_backend.py b/decent_array/interoperability/_numpy/numpy_backend.py index 292d12c..72f363d 100644 --- a/decent_array/interoperability/_numpy/numpy_backend.py +++ b/decent_array/interoperability/_numpy/numpy_backend.py @@ -149,7 +149,7 @@ def astype(self, x: Array, dtype: DTypes) -> Array: # Linalg - def dot(self, x1: Array, x2: Array) -> Array: + def vecdot(self, x1: Array, x2: Array) -> Array: return Array(np.dot(x1.value, x2.value)) def matmul(self, x1: Array, x2: Array) -> Array: @@ -158,11 +158,11 @@ def matmul(self, x1: Array, x2: Array) -> Array: def vector_norm( self, x: Array, - p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, + ord: int | float = 2, # noqa: A002 ) -> Array: - return Array(np.linalg.norm(x.value, ord=p, axis=axis, keepdims=keepdims)) + return Array(np.linalg.norm(x.value, ord=ord, axis=axis, keepdims=keepdims)) # Math reductions @@ -215,8 +215,8 @@ def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: x1.value /= _unwrap(x2) return x1 - def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: - return Array(np.power(_unwrap(x), _unwrap(p))) + def pow(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(np.power(_unwrap(x1), _unwrap(x2))) def negative(self, x: Array) -> Array: return Array(np.negative(x.value)) diff --git a/decent_array/interoperability/_pytorch/pytorch_backend.py b/decent_array/interoperability/_pytorch/pytorch_backend.py index 9b7c475..1439f4f 100644 --- a/decent_array/interoperability/_pytorch/pytorch_backend.py +++ b/decent_array/interoperability/_pytorch/pytorch_backend.py @@ -158,7 +158,7 @@ def astype(self, x: Array, dtype: DTypes) -> Array: # Linalg - def dot(self, x1: Array, x2: Array) -> Array: + def vecdot(self, x1: Array, x2: Array) -> Array: return Array(torch.dot(x1.value, x2.value)) def matmul(self, x1: Array, x2: Array) -> Array: @@ -167,11 +167,11 @@ def matmul(self, x1: Array, x2: Array) -> Array: def vector_norm( self, x: Array, - p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, + ord: int | float = 2, # noqa: A002 ) -> Array: - return Array(torch.linalg.norm(x.value, ord=p, axis=axis, keepdim=keepdims)) + return Array(torch.linalg.norm(x.value, ord=ord, axis=axis, keepdim=keepdims)) # Math reductions @@ -236,8 +236,8 @@ def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: x1.value.div_(_unwrap(x2)) return x1 - def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: - return Array(torch.pow(_unwrap(x), _unwrap(p))) + def pow(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(torch.pow(_unwrap(x1), _unwrap(x2))) def negative(self, x: Array) -> Array: return Array(torch.neg(x.value)) diff --git a/decent_array/interoperability/_tensorflow/tensorflow_backend.py b/decent_array/interoperability/_tensorflow/tensorflow_backend.py index 83eb018..586acae 100644 --- a/decent_array/interoperability/_tensorflow/tensorflow_backend.py +++ b/decent_array/interoperability/_tensorflow/tensorflow_backend.py @@ -163,7 +163,7 @@ def astype(self, x: Array, dtype: DTypes) -> Array: # Linalg - def dot(self, x1: Array, x2: Array) -> Array: + def vecdot(self, x1: Array, x2: Array) -> Array: return Array(tf.tensordot(x1.value, x2.value, axes=1)) def matmul(self, x1: Array, x2: Array) -> Array: @@ -177,15 +177,15 @@ def matmul(self, x1: Array, x2: Array) -> Array: def vector_norm( self, x: Array, - p: float = 2, axis: int | tuple[int, ...] | None = None, keepdims: bool = False, + ord: int | float = 2, # noqa: A002 ) -> Array: v = x.value # tf.norm defaults differ from np.linalg.norm on 2-D inputs (operator vs. # Frobenius); match numpy's flat default by reducing over both trailing axes. axis = axis if axis is not None else (-2, -1) if v.ndim == 2 else None - return Array(tf.norm(v, ord=p, axis=axis, keepdims=keepdims)) + return Array(tf.norm(v, ord=ord, axis=axis, keepdims=keepdims)) # Math reductions @@ -239,8 +239,8 @@ def idivide[T: Array](self, x1: T, x2: int | float | complex | Array) -> T: x1.value = tf.divide(x1.value, _unwrap(x2)) return x1 - def pow(self, x: int | float | complex | Array, p: int | float | complex | Array) -> Array: - return Array(tf.pow(_unwrap(x), _unwrap(p))) + def pow(self, x1: int | float | complex | Array, x2: int | float | complex | Array) -> Array: + return Array(tf.pow(_unwrap(x1), _unwrap(x2))) def negative(self, x: Array) -> Array: return Array(tf.negative(x.value)) diff --git a/tests/test_iop_functions.py b/tests/test_iop_functions.py index cf42df1..671ecd1 100644 --- a/tests/test_iop_functions.py +++ b/tests/test_iop_functions.py @@ -252,12 +252,12 @@ def test_norm_default_l2(backend: tuple) -> None: def test_norm_p1(backend: tuple) -> None: arr = iop.from_numpy(np.array([3.0, -4.0], dtype=np.float32)) - np.testing.assert_allclose(_np(iop.vector_norm(arr, p=1)), 7.0) + np.testing.assert_allclose(_np(iop.vector_norm(arr, ord=1)), 7.0) def test_norm_dim_keepdims(backend: tuple) -> None: arr = iop.from_numpy(np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)) - out = iop.vector_norm(arr, p=2, axis=1, keepdims=True) + out = iop.vector_norm(arr, ord=2, axis=1, keepdims=True) assert iop.shape(out) == (2, 1) np.testing.assert_allclose(_np(out).reshape(-1), [5.0, 10.0]) @@ -395,6 +395,8 @@ def test_idiv_func(backend: tuple) -> None: def test_pow_function(backend: tuple) -> None: arr = iop.from_numpy(np.array([2.0, 3.0, 4.0], dtype=np.float32)) np.testing.assert_allclose(_np(iop.pow(arr, 2)), [4.0, 9.0, 16.0]) + arr2 = iop.from_numpy(np.array([1.0, 2.0, 3.0], dtype=np.float32)) + np.testing.assert_allclose(_np(iop.pow(arr, arr2)), [2.0, 9.0, 64.0]) def test_negative(backend: tuple) -> None:

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