diff --git a/.github/workflows/dockgen.yml b/.github/workflows/dockgen.yml index 82890fbc2..a914b93b2 100644 --- a/.github/workflows/dockgen.yml +++ b/.github/workflows/dockgen.yml @@ -16,7 +16,7 @@ jobs: attestations: write id-token: write steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 - uses: astral-sh/setup-uv@v6 - run: uvx dockgen @@ -46,7 +46,7 @@ jobs: labels: ${{ steps.meta.outputs.labels }} - name: Generate artifact attestation - uses: actions/attest-build-provenance@v2 + uses: actions/attest-build-provenance@v3 with: subject-name: ghcr.io/${{ github.repository }} subject-digest: ${{ steps.push.outputs.digest }} diff --git a/.github/workflows/jrl-cmakemodules.yml b/.github/workflows/jrl-cmakemodules.yml index 7c782fef6..e21901eb8 100644 --- a/.github/workflows/jrl-cmakemodules.yml +++ b/.github/workflows/jrl-cmakemodules.yml @@ -2,6 +2,8 @@ name: CI - JRL-cmakemodules on: push: + branches: + - devel paths-ignore: - 'doc/**' - '.gitlab-ci.yml' @@ -28,7 +30,7 @@ jobs: name: Check configuration with git submodules runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: submodules: true - run: sudo apt install libboost-all-dev libeigen3-dev python3-numpy python3-scipy @@ -39,7 +41,7 @@ jobs: name: Check configuration without git submodules runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: submodules: false path: eigenpy diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml index 29fc514da..fa5576b6f 100644 --- a/.github/workflows/linux.yml +++ b/.github/workflows/linux.yml @@ -2,6 +2,8 @@ name: CI - Linux via APT on: push: + branches: + - devel paths-ignore: - 'doc/**' - '.gitlab-ci.yml' @@ -28,11 +30,12 @@ jobs: name: "Test python ${{ matrix.python }} on ${{ matrix.ubuntu }}.04" runs-on: "ubuntu-${{ matrix.ubuntu }}.04" strategy: + fail-fast: false matrix: python: [3] ubuntu: [22, 24] steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: submodules: 'true' - run: | diff --git a/.github/workflows/macos-linux-windows-pixi.yml b/.github/workflows/macos-linux-windows-pixi.yml index 2dcb2d425..0c56d9638 100644 --- a/.github/workflows/macos-linux-windows-pixi.yml +++ b/.github/workflows/macos-linux-windows-pixi.yml @@ -2,6 +2,8 @@ name: CI - MacOS/Linux/Windows via Pixi on: push: + branches: + - devel paths-ignore: - 'doc/**' - '.gitlab-ci.yml' @@ -58,7 +60,7 @@ jobs: build_type: Release steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: submodules: recursive @@ -68,7 +70,7 @@ jobs: key: ccache-macos-linux-windows-pixi-${{ matrix.os }}-${{ matrix.build_type }}-${{ matrix.cxx_options }}-${{ matrix.environment }}-${{ github.sha }} restore-keys: ccache-macos-linux-windows-pixi-${{ matrix.os }}-${{ matrix.build_type }}-${{ matrix.cxx_options }}-${{ matrix.environment }}- - - uses: prefix-dev/setup-pixi@v0.8.14 + - uses: prefix-dev/setup-pixi@v0.9.1 with: cache: true environments: ${{ matrix.environment }} diff --git a/.github/workflows/nix.yml b/.github/workflows/nix.yml index eaba844f2..af3db8fd6 100644 --- a/.github/workflows/nix.yml +++ b/.github/workflows/nix.yml @@ -3,27 +3,28 @@ name: "CI - Nix" on: push: branches: - - master - devel pull_request: - branches: - - master - - devel +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: nix: runs-on: "${{ matrix.os }}-latest" strategy: + fail-fast: false matrix: os: [ubuntu, macos] + eigen: [3, 5] steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 - uses: cachix/install-nix-action@v31 - uses: cachix/cachix-action@v16 with: name: gepetto authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' - - run: nix build -L + - run: nix build -L ".#eigenpy-eigen${{ matrix.eigen }}" check: if: always() diff --git a/.github/workflows/reloc.yml b/.github/workflows/reloc.yml index 80de88faf..e90ac6fb3 100644 --- a/.github/workflows/reloc.yml +++ b/.github/workflows/reloc.yml @@ -2,6 +2,8 @@ name: CI - Ensure relocatable on: push: + branches: + - devel paths-ignore: - 'doc/**' - '.gitlab-ci.yml' @@ -32,7 +34,7 @@ jobs: CMAKE_CXX_COMPILER_LAUNCHER: ccache steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: submodules: recursive diff --git a/.github/workflows/ros_ci.yml b/.github/workflows/ros_ci.yml index 8236a1d2d..ed2edd2c8 100644 --- a/.github/workflows/ros_ci.yml +++ b/.github/workflows/ros_ci.yml @@ -6,6 +6,8 @@ name: CI - Linux via ROS # This determines when this workflow is run on: push: + branches: + - devel paths-ignore: - 'doc/**' - '.gitlab-ci.yml' @@ -30,6 +32,7 @@ concurrency: jobs: CI: strategy: + fail-fast: false matrix: env: - {ROS_DISTRO: humble} @@ -40,11 +43,11 @@ jobs: BUILDER: colcon runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: submodules: recursive # Run industrial_ci - - uses: 'ros-industrial/industrial_ci@e3d16c224caf4832cf68e74093eb70f3a979b4cc' + - uses: 'ros-industrial/industrial_ci@eb3ea328ff056aa2435d5b3493e7e2929c310f8e' env: ${{ matrix.env }} check: diff --git a/.github/workflows/update-flake-lock.yml b/.github/workflows/update-flake-lock.yml index 404e8f49a..4a3ac072f 100644 --- a/.github/workflows/update-flake-lock.yml +++ b/.github/workflows/update-flake-lock.yml @@ -10,7 +10,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v5 - name: Install Nix uses: DeterminateSystems/nix-installer-action@main - name: Update flake.lock diff --git a/.github/workflows/update_pixi_lockfile.yml b/.github/workflows/update_pixi_lockfile.yml index 9298efd8a..b70d66b29 100644 --- a/.github/workflows/update_pixi_lockfile.yml +++ b/.github/workflows/update_pixi_lockfile.yml @@ -19,7 +19,7 @@ jobs: app-id: ${{ secrets.APP_ID }} private-key: ${{ secrets.APP_PRIVATE_KEY }} - - uses: actions/checkout@v4 + - uses: actions/checkout@v5 with: token: ${{ steps.generate-token.outputs.token }} ref: devel @@ -27,7 +27,7 @@ jobs: persist-credentials: false - name: Set up pixi - uses: prefix-dev/setup-pixi@v0.8.14 + uses: prefix-dev/setup-pixi@v0.9.1 with: run-install: false diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index f16c60239..0a0313cde 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -4,7 +4,7 @@ ci: autoupdate_schedule: quarterly repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.12.2 + rev: v0.13.3 hooks: - id: ruff args: @@ -18,15 +18,15 @@ repos: hooks: - id: cmake-format - repo: https://github.com/pappasam/toml-sort - rev: v0.24.2 + rev: v0.24.3 hooks: - id: toml-sort-fix exclude: pixi.toml|dockgen.toml - repo: https://github.com/pre-commit/mirrors-clang-format - rev: v20.1.7 + rev: v21.1.2 hooks: - id: clang-format - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v5.0.0 + rev: v6.0.0 hooks: - id: trailing-whitespace diff --git a/CHANGELOG.md b/CHANGELOG.md index bd14ced6f..e89b31143 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,8 +6,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). ## [Unreleased] +### Changed +- Remove `accelerate.hpp` header that clash with Accelerate.hpp in non case sensitive OS ([#593](https://github.com/stack-of-tasks/eigenpy/pull/593) + We don't consider it an API break since this header was rarely used. + +### Added +- Support for Python slice, tuple and list indexing for `std::vector` bindings ([#592](https://github.com/stack-of-tasks/eigenpy/pull/592)) + +### Fixed +- Fix partly the support of the change of API of GeneralizedEigenSolver in Eigen 5+ ([#594](https://github.com/stack-of-tasks/eigenpy/pull/594)) +- Fix Eigen decompositions and solvers for Eigen 5 ([#596](https://github.com/stack-of-tasks/eigenpy/pull/596)) + +## [3.12.0] - 2025-08-12 + ### Added +- Add additional decompositions and solvers from Eigen ([#571](https://github.com/stack-of-tasks/eigenpy/pull/571)) - Docker images `ghcr.io/stack-of-tasks/eigenpy` ([#575](https://github.com/stack-of-tasks/eigenpy/pull/575)) ### Changed @@ -746,7 +760,8 @@ One can now easily expose C++ struct containing Eigen objects in Python avoiding ## [1.0.0] - 2014-07-18 -[Unreleased]: https://github.com/stack-of-tasks/eigenpy/compare/v3.11.0...HEAD +[Unreleased]: https://github.com/stack-of-tasks/eigenpy/compare/v3.12.0...HEAD +[3.12.0]: https://github.com/stack-of-tasks/eigenpy/compare/v3.11.0...v3.12.0 [3.11.0]: https://github.com/stack-of-tasks/eigenpy/compare/v3.10.3...v3.11.0 [3.10.3]: https://github.com/stack-of-tasks/eigenpy/compare/v3.10.2...v3.10.3 [3.10.2]: https://github.com/stack-of-tasks/eigenpy/compare/v3.10.1...v3.10.2 diff --git a/CMakeLists.txt b/CMakeLists.txt index e82a3c6ae..0ca21e2c6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -190,10 +190,14 @@ set(${PROJECT_NAME}_SOLVERS_HEADERS include/eigenpy/solvers/preconditioners.hpp include/eigenpy/solvers/IterativeSolverBase.hpp include/eigenpy/solvers/LeastSquaresConjugateGradient.hpp + include/eigenpy/solvers/BiCGSTAB.hpp + include/eigenpy/solvers/MINRES.hpp include/eigenpy/solvers/ConjugateGradient.hpp include/eigenpy/solvers/SparseSolverBase.hpp include/eigenpy/solvers/BasicPreconditioners.hpp - include/eigenpy/solvers/BFGSPreconditioners.hpp) + include/eigenpy/solvers/BFGSPreconditioners.hpp + include/eigenpy/solvers/IncompleteCholesky.hpp + include/eigenpy/solvers/IncompleteLUT.hpp) set(${PROJECT_NAME}_EIGEN_HEADERS include/eigenpy/eigen/EigenBase.hpp) @@ -205,13 +209,17 @@ set(${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_CHOLMOD_HEADERS include/eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp) set(${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_ACCELERATE_HEADERS - include/eigenpy/decompositions/sparse/accelerate/accelerate.hpp) + include/eigenpy/decompositions/sparse/accelerate/Accelerate.hpp) set(${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_HEADERS - include/eigenpy/decompositions/sparse/LLT.hpp - include/eigenpy/decompositions/sparse/LDLT.hpp + include/eigenpy/decompositions/sparse/SimplicialLLT.hpp + include/eigenpy/decompositions/sparse/SimplicialLDLT.hpp + include/eigenpy/decompositions/sparse/SparseLU.hpp + include/eigenpy/decompositions/sparse/SparseQR.hpp include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp - include/eigenpy/decompositions/sparse/SparseSolverBase.hpp) + include/eigenpy/decompositions/sparse/SparseSolverBase.hpp + include/eigenpy/decompositions/sparse/LDLT.hpp + include/eigenpy/decompositions/sparse/LLT.hpp) if(BUILD_WITH_CHOLMOD_SUPPORT) list(APPEND ${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_HEADERS @@ -227,6 +235,16 @@ set(${PROJECT_NAME}_DECOMPOSITIONS_HEADERS ${${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_HEADERS} include/eigenpy/decompositions/decompositions.hpp include/eigenpy/decompositions/EigenSolver.hpp + include/eigenpy/decompositions/GeneralizedEigenSolver.hpp + include/eigenpy/decompositions/GeneralizedSelfAdjointEigenSolver.hpp + include/eigenpy/decompositions/HessenbergDecomposition.hpp + include/eigenpy/decompositions/RealQZ.hpp + include/eigenpy/decompositions/Tridiagonalization.hpp + include/eigenpy/decompositions/RealSchur.hpp + include/eigenpy/decompositions/ComplexEigenSolver.hpp + include/eigenpy/decompositions/ComplexSchur.hpp + include/eigenpy/decompositions/FullPivLU.hpp + include/eigenpy/decompositions/PartialPivLU.hpp include/eigenpy/decompositions/PermutationMatrix.hpp include/eigenpy/decompositions/LDLT.hpp include/eigenpy/decompositions/LLT.hpp @@ -236,6 +254,9 @@ set(${PROJECT_NAME}_DECOMPOSITIONS_HEADERS include/eigenpy/decompositions/CompleteOrthogonalDecomposition.hpp include/eigenpy/decompositions/FullPivHouseholderQR.hpp include/eigenpy/decompositions/SelfAdjointEigenSolver.hpp + include/eigenpy/decompositions/SVDBase.hpp + include/eigenpy/decompositions/BDCSVD.hpp + include/eigenpy/decompositions/JacobiSVD.hpp include/eigenpy/decompositions/minres.hpp) set(${PROJECT_NAME}_HEADERS @@ -300,17 +321,36 @@ list( # ---------------------------------------------------- # --- TARGETS ---------------------------------------- # ---------------------------------------------------- -set(${PROJECT_NAME}_SOLVERS_SOURCES src/solvers/preconditioners.cpp - src/solvers/solvers.cpp) +set(${PROJECT_NAME}_SOLVERS_SOURCES + src/solvers/preconditioners.cpp + src/solvers/solvers.cpp + src/solvers/minres.cpp + src/solvers/bicgstab.cpp + src/solvers/conjugate-gradient.cpp + src/solvers/least-squares-conjugate-gradient.cpp + src/solvers/incomplete-cholesky.cpp + src/solvers/incomplete-lut.cpp) set(${PROJECT_NAME}_DECOMPOSITIONS_SOURCES src/decompositions/decompositions.cpp src/decompositions/eigen-solver.cpp + src/decompositions/generalized-eigen-solver.cpp + src/decompositions/generalized-self-adjoint-eigen-solver.cpp + src/decompositions/complex-eigen-solver.cpp + src/decompositions/complex-schur.cpp src/decompositions/llt-solver.cpp src/decompositions/ldlt-solver.cpp - src/decompositions/minres-solver.cpp + src/decompositions/bdcsvd-solver.cpp + src/decompositions/jacobisvd-solver.cpp + src/decompositions/fullpivlu-solver.cpp + src/decompositions/hessenberg-decomposition.cpp + src/decompositions/real-qz.cpp + src/decompositions/tridiagonalization.cpp + src/decompositions/real-schur.cpp + src/decompositions/partialpivlu-solver.cpp + src/decompositions/sparse-lu-solver.cpp + src/decompositions/sparse-qr-solver.cpp src/decompositions/qr-solvers.cpp - src/decompositions/eigen-solver.cpp src/decompositions/self-adjoint-eigen-solver.cpp src/decompositions/permutation-matrix.cpp src/decompositions/simplicial-llt-solver.cpp diff --git a/README.md b/README.md index f5a5bae17..c1e9d8763 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ EigenPy — Versatile and efficient Python bindings between Numpy and Eigen - full support Eigen::Ref avoiding memory allocation - full support of the Eigen::Tensor module - exposition of the Geometry module of Eigen for easy code prototyping -- standard matrix decomposion routines of Eigen such as the Cholesky decomposition (SVD and QR decompositions [can be added](#contributing)) +- standard matrix decomposion routines of Eigen such as the Cholesky, SVD and QR decompositions - full support of SWIG objects - full support of runtime declaration of Numpy scalar types - extended API to expose several STL types and some of their Boost equivalents: `optional` types, `std::pair`, maps, variants... @@ -100,6 +100,7 @@ The following people have been involved in the development of **EigenPy**: - [Loïc Estève](https://github.com/lesteve) (Inria): Conda integration - [Wilson Jallet](https://manifoldfr.github.io/) (Inria): core developer - [Joris Vaillant](https://github.com/jorisv) (Inria): core developer and manager of the project +- [Lucas Haubert](https://www.linkedin.com/in/lucas-haubert-b668a421a/) (Inria): core developer If you have taken part in the development of **EigenPy**, feel free to add your name and contribution here. diff --git a/cmake b/cmake index 3632eb9ed..34ded94e5 160000 --- a/cmake +++ b/cmake @@ -1 +1 @@ -Subproject commit 3632eb9ed43e29d7acbc5b35d30c9b2aee801702 +Subproject commit 34ded94e5d33ce56746abb4898b4ccc6dc69bfe8 diff --git a/flake.lock b/flake.lock index 807a125f8..58b5a8e4a 100644 --- a/flake.lock +++ b/flake.lock @@ -5,11 +5,11 @@ "nixpkgs-lib": "nixpkgs-lib" }, "locked": { - "lastModified": 1751413152, - "narHash": "sha256-Tyw1RjYEsp5scoigs1384gIg6e0GoBVjms4aXFfRssQ=", + "lastModified": 1759362264, + "narHash": "sha256-wfG0S7pltlYyZTM+qqlhJ7GMw2fTF4mLKCIVhLii/4M=", "owner": "hercules-ci", "repo": "flake-parts", - "rev": "77826244401ea9de6e3bac47c2db46005e1f30b5", + "rev": "758cf7296bee11f1706a574c77d072b8a7baa881", "type": "github" }, "original": { @@ -20,11 +20,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 1751271578, - "narHash": "sha256-P/SQmKDu06x8yv7i0s8bvnnuJYkxVGBWLWHaU+tt4YY=", + "lastModified": 1759381078, + "narHash": "sha256-gTrEEp5gEspIcCOx9PD8kMaF1iEmfBcTbO0Jag2QhQs=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "3016b4b15d13f3089db8a41ef937b13a9e33a8df", + "rev": "7df7ff7d8e00218376575f0acdcc5d66741351ee", "type": "github" }, "original": { @@ -36,11 +36,11 @@ }, "nixpkgs-lib": { "locked": { - "lastModified": 1751159883, - "narHash": "sha256-urW/Ylk9FIfvXfliA1ywh75yszAbiTEVgpPeinFyVZo=", + "lastModified": 1754788789, + "narHash": "sha256-x2rJ+Ovzq0sCMpgfgGaaqgBSwY+LST+WbZ6TytnT9Rk=", "owner": "nix-community", "repo": "nixpkgs.lib", - "rev": "14a40a1d7fb9afa4739275ac642ed7301a9ba1ab", + "rev": "a73b9c743612e4244d865a2fdee11865283c04e6", "type": "github" }, "original": { diff --git a/flake.nix b/flake.nix index cd7e7d1f6..7d0382988 100644 --- a/flake.nix +++ b/flake.nix @@ -19,21 +19,42 @@ }; devShells.default = pkgs.mkShell { inputsFrom = [ self'.packages.default ]; }; packages = { - default = self'.packages.eigenpy; - eigenpy = pkgs.python3Packages.eigenpy.overrideAttrs (_: { - src = pkgs.lib.fileset.toSource { - root = ./.; - fileset = pkgs.lib.fileset.unions [ - ./CMakeLists.txt - ./doc - ./include - ./package.xml - ./python - ./src - ./unittest - ]; + default = self'.packages.eigenpy-eigen5; + eigen3 = pkgs.eigen.overrideAttrs (super: rec { + version = "3.4.1"; + src = pkgs.fetchFromGitLab { + inherit (super.src) owner repo; + tag = version; + hash = "sha256-NSq1tUfy2thz5gtsyASsKeYE4vMf71aSG4uXfrX86rk="; }; + patches = [ ]; + postPatch = ""; }); + eigen5 = self'.packages.eigen3.overrideAttrs (super: rec { + version = "5.0.0"; + src = pkgs.fetchFromGitLab { + inherit (super.src) owner repo; + tag = version; + hash = "sha256-L1KUFZsaibC/FD6abTXrT3pvaFhbYnw+GaWsxM2gaxM="; + }; + }); + eigenpy-eigen3 = + (pkgs.python3Packages.eigenpy.override { eigen = self'.packages.eigen3; }).overrideAttrs + (_: { + src = pkgs.lib.fileset.toSource { + root = ./.; + fileset = pkgs.lib.fileset.unions [ + ./CMakeLists.txt + ./doc + ./include + ./package.xml + ./python + ./src + ./unittest + ]; + }; + }); + eigenpy-eigen5 = self'.packages.eigenpy-eigen3.override { eigen = self'.packages.eigen5; }; }; }; }; diff --git a/include/eigenpy/alignment.hpp b/include/eigenpy/alignment.hpp index 4e0594a80..33cf1e182 100644 --- a/include/eigenpy/alignment.hpp +++ b/include/eigenpy/alignment.hpp @@ -23,23 +23,23 @@ struct aligned_storage { template struct aligned_instance { - PyObject_VAR_HEAD PyObject *dict; - PyObject *weakrefs; - boost::python::instance_holder *objects; + PyObject_VAR_HEAD PyObject* dict; + PyObject* weakrefs; + boost::python::instance_holder* objects; typename aligned_storage::type storage; }; -inline void *aligned_malloc( +inline void* aligned_malloc( std::size_t size, std::size_t alignment = EIGENPY_DEFAULT_ALIGN_BYTES) { - void *original = std::malloc(size + alignment); + void* original = std::malloc(size + alignment); if (original == 0) return 0; if (is_aligned(original, alignment)) return original; - void *aligned = - reinterpret_cast((reinterpret_cast(original) & - ~(std::size_t(alignment - 1))) + - alignment); - *(reinterpret_cast(aligned) - 1) = original; + void* aligned = + reinterpret_cast((reinterpret_cast(original) & + ~(std::size_t(alignment - 1))) + + alignment); + *(reinterpret_cast(aligned) - 1) = original; return aligned; } @@ -52,50 +52,50 @@ namespace detail { template struct referent_storage< - Eigen::Matrix &> { + Eigen::Matrix&> { typedef Eigen::Matrix T; typedef - typename eigenpy::aligned_storage::value>::type type; + typename eigenpy::aligned_storage::value>::type type; }; template struct referent_storage< - const Eigen::Matrix &> { + const Eigen::Matrix&> { typedef Eigen::Matrix T; typedef - typename eigenpy::aligned_storage::value>::type type; + typename eigenpy::aligned_storage::value>::type type; }; #ifdef EIGENPY_WITH_TENSOR_SUPPORT template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::Tensor T; typedef - typename eigenpy::aligned_storage::value>::type type; + typename eigenpy::aligned_storage::value>::type type; }; template struct referent_storage< - const Eigen::Tensor &> { + const Eigen::Tensor&> { typedef Eigen::Tensor T; typedef - typename eigenpy::aligned_storage::value>::type type; + typename eigenpy::aligned_storage::value>::type type; }; #endif template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::Quaternion T; typedef - typename eigenpy::aligned_storage::value>::type type; + typename eigenpy::aligned_storage::value>::type type; }; template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::Quaternion T; typedef - typename eigenpy::aligned_storage::value>::type type; + typename eigenpy::aligned_storage::value>::type type; }; } // namespace detail @@ -119,10 +119,10 @@ namespace eigenpy { template struct call_destructor { - static void run(void *bytes) { + static void run(void* bytes) { typedef typename boost::remove_const< typename boost::remove_reference::type>::type T_; - static_cast((void *)bytes)->~T_(); + static_cast((void*)bytes)->~T_(); } }; @@ -143,22 +143,22 @@ struct rvalue_from_python_data // The usual constructor rvalue_from_python_data( - ::boost::python::converter::rvalue_from_python_stage1_data const - &_stage1) { + ::boost::python::converter::rvalue_from_python_stage1_data const& + _stage1) { this->stage1 = _stage1; } // This constructor just sets m_convertible -- used by // implicitly_convertible<> to perform the final step of the // conversion, where the construct() function is already known. - rvalue_from_python_data(void *convertible) { + rvalue_from_python_data(void* convertible) { this->stage1.convertible = convertible; } // Destroys any object constructed in the storage. ~rvalue_from_python_data() { if (this->stage1.convertible == this->storage.bytes) { - void *storage = reinterpret_cast(this->storage.bytes); + void* storage = reinterpret_cast(this->storage.bytes); call_destructor::run(storage); } } diff --git a/include/eigenpy/decompositions/BDCSVD.hpp b/include/eigenpy/decompositions/BDCSVD.hpp new file mode 100644 index 000000000..231b304cc --- /dev/null +++ b/include/eigenpy/decompositions/BDCSVD.hpp @@ -0,0 +1,104 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_bdcsvd_hpp__ +#define __eigenpy_decompositions_bdcsvd_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/eigen/EigenBase.hpp" +#include "eigenpy/decompositions/SVDBase.hpp" + +namespace eigenpy { + +template +struct BDCSVDVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef Eigen::BDCSVD Solver; + typedef typename MatrixType::Scalar Scalar; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init>( + bp::args("self", "rows", "cols", "computationOptions "), + "Default Constructor with memory preallocation. ")) + .def(bp::init>( + bp::args("self", "matrix", "computationOptions "), + "Constructor performing the decomposition of given matrix.")) + + .def("cols", &Solver::cols, bp::arg("self"), + "Returns the number of columns. ") + .def( + "compute", + +[](Solver& self, const MatrixType& matrix) -> Solver& { + return self.compute(matrix); + }, + bp::args("self", "matrix"), + "Method performing the decomposition of given matrix. Computes " + "Thin/Full " + "unitaries U/V if specified using the Options template parameter " + "or the class constructor. ", + bp::return_self<>()) + .def( + "compute", + +[](Solver& self, const MatrixType& matrix, + unsigned int computationOptions) -> Solver& { + return self.compute(matrix, computationOptions); + }, + bp::args("self", "matrix", "computationOptions"), + "Method performing the decomposition of given matrix, as " + "specified by the computationOptions parameter. ", + bp::return_self<>()) + .def("rows", &Solver::rows, bp::arg("self"), + "Returns the number of rows. ") + .def("setSwitchSize", &Solver::setSwitchSize, bp::args("self", "s")) + + .def(SVDBaseVisitor()); + } + + static void expose() { + static const std::string classname = + "BDCSVD_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "Class Bidiagonal Divide and Conquer SVD.\n\n" + "This class first reduces the input matrix to bi-diagonal form using " + "class " + "UpperBidiagonalization, and then performs a divide-and-conquer " + "diagonalization. " + "Small blocks are diagonalized using class JacobiSVD. You can control " + "the " + "switching size with the setSwitchSize() method, default is 16. For " + "small matrice " + "(<16), it is thus preferable to directly use JacobiSVD. For larger " + "ones, BDCSVD " + "is highly recommended and can several order of magnitude faster.\n\n" + "Warming: this algorithm is unlikely to provide accurate result when " + "compiled with " + "unsafe math optimizations. For instance, this concerns Intel's " + "compiler (ICC), which " + "performs such optimization by default unless you compile with the " + "-fp-model precise " + "option. Likewise, the -ffast-math option of GCC or clang will " + "significantly degrade the " + "accuracy.", + bp::no_init) + .def(BDCSVDVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_bdcsvd_hpp__ diff --git a/include/eigenpy/decompositions/ColPivHouseholderQR.hpp b/include/eigenpy/decompositions/ColPivHouseholderQR.hpp index b7068b288..f56697cd4 100644 --- a/include/eigenpy/decompositions/ColPivHouseholderQR.hpp +++ b/include/eigenpy/decompositions/ColPivHouseholderQR.hpp @@ -28,7 +28,7 @@ struct ColPivHouseholderQRSolverVisitor typedef Solver Self; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor.\n" "The default constructor is useful in cases in which the " @@ -107,7 +107,7 @@ struct ColPivHouseholderQRSolverVisitor "you can control by calling setThreshold(threshold).") .def("setThreshold", - (Self & (Self::*)(const RealScalar &)) & Self::setThreshold, + (Self & (Self::*)(const RealScalar&)) & Self::setThreshold, bp::args("self", "threshold"), "Allows to prescribe a threshold to be used by certain methods, " "such as rank(), who need to determine when pivots are to be " @@ -138,7 +138,7 @@ struct ColPivHouseholderQRSolverVisitor .def( "compute", - (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the QR factorization of given matrix.", @@ -159,7 +159,7 @@ struct ColPivHouseholderQRSolverVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "This class performs a rank-revealing QR decomposition of a matrix A " @@ -178,10 +178,10 @@ struct ColPivHouseholderQRSolverVisitor private: template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } - static MatrixXs inverse(const Self &self) { return self.inverse(); } + static MatrixXs inverse(const Self& self) { return self.inverse(); } }; } // namespace eigenpy diff --git a/include/eigenpy/decompositions/CompleteOrthogonalDecomposition.hpp b/include/eigenpy/decompositions/CompleteOrthogonalDecomposition.hpp index 5a2ab8f63..cce0b1c07 100644 --- a/include/eigenpy/decompositions/CompleteOrthogonalDecomposition.hpp +++ b/include/eigenpy/decompositions/CompleteOrthogonalDecomposition.hpp @@ -28,7 +28,7 @@ struct CompleteOrthogonalDecompositionSolverVisitor typedef Solver Self; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor.\n" "The default constructor is useful in cases in which the " @@ -117,7 +117,7 @@ struct CompleteOrthogonalDecompositionSolverVisitor "you can control by calling setThreshold(threshold).") .def("setThreshold", - (Self & (Self::*)(const RealScalar &)) & Self::setThreshold, + (Self & (Self::*)(const RealScalar&)) & Self::setThreshold, bp::args("self", "threshold"), "Allows to prescribe a threshold to be used by certain methods, " "such as rank(), who need to determine when pivots are to be " @@ -152,7 +152,7 @@ struct CompleteOrthogonalDecompositionSolverVisitor .def( "compute", - (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the complete orthogonal factorization of given matrix.", @@ -174,7 +174,7 @@ struct CompleteOrthogonalDecompositionSolverVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "This class performs a rank-revealing complete orthogonal " @@ -190,10 +190,10 @@ struct CompleteOrthogonalDecompositionSolverVisitor private: template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } - static MatrixXs pseudoInverse(const Self &self) { + static MatrixXs pseudoInverse(const Self& self) { return self.pseudoInverse(); } }; diff --git a/include/eigenpy/decompositions/ComplexEigenSolver.hpp b/include/eigenpy/decompositions/ComplexEigenSolver.hpp new file mode 100644 index 000000000..691455418 --- /dev/null +++ b/include/eigenpy/decompositions/ComplexEigenSolver.hpp @@ -0,0 +1,86 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_complex_eigen_solver_hpp__ +#define __eigenpy_decompositions_complex_eigen_solver_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct ComplexEigenSolverVisitor : public boost::python::def_visitor< + ComplexEigenSolverVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::ComplexEigenSolver Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>("Default constructor")) + .def(bp::init( + bp::arg("size"), "Default constructor with memory preallocation")) + .def(bp::init>( + bp::args("matrix", "compute_eigen_vectors"), + "Computes eigendecomposition of given matrix")) + + .def("eigenvalues", &Solver::eigenvalues, bp::arg("self"), + "Returns the eigenvalues of given matrix.", + bp::return_internal_reference<>()) + .def("eigenvectors", &Solver::eigenvectors, bp::arg("self"), + "Returns the eigenvectors of given matrix.", + bp::return_internal_reference<>()) + + .def("compute", &ComplexEigenSolverVisitor::compute_proxy, + bp::args("self", "matrix"), + "Computes the eigendecomposition of given matrix.", + bp::return_self<>()) + .def("compute", + (Solver & + (Solver::*)(const Eigen::EigenBase& matrix, bool)) & + Solver::compute, + bp::args("self", "matrix", "compute_eigen_vectors"), + "Computes the eigendecomposition of given matrix.", + bp::return_self<>()) + + .def("info", &Solver::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + + .def("getMaxIterations", &Solver::getMaxIterations, bp::arg("self"), + "Returns the maximum number of iterations.") + .def("setMaxIterations", &Solver::setMaxIterations, + bp::args("self", "max_iter"), + "Sets the maximum number of iterations allowed.", + bp::return_self<>()); + } + + static void expose() { + static const std::string classname = + "ComplexEigenSolver" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(ComplexEigenSolverVisitor()) + .def(IdVisitor()); + } + + private: + template + static Solver& compute_proxy(Solver& self, + const Eigen::EigenBase& matrix) { + return self.compute(matrix); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_complex_eigen_solver_hpp__ diff --git a/include/eigenpy/decompositions/ComplexSchur.hpp b/include/eigenpy/decompositions/ComplexSchur.hpp new file mode 100644 index 000000000..bac2ea1bd --- /dev/null +++ b/include/eigenpy/decompositions/ComplexSchur.hpp @@ -0,0 +1,90 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_complex_schur_hpp__ +#define __eigenpy_decompositions_complex_schur_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct ComplexSchurVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::ComplexSchur Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init(bp::arg("size"), "Default constructor")) + .def(bp::init>( + bp::args("matrix", "computeU"), "Computes Schur of given matrix")) + + .def("matrixU", &Solver::matrixU, bp::arg("self"), + "Returns the unitary matrix in the Schur decomposition. ", + bp::return_value_policy()) + .def("matrixT", &Solver::matrixT, bp::arg("self"), + "Returns the triangular matrix in the Schur decomposition. ", + bp::return_value_policy()) + + .def("compute", &ComplexSchurVisitor::compute_proxy, + bp::args("self", "matrix"), "Computes the Schur of given matrix.", + bp::return_self<>()) + .def("compute", + (Solver & + (Solver::*)(const Eigen::EigenBase& matrix, bool)) & + Solver::compute, + bp::args("self", "matrix", "computeU"), + "Computes the Schur of given matrix.", bp::return_self<>()) + + .def("computeFromHessenberg", + (Solver & (Solver::*)(const Eigen::EigenBase& matrixH, + const Eigen::EigenBase& matrixQ, + bool)) & + Solver::computeFromHessenberg, + bp::args("self", "matrixH", "matrixQ", "computeU"), + "Compute Schur decomposition from a given Hessenberg matrix. ", + bp::return_self<>()) + + .def("info", &Solver::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + + .def("getMaxIterations", &Solver::getMaxIterations, bp::arg("self"), + "Returns the maximum number of iterations.") + .def("setMaxIterations", &Solver::setMaxIterations, + bp::args("self", "max_iter"), + "Sets the maximum number of iterations allowed.", + bp::return_self<>()); + } + + static void expose() { + static const std::string classname = + "ComplexSchur" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(ComplexSchurVisitor()) + .def(IdVisitor()); + } + + private: + template + static Solver& compute_proxy(Solver& self, + const Eigen::EigenBase& matrix) { + return self.compute(matrix); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_complex_schur_hpp__ diff --git a/include/eigenpy/decompositions/FullPivHouseholderQR.hpp b/include/eigenpy/decompositions/FullPivHouseholderQR.hpp index 99adc9386..3e4180f74 100644 --- a/include/eigenpy/decompositions/FullPivHouseholderQR.hpp +++ b/include/eigenpy/decompositions/FullPivHouseholderQR.hpp @@ -28,7 +28,7 @@ struct FullPivHouseholderQRSolverVisitor typedef Solver Self; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor.\n" "The default constructor is useful in cases in which the " @@ -103,7 +103,7 @@ struct FullPivHouseholderQRSolverVisitor "you can control by calling setThreshold(threshold).") .def("setThreshold", - (Self & (Self::*)(const RealScalar &)) & Self::setThreshold, + (Self & (Self::*)(const RealScalar&)) & Self::setThreshold, bp::args("self", "threshold"), "Allows to prescribe a threshold to be used by certain methods, " "such as rank(), who need to determine when pivots are to be " @@ -131,7 +131,7 @@ struct FullPivHouseholderQRSolverVisitor .def( "compute", - (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the QR factorization of given matrix.", @@ -152,7 +152,7 @@ struct FullPivHouseholderQRSolverVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "This class performs a rank-revealing QR decomposition of a matrix A " @@ -172,10 +172,10 @@ struct FullPivHouseholderQRSolverVisitor private: template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } - static MatrixXs inverse(const Self &self) { return self.inverse(); } + static MatrixXs inverse(const Self& self) { return self.inverse(); } }; } // namespace eigenpy diff --git a/include/eigenpy/decompositions/FullPivLU.hpp b/include/eigenpy/decompositions/FullPivLU.hpp new file mode 100644 index 000000000..3143e69cf --- /dev/null +++ b/include/eigenpy/decompositions/FullPivLU.hpp @@ -0,0 +1,192 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_fullpivlu_hpp__ +#define __eigenpy_decompositions_fullpivlu_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/eigen/EigenBase.hpp" + +namespace eigenpy { + +template +struct FullPivLUSolverVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::Matrix + VectorXs; + typedef Eigen::Matrix + MatrixXs; + typedef Eigen::FullPivLU Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init( + bp::args("self", "rows", "cols"), + "Default constructor with memory preallocation")) + .def(bp::init( + bp::args("self", "matrix"), + "Constructs a LU factorization from a given matrix.")) + + .def(EigenBaseVisitor()) + + .def( + "compute", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::compute, + bp::args("self", "matrix"), + "Computes the LU decomposition of the given matrix.", + bp::return_self<>()) + + .def("determinant", &Solver::determinant, bp::arg("self"), + "Returns the determinant of the matrix of which *this is the LU " + "decomposition.") + .def("dimensionOfKernel", &Solver::dimensionOfKernel, bp::arg("self"), + "Returns the dimension of the kernel of the matrix of which *this " + "is the LU decomposition.") + .def( + "image", + +[](Solver& self, const MatrixType& mat) -> MatrixType { + return self.image(mat); + }, + bp::args("self", "originalMatrix"), + "Returns the image of the matrix, also called its column-space. " + "The columns of the returned matrix will form a basis of the " + "image (column-space).") + .def( + "inverse", + +[](Solver& self) -> MatrixType { return self.inverse(); }, + bp::arg("self"), + "Returns the inverse of the matrix of which *this is the LU " + "decomposition.") + + .def("isInjective", &Solver::isInjective, bp::arg("self")) + .def("isInvertible", &Solver::isInvertible, bp::arg("self")) + .def("isSurjective", &Solver::isSurjective, bp::arg("self")) + + .def( + "kernel", +[](Solver& self) -> MatrixType { return self.kernel(); }, + bp::arg("self"), + "Returns the kernel of the matrix, also called its null-space. " + "The columns of the returned matrix will form a basis of the " + "kernel.") + + .def("matrixLU", &Solver::matrixLU, bp::arg("self"), + "Returns the LU decomposition matrix.", + bp::return_internal_reference<>()) + + .def("maxPivot", &Solver::maxPivot, bp::arg("self")) + .def("nonzeroPivots", &Solver::nonzeroPivots, bp::arg("self")) + + .def("permutationP", &Solver::permutationP, bp::arg("self"), + "Returns the permutation P.", + bp::return_value_policy()) + .def("permutationQ", &Solver::permutationQ, bp::arg("self"), + "Returns the permutation Q.", + bp::return_value_policy()) + + .def("rank", &Solver::rank, bp::arg("self")) + + .def("rcond", &Solver::rcond, bp::arg("self"), + "Returns an estimate of the reciprocal condition number of the " + "matrix.") + .def("reconstructedMatrix", &Solver::reconstructedMatrix, + bp::arg("self"), + "Returns the matrix represented by the decomposition, i.e., it " + "returns the product: P-1LUQ-1. This function is provided for " + "debug " + "purpose.") + + .def("setThreshold", + (Solver & (Solver::*)(const RealScalar&)) & Solver::setThreshold, + bp::args("self", "threshold"), + "Allows to prescribe a threshold to be used by certain methods, " + "such as rank(), who need to determine when pivots are to be " + "considered nonzero. This is not used for the LU decomposition " + "itself.\n" + "\n" + "When it needs to get the threshold value, Eigen calls " + "threshold(). By default, this uses a formula to automatically " + "determine a reasonable threshold. Once you have called the " + "present method setThreshold(const RealScalar&), your value is " + "used instead.\n" + "\n" + "Note: A pivot will be considered nonzero if its absolute value " + "is strictly greater than |pivot| ⩽ threshold×|maxpivot| where " + "maxpivot is the biggest pivot.", + bp::return_self<>()) + .def( + "setThreshold", + +[](Solver& self) -> Solver& { + return self.setThreshold(Eigen::Default); + }, + bp::arg("self"), + "Allows to come back to the default behavior, letting Eigen use " + "its default formula for determining the threshold.", + bp::return_self<>()) + + .def("solve", &solve, bp::args("self", "b"), + "Returns the solution x of A x = b using the current " + "decomposition of A.") + .def("solve", &solve, bp::args("self", "B"), + "Returns the solution X of A X = B using the current " + "decomposition of A where B is a right hand side matrix.") + + .def("threshold", &Solver::threshold, bp::arg("self"), + "Returns the threshold that will be used by certain methods such " + "as rank()."); + } + + static void expose() { + static const std::string classname = + "FullPivLU" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "LU decomposition of a matrix with complete pivoting, and related " + "features.\n\n" + "This class represents a LU decomposition of any matrix, with complete " + "pivoting: the matrix A is decomposed as A=P−1LUQ−1 where L is " + "unit-lower-triangular, U is upper-triangular, and P and Q are " + "permutation matrices. This is a rank-revealing LU decomposition. " + "The eigenvalues (diagonal coefficients) of U are sorted in such a " + "way that any zeros are at the end.\n\n" + "This decomposition provides the generic approach to solving systems " + "of " + "linear equations, computing the rank, invertibility, inverse, kernel, " + "and determinant. \n\n" + "This LU decomposition is very stable and well tested with large " + "matrices. " + "However there are use cases where the SVD decomposition is inherently " + "more " + "stable and/or flexible. For example, when computing the kernel of a " + "matrix, " + "working with the SVD allows to select the smallest singular values of " + "the matrix, something that the LU decomposition doesn't see.", + bp::no_init) + .def(IdVisitor()) + .def(FullPivLUSolverVisitor()); + } + + private: + template + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { + return self.solve(vec); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_fullpivlu_hpp__ diff --git a/include/eigenpy/decompositions/GeneralizedEigenSolver.hpp b/include/eigenpy/decompositions/GeneralizedEigenSolver.hpp new file mode 100644 index 000000000..a579da65b --- /dev/null +++ b/include/eigenpy/decompositions/GeneralizedEigenSolver.hpp @@ -0,0 +1,94 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_generalized_eigen_solver_hpp__ +#define __eigenpy_decompositions_generalized_eigen_solver_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct GeneralizedEigenSolverVisitor + : public boost::python::def_visitor< + GeneralizedEigenSolverVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::GeneralizedEigenSolver Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>("Default constructor")) + .def(bp::init( + bp::arg("size"), "Default constructor with memory preallocation. ")) + .def(bp::init>( + bp::args("A", "B", "computeEigenVectors"), + "Computes the generalized eigendecomposition of given matrix " + "pair. ")) + + .def("eigenvectors", &Solver::eigenvectors, bp::arg("self"), + "Returns an expression of the computed generalized eigenvectors. ") + .def( + "eigenvalues", + +[](const Solver& c) { return c.eigenvalues().eval(); }, + "Returns the computed generalized eigenvalues.") + + .def("alphas", &Solver::alphas, bp::arg("self"), + "Returns the vectors containing the alpha values. ", + bp::return_value_policy()) + .def("betas", &Solver::betas, bp::arg("self"), + "Returns the vectors containing the beta values. ", + bp::return_value_policy()) + + .def("compute", + &GeneralizedEigenSolverVisitor::compute_proxy, + bp::args("self", "A", "B"), + "Computes generalized eigendecomposition of given matrix. ", + bp::return_self<>()) + .def("compute", + (Solver & + (Solver::*)(const MatrixType& A, const MatrixType& B, bool)) & + Solver::compute, + bp::args("self", "A", "B", "computeEigenvectors"), + "Computes generalized eigendecomposition of given matrix. .", + bp::return_self<>()) + + .def("info", &Solver::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + + .def("setMaxIterations", &Solver::setMaxIterations, + bp::args("self", "max_iter"), + "Sets the maximum number of iterations allowed.", + bp::return_self<>()); + } + + static void expose() { + static const std::string classname = + "GeneralizedEigenSolver" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(GeneralizedEigenSolverVisitor()) + .def(IdVisitor()); + } + + private: + template + static Solver& compute_proxy(Solver& self, const MatrixType& A, + const MatrixType& B) { + return self.compute(A, B); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_generalized_eigen_solver_hpp__ diff --git a/include/eigenpy/decompositions/GeneralizedSelfAdjointEigenSolver.hpp b/include/eigenpy/decompositions/GeneralizedSelfAdjointEigenSolver.hpp new file mode 100644 index 000000000..7d23c7ac6 --- /dev/null +++ b/include/eigenpy/decompositions/GeneralizedSelfAdjointEigenSolver.hpp @@ -0,0 +1,75 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_generalized_self_adjoint_eigen_solver_hpp__ +#define __eigenpy_decompositions_generalized_self_adjoint_eigen_solver_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/decompositions/SelfAdjointEigenSolver.hpp" + +namespace eigenpy { + +template +struct GeneralizedSelfAdjointEigenSolverVisitor + : public boost::python::def_visitor< + GeneralizedSelfAdjointEigenSolverVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::GeneralizedSelfAdjointEigenSolver Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>("Default constructor")) + .def(bp::init( + bp::arg("size"), "Default constructor with memory preallocation. ")) + .def(bp::init>( + bp::args("matA", "matB", "options"), + "Constructor: Computes generalized eigendecomposition of given " + "matrix pencil. ")) + + .def("compute", + &GeneralizedSelfAdjointEigenSolverVisitor::compute_proxy< + MatrixType>, + bp::args("self", "A", "B"), + "Computes generalized eigendecomposition of given matrix pencil. ", + bp::return_self<>()) + .def("compute", + (Solver & + (Solver::*)(const MatrixType& A, const MatrixType& B, int)) & + Solver::compute, + bp::args("self", "A", "B", "options"), + "Computes generalized eigendecomposition of given matrix pencil.", + bp::return_self<>()); + } + + static void expose() { + static const std::string classname = + "GeneralizedSelfAdjointEigenSolver" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_>>( + name.c_str(), bp::no_init) + .def(GeneralizedSelfAdjointEigenSolverVisitor()) + .def(IdVisitor()); + } + + private: + template + static Solver& compute_proxy(Solver& self, const MatrixType& A, + const MatrixType& B) { + return self.compute(A, B); + } +}; + +} // namespace eigenpy + +#endif // ifndef + // __eigenpy_decompositions_generalized_self_adjoint_eigen_solver_hpp__ diff --git a/include/eigenpy/decompositions/HessenbergDecomposition.hpp b/include/eigenpy/decompositions/HessenbergDecomposition.hpp new file mode 100644 index 000000000..a547a3fb7 --- /dev/null +++ b/include/eigenpy/decompositions/HessenbergDecomposition.hpp @@ -0,0 +1,76 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_hessenberg_decomposition_hpp__ +#define __eigenpy_decompositions_hessenberg_decomposition_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct HessenbergDecompositionVisitor + : public boost::python::def_visitor< + HessenbergDecompositionVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::HessenbergDecomposition Solver; + + template + void visit(PyClass& cl) const { + cl + .def(bp::init( + bp::arg("size"), + "Default constructor; the decomposition will be computed later. ")) + .def(bp::init( + bp::arg("matrix"), + "Constructor; computes Hessenberg decomposition of given matrix. ")) + + .def( + "compute", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::compute, + bp::args("self", "A"), + "Computes Hessenberg decomposition of given matrix. ", + bp::return_self<>()) + + .def("householderCoefficients", &Solver::householderCoefficients, + bp::arg("self"), "Returns the Householder coefficients. ", + bp::return_value_policy()) + + .def( + "matrixQ", + +[](const Solver& c) -> MatrixType { return c.matrixQ(); }, + "Reconstructs the orthogonal matrix Q in the decomposition.") + .def( + "matrixH", + +[](const Solver& c) -> MatrixType { return c.matrixH(); }, + "Constructs the Hessenberg matrix H in the decomposition.") + + .def("packedMatrix", &Solver::packedMatrix, bp::arg("self"), + "Returns the internal representation of the decomposition. ", + bp::return_value_policy()); + } + + static void expose() { + static const std::string classname = + "HessenbergDecomposition" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(HessenbergDecompositionVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_hessenberg_decomposition_hpp__ diff --git a/include/eigenpy/decompositions/HouseholderQR.hpp b/include/eigenpy/decompositions/HouseholderQR.hpp index 34d3f744b..1b548d928 100644 --- a/include/eigenpy/decompositions/HouseholderQR.hpp +++ b/include/eigenpy/decompositions/HouseholderQR.hpp @@ -28,7 +28,7 @@ struct HouseholderQRSolverVisitor typedef Solver Self; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor.\n" "The default constructor is useful in cases in which the " @@ -69,7 +69,7 @@ struct HouseholderQRSolverVisitor .def( "compute", - (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the QR factorization of given matrix.", @@ -86,7 +86,7 @@ struct HouseholderQRSolverVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "This class performs a QR decomposition of a matrix A into matrices Q " @@ -108,7 +108,7 @@ struct HouseholderQRSolverVisitor private: template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } }; diff --git a/include/eigenpy/decompositions/JacobiSVD.hpp b/include/eigenpy/decompositions/JacobiSVD.hpp new file mode 100644 index 000000000..4454e5eb6 --- /dev/null +++ b/include/eigenpy/decompositions/JacobiSVD.hpp @@ -0,0 +1,111 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_jacobisvd_hpp__ +#define __eigenpy_decompositions_jacobisvd_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/eigen/EigenBase.hpp" +#include "eigenpy/decompositions/SVDBase.hpp" + +namespace eigenpy { + +template +struct JacobiSVDVisitor + : public boost::python::def_visitor> { + typedef JacobiSVD Solver; + typedef typename JacobiSVD::MatrixType MatrixType; + typedef Eigen::MatrixBase MatrixBaseType; + typedef typename MatrixType::Scalar Scalar; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init>( + bp::args("self", "rows", "cols", "computationOptions "), + "Default Constructor with memory preallocation.")) + .def(bp::init>( + bp::args("self", "matrix", "computationOptions "), + "Constructor performing the decomposition of given matrix.")) + + .def("cols", &JacobiSVD::cols, bp::arg("self"), + "Returns the number of columns. ") + .def( + "compute", + +[](Solver& self, const MatrixType& matrix) -> Solver& { + return self.compute(matrix); + }, + bp::args("self", "matrix"), + "Method performing the decomposition of given matrix. Computes " + "Thin/Full " + "unitaries U/V if specified using the Options template parameter " + "or the class constructor. ", + bp::return_self<>()) + .def( + "compute", + +[](Solver& self, const MatrixType& matrix, + unsigned int computationOptions) -> Solver& { + return self.compute(matrix, computationOptions); + }, + bp::args("self", "matrix", "computation_options"), + "Method performing the decomposition of given matrix, as " + "specified by the computationOptions parameter. ", + bp::return_self<>()) + .def("rows", &JacobiSVD::rows, bp::arg("self"), + "Returns the number of rows.") + + .def(SVDBaseVisitor()); + } + + static void expose() { + static const std::string classname = + "JacobiSVD_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "Two-sided Jacobi SVD decomposition of a rectangular matrix. \n\n" + "SVD decomposition consists in decomposing any n-by-p matrix A as a " + "product " + "A=USV∗ where U is a n-by-n unitary, V is a p-by-p unitary, and S is a " + "n-by-p r" + "eal positive matrix which is zero outside of its main diagonal; the " + "diagonal " + "entries of S are known as the singular values of A and the columns of " + "U and V " + "are known as the left and right singular vectors of A respectively. " + "\n\n" + "Singular values are always sorted in decreasing order. \n\n " + "This JacobiSVD decomposition computes only the singular values by " + "default. " + "If you want U or V, you need to ask for them explicitly. \n\n" + "You can ask for only thin U or V to be computed, meaning the " + "following. " + "In case of a rectangular n-by-p matrix, letting m be the smaller " + "value among " + "n and p, there are only m singular vectors; the remaining columns of " + "U and V " + "do not correspond to actual singular vectors. Asking for thin U or V " + "means asking " + "for only their m first columns to be formed. So U is then a n-by-m " + "matrix, and V " + "is then a p-by-m matrix. Notice that thin U and V are all you need " + "for (least squares) " + "solving.", + bp::no_init) + .def(JacobiSVDVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_jacobisvd_hpp__ diff --git a/include/eigenpy/decompositions/LDLT.hpp b/include/eigenpy/decompositions/LDLT.hpp index 5360801a8..bf3600b07 100644 --- a/include/eigenpy/decompositions/LDLT.hpp +++ b/include/eigenpy/decompositions/LDLT.hpp @@ -28,7 +28,7 @@ struct LDLTSolverVisitor typedef Eigen::LDLT Solver; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor")) .def(bp::init( bp::args("self", "size"), @@ -58,8 +58,8 @@ struct LDLTSolverVisitor bp::return_internal_reference<>()) .def("rankUpdate", - (Solver & (Solver::*)(const Eigen::MatrixBase &, - const RealScalar &)) & + (Solver & (Solver::*)(const Eigen::MatrixBase&, + const RealScalar&)) & Solver::template rankUpdate, bp::args("self", "vector", "sigma"), bp::return_self<>()) @@ -72,7 +72,7 @@ struct LDLTSolverVisitor .def( "compute", - (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the LDLT of given matrix.", bp::return_self<>()) @@ -107,7 +107,7 @@ struct LDLTSolverVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "Robust Cholesky decomposition of a matrix with pivoting.\n\n" @@ -124,17 +124,17 @@ struct LDLTSolverVisitor } private: - static MatrixType matrixL(const Solver &self) { return self.matrixL(); } - static MatrixType matrixU(const Solver &self) { return self.matrixU(); } - static VectorXs vectorD(const Solver &self) { return self.vectorD(); } + static MatrixType matrixL(const Solver& self) { return self.matrixL(); } + static MatrixType matrixU(const Solver& self) { return self.matrixU(); } + static VectorXs vectorD(const Solver& self) { return self.vectorD(); } - static MatrixType transpositionsP(const Solver &self) { + static MatrixType transpositionsP(const Solver& self) { return self.transpositionsP() * MatrixType::Identity(self.matrixL().rows(), self.matrixL().rows()); } template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } }; diff --git a/include/eigenpy/decompositions/LLT.hpp b/include/eigenpy/decompositions/LLT.hpp index 24763ee43..e4f0e7eb0 100644 --- a/include/eigenpy/decompositions/LLT.hpp +++ b/include/eigenpy/decompositions/LLT.hpp @@ -28,7 +28,7 @@ struct LLTSolverVisitor typedef Eigen::LLT Solver; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor")) .def(bp::init( bp::args("self", "size"), @@ -49,14 +49,14 @@ struct LLTSolverVisitor #if EIGEN_VERSION_AT_LEAST(3, 3, 90) .def("rankUpdate", - (Solver & (Solver::*)(const VectorXs &, const RealScalar &)) & + (Solver & (Solver::*)(const VectorXs&, const RealScalar&)) & Solver::template rankUpdate, bp::args("self", "vector", "sigma"), bp::return_self<>()) #else .def("rankUpdate", (Solver (Solver::*)( - const VectorXs &, - const RealScalar &))&Solver::template rankUpdate, + const VectorXs&, + const RealScalar&))&Solver::template rankUpdate, bp::args("self", "vector", "sigma")) #endif @@ -69,7 +69,7 @@ struct LLTSolverVisitor .def( "compute", - (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the LLT of given matrix.", bp::return_self<>()) @@ -101,7 +101,7 @@ struct LLTSolverVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "Standard Cholesky decomposition (LL^T) of a matrix and associated " @@ -121,11 +121,11 @@ struct LLTSolverVisitor } private: - static MatrixType matrixL(const Solver &self) { return self.matrixL(); } - static MatrixType matrixU(const Solver &self) { return self.matrixU(); } + static MatrixType matrixL(const Solver& self) { return self.matrixL(); } + static MatrixType matrixU(const Solver& self) { return self.matrixU(); } template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } }; diff --git a/include/eigenpy/decompositions/PartialPivLU.hpp b/include/eigenpy/decompositions/PartialPivLU.hpp new file mode 100644 index 000000000..52ee95db0 --- /dev/null +++ b/include/eigenpy/decompositions/PartialPivLU.hpp @@ -0,0 +1,138 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_partialpivlu_hpp__ +#define __eigenpy_decompositions_partialpivlu_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/eigen/EigenBase.hpp" + +namespace eigenpy { + +template +struct PartialPivLUSolverVisitor : public boost::python::def_visitor< + PartialPivLUSolverVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::Matrix + VectorXs; + typedef Eigen::Matrix + MatrixXs; + typedef Eigen::PartialPivLU Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init( + bp::args("self", "size"), + "Default constructor with memory preallocation")) + .def(bp::init( + bp::args("self", "matrix"), + "Constructs a LU factorization from a given matrix.")) + + .def(EigenBaseVisitor()) + + .def("determinant", &Solver::determinant, bp::arg("self"), + "Returns the determinant of the matrix of which *this is the LU " + "decomposition.") + .def( + "compute", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::compute, + bp::args("self", "matrix"), + "Computes the LU factorization of given matrix.", + bp::return_self<>()) + .def( + "inverse", + +[](const Solver& self) -> MatrixType { return self.inverse(); }, + bp::arg("self"), + "Returns the inverse of the matrix of which *this is the LU " + "decomposition.") + .def("matrixLU", &Solver::matrixLU, bp::arg("self"), + "Returns the LU decomposition matrix.", + bp::return_internal_reference<>()) + + .def("permutationP", &Solver::permutationP, bp::arg("self"), + "Returns the permutation P.", + bp::return_value_policy()) + + .def("rcond", &Solver::rcond, bp::arg("self"), + "Returns an estimate of the reciprocal condition number of the " + "matrix.") + .def("reconstructedMatrix", &Solver::reconstructedMatrix, + bp::arg("self"), + "Returns the matrix represented by the decomposition, i.e., it " + "returns the product: P-1LUQ-1. This function is provided for " + "debug " + "purpose.") + .def("solve", &solve, bp::args("self", "b"), + "Returns the solution x of A x = b using the current " + "decomposition of A.") + .def("solve", &solve, bp::args("self", "B"), + "Returns the solution X of A X = B using the current " + "decomposition of A where B is a right hand side matrix."); + } + + static void expose() { + static const std::string classname = + "FullPivLU" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "LU decomposition of a matrix with partial pivoting, " + "and related features. \n\n" + "This class represents a LU decomposition of a square " + "invertible matrix, " + "with partial pivoting: the matrix A is decomposed as A " + "= PLU where L is " + "unit-lower-triangular, U is upper-triangular, and P is " + "a permutation matrix.\n\n" + "Typically, partial pivoting LU decomposition is only " + "considered numerically " + "stable for square invertible matrices. Thus LAPACK's " + "dgesv and dgesvx require " + "the matrix to be square and invertible. The present " + "class does the same. It " + "will assert that the matrix is square, but it won't " + "(actually it can't) check " + "that the matrix is invertible: it is your task to " + "check that you only use this " + "decomposition on invertible matrices. \n\n" + "The guaranteed safe alternative, working for all matrices, " + "is the full pivoting LU decomposition, provided by class " + "FullPivLU. \n\n" + "This is not a rank-revealing LU decomposition. Many features " + "are intentionally absent from this class, such as " + "rank computation. If you need these features, use class " + "FullPivLU. \n\n" + "This LU decomposition is suitable to invert invertible " + "matrices. It is what MatrixBase::inverse() uses in the " + "general case. On the other hand, it is not suitable to " + "determine whether a given matrix is invertible. \n\n" + "The data of the LU decomposition can be directly accessed " + "through the methods matrixLU(), permutationP().", + bp::no_init) + .def(IdVisitor()) + .def(PartialPivLUSolverVisitor()); + } + + private: + template + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { + return self.solve(vec); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_partialpivlu_hpp__ diff --git a/include/eigenpy/decompositions/PermutationMatrix.hpp b/include/eigenpy/decompositions/PermutationMatrix.hpp index 5ac7535e3..f589e20fe 100644 --- a/include/eigenpy/decompositions/PermutationMatrix.hpp +++ b/include/eigenpy/decompositions/PermutationMatrix.hpp @@ -26,7 +26,7 @@ struct PermutationMatrixVisitor VectorIndex; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def(bp::init(bp::args("self", "size"), "Default constructor")) .def(bp::init( @@ -40,7 +40,7 @@ struct PermutationMatrixVisitor .def( "indices", - +[](const PermutationMatrix &self) { + +[](const PermutationMatrix& self) { return VectorIndex(self.indices()); }, bp::arg("self"), "The stored array representing the permutation.") @@ -73,13 +73,13 @@ struct PermutationMatrixVisitor .def( "transpose", - +[](const PermutationMatrix &self) -> PermutationMatrix { + +[](const PermutationMatrix& self) -> PermutationMatrix { return self.transpose(); }, bp::arg("self"), "Returns the tranpose permutation matrix.") .def( "inverse", - +[](const PermutationMatrix &self) -> PermutationMatrix { + +[](const PermutationMatrix& self) -> PermutationMatrix { return self.inverse(); }, bp::arg("self"), "Returns the inverse permutation matrix.") @@ -91,7 +91,7 @@ struct PermutationMatrixVisitor .def(EigenBaseVisitor()); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_(name.c_str(), "Permutation matrix.\n" "This class represents a permutation matrix, " diff --git a/include/eigenpy/decompositions/RealQZ.hpp b/include/eigenpy/decompositions/RealQZ.hpp new file mode 100644 index 000000000..76b45dbc2 --- /dev/null +++ b/include/eigenpy/decompositions/RealQZ.hpp @@ -0,0 +1,90 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_generalized_real_qz_hpp__ +#define __eigenpy_decompositions_generalized_real_qz_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct RealQZVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::RealQZ Solver; + + template + void visit(PyClass& cl) const { + cl.def( + bp::init(bp::arg("size"), "Default constructor. ")) + .def(bp::init>( + bp::args("A", "B", "computeQZ"), + "Constructor; computes real QZ decomposition of given matrices. ")) + + .def("compute", &RealQZVisitor::compute_proxy, + bp::args("self", "A", "B"), + "Computes QZ decomposition of given matrix. ", + bp::return_self<>()) + .def("compute", + (Solver & + (Solver::*)(const MatrixType& A, const MatrixType& B, bool)) & + Solver::compute, + bp::args("self", "A", "B", "computeEigenvectors"), + "Computes QZ decomposition of given matrix. ", bp::return_self<>()) + + .def("info", &Solver::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + + .def("matrixQ", &Solver::matrixQ, bp::arg("self"), + "Returns matrix Q in the QZ decomposition. ", + bp::return_value_policy()) + .def("matrixS", &Solver::matrixS, bp::arg("self"), + "Returns matrix S in the QZ decomposition. ", + bp::return_value_policy()) + .def("matrixT", &Solver::matrixT, bp::arg("self"), + "Returns matrix T in the QZ decomposition. ", + bp::return_value_policy()) + .def("matrixZ", &Solver::matrixZ, bp::arg("self"), + "Returns matrix Z in the QZ decomposition. ", + bp::return_value_policy()) + + .def("iterations", &Solver::iterations, bp::arg("self"), + "Returns number of performed QR-like iterations. ") + .def("setMaxIterations", &Solver::setMaxIterations, + bp::args("self", "max_iter"), + "Sets the maximum number of iterations allowed.", + bp::return_self<>()); + } + + static void expose() { + static const std::string classname = + "RealQZVisitor" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(RealQZVisitor()) + .def(IdVisitor()); + } + + private: + template + static Solver& compute_proxy(Solver& self, const MatrixType& A, + const MatrixType& B) { + return self.compute(A, B); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_generalized_real_qz_hpp__ diff --git a/include/eigenpy/decompositions/RealSchur.hpp b/include/eigenpy/decompositions/RealSchur.hpp new file mode 100644 index 000000000..ba0de9e59 --- /dev/null +++ b/include/eigenpy/decompositions/RealSchur.hpp @@ -0,0 +1,92 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_generalized_real_schur_hpp__ +#define __eigenpy_decompositions_generalized_real_schur_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct RealSchurVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::RealSchur Solver; + + template + void visit(PyClass& cl) const { + cl.def( + bp::init(bp::arg("size"), "Default constructor. ")) + .def(bp::init>( + bp::args("matrix", "computeU"), + "Constructor; computes real Schur decomposition of given matrix. ")) + + .def("compute", &RealSchurVisitor::compute_proxy, + bp::args("self", "matrix"), + "Computes Schur decomposition of given matrix. ", + bp::return_self<>()) + .def("compute", + (Solver & + (Solver::*)(const Eigen::EigenBase& matrix, bool)) & + Solver::compute, + bp::args("self", "matrix", "computeEigenvectors"), + "Computes Schur decomposition of given matrix. ", + bp::return_self<>()) + + .def("computeFromHessenberg", + (Solver & (Solver::*)(const MatrixType& matrixH, + const MatrixType& matrixQ, bool)) & + Solver::computeFromHessenberg, + bp::args("self", "matrixH", "matrixQ", "computeU"), + "Compute Schur decomposition from a given Hessenberg matrix. ", + bp::return_self<>()) + + .def("info", &Solver::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + + .def("matrixT", &Solver::matrixT, bp::arg("self"), + "Returns the quasi-triangular matrix in the Schur decomposition.", + bp::return_value_policy()) + .def("matrixU", &Solver::matrixU, bp::arg("self"), + "Returns the orthogonal matrix in the Schur decomposition. ", + bp::return_value_policy()) + + .def("setMaxIterations", &Solver::setMaxIterations, + bp::args("self", "max_iter"), + "Sets the maximum number of iterations allowed.", + bp::return_self<>()) + .def("getMaxIterations", &Solver::getMaxIterations, bp::arg("self"), + "Returns the maximum number of iterations."); + } + + static void expose() { + static const std::string classname = + "RealSchurVisitor" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(RealSchurVisitor()) + .def(IdVisitor()); + } + + private: + template + static Solver& compute_proxy(Solver& self, const MatrixType& A) { + return self.compute(A); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_generalized_real_schur_hpp__ diff --git a/include/eigenpy/decompositions/SVDBase.hpp b/include/eigenpy/decompositions/SVDBase.hpp new file mode 100644 index 000000000..fa6658bdf --- /dev/null +++ b/include/eigenpy/decompositions/SVDBase.hpp @@ -0,0 +1,108 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_svdbase_hpp__ +#define __eigenpy_decompositions_svdbase_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/eigen/EigenBase.hpp" + +namespace eigenpy { + +template +struct SVDBaseVisitor + : public boost::python::def_visitor> { + typedef Derived Solver; + + typedef typename Derived::MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + + typedef Eigen::Matrix + VectorXs; + typedef Eigen::Matrix + MatrixXs; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + + .def("computeU", &Solver::computeU, bp::arg("self"), + "Returns true if U (full or thin) is asked for in this " + "SVD decomposition ") + .def("computeV", &Solver::computeV, bp::arg("self"), + "Returns true if V (full or thin) is asked for in this " + "SVD decomposition ") + + .def("info", &Solver::info, bp::arg("self"), + "Reports whether previous computation was successful. ") + + .def("matrixU", &matrixU, bp::arg("self"), "Returns the matrix U.") + .def("matrixV", &matrixV, bp::arg("self"), "Returns the matrix V.") + + .def("nonzeroSingularValues", &Solver::nonzeroSingularValues, + bp::arg("self"), + "Returns the number of singular values that are not exactly 0 ") + .def("rank", &Solver::rank, bp::arg("self"), + "the rank of the matrix of which *this is the SVD. ") + + .def("setThreshold", + (Solver & (Solver::*)(const RealScalar&)) & Solver::setThreshold, + bp::args("self", "threshold"), + "Allows to prescribe a threshold to be used by certain methods, " + "such as " + "rank() and solve(), which need to determine when singular values " + "are " + "to be considered nonzero. This is not used for the SVD " + "decomposition " + "itself.\n" + "\n" + "When it needs to get the threshold value, Eigen calls " + "threshold(). " + "The default is NumTraits::epsilon()", + bp::return_self<>()) + .def( + "setThreshold", + +[](Solver& self) -> Solver& { + return self.setThreshold(Eigen::Default); + }, + bp::arg("self"), + "Allows to come back to the default behavior, letting Eigen use " + "its default formula for determining the threshold.", + bp::return_self<>()) + + .def("singularValues", &Solver::singularValues, bp::arg("self"), + "Returns the vector of singular values.", + bp::return_value_policy()) + + .def("solve", &solve, bp::args("self", "b"), + "Returns the solution x of A x = b using the current " + "decomposition of A.") + .def("solve", &solve, bp::args("self", "B"), + "Returns the solution X of A X = B using the current " + "decomposition of A where B is a right hand side matrix.") + + .def("threshold", &Solver::threshold, bp::arg("self"), + "Returns the threshold that will be used by certain methods such " + "as rank(). "); + } + + private: + static MatrixXs matrixU(const Solver& self) { return self.matrixU(); } + static MatrixXs matrixV(const Solver& self) { return self.matrixV(); } + + template + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { + return self.solve(vec); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_svdbase_hpp__ diff --git a/include/eigenpy/decompositions/SelfAdjointEigenSolver.hpp b/include/eigenpy/decompositions/SelfAdjointEigenSolver.hpp index 221f3d434..987577d6f 100644 --- a/include/eigenpy/decompositions/SelfAdjointEigenSolver.hpp +++ b/include/eigenpy/decompositions/SelfAdjointEigenSolver.hpp @@ -21,6 +21,7 @@ struct SelfAdjointEigenSolverVisitor typedef _MatrixType MatrixType; typedef typename MatrixType::Scalar Scalar; typedef Eigen::SelfAdjointEigenSolver Solver; + typedef Eigen::Matrix VectorType; template void visit(PyClass& cl) const { @@ -32,12 +33,20 @@ struct SelfAdjointEigenSolverVisitor bp::args("self", "matrix", "options"), "Computes eigendecomposition of given matrix")) - .def("eigenvalues", &Solver::eigenvalues, bp::arg("self"), - "Returns the eigenvalues of given matrix.", - bp::return_internal_reference<>()) - .def("eigenvectors", &Solver::eigenvectors, bp::arg("self"), - "Returns the eigenvectors of given matrix.", - bp::return_internal_reference<>()) + .def( + "eigenvalues", + +[](const Solver& c) -> const VectorType& { + return c.eigenvalues(); + }, + "Returns the eigenvalues of given matrix.", + bp::return_internal_reference<>()) + .def( + "eigenvectors", + +[](const Solver& c) -> const MatrixType& { + return c.eigenvectors(); + }, + "Returns the eigenvectors of given matrix.", + bp::return_internal_reference<>()) .def("compute", &SelfAdjointEigenSolverVisitor::compute_proxy, diff --git a/include/eigenpy/decompositions/Tridiagonalization.hpp b/include/eigenpy/decompositions/Tridiagonalization.hpp new file mode 100644 index 000000000..8e93faed8 --- /dev/null +++ b/include/eigenpy/decompositions/Tridiagonalization.hpp @@ -0,0 +1,87 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_tridiagonalization_hpp__ +#define __eigenpy_decompositions_tridiagonalization_hpp__ + +#include +#include + +#include "eigenpy/eigen-to-python.hpp" +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct TridiagonalizationVisitor : public boost::python::def_visitor< + TridiagonalizationVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef Eigen::Tridiagonalization Solver; + typedef Eigen::VectorXd VectorType; + + template + void visit(PyClass& cl) const { + cl.def( + bp::init(bp::arg("size"), "Default constructor. ")) + .def(bp::init(bp::arg("matrix"), + "Constructor; computes tridiagonal " + "decomposition of given matrix. ")) + + .def( + "compute", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::compute, + bp::args("self", "matrix"), + "Computes tridiagonal decomposition of given matrix. ", + bp::return_self<>()) + + .def("householderCoefficients", &Solver::householderCoefficients, + bp::arg("self"), "Returns the Householder coefficients. ") + .def("packedMatrix", &Solver::packedMatrix, bp::arg("self"), + "Returns the internal representation of the decomposition. ", + bp::return_value_policy()) + + .def( + "matrixQ", + +[](const Solver& c) -> MatrixType { return c.matrixQ(); }, + "Returns the unitary matrix Q in the decomposition.") + .def( + "matrixT", + +[](const Solver& c) -> MatrixType { return c.matrixT(); }, + "Returns an expression of the tridiagonal matrix T in the " + "decomposition.") + + .def( + "diagonal", + +[](const Solver& c) -> VectorType { return c.diagonal(); }, + bp::arg("self"), + "Returns the diagonal of the tridiagonal matrix T in the " + "decomposition. ") + + .def( + "subDiagonal", + +[](const Solver& c) -> VectorType { return c.subDiagonal(); }, + bp::arg("self"), + "Returns the subdiagonal of the tridiagonal matrix T in the " + "decomposition."); + } + + static void expose() { + static const std::string classname = + "TridiagonalizationVisitor" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), bp::no_init) + .def(TridiagonalizationVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_tridiagonalization_hpp__ diff --git a/include/eigenpy/decompositions/minres.hpp b/include/eigenpy/decompositions/minres.hpp index fa53870e9..c5bb0dae0 100644 --- a/include/eigenpy/decompositions/minres.hpp +++ b/include/eigenpy/decompositions/minres.hpp @@ -1,181 +1,16 @@ /* - * Copyright 2021 INRIA + * Copyright 2025 INRIA */ #ifndef __eigenpy_decompositions_minres_hpp__ #define __eigenpy_decompositions_minres_hpp__ -#include -#include -#include +#include "eigenpy/fwd.hpp" -#include "eigenpy/eigenpy.hpp" -#include "eigenpy/utils/scalar-name.hpp" +// clang-format off +EIGENPY_PRAGMA_DEPRECATED_HEADER(eigenpy/decompositions/minres.hpp, eigenpy/solvers/MINRES.hpp) +// clang-format on -namespace eigenpy { -template -struct IterativeSolverBaseVisitor - : public boost::python::def_visitor> { - typedef _Solver Solver; - typedef typename Solver::MatrixType MatrixType; - typedef typename Solver::Preconditioner Preconditioner; - typedef typename Solver::Scalar Scalar; - typedef typename Solver::RealScalar RealScalar; - - typedef Eigen::Matrix - MatrixXs; - - template - void visit(PyClass& cl) const { - cl.def("analyzePattern", - (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & - Solver::analyzePattern, - bp::args("self", "A"), - "Initializes the iterative solver for the sparsity pattern of the " - "matrix A for further solving Ax=b problems.", - bp::return_self<>()) - .def( - "factorize", - (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & - Solver::factorize, - bp::args("self", "A"), - "Initializes the iterative solver with the numerical values of the " - "matrix A for further solving Ax=b problems.", - bp::return_self<>()) - .def( - "compute", - (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & - Solver::compute, - bp::args("self", "A"), - "Initializes the iterative solver with the matrix A for further " - "solving Ax=b problems.", - bp::return_self<>()) - - .def("rows", &Solver::rows, bp::arg("self"), - "Returns the number of rows.") - .def("cols", &Solver::cols, bp::arg("self"), - "Returns the number of columns.") - .def("tolerance", &Solver::tolerance, bp::arg("self"), - "Returns the tolerance threshold used by the stopping criteria.") - .def("setTolerance", &Solver::setTolerance, - bp::args("self", "tolerance"), - "Sets the tolerance threshold used by the stopping criteria.\n" - "This value is used as an upper bound to the relative residual " - "error: |Ax-b|/|b|.\n" - "The default value is the machine precision given by " - "NumTraits::epsilon().", - bp::return_self<>()) - .def("preconditioner", - (Preconditioner & (Solver::*)()) & Solver::preconditioner, - bp::arg("self"), - "Returns a read-write reference to the preconditioner for custom " - "configuration.", - bp::return_internal_reference<>()) - - .def("maxIterations", &Solver::maxIterations, bp::arg("self"), - "Returns the max number of iterations.\n" - "It is either the value setted by setMaxIterations or, by " - "default, twice the number of columns of the matrix.") - .def("setMaxIterations", &Solver::setMaxIterations, - bp::args("self", "max_iterations"), - "Sets the max number of iterations.\n" - "Default is twice the number of columns of the matrix.", - bp::return_self<>()) - - .def( - "iterations", &Solver::iterations, bp::arg("self"), - "Returns the number of iterations performed during the last solve.") - .def("error", &Solver::error, bp::arg("self"), - "Returns the tolerance error reached during the last solve.\n" - "It is a close approximation of the true relative residual error " - "|Ax-b|/|b|.") - .def("info", &Solver::error, bp::arg("info"), - "Returns Success if the iterations converged, and NoConvergence " - "otherwise.") - - .def("solveWithGuess", &solveWithGuess, - bp::args("self", "b", "x0"), - "Returns the solution x of A x = b using the current " - "decomposition of A and x0 as an initial solution.") - - .def( - "solve", &solve, bp::args("self", "b"), - "Returns the solution x of A x = b using the current decomposition " - "of A where b is a right hand side matrix or vector."); - } - - private: - template - static MatrixOrVector1 solveWithGuess(const Solver& self, - const MatrixOrVector1& b, - const MatrixOrVector2& guess) { - return self.solveWithGuess(b, guess); - } - - template - static MatrixOrVector solve(const Solver& self, - const MatrixOrVector& mat_or_vec) { - MatrixOrVector res = self.solve(mat_or_vec); - return res; - } -}; - -template -struct MINRESSolverVisitor - : public boost::python::def_visitor> { - typedef _MatrixType MatrixType; - typedef typename MatrixType::Scalar Scalar; - typedef typename MatrixType::RealScalar RealScalar; - typedef Eigen::Matrix - VectorXs; - typedef Eigen::Matrix - MatrixXs; - typedef Eigen::MINRES Solver; - - template - void visit(PyClass& cl) const { - cl.def(bp::init<>(bp::arg("self"), "Default constructor")) - .def(bp::init( - bp::args("self", "matrix"), - "Initialize the solver with matrix A for further Ax=b solving.\n" - "This constructor is a shortcut for the default constructor " - "followed by a call to compute().")) - - .def(IterativeSolverBaseVisitor()); - } - - static void expose() { - static const std::string classname = - "MINRES" + scalar_name::shortname(); - expose(classname); - } - - static void expose(const std::string& name) { - bp::class_( - name.c_str(), - "A minimal residual solver for sparse symmetric problems.\n" - "This class allows to solve for A.x = b sparse linear problems using " - "the MINRES algorithm of Paige and Saunders (1975). The sparse matrix " - "A must be symmetric (possibly indefinite). The vectors x and b can be " - "either dense or sparse.\n" - "The maximal number of iterations and tolerance value can be " - "controlled via the setMaxIterations() and setTolerance() methods. The " - "defaults are the size of the problem for the maximal number of " - "iterations and NumTraits::epsilon() for the tolerance.\n", - bp::no_init) - .def(MINRESSolverVisitor()) - .def(IdVisitor()); - } - - private: - template - static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { - return self.solve(vec); - } -}; - -} // namespace eigenpy +#include "eigenpy/solvers/MINRES.hpp" #endif // ifndef __eigenpy_decompositions_minres_hpp__ diff --git a/include/eigenpy/decompositions/sparse/LDLT.hpp b/include/eigenpy/decompositions/sparse/LDLT.hpp index 6c9c39773..07664e992 100644 --- a/include/eigenpy/decompositions/sparse/LDLT.hpp +++ b/include/eigenpy/decompositions/sparse/LDLT.hpp @@ -1,72 +1,16 @@ /* - * Copyright 2024 INRIA + * Copyright 2025 INRIA */ #ifndef __eigenpy_decompositions_sparse_ldlt_hpp__ #define __eigenpy_decompositions_sparse_ldlt_hpp__ -#include "eigenpy/eigenpy.hpp" -#include "eigenpy/decompositions/sparse/SimplicialCholesky.hpp" -#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/fwd.hpp" -namespace eigenpy { +// clang-format off +EIGENPY_PRAGMA_DEPRECATED_HEADER(eigenpy/decompositions/sparse/LDLT.hpp, eigenpy/decompositions/sparse/SimplicialLDLT.hpp) +// clang-format on -template > -struct SimplicialLDLTVisitor - : public boost::python::def_visitor< - SimplicialLDLTVisitor<_MatrixType, _UpLo, _Ordering>> { - typedef SimplicialLDLTVisitor<_MatrixType, _UpLo, _Ordering> Visitor; - typedef _MatrixType MatrixType; - - typedef Eigen::SimplicialLDLT Solver; - typedef typename MatrixType::Scalar Scalar; - typedef typename MatrixType::RealScalar RealScalar; - typedef Eigen::Matrix - DenseVectorXs; - typedef Eigen::Matrix - DenseMatrixXs; - - template - void visit(PyClass &cl) const { - cl.def(bp::init<>(bp::arg("self"), "Default constructor")) - .def(bp::init(bp::args("self", "matrix"), - "Constructs and performs the LDLT " - "factorization from a given matrix.")) - - .def("vectorD", &vectorD, bp::arg("self"), - "Returns the diagonal vector D.") - .def(SimplicialCholeskyVisitor()); - } - - static void expose() { - static const std::string classname = - "SimplicialLDLT_" + scalar_name::shortname(); - expose(classname); - } - - static void expose(const std::string &name) { - bp::class_( - name.c_str(), - "A direct sparse LDLT Cholesky factorizations.\n\n" - "This class provides a LDL^T Cholesky factorizations of sparse " - "matrices that are selfadjoint and positive definite." - "The factorization allows for solving A.X = B where X and B can be " - "either dense or sparse.\n\n" - "In order to reduce the fill-in, a symmetric permutation P is applied " - "prior to the factorization such that the factorized matrix is P A " - "P^-1.", - bp::no_init) - .def(SimplicialLDLTVisitor()) - .def(IdVisitor()); - } - - private: - static DenseVectorXs vectorD(const Solver &self) { return self.vectorD(); } -}; - -} // namespace eigenpy +#include "eigenpy/decompositions/sparse/SimplicialLDLT.hpp" #endif // ifndef __eigenpy_decompositions_sparse_ldlt_hpp__ diff --git a/include/eigenpy/decompositions/sparse/LLT.hpp b/include/eigenpy/decompositions/sparse/LLT.hpp index 259f796c1..795d18e5c 100644 --- a/include/eigenpy/decompositions/sparse/LLT.hpp +++ b/include/eigenpy/decompositions/sparse/LLT.hpp @@ -1,67 +1,16 @@ /* - * Copyright 2024 INRIA + * Copyright 2025 INRIA */ #ifndef __eigenpy_decompositions_sparse_llt_hpp__ #define __eigenpy_decompositions_sparse_llt_hpp__ -#include "eigenpy/eigenpy.hpp" -#include "eigenpy/decompositions/sparse/SimplicialCholesky.hpp" -#include "eigenpy/utils/scalar-name.hpp" +#include "eigenpy/fwd.hpp" -namespace eigenpy { +// clang-format off +EIGENPY_PRAGMA_DEPRECATED_HEADER(eigenpy/decompositions/sparse/LLT.hpp, eigenpy/decompositions/sparse/SimplicialLLT.hpp) +// clang-format on -template > -struct SimplicialLLTVisitor - : public boost::python::def_visitor< - SimplicialLLTVisitor<_MatrixType, _UpLo, _Ordering>> { - typedef SimplicialLLTVisitor<_MatrixType, _UpLo, _Ordering> Visitor; - typedef _MatrixType MatrixType; - - typedef Eigen::SimplicialLLT Solver; - typedef typename MatrixType::Scalar Scalar; - typedef typename MatrixType::RealScalar RealScalar; - typedef Eigen::Matrix - DenseVectorXs; - typedef Eigen::Matrix - DenseMatrixXs; - - template - void visit(PyClass &cl) const { - cl.def(bp::init<>(bp::arg("self"), "Default constructor")) - .def(bp::init(bp::args("self", "matrix"), - "Constructs and performs the LLT " - "factorization from a given matrix.")) - - .def(SimplicialCholeskyVisitor()); - } - - static void expose() { - static const std::string classname = - "SimplicialLLT_" + scalar_name::shortname(); - expose(classname); - } - - static void expose(const std::string &name) { - bp::class_( - name.c_str(), - "A direct sparse LLT Cholesky factorizations.\n\n" - "This class provides a LL^T Cholesky factorizations of sparse matrices " - "that are selfadjoint and positive definite." - "The factorization allows for solving A.X = B where X and B can be " - "either dense or sparse.\n\n" - "In order to reduce the fill-in, a symmetric permutation P is applied " - "prior to the factorization such that the factorized matrix is P A " - "P^-1.", - bp::no_init) - .def(SimplicialLLTVisitor()) - .def(IdVisitor()); - } -}; - -} // namespace eigenpy +#include "eigenpy/decompositions/sparse/SimplicialLLT.hpp" #endif // ifndef __eigenpy_decompositions_sparse_llt_hpp__ diff --git a/include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp b/include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp index 7fddd79d2..3924f3d1b 100644 --- a/include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp +++ b/include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp @@ -30,7 +30,7 @@ struct SimplicialCholeskyVisitor DenseMatrixXs; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def("analyzePattern", &Solver::analyzePattern, bp::args("self", "matrix"), "Performs a symbolic decomposition on the sparcity of matrix.\n" @@ -46,7 +46,7 @@ struct SimplicialCholeskyVisitor "Returns the upper triangular matrix U.") .def("compute", - (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute, + (Solver & (Solver::*)(const MatrixType& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the sparse Cholesky decomposition of a given matrix.", bp::return_self<>()) @@ -85,8 +85,8 @@ struct SimplicialCholeskyVisitor } private: - static MatrixType matrixL(const Solver &self) { return self.matrixL(); } - static MatrixType matrixU(const Solver &self) { return self.matrixU(); } + static MatrixType matrixL(const Solver& self) { return self.matrixL(); } + static MatrixType matrixU(const Solver& self) { return self.matrixU(); } }; } // namespace eigenpy diff --git a/include/eigenpy/decompositions/sparse/SimplicialLDLT.hpp b/include/eigenpy/decompositions/sparse/SimplicialLDLT.hpp new file mode 100644 index 000000000..e17bc7c0b --- /dev/null +++ b/include/eigenpy/decompositions/sparse/SimplicialLDLT.hpp @@ -0,0 +1,72 @@ +/* + * Copyright 2024 INRIA + */ + +#ifndef __eigenpy_decompositions_sparse_simplicial_ldlt_hpp__ +#define __eigenpy_decompositions_sparse_simplicial_ldlt_hpp__ + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/decompositions/sparse/SimplicialCholesky.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template > +struct SimplicialLDLTVisitor + : public boost::python::def_visitor< + SimplicialLDLTVisitor<_MatrixType, _UpLo, _Ordering>> { + typedef SimplicialLDLTVisitor<_MatrixType, _UpLo, _Ordering> Visitor; + typedef _MatrixType MatrixType; + + typedef Eigen::SimplicialLDLT Solver; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::Matrix + DenseVectorXs; + typedef Eigen::Matrix + DenseMatrixXs; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init(bp::args("self", "matrix"), + "Constructs and performs the LDLT " + "factorization from a given matrix.")) + + .def("vectorD", &vectorD, bp::arg("self"), + "Returns the diagonal vector D.") + .def(SimplicialCholeskyVisitor()); + } + + static void expose() { + static const std::string classname = + "SimplicialLDLT_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "A direct sparse LDLT Cholesky factorizations.\n\n" + "This class provides a LDL^T Cholesky factorizations of sparse " + "matrices that are selfadjoint and positive definite." + "The factorization allows for solving A.X = B where X and B can be " + "either dense or sparse.\n\n" + "In order to reduce the fill-in, a symmetric permutation P is applied " + "prior to the factorization such that the factorized matrix is P A " + "P^-1.", + bp::no_init) + .def(SimplicialLDLTVisitor()) + .def(IdVisitor()); + } + + private: + static DenseVectorXs vectorD(const Solver& self) { return self.vectorD(); } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_sparse_simplicial_ldlt_hpp__ diff --git a/include/eigenpy/decompositions/sparse/SimplicialLLT.hpp b/include/eigenpy/decompositions/sparse/SimplicialLLT.hpp new file mode 100644 index 000000000..331b85c20 --- /dev/null +++ b/include/eigenpy/decompositions/sparse/SimplicialLLT.hpp @@ -0,0 +1,67 @@ +/* + * Copyright 2024 INRIA + */ + +#ifndef __eigenpy_decompositions_sparse_simplicial_llt_hpp__ +#define __eigenpy_decompositions_sparse_simplicial_llt_hpp__ + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/decompositions/sparse/SimplicialCholesky.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template > +struct SimplicialLLTVisitor + : public boost::python::def_visitor< + SimplicialLLTVisitor<_MatrixType, _UpLo, _Ordering>> { + typedef SimplicialLLTVisitor<_MatrixType, _UpLo, _Ordering> Visitor; + typedef _MatrixType MatrixType; + + typedef Eigen::SimplicialLLT Solver; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::Matrix + DenseVectorXs; + typedef Eigen::Matrix + DenseMatrixXs; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init(bp::args("self", "matrix"), + "Constructs and performs the LLT " + "factorization from a given matrix.")) + + .def(SimplicialCholeskyVisitor()); + } + + static void expose() { + static const std::string classname = + "SimplicialLLT_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "A direct sparse LLT Cholesky factorizations.\n\n" + "This class provides a LL^T Cholesky factorizations of sparse matrices " + "that are selfadjoint and positive definite." + "The factorization allows for solving A.X = B where X and B can be " + "either dense or sparse.\n\n" + "In order to reduce the fill-in, a symmetric permutation P is applied " + "prior to the factorization such that the factorized matrix is P A " + "P^-1.", + bp::no_init) + .def(SimplicialLLTVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_sparse_simplicial_llt_hpp__ diff --git a/include/eigenpy/decompositions/sparse/SparseLU.hpp b/include/eigenpy/decompositions/sparse/SparseLU.hpp new file mode 100644 index 000000000..b099c9b3c --- /dev/null +++ b/include/eigenpy/decompositions/sparse/SparseLU.hpp @@ -0,0 +1,223 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_sparse_lu_hpp__ +#define __eigenpy_decompositions_sparse_lu_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct SparseLUMatrixLReturnTypeVisitor + : public boost::python::def_visitor< + SparseLUMatrixLReturnTypeVisitor> { + typedef Eigen::SparseLUMatrixLReturnType LType; + typedef typename MappedSupernodalType::Scalar Scalar; + typedef Eigen::Matrix VectorXs; + typedef Eigen::Matrix + MatrixXs; + + template + static void solveInPlace(const LType& self, + Eigen::Ref mat_vec) { + self.solveInPlace(mat_vec); + } + + template + void visit(PyClass& cl) const { + cl.def(bp::init(bp::args("self", "mapL"))) + + .def("rows", <ype::rows) + .def("cols", <ype::cols) + + .def("solveInPlace", &solveInPlace, bp::args("self", "X")) + .def("solveInPlace", &solveInPlace, bp::args("self", "x")); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), "Eigen SparseLUMatrixLReturnType", + bp::no_init) + .def(SparseLUMatrixLReturnTypeVisitor()) + .def(IdVisitor()); + } +}; + +template +struct SparseLUMatrixUReturnTypeVisitor + : public boost::python::def_visitor< + SparseLUMatrixUReturnTypeVisitor> { + typedef Eigen::SparseLUMatrixUReturnType UType; + typedef typename MatrixLType::Scalar Scalar; + typedef Eigen::Matrix VectorXs; + typedef Eigen::Matrix + MatrixXs; + + template + static void solveInPlace(const UType& self, + Eigen::Ref mat_vec) { + self.solveInPlace(mat_vec); + } + + template + void visit(PyClass& cl) const { + cl.def(bp::init(bp::args("self", "mapL", "mapU"))) + + .def("rows", &UType::rows) + .def("cols", &UType::cols) + + .def("solveInPlace", &solveInPlace, bp::args("self", "X")) + .def("solveInPlace", &solveInPlace, bp::args("self", "x")); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), "Eigen SparseLUMatrixUReturnType", + bp::no_init) + .def(SparseLUMatrixUReturnTypeVisitor()) + .def(IdVisitor()); + } +}; + +template > +struct SparseLUVisitor : public boost::python::def_visitor< + SparseLUVisitor<_MatrixType, _Ordering>> { + typedef SparseLUVisitor<_MatrixType, _Ordering> Visitor; + typedef _MatrixType MatrixType; + + typedef Eigen::SparseLU Solver; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + + typedef typename Solver::SCMatrix SCMatrix; + typedef typename MatrixType::StorageIndex StorageIndex; + +#if EIGEN_VERSION_AT_LEAST(3, 4, 90) + typedef Eigen::Map> + MappedSparseMatrix; +#else + typedef Eigen::MappedSparseMatrix + MappedSparseMatrix; +#endif + typedef Eigen::SparseLUMatrixLReturnType LType; + typedef Eigen::SparseLUMatrixUReturnType UType; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init(bp::args("self", "matrix"), + "Constructs and performs the LU " + "factorization from a given matrix.")) + + .def("determinant", &Solver::determinant, bp::arg("self"), + "Returns the determinant of the matrix.") + .def("signDeterminant", &Solver::signDeterminant, bp::arg("self"), + "A number representing the sign of the determinant. ") + .def("absDeterminant", &Solver::absDeterminant, bp::arg("self"), + "Returns the absolute value of the determinant of the matrix of " + "which *this is the QR decomposition.") + .def("logAbsDeterminant", &Solver::logAbsDeterminant, bp::arg("self"), + "Returns the natural log of the absolute value of the determinant " + "of the matrix of which *this is the QR decomposition") + + .def("rows", &Solver::rows, bp::arg("self"), + "Returns the number of rows of the matrix.") + .def("cols", &Solver::cols, bp::arg("self"), + "Returns the number of cols of the matrix.") + + .def("nnzL", &Solver::nnzL, bp::arg("self"), + "The number of non zero elements in L") + .def("nnzU", &Solver::nnzU, bp::arg("self"), + "The number of non zero elements in U") + + .def( + "matrixL", + +[](const Solver& self) -> LType { return self.matrixL(); }, + "Returns an expression of the matrix L.") + .def( + "matrixU", + +[](const Solver& self) -> UType { return self.matrixU(); }, + "Returns an expression of the matrix U.") + + .def("colsPermutation", &Solver::colsPermutation, bp::arg("self"), + "Returns a reference to the column matrix permutation PTc such " + "that Pr A PTc = LU.", + bp::return_value_policy()) + .def("rowsPermutation", &Solver::rowsPermutation, bp::arg("self"), + "Returns a reference to the row matrix permutation Pr such that " + "Pr A PTc = LU", + bp::return_value_policy()) + + .def("compute", &Solver::compute, bp::args("self", "matrix"), + "Compute the symbolic and numeric factorization of the input " + "sparse matrix. " + "The input matrix should be in column-major storage. ") + + .def("analyzePattern", &Solver::analyzePattern, + bp::args("self", "matrix"), + "Compute the column permutation to minimize the fill-in.") + .def("factorize", &Solver::factorize, bp::args("self", "matrix"), + "Performs a numeric decomposition of a given matrix.\n" + "The given matrix must has the same sparcity than the matrix on " + "which the symbolic decomposition has been performed.") + + .def("isSymmetric", &Solver::isSymmetric, bp::args("self", "sym"), + "Indicate that the pattern of the input matrix is symmetric. ") + + .def("setPivotThreshold", &Solver::setPivotThreshold, + bp::args("self", "thresh"), + "Set the threshold used for a diagonal entry to be an acceptable " + "pivot.") + + .def("info", &Solver::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + .def("lastErrorMessage", &Solver::lastErrorMessage, bp::arg("self"), + "Returns a string describing the type of error. ") + + .def(SparseSolverBaseVisitor()); + } + + static void expose() { + static const std::string classname = + "SparseLU_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "Sparse supernodal LU factorization for general matrices. \n\n" + "This class implements the supernodal LU factorization for general " + "matrices. " + "It uses the main techniques from the sequential SuperLU package " + "(http://crd-legacy.lbl.gov/~xiaoye/SuperLU/). It handles " + "transparently real " + "and complex arithmetic with single and double precision, depending on " + "the scalar " + "type of your input matrix. The code has been optimized to provide " + "BLAS-3 operations " + "during supernode-panel updates. It benefits directly from the " + "built-in high-performant " + "Eigen BLAS routines. Moreover, when the size of a supernode is very " + "small, the BLAS " + "calls are avoided to enable a better optimization from the compiler. " + "For best performance, " + "you should compile it with NDEBUG flag to avoid the numerous bounds " + "checking on vectors.", + bp::no_init) + .def(SparseLUVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_sparse_lu_hpp__ diff --git a/include/eigenpy/decompositions/sparse/SparseQR.hpp b/include/eigenpy/decompositions/sparse/SparseQR.hpp new file mode 100644 index 000000000..e78ca0025 --- /dev/null +++ b/include/eigenpy/decompositions/sparse/SparseQR.hpp @@ -0,0 +1,239 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_decompositions_sparse_qr_hpp__ +#define __eigenpy_decompositions_sparse_qr_hpp__ + +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct SparseQRMatrixQTransposeReturnTypeVisitor + : public boost::python::def_visitor< + SparseQRMatrixQTransposeReturnTypeVisitor> { + typedef typename SparseQRType::Scalar Scalar; + typedef Eigen::SparseQRMatrixQTransposeReturnType + QTransposeType; + typedef Eigen::VectorXd VectorXd; + typedef Eigen::MatrixXd MatrixXd; + + template + void visit(PyClass& cl) const { + cl.def(bp::init(bp::args("self", "qr"))) + .def( + "__matmul__", + +[](QTransposeType& self, const MatrixXd& other) -> MatrixXd { + return MatrixXd(self * other); + }, + bp::args("self", "other")) + + .def( + "__matmul__", + +[](QTransposeType& self, const VectorXd& other) -> VectorXd { + return VectorXd(self * other); + }, + bp::args("self", "other")); + } + + static void expose() { + static const std::string classname = "SparseQRMatrixQTransposeReturnType_" + + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), "Eigen SparseQRMatrixQTransposeReturnType", bp::no_init) + .def(SparseQRMatrixQTransposeReturnTypeVisitor()) + .def(IdVisitor()); + } +}; + +template +struct SparseQRMatrixQReturnTypeVisitor + : public boost::python::def_visitor< + SparseQRMatrixQReturnTypeVisitor> { + typedef typename SparseQRType::Scalar Scalar; + typedef Eigen::SparseQRMatrixQTransposeReturnType + QTransposeType; + typedef Eigen::SparseQRMatrixQReturnType QType; + typedef typename SparseQRType::QRMatrixType QRMatrixType; + typedef Eigen::VectorXd VectorXd; + typedef Eigen::MatrixXd MatrixXd; + + template + void visit(PyClass& cl) const { + cl.def(bp::init(bp::args("self", "qr"))) + .def( + "__matmul__", + +[](QType& self, const MatrixXd& other) -> MatrixXd { + return MatrixXd(self * other); + }, + bp::args("self", "other")) + + .def( + "__matmul__", + +[](QType& self, const VectorXd& other) -> VectorXd { + return VectorXd(self * other); + }, + bp::args("self", "other")) + + .def("rows", &QType::rows) + .def("cols", &QType::cols) + + .def( + "adjoint", + +[](const QType& self) -> QTransposeType { return self.adjoint(); }) + + .def( + "transpose", + +[](const QType& self) -> QTransposeType { + return self.transpose(); + }) + + .def( + "toSparse", + +[](QType& self) -> QRMatrixType { + Eigen::Index m = self.rows(); + MatrixXd I = MatrixXd::Identity(m, m); + MatrixXd Q_dense = self * I; + return Q_dense.sparseView(); + }, + bp::arg("self"), + "Convert the Q matrix to a sparse matrix representation."); + } + + static void expose() { + static const std::string classname = + "SparseQRMatrixQReturnType_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), "Eigen SparseQRMatrixQReturnType", + bp::no_init) + .def(SparseQRMatrixQReturnTypeVisitor()) + .def(IdVisitor()); + } +}; + +template +struct SparseQRVisitor + : public boost::python::def_visitor> { + typedef typename SparseQRType::MatrixType MatrixType; + + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::Matrix + DenseVectorXs; + typedef Eigen::Matrix + DenseMatrixXs; + + typedef typename SparseQRType::QRMatrixType QRMatrixType; + typedef Eigen::SparseQRMatrixQReturnType QType; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init( + bp::args("self", "mat"), + "Construct a QR factorization of the matrix mat.")) + + .def("cols", &SparseQRType::cols, bp::arg("self"), + "Returns the number of columns of the represented matrix. ") + .def("rows", &SparseQRType::rows, bp::arg("self"), + "Returns the number of rows of the represented matrix. ") + + .def("compute", &SparseQRType::compute, bp::args("self", "matrix"), + "Compute the symbolic and numeric factorization of the input " + "sparse matrix. " + "The input matrix should be in column-major storage. ") + .def("analyzePattern", &SparseQRType::analyzePattern, + bp::args("self", "mat"), + "Compute the column permutation to minimize the fill-in.") + .def("factorize", &SparseQRType::factorize, bp::args("self", "matrix"), + "Performs a numeric decomposition of a given matrix.\n" + "The given matrix must has the same sparcity than the matrix on " + "which the symbolic decomposition has been performed.") + + .def("colsPermutation", &SparseQRType::colsPermutation, bp::arg("self"), + "Returns a reference to the column matrix permutation PTc such " + "that Pr A PTc = LU.", + bp::return_value_policy()) + + .def("info", &SparseQRType::info, bp::arg("self"), + "NumericalIssue if the input contains INF or NaN values or " + "overflow occured. Returns Success otherwise.") + .def("lastErrorMessage", &SparseQRType::lastErrorMessage, + bp::arg("self"), "Returns a string describing the type of error. ") + + .def("rank", &SparseQRType::rank, bp::arg("self"), + "Returns the number of non linearly dependent columns as " + "determined " + "by the pivoting threshold. ") + + .def( + "matrixQ", + +[](const SparseQRType& self) -> QType { return self.matrixQ(); }, + "Returns an expression of the matrix Q as products of sparse " + "Householder reflectors.") + .def( + "matrixR", + +[](const SparseQRType& self) -> const QRMatrixType& { + return self.matrixR(); + }, + "Returns a const reference to the \b sparse upper triangular " + "matrix " + "R of the QR factorization.", + bp::return_value_policy()) + + .def("setPivotThreshold", &SparseQRType::setPivotThreshold, + bp::args("self", "thresh"), + "Set the threshold used for a diagonal entry to be an acceptable " + "pivot.") + + .def(SparseSolverBaseVisitor()); + } + + static void expose() { + static const std::string classname = + "SparseQR_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "Sparse left-looking QR factorization with numerical column pivoting. " + "This class implements a left-looking QR decomposition of sparse " + "matrices " + "with numerical column pivoting. When a column has a norm less than a " + "given " + "tolerance it is implicitly permuted to the end. The QR factorization " + "thus " + "obtained is given by A*P = Q*R where R is upper triangular or " + "trapezoidal. \n\n" + "P is the column permutation which is the product of the fill-reducing " + "and the " + "numerical permutations. \n\n" + "Q is the orthogonal matrix represented as products of Householder " + "reflectors. \n\n" + "R is the sparse triangular or trapezoidal matrix. The later occurs " + "when A is rank-deficient. \n\n", + bp::no_init) + .def(SparseQRVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_decompositions_sparse_qr_hpp__ diff --git a/include/eigenpy/decompositions/sparse/SparseSolverBase.hpp b/include/eigenpy/decompositions/sparse/SparseSolverBase.hpp index 7ce3a2237..71939a060 100644 --- a/include/eigenpy/decompositions/sparse/SparseSolverBase.hpp +++ b/include/eigenpy/decompositions/sparse/SparseSolverBase.hpp @@ -29,7 +29,7 @@ struct SparseSolverBaseVisitor DenseMatrixXs; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def("solve", &solve, bp::args("self", "b"), "Returns the solution x of A x = b using the current " "decomposition of A.") @@ -44,7 +44,7 @@ struct SparseSolverBaseVisitor private: template - static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { return self.solve(vec); } }; diff --git a/include/eigenpy/decompositions/sparse/accelerate/accelerate.hpp b/include/eigenpy/decompositions/sparse/accelerate/Accelerate.hpp similarity index 93% rename from include/eigenpy/decompositions/sparse/accelerate/accelerate.hpp rename to include/eigenpy/decompositions/sparse/accelerate/Accelerate.hpp index 29cf9cdef..580109e13 100644 --- a/include/eigenpy/decompositions/sparse/accelerate/accelerate.hpp +++ b/include/eigenpy/decompositions/sparse/accelerate/Accelerate.hpp @@ -25,7 +25,7 @@ struct AccelerateImplVisitor : public boost::python::def_visitor< typedef typename MatrixType::StorageIndex StorageIndex; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl .def("analyzePattern", &Solver::analyzePattern, @@ -38,7 +38,7 @@ struct AccelerateImplVisitor : public boost::python::def_visitor< .def(SparseSolverBaseVisitor()) .def("compute", - (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute, + (Solver & (Solver::*)(const MatrixType& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the sparse Cholesky decomposition of a given matrix.", bp::return_self<>()) @@ -56,7 +56,7 @@ struct AccelerateImplVisitor : public boost::python::def_visitor< .def("setOrder", &Solver::setOrder, bp::arg("self"), "Set order"); } - static void expose(const std::string &name, const std::string &doc = "") { + static void expose(const std::string& name, const std::string& doc = "") { bp::class_(name.c_str(), doc.c_str(), bp::no_init) .def(AccelerateImplVisitor()) diff --git a/include/eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp b/include/eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp index 9cb5e54a4..17ca6a458 100644 --- a/include/eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp +++ b/include/eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp @@ -25,7 +25,7 @@ struct CholmodBaseVisitor typedef typename MatrixType::StorageIndex StorageIndex; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def("analyzePattern", &Solver::analyzePattern, bp::args("self", "matrix"), "Performs a symbolic decomposition on the sparcity of matrix.\n" @@ -36,7 +36,7 @@ struct CholmodBaseVisitor .def(SparseSolverBaseVisitor()) .def("compute", - (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute, + (Solver & (Solver::*)(const MatrixType& matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the sparse Cholesky decomposition of a given matrix.", bp::return_self<>()) diff --git a/include/eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp b/include/eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp index 2525169ca..8e7abde54 100644 --- a/include/eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp +++ b/include/eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp @@ -17,7 +17,7 @@ struct CholmodDecompositionVisitor typedef CholdmodDerived Solver; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl .def(CholmodBaseVisitor()) diff --git a/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLDLT.hpp b/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLDLT.hpp index 9710628c7..c8cd51e26 100644 --- a/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLDLT.hpp +++ b/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLDLT.hpp @@ -22,7 +22,7 @@ struct CholmodSimplicialLDLTVisitor typedef Eigen::CholmodSimplicialLDLT Solver; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl .def(CholmodBaseVisitor()) @@ -40,7 +40,7 @@ struct CholmodSimplicialLDLTVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "A simplicial direct Cholesky (LDLT) factorization and solver based on " diff --git a/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLLT.hpp b/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLLT.hpp index c9404b00f..3fed248ea 100644 --- a/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLLT.hpp +++ b/include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLLT.hpp @@ -22,7 +22,7 @@ struct CholmodSimplicialLLTVisitor typedef Eigen::CholmodSimplicialLLT Solver; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl .def(CholmodBaseVisitor()) @@ -40,7 +40,7 @@ struct CholmodSimplicialLLTVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "A simplicial direct Cholesky (LLT) factorization and solver based on " diff --git a/include/eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp b/include/eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp index ea818e2e4..ed4d45c0f 100644 --- a/include/eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp +++ b/include/eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp @@ -22,7 +22,7 @@ struct CholmodSupernodalLLTVisitor typedef Eigen::CholmodSupernodalLLT Solver; template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl .def(CholmodBaseVisitor()) @@ -40,7 +40,7 @@ struct CholmodSupernodalLLTVisitor expose(classname); } - static void expose(const std::string &name) { + static void expose(const std::string& name) { bp::class_( name.c_str(), "A supernodal direct Cholesky (LLT) factorization and solver based on " diff --git a/include/eigenpy/deprecation-policy.hpp b/include/eigenpy/deprecation-policy.hpp index e1e953f5a..9824e3019 100644 --- a/include/eigenpy/deprecation-policy.hpp +++ b/include/eigenpy/deprecation-policy.hpp @@ -13,7 +13,7 @@ enum class DeprecationType { DEPRECATION, FUTURE }; namespace detail { -inline PyObject *deprecationTypeToPyObj(DeprecationType dep) { +inline PyObject* deprecationTypeToPyObj(DeprecationType dep) { switch (dep) { case DeprecationType::DEPRECATION: return PyExc_DeprecationWarning; @@ -36,17 +36,17 @@ struct deprecation_warning_policy : BasePolicy { using result_converter = typename BasePolicy::result_converter; using argument_package = typename BasePolicy::argument_package; - deprecation_warning_policy(const std::string &warning_msg) + deprecation_warning_policy(const std::string& warning_msg) : BasePolicy(), m_what(warning_msg) {} std::string what() const { return m_what; } - const BasePolicy *derived() const { - return static_cast(this); + const BasePolicy* derived() const { + return static_cast(this); } template - bool precall(const ArgPackage &args) const { + bool precall(const ArgPackage& args) const { PyErr_WarnEx(detail::deprecationTypeToPyObj(deprecation_type), m_what.c_str(), 1); return derived()->precall(args); @@ -60,7 +60,7 @@ template struct deprecated_function : deprecation_warning_policy { - deprecated_function(const std::string &msg = + deprecated_function(const std::string& msg = "This function has been marked as deprecated, and " "will be removed in the future.") : deprecation_warning_policy(msg) {} @@ -70,7 +70,7 @@ template struct deprecated_member : deprecation_warning_policy { - deprecated_member(const std::string &msg = + deprecated_member(const std::string& msg = "This attribute or method has been marked as " "deprecated, and will be removed in the future.") : deprecation_warning_policy(msg) {} diff --git a/include/eigenpy/eigen-allocator.hpp b/include/eigenpy/eigen-allocator.hpp index 2b4c88252..881bd9e5d 100644 --- a/include/eigenpy/eigen-allocator.hpp +++ b/include/eigenpy/eigen-allocator.hpp @@ -17,14 +17,14 @@ namespace details { template struct init_matrix_or_array { - static MatType *run(int rows, int cols, void *storage) { + static MatType* run(int rows, int cols, void* storage) { if (storage) return new (storage) MatType(rows, cols); else return new MatType(rows, cols); } - static MatType *run(PyArrayObject *pyArray, void *storage = NULL) { + static MatType* run(PyArrayObject* pyArray, void* storage = NULL) { assert(PyArray_NDIM(pyArray) == 1 || PyArray_NDIM(pyArray) == 2); int rows = -1, cols = -1; @@ -43,21 +43,21 @@ struct init_matrix_or_array { template struct init_matrix_or_array { - static MatType *run(int rows, int cols, void *storage) { + static MatType* run(int rows, int cols, void* storage) { if (storage) return new (storage) MatType(rows, cols); else return new MatType(rows, cols); } - static MatType *run(int size, void *storage) { + static MatType* run(int size, void* storage) { if (storage) return new (storage) MatType(size); else return new MatType(size); } - static MatType *run(PyArrayObject *pyArray, void *storage = NULL) { + static MatType* run(PyArrayObject* pyArray, void* storage = NULL) { const int ndim = PyArray_NDIM(pyArray); if (ndim == 1) { const int size = (int)PyArray_DIMS(pyArray)[0]; @@ -73,7 +73,7 @@ struct init_matrix_or_array { #ifdef EIGENPY_WITH_TENSOR_SUPPORT template struct init_tensor { - static Tensor *run(PyArrayObject *pyArray, void *storage = NULL) { + static Tensor* run(PyArrayObject* pyArray, void* storage = NULL) { enum { Rank = Tensor::NumDimensions }; assert(PyArray_NDIM(pyArray) == Rank); typedef typename Tensor::Index Index; @@ -103,8 +103,8 @@ struct check_swap_impl> template struct check_swap_impl_matrix { - static bool run(PyArrayObject *pyArray, - const Eigen::MatrixBase &mat) { + static bool run(PyArrayObject* pyArray, + const Eigen::MatrixBase& mat) { if (PyArray_NDIM(pyArray) == 0) return false; if (mat.rows() == PyArray_DIMS(pyArray)[0]) return false; @@ -114,14 +114,14 @@ struct check_swap_impl_matrix { }; template -bool check_swap(PyArrayObject *pyArray, const EigenType &mat) { +bool check_swap(PyArrayObject* pyArray, const EigenType& mat) { return check_swap_impl::run(pyArray, mat); } #ifdef EIGENPY_WITH_TENSOR_SUPPORT template struct check_swap_impl_tensor { - static bool run(PyArrayObject * /*pyArray*/, const TensorType & /*tensor*/) { + static bool run(PyArrayObject* /*pyArray*/, const TensorType& /*tensor*/) { return false; } }; @@ -157,8 +157,8 @@ template ::value> struct cast { template - static void run(const Eigen::MatrixBase &input, - const Eigen::MatrixBase &dest) { + static void run(const Eigen::MatrixBase& input, + const Eigen::MatrixBase& dest) { dest.const_cast_derived() = input.template cast(); } }; @@ -167,7 +167,7 @@ struct cast { template struct cast { template - static void run(const TensorIn &input, TensorOut &dest) { + static void run(const TensorIn& input, TensorOut& dest) { dest = input.template cast(); } }; @@ -307,23 +307,23 @@ struct eigen_allocator_impl_matrix { typedef typename MatType::Scalar Scalar; static void allocate( - PyArrayObject *pyArray, - boost::python::converter::rvalue_from_python_storage *storage) { - void *raw_ptr = storage->storage.bytes; + PyArrayObject* pyArray, + boost::python::converter::rvalue_from_python_storage* storage) { + void* raw_ptr = storage->storage.bytes; assert(is_aligned(raw_ptr, EIGENPY_DEFAULT_ALIGN_BYTES) && "The pointer is not aligned."); - Type *mat_ptr = details::init_matrix_or_array::run(pyArray, raw_ptr); - Type &mat = *mat_ptr; + Type* mat_ptr = details::init_matrix_or_array::run(pyArray, raw_ptr); + Type& mat = *mat_ptr; copy(pyArray, mat); } /// \brief Copy Python array into the input matrix mat. template - static void copy(PyArrayObject *pyArray, - const Eigen::MatrixBase &mat_) { - MatrixDerived &mat = mat_.const_cast_derived(); + static void copy(PyArrayObject* pyArray, + const Eigen::MatrixBase& mat_) { + MatrixDerived& mat = mat_.const_cast_derived(); const int pyArray_type_code = EIGENPY_GET_PY_ARRAY_TYPE(pyArray); const int Scalar_type_code = Register::getTypeCode(); @@ -339,10 +339,9 @@ struct eigen_allocator_impl_matrix { /// \brief Copy mat into the Python array using Eigen::Map template - static void copy(const Eigen::MatrixBase &mat_, - PyArrayObject *pyArray) { - const MatrixDerived &mat = - const_cast(mat_.derived()); + static void copy(const Eigen::MatrixBase& mat_, + PyArrayObject* pyArray) { + const MatrixDerived& mat = const_cast(mat_.derived()); const int pyArray_type_code = EIGENPY_GET_PY_ARRAY_TYPE(pyArray); const int Scalar_type_code = Register::getTypeCode(); @@ -374,16 +373,16 @@ template struct eigen_allocator_impl_tensor { typedef typename TensorType::Scalar Scalar; static void allocate( - PyArrayObject *pyArray, - boost::python::converter::rvalue_from_python_storage - *storage) { - void *raw_ptr = storage->storage.bytes; + PyArrayObject* pyArray, + boost::python::converter::rvalue_from_python_storage* + storage) { + void* raw_ptr = storage->storage.bytes; assert(is_aligned(raw_ptr, EIGENPY_DEFAULT_ALIGN_BYTES) && "The pointer is not aligned."); - TensorType *tensor_ptr = + TensorType* tensor_ptr = details::init_tensor::run(pyArray, raw_ptr); - TensorType &tensor = *tensor_ptr; + TensorType& tensor = *tensor_ptr; copy(pyArray, tensor); } @@ -400,7 +399,7 @@ struct eigen_allocator_impl_tensor { /// \brief Copy Python array into the input matrix mat. template - static void copy(PyArrayObject *pyArray, TensorDerived &tensor) { + static void copy(PyArrayObject* pyArray, TensorDerived& tensor) { const int pyArray_type_code = EIGENPY_GET_PY_ARRAY_TYPE(pyArray); const int Scalar_type_code = Register::getTypeCode(); @@ -426,7 +425,7 @@ struct eigen_allocator_impl_tensor { } /// \brief Copy mat into the Python array using Eigen::Map - static void copy(const TensorType &tensor, PyArrayObject *pyArray) { + static void copy(const TensorType& tensor, PyArrayObject* pyArray) { const int pyArray_type_code = EIGENPY_GET_PY_ARRAY_TYPE(pyArray); const int Scalar_type_code = Register::getTypeCode(); @@ -452,7 +451,7 @@ struct eigen_allocator_impl_tensor { /// you want a compile-time vector /// in these cases, data layout fits desired view layout template -inline bool is_arr_layout_compatible_with_mat_type(PyArrayObject *pyArray) { +inline bool is_arr_layout_compatible_with_mat_type(PyArrayObject* pyArray) { bool is_array_C_cont = PyArray_IS_C_CONTIGUOUS(pyArray); bool is_array_F_cont = PyArray_IS_F_CONTIGUOUS(pyArray); return (MatType::IsRowMajor && is_array_C_cont) || @@ -467,13 +466,13 @@ struct eigen_allocator_impl_matrix> { typedef typename MatType::Scalar Scalar; typedef - typename ::boost::python::detail::referent_storage::StorageType + typename ::boost::python::detail::referent_storage::StorageType StorageType; static void allocate( - PyArrayObject *pyArray, - ::boost::python::converter::rvalue_from_python_storage - *storage) { + PyArrayObject* pyArray, + ::boost::python::converter::rvalue_from_python_storage* + storage) { typedef typename StrideType< MatType, Eigen::internal::traits::StrideType::InnerStrideAtCompileTime, @@ -491,20 +490,20 @@ struct eigen_allocator_impl_matrix> { Eigen::Unaligned) // we need to check whether the memory is correctly // aligned and composed of a continuous segment { - void *data_ptr = PyArray_DATA(pyArray); + void* data_ptr = PyArray_DATA(pyArray); if (!PyArray_ISONESEGMENT(pyArray) || !is_aligned(data_ptr, Options)) need_to_allocate |= true; } - void *raw_ptr = storage->storage.bytes; + void* raw_ptr = storage->storage.bytes; if (need_to_allocate) { - MatType *mat_ptr; + MatType* mat_ptr; mat_ptr = details::init_matrix_or_array::run(pyArray); RefType mat_ref(*mat_ptr); new (raw_ptr) StorageType(mat_ref, pyArray, mat_ptr); - RefType &mat = *reinterpret_cast(raw_ptr); + RefType& mat = *reinterpret_cast(raw_ptr); EigenAllocator::copy(pyArray, mat); } else { assert(pyArray_type_code == Scalar_type_code); @@ -516,7 +515,7 @@ struct eigen_allocator_impl_matrix> { } } - static void copy(RefType const &ref, PyArrayObject *pyArray) { + static void copy(RefType const& ref, PyArrayObject* pyArray) { EigenAllocator::copy(ref, pyArray); } }; @@ -528,13 +527,13 @@ struct eigen_allocator_impl_matrix< typedef typename MatType::Scalar Scalar; typedef - typename ::boost::python::detail::referent_storage::StorageType + typename ::boost::python::detail::referent_storage::StorageType StorageType; static void allocate( - PyArrayObject *pyArray, - ::boost::python::converter::rvalue_from_python_storage - *storage) { + PyArrayObject* pyArray, + ::boost::python::converter::rvalue_from_python_storage* + storage) { typedef typename StrideType< MatType, Eigen::internal::traits::StrideType::InnerStrideAtCompileTime, @@ -553,20 +552,20 @@ struct eigen_allocator_impl_matrix< Eigen::Unaligned) // we need to check whether the memory is correctly // aligned and composed of a continuous segment { - void *data_ptr = PyArray_DATA(pyArray); + void* data_ptr = PyArray_DATA(pyArray); if (!PyArray_ISONESEGMENT(pyArray) || !is_aligned(data_ptr, Options)) need_to_allocate |= true; } - void *raw_ptr = storage->storage.bytes; + void* raw_ptr = storage->storage.bytes; if (need_to_allocate) { - MatType *mat_ptr; + MatType* mat_ptr; mat_ptr = details::init_matrix_or_array::run(pyArray); RefType mat_ref(*mat_ptr); new (raw_ptr) StorageType(mat_ref, pyArray, mat_ptr); - MatType &mat = *mat_ptr; + MatType& mat = *mat_ptr; EigenAllocator::copy(pyArray, mat); } else { assert(pyArray_type_code == Scalar_type_code); @@ -578,7 +577,7 @@ struct eigen_allocator_impl_matrix< } } - static void copy(RefType const &ref, PyArrayObject *pyArray) { + static void copy(RefType const& ref, PyArrayObject* pyArray) { EigenAllocator::copy(ref, pyArray); } }; @@ -604,13 +603,13 @@ struct eigen_allocator_impl_tensor_ref { typedef typename TensorType::Scalar Scalar; typedef - typename ::boost::python::detail::referent_storage::StorageType + typename ::boost::python::detail::referent_storage::StorageType StorageType; static void allocate( - PyArrayObject *pyArray, - ::boost::python::converter::rvalue_from_python_storage - *storage) { + PyArrayObject* pyArray, + ::boost::python::converter::rvalue_from_python_storage* + storage) { // typedef typename StrideType< // MatType, // Eigen::internal::traits::StrideType::InnerStrideAtCompileTime, @@ -637,16 +636,16 @@ struct eigen_allocator_impl_tensor_ref { // need_to_allocate |= true; // } - void *raw_ptr = storage->storage.bytes; + void* raw_ptr = storage->storage.bytes; if (need_to_allocate) { typedef typename boost::remove_const::type TensorTypeNonConst; - TensorTypeNonConst *tensor_ptr; + TensorTypeNonConst* tensor_ptr; tensor_ptr = details::init_tensor::run(pyArray); RefType tensor_ref(*tensor_ptr); new (raw_ptr) StorageType(tensor_ref, pyArray, tensor_ptr); - TensorTypeNonConst &tensor = *tensor_ptr; + TensorTypeNonConst& tensor = *tensor_ptr; EigenAllocator::copy(pyArray, tensor); } else { assert(pyArray_type_code == Scalar_type_code); @@ -657,7 +656,7 @@ struct eigen_allocator_impl_tensor_ref { } } - static void copy(RefType const &ref, PyArrayObject *pyArray) { + static void copy(RefType const& ref, PyArrayObject* pyArray) { EigenAllocator::copy(ref, pyArray); } }; diff --git a/include/eigenpy/eigen-from-python.hpp b/include/eigenpy/eigen-from-python.hpp index 0d0ab4ace..e0a93df03 100644 --- a/include/eigenpy/eigen-from-python.hpp +++ b/include/eigenpy/eigen-from-python.hpp @@ -18,8 +18,8 @@ struct expected_pytype_for_arg {}; template struct expected_pytype_for_arg> { - static PyTypeObject const *get_pytype() { - PyTypeObject const *py_type = eigenpy::getPyArrayType(); + static PyTypeObject const* get_pytype() { + PyTypeObject const* py_type = eigenpy::getPyArrayType(); return py_type; } }; @@ -45,16 +45,16 @@ namespace eigenpy { namespace details { template ::value> struct copy_if_non_const { - static void run(const Eigen::MatrixBase &input, - PyArrayObject *pyArray) { + static void run(const Eigen::MatrixBase& input, + PyArrayObject* pyArray) { EigenAllocator::copy(input, pyArray); } }; template struct copy_if_non_const { - static void run(const Eigen::MatrixBase & /*input*/, - PyArrayObject * /*pyArray*/) {} + static void run(const Eigen::MatrixBase& /*input*/, + PyArrayObject* /*pyArray*/) {} }; #if EIGEN_VERSION_AT_LEAST(3, 2, 0) @@ -64,19 +64,19 @@ struct referent_storage_eigen_ref { typedef _RefType RefType; typedef typename get_eigen_plain_type::type PlainObjectType; typedef typename ::eigenpy::aligned_storage< - ::boost::python::detail::referent_size::value>::type + ::boost::python::detail::referent_size::value>::type AlignedStorage; referent_storage_eigen_ref() : pyArray(NULL), plain_ptr(NULL), - ref_ptr(reinterpret_cast(ref_storage.bytes)) {} + ref_ptr(reinterpret_cast(ref_storage.bytes)) {} - referent_storage_eigen_ref(const RefType &ref, PyArrayObject *pyArray, - PlainObjectType *plain_ptr = NULL) + referent_storage_eigen_ref(const RefType& ref, PyArrayObject* pyArray, + PlainObjectType* plain_ptr = NULL) : pyArray(pyArray), plain_ptr(plain_ptr), - ref_ptr(reinterpret_cast(ref_storage.bytes)) { + ref_ptr(reinterpret_cast(ref_storage.bytes)) { Py_INCREF(pyArray); new (ref_storage.bytes) RefType(ref); } @@ -93,9 +93,9 @@ struct referent_storage_eigen_ref { } AlignedStorage ref_storage; - PyArrayObject *pyArray; - PlainObjectType *plain_ptr; - RefType *ref_ptr; + PyArrayObject* pyArray; + PlainObjectType* plain_ptr; + RefType* ref_ptr; }; #endif @@ -107,19 +107,19 @@ namespace python { namespace detail { #if EIGEN_VERSION_AT_LEAST(3, 2, 0) template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::Ref RefType; typedef ::eigenpy::details::referent_storage_eigen_ref StorageType; typedef typename ::eigenpy::aligned_storage< - referent_size::value>::type type; + referent_size::value>::type type; }; template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::Ref RefType; typedef ::eigenpy::details::referent_storage_eigen_ref StorageType; typedef typename ::eigenpy::aligned_storage< - referent_size::value>::type type; + referent_size::value>::type type; }; #endif } // namespace detail @@ -133,42 +133,42 @@ namespace converter { #define EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(type) \ typedef ::eigenpy::rvalue_from_python_data Base; \ \ - rvalue_from_python_data(rvalue_from_python_stage1_data const &_stage1) \ + rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1) \ : Base(_stage1) {} \ \ - rvalue_from_python_data(void *convertible) : Base(convertible){}; + rvalue_from_python_data(void* convertible) : Base(convertible){}; template struct rvalue_from_python_data< - Eigen::Matrix const &> - : ::eigenpy::rvalue_from_python_data const &> { + Eigen::Matrix const&> + : ::eigenpy::rvalue_from_python_data< + Eigen::Matrix const&> { typedef Eigen::Matrix T; - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(T const &) + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(T const&) }; template -struct rvalue_from_python_data const &> - : ::eigenpy::rvalue_from_python_data { - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const &) +struct rvalue_from_python_data const&> + : ::eigenpy::rvalue_from_python_data { + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const&) }; template -struct rvalue_from_python_data const &> - : ::eigenpy::rvalue_from_python_data { - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const &) +struct rvalue_from_python_data const&> + : ::eigenpy::rvalue_from_python_data { + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const&) }; template -struct rvalue_from_python_data const &> - : ::eigenpy::rvalue_from_python_data { - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const &) +struct rvalue_from_python_data const&> + : ::eigenpy::rvalue_from_python_data { + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const&) }; template -struct rvalue_from_python_data &> - : rvalue_from_python_storage &> { +struct rvalue_from_python_data&> + : rvalue_from_python_storage&> { typedef Eigen::Ref RefType; #if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) && \ @@ -182,14 +182,14 @@ struct rvalue_from_python_data &> #endif // The usual constructor - rvalue_from_python_data(rvalue_from_python_stage1_data const &_stage1) { + rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1) { this->stage1 = _stage1; } // This constructor just sets m_convertible -- used by // implicitly_convertible<> to perform the final step of the // conversion, where the construct() function is already known. - rvalue_from_python_data(void *convertible) { + rvalue_from_python_data(void* convertible) { this->stage1.convertible = convertible; } @@ -197,15 +197,15 @@ struct rvalue_from_python_data &> ~rvalue_from_python_data() { typedef ::eigenpy::details::referent_storage_eigen_ref StorageType; if (this->stage1.convertible == this->storage.bytes) - static_cast((void *)this->storage.bytes)->~StorageType(); + static_cast((void*)this->storage.bytes)->~StorageType(); } }; template struct rvalue_from_python_data< - const Eigen::Ref &> + const Eigen::Ref&> : rvalue_from_python_storage< - const Eigen::Ref &> { + const Eigen::Ref&> { typedef Eigen::Ref RefType; #if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) && \ @@ -219,14 +219,14 @@ struct rvalue_from_python_data< #endif // The usual constructor - rvalue_from_python_data(rvalue_from_python_stage1_data const &_stage1) { + rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1) { this->stage1 = _stage1; } // This constructor just sets m_convertible -- used by // implicitly_convertible<> to perform the final step of the // conversion, where the construct() function is already known. - rvalue_from_python_data(void *convertible) { + rvalue_from_python_data(void* convertible) { this->stage1.convertible = convertible; } @@ -234,7 +234,7 @@ struct rvalue_from_python_data< ~rvalue_from_python_data() { typedef ::eigenpy::details::referent_storage_eigen_ref StorageType; if (this->stage1.convertible == this->storage.bytes) - static_cast((void *)this->storage.bytes)->~StorageType(); + static_cast((void*)this->storage.bytes)->~StorageType(); } }; @@ -246,15 +246,15 @@ namespace eigenpy { template void eigen_from_py_construct( - PyObject *pyObj, bp::converter::rvalue_from_python_stage1_data *memory) { - PyArrayObject *pyArray = reinterpret_cast(pyObj); + PyObject* pyObj, bp::converter::rvalue_from_python_stage1_data* memory) { + PyArrayObject* pyArray = reinterpret_cast(pyObj); assert((PyArray_DIMS(pyArray)[0] < INT_MAX) && (PyArray_DIMS(pyArray)[1] < INT_MAX)); - bp::converter::rvalue_from_python_storage *storage = + bp::converter::rvalue_from_python_storage* storage = reinterpret_cast< - bp::converter::rvalue_from_python_storage *>( - reinterpret_cast(memory)); + bp::converter::rvalue_from_python_storage*>( + reinterpret_cast(memory)); EigenAllocator::allocate(pyArray, storage); @@ -267,11 +267,11 @@ struct eigen_from_py_impl { typedef typename EigenType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj); + static void* convertible(PyObject* pyObj); /// \brief Allocate memory and copy pyObj in the new storage - static void construct(PyObject *pyObj, - bp::converter::rvalue_from_python_stage1_data *memory); + static void construct(PyObject* pyObj, + bp::converter::rvalue_from_python_stage1_data* memory); static void registration(); }; @@ -281,11 +281,11 @@ struct eigen_from_py_impl> { typedef typename MatType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj); + static void* convertible(PyObject* pyObj); /// \brief Allocate memory and copy pyObj in the new storage - static void construct(PyObject *pyObj, - bp::converter::rvalue_from_python_stage1_data *memory); + static void construct(PyObject* pyObj, + bp::converter::rvalue_from_python_stage1_data* memory); static void registration(); }; @@ -296,11 +296,11 @@ template {}; template -void *eigen_from_py_impl>::convertible( - PyObject *pyObj) { - if (!call_PyArray_Check(reinterpret_cast(pyObj))) return 0; +void* eigen_from_py_impl>::convertible( + PyObject* pyObj) { + if (!call_PyArray_Check(reinterpret_cast(pyObj))) return 0; - PyArrayObject *pyArray = reinterpret_cast(pyObj); + PyArrayObject* pyArray = reinterpret_cast(pyObj); if (!np_type_is_convertible_into_scalar( EIGENPY_GET_PY_ARRAY_TYPE(pyArray))) @@ -399,14 +399,14 @@ void *eigen_from_py_impl>::convertible( template void eigen_from_py_impl>::construct( - PyObject *pyObj, bp::converter::rvalue_from_python_stage1_data *memory) { + PyObject* pyObj, bp::converter::rvalue_from_python_stage1_data* memory) { eigen_from_py_construct(pyObj, memory); } template void eigen_from_py_impl>::registration() { bp::converter::registry::push_back( - reinterpret_cast(&eigen_from_py_impl::convertible), + reinterpret_cast(&eigen_from_py_impl::convertible), &eigen_from_py_impl::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -458,7 +458,7 @@ struct EigenFromPy> : EigenFromPy { static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &EigenFromPy::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -476,7 +476,7 @@ struct EigenFromPy, typename MatType::Scalar> static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &EigenFromPy::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -493,7 +493,7 @@ struct EigenFromPy> : EigenFromPy { static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &EigenFromPy::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -511,16 +511,16 @@ struct EigenFromPy> { typedef typename MatType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj) { + static void* convertible(PyObject* pyObj) { if (!call_PyArray_Check(pyObj)) return 0; - PyArrayObject *pyArray = reinterpret_cast(pyObj); + PyArrayObject* pyArray = reinterpret_cast(pyObj); if (!PyArray_ISWRITEABLE(pyArray)) return 0; return EigenFromPy::convertible(pyObj); } static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &eigen_from_py_construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -536,13 +536,13 @@ struct EigenFromPy> { typedef typename MatType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj) { + static void* convertible(PyObject* pyObj) { return EigenFromPy::convertible(pyObj); } static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &eigen_from_py_construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , diff --git a/include/eigenpy/eigen/EigenBase.hpp b/include/eigenpy/eigen/EigenBase.hpp index 2a589faf7..8f42128d5 100644 --- a/include/eigenpy/eigen/EigenBase.hpp +++ b/include/eigenpy/eigen/EigenBase.hpp @@ -13,7 +13,7 @@ template struct EigenBaseVisitor : public boost::python::def_visitor> { template - void visit(PyClass &cl) const { + void visit(PyClass& cl) const { cl.def("cols", &Derived::cols, bp::arg("self"), "Returns the number of columns.") .def("rows", &Derived::rows, bp::arg("self"), diff --git a/include/eigenpy/exception.hpp b/include/eigenpy/exception.hpp index c7694fb00..3247a5542 100644 --- a/include/eigenpy/exception.hpp +++ b/include/eigenpy/exception.hpp @@ -19,10 +19,10 @@ namespace eigenpy { class Exception : public std::exception { public: Exception() : message() {} - Exception(const std::string &msg) : message(msg) {} - const char *what() const throw() { return this->getMessage().c_str(); } + Exception(const std::string& msg) : message(msg) {} + const char* what() const throw() { return this->getMessage().c_str(); } ~Exception() throw() {} - virtual const std::string &getMessage() const { return message; } + virtual const std::string& getMessage() const { return message; } std::string copyMessage() const { return getMessage(); } /* Call this static function to "enable" the translation of this C++ exception @@ -30,8 +30,8 @@ class Exception : public std::exception { static void registerException(); private: - static void translateException(Exception const &e); - static PyObject *pyType; + static void translateException(Exception const& e); + static PyObject* pyType; protected: std::string message; diff --git a/include/eigenpy/fwd.hpp b/include/eigenpy/fwd.hpp index c0fe4c75f..9111ebafc 100644 --- a/include/eigenpy/fwd.hpp +++ b/include/eigenpy/fwd.hpp @@ -36,11 +36,11 @@ #if defined(EIGENPY_CLANG_COMPILER) || defined(EIGENPY_GCC_COMPILER) #define EIGENPY_PRAGMA(x) _Pragma(#x) #define EIGENPY_PRAGMA_MESSAGE(the_message) \ - EIGENPY_PRAGMA(GCC message the_message) + EIGENPY_PRAGMA(GCC message #the_message) #define EIGENPY_PRAGMA_WARNING(the_message) \ - EIGENPY_PRAGMA(GCC warning the_message) + EIGENPY_PRAGMA(GCC warning #the_message) #define EIGENPY_PRAGMA_DEPRECATED(the_message) \ - EIGENPY_PRAGMA_WARNING(Deprecated : the_message) + EIGENPY_PRAGMA_WARNING(Deprecated : #the_message) #define EIGENPY_PRAGMA_DEPRECATED_HEADER(old_header, new_header) \ EIGENPY_PRAGMA_WARNING( \ Deprecated header file : #old_header has been replaced \ @@ -108,7 +108,7 @@ namespace bp = boost::python; #define EIGENPY_NO_ALIGNMENT_VALUE Eigen::Unaligned #define EIGENPY_UNUSED_VARIABLE(var) (void)(var) -#define EIGENPY_UNUSED_TYPE(type) EIGENPY_UNUSED_VARIABLE((type *)(NULL)) +#define EIGENPY_UNUSED_TYPE(type) EIGENPY_UNUSED_VARIABLE((type*)(NULL)) #ifndef NDEBUG #define EIGENPY_USED_VARIABLE_ONLY_IN_DEBUG_MODE(var) #else @@ -185,7 +185,7 @@ namespace internal { template struct has_operator_equal_impl { template - static auto check(U *) -> decltype(std::declval() == std::declval()); + static auto check(U*) -> decltype(std::declval() == std::declval()); template static auto check(...) -> std::false_type; @@ -201,7 +201,7 @@ namespace literals { /// /// Using-declare this operator or do `using namespace eigenpy::literals`. Then /// `bp::arg("matrix")` can be replaced by the literal `"matrix"_a`. -inline boost::python::arg operator"" _a(const char *name, std::size_t) { +inline boost::python::arg operator"" _a(const char* name, std::size_t) { return boost::python::arg(name); } } // namespace literals diff --git a/include/eigenpy/numpy-allocator.hpp b/include/eigenpy/numpy-allocator.hpp index 6c5fc4c9c..1a50d3765 100644 --- a/include/eigenpy/numpy-allocator.hpp +++ b/include/eigenpy/numpy-allocator.hpp @@ -35,8 +35,8 @@ struct numpy_allocator_impl< //{}; template -struct numpy_allocator_impl> - : numpy_allocator_impl_matrix {}; +struct numpy_allocator_impl> + : numpy_allocator_impl_matrix {}; template ::type> @@ -45,13 +45,13 @@ struct NumpyAllocator : numpy_allocator_impl {}; template struct numpy_allocator_impl_matrix { template - static PyArrayObject *allocate( - const Eigen::MatrixBase &mat, npy_intp nd, - npy_intp *shape) { + static PyArrayObject* allocate( + const Eigen::MatrixBase& mat, npy_intp nd, + npy_intp* shape) { typedef typename SimilarMatrixType::Scalar Scalar; const int code = Register::getTypeCode(); - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_SimpleNew( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_SimpleNew( static_cast(nd), shape, code); // Copy data @@ -78,15 +78,15 @@ struct numpy_allocator_impl struct numpy_allocator_impl_tensor { template - static PyArrayObject *allocate(const TensorDerived &tensor, npy_intp nd, - npy_intp *shape) { + static PyArrayObject* allocate(const TensorDerived& tensor, npy_intp nd, + npy_intp* shape) { const int code = Register::getTypeCode(); - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_SimpleNew( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_SimpleNew( static_cast(nd), shape, code); // Copy data EigenAllocator::copy( - static_cast(tensor), pyArray); + static_cast(tensor), pyArray); return pyArray; } @@ -94,10 +94,10 @@ struct numpy_allocator_impl_tensor { #endif template -struct numpy_allocator_impl_matrix { +struct numpy_allocator_impl_matrix { template - static PyArrayObject *allocate(Eigen::PlainObjectBase &mat, - npy_intp nd, npy_intp *shape) { + static PyArrayObject* allocate(Eigen::PlainObjectBase& mat, + npy_intp nd, npy_intp* shape) { typedef typename SimilarMatrixType::Scalar Scalar; enum { NPY_ARRAY_MEMORY_CONTIGUOUS = @@ -106,7 +106,7 @@ struct numpy_allocator_impl_matrix { if (NumpyType::sharedMemory()) { const int Scalar_type_code = Register::getTypeCode(); - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_New( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_New( getPyArrayType(), static_cast(nd), shape, Scalar_type_code, mat.data(), NPY_ARRAY_MEMORY_CONTIGUOUS | NPY_ARRAY_ALIGNED); @@ -123,7 +123,7 @@ template struct numpy_allocator_impl_matrix> { typedef Eigen::Ref RefType; - static PyArrayObject *allocate(RefType &mat, npy_intp nd, npy_intp *shape) { + static PyArrayObject* allocate(RefType& mat, npy_intp nd, npy_intp* shape) { typedef typename RefType::Scalar Scalar; enum { NPY_ARRAY_MEMORY_CONTIGUOUS = @@ -146,7 +146,7 @@ struct numpy_allocator_impl_matrix> { #endif npy_intp strides[2] = {elsize * inner_stride, elsize * outer_stride}; - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_New( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_New( getPyArrayType(), static_cast(nd), shape, Scalar_type_code, strides, mat.data(), NPY_ARRAY_MEMORY_CONTIGUOUS | NPY_ARRAY_ALIGNED); @@ -160,11 +160,11 @@ struct numpy_allocator_impl_matrix> { #endif template -struct numpy_allocator_impl_matrix { +struct numpy_allocator_impl_matrix { template - static PyArrayObject *allocate( - const Eigen::PlainObjectBase &mat, npy_intp nd, - npy_intp *shape) { + static PyArrayObject* allocate( + const Eigen::PlainObjectBase& mat, npy_intp nd, + npy_intp* shape) { typedef typename SimilarMatrixType::Scalar Scalar; enum { NPY_ARRAY_MEMORY_CONTIGUOUS_RO = SimilarMatrixType::IsRowMajor @@ -174,9 +174,9 @@ struct numpy_allocator_impl_matrix { if (NumpyType::sharedMemory()) { const int Scalar_type_code = Register::getTypeCode(); - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_New( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_New( getPyArrayType(), static_cast(nd), shape, Scalar_type_code, - const_cast(mat.data()), + const_cast(mat.data()), NPY_ARRAY_MEMORY_CONTIGUOUS_RO | NPY_ARRAY_ALIGNED); return pyArray; @@ -193,7 +193,7 @@ struct numpy_allocator_impl_matrix< const Eigen::Ref> { typedef const Eigen::Ref RefType; - static PyArrayObject *allocate(RefType &mat, npy_intp nd, npy_intp *shape) { + static PyArrayObject* allocate(RefType& mat, npy_intp nd, npy_intp* shape) { typedef typename RefType::Scalar Scalar; enum { NPY_ARRAY_MEMORY_CONTIGUOUS_RO = @@ -217,9 +217,9 @@ struct numpy_allocator_impl_matrix< #endif npy_intp strides[2] = {elsize * inner_stride, elsize * outer_stride}; - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_New( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_New( getPyArrayType(), static_cast(nd), shape, Scalar_type_code, - strides, const_cast(mat.data()), + strides, const_cast(mat.data()), NPY_ARRAY_MEMORY_CONTIGUOUS_RO | NPY_ARRAY_ALIGNED); return pyArray; @@ -236,8 +236,8 @@ template struct numpy_allocator_impl_tensor> { typedef Eigen::TensorRef RefType; - static PyArrayObject *allocate(RefType &tensor, npy_intp nd, - npy_intp *shape) { + static PyArrayObject* allocate(RefType& tensor, npy_intp nd, + npy_intp* shape) { typedef typename RefType::Scalar Scalar; static const bool IsRowMajor = TensorType::Options & Eigen::RowMajorBit; enum { @@ -253,9 +253,9 @@ struct numpy_allocator_impl_tensor> { // call_PyArray_DescrFromType(Scalar_type_code)->elsize; npy_intp // strides[NumIndices]; - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_New( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_New( getPyArrayType(), static_cast(nd), shape, Scalar_type_code, NULL, - const_cast(tensor.data()), + const_cast(tensor.data()), NPY_ARRAY_MEMORY_CONTIGUOUS | NPY_ARRAY_ALIGNED); return pyArray; @@ -269,8 +269,8 @@ template struct numpy_allocator_impl_tensor> { typedef const Eigen::TensorRef RefType; - static PyArrayObject *allocate(RefType &tensor, npy_intp nd, - npy_intp *shape) { + static PyArrayObject* allocate(RefType& tensor, npy_intp nd, + npy_intp* shape) { typedef typename RefType::Scalar Scalar; static const bool IsRowMajor = TensorType::Options & Eigen::RowMajorBit; enum { @@ -281,9 +281,9 @@ struct numpy_allocator_impl_tensor> { if (NumpyType::sharedMemory()) { const int Scalar_type_code = Register::getTypeCode(); - PyArrayObject *pyArray = (PyArrayObject *)call_PyArray_New( + PyArrayObject* pyArray = (PyArrayObject*)call_PyArray_New( getPyArrayType(), static_cast(nd), shape, Scalar_type_code, NULL, - const_cast(tensor.data()), + const_cast(tensor.data()), NPY_ARRAY_MEMORY_CONTIGUOUS_RO | NPY_ARRAY_ALIGNED); return pyArray; diff --git a/include/eigenpy/optional.hpp b/include/eigenpy/optional.hpp index 5e123fd5e..8987c987b 100644 --- a/include/eigenpy/optional.hpp +++ b/include/eigenpy/optional.hpp @@ -63,7 +63,7 @@ struct nullopt_helper { template struct NoneToPython { - static PyObject *convert(const NoneType &) { Py_RETURN_NONE; } + static PyObject* convert(const NoneType&) { Py_RETURN_NONE; } static void registration() { if (!check_registration()) { @@ -75,7 +75,7 @@ struct NoneToPython { template class OptionalTpl = EIGENPY_DEFAULT_OPTIONAL> struct OptionalToPython { - static PyObject *convert(const OptionalTpl &obj) { + static PyObject* convert(const OptionalTpl& obj) { if (obj) return bp::incref(bp::object(*obj).ptr()); else { @@ -83,7 +83,7 @@ struct OptionalToPython { } } - static PyTypeObject const *get_pytype() { + static PyTypeObject const* get_pytype() { return bp::converter::registered_pytype::get_pytype(); } @@ -97,16 +97,16 @@ struct OptionalToPython { template class OptionalTpl = EIGENPY_DEFAULT_OPTIONAL> struct OptionalFromPython { - static void *convertible(PyObject *obj_ptr); + static void* convertible(PyObject* obj_ptr); - static void construct(PyObject *obj_ptr, - bp::converter::rvalue_from_python_stage1_data *memory); + static void construct(PyObject* obj_ptr, + bp::converter::rvalue_from_python_stage1_data* memory); static void registration(); }; template class OptionalTpl> -void *OptionalFromPython::convertible(PyObject *obj_ptr) { +void* OptionalFromPython::convertible(PyObject* obj_ptr) { if (obj_ptr == Py_None) { return obj_ptr; } @@ -119,12 +119,12 @@ void *OptionalFromPython::convertible(PyObject *obj_ptr) { template class OptionalTpl> void OptionalFromPython::construct( - PyObject *obj_ptr, bp::converter::rvalue_from_python_stage1_data *memory) { + PyObject* obj_ptr, bp::converter::rvalue_from_python_stage1_data* memory) { // create storage using rvalue_storage_t = bp::converter::rvalue_from_python_storage>; - void *storage = - reinterpret_cast(reinterpret_cast(memory)) + void* storage = + reinterpret_cast(reinterpret_cast(memory)) ->storage.bytes; if (obj_ptr == Py_None) { diff --git a/include/eigenpy/register.hpp b/include/eigenpy/register.hpp index 5b5055ad2..fb2171299 100644 --- a/include/eigenpy/register.hpp +++ b/include/eigenpy/register.hpp @@ -18,22 +18,22 @@ namespace eigenpy { /// \brief Structure collecting all the types registers in Numpy via EigenPy struct EIGENPY_DLLAPI Register { - static PyArray_Descr *getPyArrayDescr(PyTypeObject *py_type_ptr); + static PyArray_Descr* getPyArrayDescr(PyTypeObject* py_type_ptr); - static PyArray_Descr *getPyArrayDescrFromTypeNum(const int type_num); + static PyArray_Descr* getPyArrayDescrFromTypeNum(const int type_num); template - static PyArray_Descr *getPyArrayDescrFromScalarType() { + static PyArray_Descr* getPyArrayDescrFromScalarType() { if (!isNumpyNativeType()) { - const std::type_info &info = typeid(Scalar); + const std::type_info& info = typeid(Scalar); if (instance().type_to_py_type_bindings.find(&info) != instance().type_to_py_type_bindings.end()) { - PyTypeObject *py_type = instance().type_to_py_type_bindings[&info]; + PyTypeObject* py_type = instance().type_to_py_type_bindings[&info]; return instance().py_array_descr_bindings[py_type]; } else return nullptr; } else { - PyArray_Descr *new_descr = + PyArray_Descr* new_descr = call_PyArray_DescrFromType(NumpyEquivalentType::type_code); return new_descr; } @@ -44,14 +44,14 @@ struct EIGENPY_DLLAPI Register { return isRegistered(Register::getPyType()); } - static bool isRegistered(PyTypeObject *py_type_ptr); + static bool isRegistered(PyTypeObject* py_type_ptr); - static int getTypeCode(PyTypeObject *py_type_ptr); + static int getTypeCode(PyTypeObject* py_type_ptr); template - static PyTypeObject *getPyType() { + static PyTypeObject* getPyType() { if (!isNumpyNativeType()) { - const PyTypeObject *const_py_type_ptr = + const PyTypeObject* const_py_type_ptr = bp::converter::registered_pytype::get_pytype(); if (const_py_type_ptr == NULL) { std::stringstream ss; @@ -60,17 +60,17 @@ struct EIGENPY_DLLAPI Register { << std::endl; throw std::invalid_argument(ss.str()); } - PyTypeObject *py_type_ptr = const_cast(const_py_type_ptr); + PyTypeObject* py_type_ptr = const_cast(const_py_type_ptr); return py_type_ptr; } else { - PyArray_Descr *new_descr = + PyArray_Descr* new_descr = call_PyArray_DescrFromType(NumpyEquivalentType::type_code); return new_descr->typeobj; } } template - static PyArray_Descr *getPyArrayDescr() { + static PyArray_Descr* getPyArrayDescr() { if (!isNumpyNativeType()) { return getPyArrayDescr(getPyType()); } else { @@ -83,10 +83,10 @@ struct EIGENPY_DLLAPI Register { if (isNumpyNativeType()) return NumpyEquivalentType::type_code; else { - const std::type_info &info = typeid(Scalar); + const std::type_info& info = typeid(Scalar); if (instance().type_to_py_type_bindings.find(&info) != instance().type_to_py_type_bindings.end()) { - PyTypeObject *py_type = instance().type_to_py_type_bindings[&info]; + PyTypeObject* py_type = instance().type_to_py_type_bindings[&info]; int code = instance().py_array_code_bindings[py_type]; return code; @@ -96,39 +96,39 @@ struct EIGENPY_DLLAPI Register { } static int registerNewType( - PyTypeObject *py_type_ptr, const std::type_info *type_info_ptr, - const int type_size, const int alignment, PyArray_GetItemFunc *getitem, - PyArray_SetItemFunc *setitem, PyArray_NonzeroFunc *nonzero, - PyArray_CopySwapFunc *copyswap, PyArray_CopySwapNFunc *copyswapn, - PyArray_DotFunc *dotfunc, PyArray_FillFunc *fill, - PyArray_FillWithScalarFunc *fillwithscalar); + PyTypeObject* py_type_ptr, const std::type_info* type_info_ptr, + const int type_size, const int alignment, PyArray_GetItemFunc* getitem, + PyArray_SetItemFunc* setitem, PyArray_NonzeroFunc* nonzero, + PyArray_CopySwapFunc* copyswap, PyArray_CopySwapNFunc* copyswapn, + PyArray_DotFunc* dotfunc, PyArray_FillFunc* fill, + PyArray_FillWithScalarFunc* fillwithscalar); - static Register &instance(); + static Register& instance(); private: Register() {}; struct Compare_PyTypeObject { - bool operator()(const PyTypeObject *a, const PyTypeObject *b) const { + bool operator()(const PyTypeObject* a, const PyTypeObject* b) const { return std::string(a->tp_name) < std::string(b->tp_name); } }; struct Compare_TypeInfo { - bool operator()(const std::type_info *a, const std::type_info *b) const { + bool operator()(const std::type_info* a, const std::type_info* b) const { return std::string(a->name()) < std::string(b->name()); } }; - typedef std::map + typedef std::map MapInfo; MapInfo type_to_py_type_bindings; - typedef std::map + typedef std::map MapDescr; MapDescr py_array_descr_bindings; - typedef std::map MapCode; + typedef std::map MapCode; MapCode py_array_code_bindings; }; diff --git a/include/eigenpy/scipy-allocator.hpp b/include/eigenpy/scipy-allocator.hpp index 6cb77d8f4..2adfb5b15 100644 --- a/include/eigenpy/scipy-allocator.hpp +++ b/include/eigenpy/scipy-allocator.hpp @@ -36,9 +36,9 @@ struct scipy_allocator_impl -struct scipy_allocator_impl> - : scipy_allocator_impl_sparse_matrix {}; + : scipy_allocator_impl_sparse_matrix {}; template ::type> @@ -47,8 +47,8 @@ struct ScipyAllocator : scipy_allocator_impl {}; template struct scipy_allocator_impl_sparse_matrix { template - static PyObject *allocate( - const Eigen::SparseCompressedBase &mat_, + static PyObject* allocate( + const Eigen::SparseCompressedBase& mat_, bool copy = false) { EIGENPY_UNUSED_VARIABLE(copy); typedef typename SimilarMatrixType::Scalar Scalar; @@ -62,7 +62,7 @@ struct scipy_allocator_impl_sparse_matrix { typedef Eigen::Matrix ScipyStorageIndexVector; typedef const Eigen::Map MapStorageIndexVector; - SimilarMatrixType &mat = mat_.const_cast_derived(); + SimilarMatrixType& mat = mat_.const_cast_derived(); bp::object scipy_sparse_matrix_type = ScipyType::get_pytype_object(); diff --git a/include/eigenpy/solvers/BFGSPreconditioners.hpp b/include/eigenpy/solvers/BFGSPreconditioners.hpp index 40da2b584..2c591bb34 100644 --- a/include/eigenpy/solvers/BFGSPreconditioners.hpp +++ b/include/eigenpy/solvers/BFGSPreconditioners.hpp @@ -1,10 +1,10 @@ /* * Copyright 2017 CNRS - * Copyright 2024 Inria + * Copyright 2024-2025 INRIA */ -#ifndef __eigenpy_bfgs_preconditioners_hpp__ -#define __eigenpy_bfgs_preconditioners_hpp__ +#ifndef __eigenpy_solvers_bfgs_preconditioners_hpp__ +#define __eigenpy_solvers_bfgs_preconditioners_hpp__ #include @@ -65,4 +65,4 @@ struct LimitedBFGSPreconditionerBaseVisitor } // namespace eigenpy -#endif // ifndef __eigenpy_bfgs_preconditioners_hpp__ +#endif // ifndef __eigenpy_solvers_bfgs_preconditioners_hpp__ diff --git a/include/eigenpy/solvers/BasicPreconditioners.hpp b/include/eigenpy/solvers/BasicPreconditioners.hpp index 7e4cd7190..2f4a0a242 100644 --- a/include/eigenpy/solvers/BasicPreconditioners.hpp +++ b/include/eigenpy/solvers/BasicPreconditioners.hpp @@ -1,10 +1,10 @@ /* * Copyright 2017 CNRS - * Copyright 2024 Inria + * Copyright 2024-2025 INRIA */ -#ifndef __eigenpy_basic_preconditioners_hpp__ -#define __eigenpy_basic_preconditioners_hpp__ +#ifndef __eigenpy_solvers_basic_preconditioners_hpp__ +#define __eigenpy_solvers_basic_preconditioners_hpp__ #include @@ -115,4 +115,4 @@ struct IdentityPreconditionerVisitor } // namespace eigenpy -#endif // ifndef __eigenpy_basic_preconditioners_hpp__ +#endif // ifndef __eigenpy_solvers_basic_preconditioners_hpp__ diff --git a/include/eigenpy/solvers/BiCGSTAB.hpp b/include/eigenpy/solvers/BiCGSTAB.hpp new file mode 100644 index 000000000..41bd4bf3c --- /dev/null +++ b/include/eigenpy/solvers/BiCGSTAB.hpp @@ -0,0 +1,41 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_solvers_bicgstab_hpp__ +#define __eigenpy_solvers_bicgstab_hpp__ + +#include + +#include "eigenpy/fwd.hpp" +#include "eigenpy/solvers/IterativeSolverBase.hpp" + +namespace eigenpy { + +template +struct BiCGSTABVisitor + : public boost::python::def_visitor> { + typedef typename BiCGSTAB::MatrixType MatrixType; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>("Default constructor")) + .def(bp::init( + bp::arg("A"), + "Initialize the solver with matrix A for further || Ax - b || " + "solving.\n" + "This constructor is a shortcut for the default constructor " + "followed by a call to compute().")); + } + + static void expose(const std::string& name = "BiCGSTAB") { + bp::class_(name.c_str(), bp::no_init) + .def(IterativeSolverVisitor()) + .def(BiCGSTABVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_solvers_bicgstab_hpp__ diff --git a/include/eigenpy/solvers/ConjugateGradient.hpp b/include/eigenpy/solvers/ConjugateGradient.hpp index f2fdf8699..2c99b277a 100644 --- a/include/eigenpy/solvers/ConjugateGradient.hpp +++ b/include/eigenpy/solvers/ConjugateGradient.hpp @@ -1,9 +1,10 @@ /* * Copyright 2017 CNRS + * Copyright 2025 INRIA */ -#ifndef __eigenpy_conjugate_gradient_hpp__ -#define __eigenpy_conjugate_gradient_hpp__ +#ifndef __eigenpy_solvers_conjugate_gradient_hpp__ +#define __eigenpy_solvers_conjugate_gradient_hpp__ #include @@ -38,4 +39,4 @@ struct ConjugateGradientVisitor } // namespace eigenpy -#endif // ifndef __eigenpy_conjugate_gradient_hpp__ +#endif // ifndef __eigenpy_solvers_conjugate_gradient_hpp__ diff --git a/include/eigenpy/solvers/IncompleteCholesky.hpp b/include/eigenpy/solvers/IncompleteCholesky.hpp new file mode 100644 index 000000000..f0f1e30ca --- /dev/null +++ b/include/eigenpy/solvers/IncompleteCholesky.hpp @@ -0,0 +1,125 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_solvers_incomplete_cholesky_hpp__ +#define __eigenpy_solvers_incomplete_cholesky_hpp__ + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct IncompleteCholeskyVisitor : public boost::python::def_visitor< + IncompleteCholeskyVisitor<_MatrixType>> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::IncompleteCholesky Solver; + typedef Eigen::Matrix + DenseVectorXs; + typedef Eigen::Matrix + DenseMatrixXs; + + typedef Eigen::SparseMatrix FactorType; + typedef Eigen::Matrix VectorRx; + typedef Eigen::PermutationMatrix + PermutationType; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init(bp::args("self", "matrix"), + "Constructs and performs the LDLT " + "factorization from a given matrix.")) + + .def("rows", &Solver::rows, bp::arg("self"), + "Returns the number of rows of the matrix.") + .def("cols", &Solver::cols, bp::arg("self"), + "Returns the number of cols of the matrix.") + + .def("info", &Solver::info, bp::arg("self"), + "Reports whether previous computation was successful.") + + .def("setInitialShift", &Solver::setInitialShift, + bp::args("self", "shift"), "Set the initial shift parameter.") + + .def( + "analyzePattern", + +[](Solver& self, const MatrixType& amat) { + self.analyzePattern(amat); + }, + bp::arg("matrix")) + .def( + "factorize", + +[](Solver& self, const MatrixType& amat) { self.factorize(amat); }, + bp::arg("matrix")) + .def( + "compute", + +[](Solver& self, const MatrixType& amat) { self.compute(amat); }, + bp::arg("matrix")) + + .def( + "matrixL", + +[](const Solver& self) -> const FactorType& { + return self.matrixL(); + }, + bp::return_value_policy()) + .def( + "scalingS", + +[](const Solver& self) -> const VectorRx& { + return self.scalingS(); + }, + bp::return_value_policy()) + .def( + "permutationP", + +[](const Solver& self) -> const PermutationType& { + return self.permutationP(); + }, + bp::return_value_policy()) + + .def( + "solve", + +[](const Solver& self, const Eigen::Ref& b) + -> DenseVectorXs { return self.solve(b); }, + bp::arg("b"), + "Returns the solution x of A x = b using the current decomposition " + "of A, where b is a right hand side vector.") + .def( + "solve", + +[](const Solver& self, const Eigen::Ref& B) + -> DenseMatrixXs { return self.solve(B); }, + bp::arg("b"), + "Returns the solution X of A X = B using the current decomposition " + "of A where B is a right hand side matrix.") + .def( + "solve", + +[](const Solver& self, const MatrixType& B) -> MatrixType { + DenseMatrixXs B_dense = DenseMatrixXs(B); + DenseMatrixXs X_dense = self.solve(B_dense); + return MatrixType(X_dense.sparseView()); + }, + bp::arg("b"), + "Returns the solution X of A X = B using the current decomposition " + "of A where B is a right hand side matrix."); + } + + static void expose() { + static const std::string classname = + "IncompleteCholesky_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_(name.c_str(), "Incomplete Cholesky.", + bp::no_init) + .def(IncompleteCholeskyVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_solvers_incomplete_cholesky_hpp__ diff --git a/include/eigenpy/solvers/IncompleteLUT.hpp b/include/eigenpy/solvers/IncompleteLUT.hpp new file mode 100644 index 000000000..04c58ff74 --- /dev/null +++ b/include/eigenpy/solvers/IncompleteLUT.hpp @@ -0,0 +1,108 @@ +/* + * Copyright 2025 INRIA + */ + +#ifndef __eigenpy_solvers_incomplete_lut_hpp__ +#define __eigenpy_solvers_incomplete_lut_hpp__ + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { + +template +struct IncompleteLUTVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::IncompleteLUT Solver; + typedef Eigen::Matrix + DenseVectorXs; + typedef Eigen::Matrix + DenseMatrixXs; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init(bp::args("self", "matrix"), + "Constructs and performs the LDLT " + "factorization from a given matrix.")) + .def(bp::init( + (bp::arg("matrix"), + bp::arg("droptol") = Eigen::NumTraits::dummy_precision(), + bp::arg("fillfactor") = 10), + "Constructs an incomplete LU factorization from a given matrix.")) + + .def("rows", &Solver::rows, bp::arg("self"), + "Returns the number of rows of the matrix.") + .def("cols", &Solver::cols, bp::arg("self"), + "Returns the number of cols of the matrix.") + + .def("info", &Solver::info, bp::arg("self"), + "Reports whether previous computation was successful.") + + .def( + "analyzePattern", + +[](Solver& self, const MatrixType& amat) { + self.analyzePattern(amat); + }, + bp::arg("matrix")) + .def( + "factorize", + +[](Solver& self, const MatrixType& amat) { self.factorize(amat); }, + bp::arg("matrix")) + .def( + "compute", + +[](Solver& self, const MatrixType& amat) { self.compute(amat); }, + bp::arg("matrix")) + + .def("setDroptol", &Solver::setDroptol, bp::arg("self")) + .def("setFillfactor", &Solver::setFillfactor, bp::arg("self")) + + .def( + "solve", + +[](const Solver& self, const Eigen::Ref& b) + -> DenseVectorXs { return self.solve(b); }, + bp::arg("b"), + "Returns the solution x of A x = b using the current decomposition " + "of A, where b is a right hand side vector.") + .def( + "solve", + +[](const Solver& self, const Eigen::Ref& B) + -> DenseMatrixXs { return self.solve(B); }, + bp::arg("b"), + "Returns the solution X of A X = B using the current decomposition " + "of A where B is a right hand side matrix.") + .def( + "solve", + +[](const Solver& self, const MatrixType& B) -> MatrixType { + DenseMatrixXs B_dense = DenseMatrixXs(B); + DenseMatrixXs X_dense = self.solve(B_dense); + return MatrixType(X_dense.sparseView()); + }, + bp::arg("b"), + "Returns the solution X of A X = B using the current decomposition " + "of A where B is a right hand side matrix."); + } + + static void expose() { + static const std::string classname = + "IncompleteLUT_" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "Incomplete LU factorization with dual-threshold strategy.", + bp::no_init) + .def(IncompleteLUTVisitor()) + .def(IdVisitor()); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_solvers_incomplete_lut_hpp__ diff --git a/include/eigenpy/solvers/IterativeSolverBase.hpp b/include/eigenpy/solvers/IterativeSolverBase.hpp index 670bde3d2..ebab5763a 100644 --- a/include/eigenpy/solvers/IterativeSolverBase.hpp +++ b/include/eigenpy/solvers/IterativeSolverBase.hpp @@ -1,9 +1,10 @@ /* * Copyright 2017 CNRS + * Copyright 2025 INRIA */ -#ifndef __eigenpy_iterative_solver_base_hpp__ -#define __eigenpy_iterative_solver_base_hpp__ +#ifndef __eigenpy_solvers_iterative_solver_base_hpp__ +#define __eigenpy_solvers_iterative_solver_base_hpp__ #include "eigenpy/fwd.hpp" #include "eigenpy/solvers/SparseSolverBase.hpp" @@ -103,4 +104,4 @@ struct IterativeSolverVisitor : public boost::python::def_visitor< } // namespace eigenpy -#endif // ifndef __eigenpy_iterative_solver_base_hpp__ +#endif // ifndef __eigenpy_solvers_iterative_solver_base_hpp__ diff --git a/include/eigenpy/solvers/LeastSquaresConjugateGradient.hpp b/include/eigenpy/solvers/LeastSquaresConjugateGradient.hpp index 043d3d7fb..2f3aae644 100644 --- a/include/eigenpy/solvers/LeastSquaresConjugateGradient.hpp +++ b/include/eigenpy/solvers/LeastSquaresConjugateGradient.hpp @@ -1,9 +1,10 @@ /* * Copyright 2017-2018 CNRS + * Copyright 2025 INRIA */ -#ifndef __eigenpy_least_square_conjugate_gradient_hpp__ -#define __eigenpy_least_square_conjugate_gradient_hpp__ +#ifndef __eigenpy_solvers_least_square_conjugate_gradient_hpp__ +#define __eigenpy_solvers_least_square_conjugate_gradient_hpp__ #include @@ -16,7 +17,7 @@ template struct LeastSquaresConjugateGradientVisitor : public boost::python::def_visitor< LeastSquaresConjugateGradientVisitor> { - typedef Eigen::MatrixXd MatrixType; + typedef typename LeastSquaresConjugateGradient::MatrixType MatrixType; template void visit(PyClass& cl) const { @@ -29,9 +30,10 @@ struct LeastSquaresConjugateGradientVisitor "followed by a call to compute().")); } - static void expose() { - bp::class_( - "LeastSquaresConjugateGradient", bp::no_init) + static void expose( + const std::string& name = "LeastSquaresConjugateGradient") { + bp::class_(name.c_str(), + bp::no_init) .def(IterativeSolverVisitor()) .def(LeastSquaresConjugateGradientVisitor< LeastSquaresConjugateGradient>()) @@ -41,4 +43,4 @@ struct LeastSquaresConjugateGradientVisitor } // namespace eigenpy -#endif // ifndef __eigenpy_least_square_conjugate_gradient_hpp__ +#endif // ifndef __eigenpy_solvers_least_square_conjugate_gradient_hpp__ diff --git a/include/eigenpy/solvers/MINRES.hpp b/include/eigenpy/solvers/MINRES.hpp new file mode 100644 index 000000000..c21fcb66d --- /dev/null +++ b/include/eigenpy/solvers/MINRES.hpp @@ -0,0 +1,181 @@ +/* + * Copyright 2021-2025 INRIA + */ + +#ifndef __eigenpy_solvers_minres_hpp__ +#define __eigenpy_solvers_minres_hpp__ + +#include +#include +#include + +#include "eigenpy/eigenpy.hpp" +#include "eigenpy/utils/scalar-name.hpp" + +namespace eigenpy { +template +struct IterativeSolverBaseVisitor + : public boost::python::def_visitor> { + typedef _Solver Solver; + typedef typename Solver::MatrixType MatrixType; + typedef typename Solver::Preconditioner Preconditioner; + typedef typename Solver::Scalar Scalar; + typedef typename Solver::RealScalar RealScalar; + + typedef Eigen::Matrix + MatrixXs; + + template + void visit(PyClass& cl) const { + cl.def("analyzePattern", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::analyzePattern, + bp::args("self", "A"), + "Initializes the iterative solver for the sparsity pattern of the " + "matrix A for further solving Ax=b problems.", + bp::return_self<>()) + .def( + "factorize", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::factorize, + bp::args("self", "A"), + "Initializes the iterative solver with the numerical values of the " + "matrix A for further solving Ax=b problems.", + bp::return_self<>()) + .def( + "compute", + (Solver & (Solver::*)(const Eigen::EigenBase& matrix)) & + Solver::compute, + bp::args("self", "A"), + "Initializes the iterative solver with the matrix A for further " + "solving Ax=b problems.", + bp::return_self<>()) + + .def("rows", &Solver::rows, bp::arg("self"), + "Returns the number of rows.") + .def("cols", &Solver::cols, bp::arg("self"), + "Returns the number of columns.") + .def("tolerance", &Solver::tolerance, bp::arg("self"), + "Returns the tolerance threshold used by the stopping criteria.") + .def("setTolerance", &Solver::setTolerance, + bp::args("self", "tolerance"), + "Sets the tolerance threshold used by the stopping criteria.\n" + "This value is used as an upper bound to the relative residual " + "error: |Ax-b|/|b|.\n" + "The default value is the machine precision given by " + "NumTraits::epsilon().", + bp::return_self<>()) + .def("preconditioner", + (Preconditioner & (Solver::*)()) & Solver::preconditioner, + bp::arg("self"), + "Returns a read-write reference to the preconditioner for custom " + "configuration.", + bp::return_internal_reference<>()) + + .def("maxIterations", &Solver::maxIterations, bp::arg("self"), + "Returns the max number of iterations.\n" + "It is either the value setted by setMaxIterations or, by " + "default, twice the number of columns of the matrix.") + .def("setMaxIterations", &Solver::setMaxIterations, + bp::args("self", "max_iterations"), + "Sets the max number of iterations.\n" + "Default is twice the number of columns of the matrix.", + bp::return_self<>()) + + .def( + "iterations", &Solver::iterations, bp::arg("self"), + "Returns the number of iterations performed during the last solve.") + .def("error", &Solver::error, bp::arg("self"), + "Returns the tolerance error reached during the last solve.\n" + "It is a close approximation of the true relative residual error " + "|Ax-b|/|b|.") + .def("info", &Solver::error, bp::arg("info"), + "Returns Success if the iterations converged, and NoConvergence " + "otherwise.") + + .def("solveWithGuess", &solveWithGuess, + bp::args("self", "b", "x0"), + "Returns the solution x of A x = b using the current " + "decomposition of A and x0 as an initial solution.") + + .def( + "solve", &solve, bp::args("self", "b"), + "Returns the solution x of A x = b using the current decomposition " + "of A where b is a right hand side matrix or vector."); + } + + private: + template + static MatrixOrVector1 solveWithGuess(const Solver& self, + const MatrixOrVector1& b, + const MatrixOrVector2& guess) { + return self.solveWithGuess(b, guess); + } + + template + static MatrixOrVector solve(const Solver& self, + const MatrixOrVector& mat_or_vec) { + MatrixOrVector res = self.solve(mat_or_vec); + return res; + } +}; + +template +struct MINRESSolverVisitor + : public boost::python::def_visitor> { + typedef _MatrixType MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Eigen::Matrix + VectorXs; + typedef Eigen::Matrix + MatrixXs; + typedef Eigen::MINRES Solver; + + template + void visit(PyClass& cl) const { + cl.def(bp::init<>(bp::arg("self"), "Default constructor")) + .def(bp::init( + bp::args("self", "matrix"), + "Initialize the solver with matrix A for further Ax=b solving.\n" + "This constructor is a shortcut for the default constructor " + "followed by a call to compute().")) + + .def(IterativeSolverBaseVisitor()); + } + + static void expose() { + static const std::string classname = + "MINRES" + scalar_name::shortname(); + expose(classname); + } + + static void expose(const std::string& name) { + bp::class_( + name.c_str(), + "A minimal residual solver for sparse symmetric problems.\n" + "This class allows to solve for A.x = b sparse linear problems using " + "the MINRES algorithm of Paige and Saunders (1975). The sparse matrix " + "A must be symmetric (possibly indefinite). The vectors x and b can be " + "either dense or sparse.\n" + "The maximal number of iterations and tolerance value can be " + "controlled via the setMaxIterations() and setTolerance() methods. The " + "defaults are the size of the problem for the maximal number of " + "iterations and NumTraits::epsilon() for the tolerance.\n", + bp::no_init) + .def(MINRESSolverVisitor()) + .def(IdVisitor()); + } + + private: + template + static MatrixOrVector solve(const Solver& self, const MatrixOrVector& vec) { + return self.solve(vec); + } +}; + +} // namespace eigenpy + +#endif // ifndef __eigenpy_solvers_minres_hpp__ diff --git a/include/eigenpy/solvers/SparseSolverBase.hpp b/include/eigenpy/solvers/SparseSolverBase.hpp index f4f2bdad1..795d98eef 100644 --- a/include/eigenpy/solvers/SparseSolverBase.hpp +++ b/include/eigenpy/solvers/SparseSolverBase.hpp @@ -1,9 +1,10 @@ /* * Copyright 2017 CNRS + * Copyright 2025 INRIA */ -#ifndef __eigenpy_sparse_solver_base_hpp__ -#define __eigenpy_sparse_solver_base_hpp__ +#ifndef __eigenpy_solvers_sparse_solver_base_hpp__ +#define __eigenpy_solvers_sparse_solver_base_hpp__ #include "eigenpy/fwd.hpp" @@ -29,4 +30,4 @@ struct SparseSolverVisitor } // namespace eigenpy -#endif // ifndef __eigenpy_sparse_solver_base_hpp__ +#endif // ifndef __eigenpy_solvers_sparse_solver_base_hpp__ diff --git a/include/eigenpy/solvers/preconditioners.hpp b/include/eigenpy/solvers/preconditioners.hpp index 3e26638ba..c537e2779 100644 --- a/include/eigenpy/solvers/preconditioners.hpp +++ b/include/eigenpy/solvers/preconditioners.hpp @@ -1,9 +1,10 @@ /* * Copyright 2017 CNRS + * Copyright 2025 INRIA */ -#ifndef __eigenpy_preconditioners_hpp__ -#define __eigenpy_preconditioners_hpp__ +#ifndef __eigenpy_solvers_preconditioners_hpp__ +#define __eigenpy_solvers_preconditioners_hpp__ #include "eigenpy/config.hpp" @@ -13,4 +14,4 @@ void EIGENPY_DLLAPI exposePreconditioners(); } // namespace eigenpy -#endif // define __eigenpy_preconditioners_hpp__ +#endif // define __eigenpy_solvers_preconditioners_hpp__ diff --git a/include/eigenpy/solvers/solvers.hpp b/include/eigenpy/solvers/solvers.hpp index af1a375c3..16e1fddce 100644 --- a/include/eigenpy/solvers/solvers.hpp +++ b/include/eigenpy/solvers/solvers.hpp @@ -1,9 +1,9 @@ /* - * Copyright 2017-2020 CNRS INRIA + * Copyright 2017-2025 CNRS INRIA */ -#ifndef __eigenpy_solvers_hpp__ -#define __eigenpy_solvers_hpp__ +#ifndef __eigenpy_solvers_solvers_hpp__ +#define __eigenpy_solvers_solvers_hpp__ #include "eigenpy/config.hpp" @@ -14,4 +14,4 @@ void EIGENPY_DLLAPI exposeSolvers(); } // namespace eigenpy -#endif // define __eigenpy_solvers_hpp__ +#endif // define __eigenpy_solvers_solvers_hpp__ diff --git a/include/eigenpy/sparse/eigen-from-python.hpp b/include/eigenpy/sparse/eigen-from-python.hpp index 1b57e0142..0f07c18bd 100644 --- a/include/eigenpy/sparse/eigen-from-python.hpp +++ b/include/eigenpy/sparse/eigen-from-python.hpp @@ -15,8 +15,8 @@ namespace eigenpy { template struct expected_pytype_for_arg> { - static PyTypeObject const *get_pytype() { - PyTypeObject const *py_type = ScipyType::get_pytype(); + static PyTypeObject const* get_pytype() { + PyTypeObject const* py_type = ScipyType::get_pytype(); return py_type; } }; @@ -35,17 +35,17 @@ struct expected_pytype_for_arg< template struct rvalue_from_python_data< - Eigen::SparseMatrix const &> + Eigen::SparseMatrix const&> : ::eigenpy::rvalue_from_python_data< - Eigen::SparseMatrix const &> { + Eigen::SparseMatrix const&> { typedef Eigen::SparseMatrix T; - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(T const &) + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(T const&) }; template -struct rvalue_from_python_data const &> - : ::eigenpy::rvalue_from_python_data { - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const &) +struct rvalue_from_python_data const&> + : ::eigenpy::rvalue_from_python_data { + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const&) }; } // namespace converter @@ -82,21 +82,21 @@ struct eigen_from_py_impl -void *eigen_from_py_impl< +void* eigen_from_py_impl< SparseMatrixType, - Eigen::SparseMatrixBase>::convertible(PyObject *pyObj) { - const PyTypeObject *type = Py_TYPE(pyObj); - const PyTypeObject *sparse_matrix_py_type = + Eigen::SparseMatrixBase>::convertible(PyObject* pyObj) { + const PyTypeObject* type = Py_TYPE(pyObj); + const PyTypeObject* sparse_matrix_py_type = ScipyType::get_pytype(); typedef typename SparseMatrixType::Scalar Scalar; @@ -113,17 +113,17 @@ void *eigen_from_py_impl< template void eigen_sparse_matrix_from_py_construct( - PyObject *pyObj, bp::converter::rvalue_from_python_stage1_data *memory) { + PyObject* pyObj, bp::converter::rvalue_from_python_stage1_data* memory) { typedef typename MatOrRefType::Scalar Scalar; typedef typename MatOrRefType::StorageIndex StorageIndex; typedef Eigen::Map MapMatOrRefType; - bp::converter::rvalue_from_python_storage *storage = + bp::converter::rvalue_from_python_storage* storage = reinterpret_cast< - bp::converter::rvalue_from_python_storage *>( - reinterpret_cast(memory)); - void *raw_ptr = storage->storage.bytes; + bp::converter::rvalue_from_python_storage*>( + reinterpret_cast(memory)); + void* raw_ptr = storage->storage.bytes; bp::object obj(bp::handle<>(bp::borrowed(pyObj))); @@ -148,8 +148,8 @@ void eigen_sparse_matrix_from_py_construct( nnz = bp::extract(obj.attr("nnz")); // Handle the specific case of the null matrix - Scalar *data_ptr = nullptr; - StorageIndex *indices_ptr = nullptr; + Scalar* data_ptr = nullptr; + StorageIndex* indices_ptr = nullptr; if (nnz > 0) { data_ptr = data.data(); indices_ptr = indices.data(); @@ -169,8 +169,8 @@ void eigen_sparse_matrix_from_py_construct( template void eigen_from_py_impl>:: - construct(PyObject *pyObj, - bp::converter::rvalue_from_python_stage1_data *memory) { + construct(PyObject* pyObj, + bp::converter::rvalue_from_python_stage1_data* memory) { eigen_sparse_matrix_from_py_construct(pyObj, memory); } @@ -179,7 +179,7 @@ void eigen_from_py_impl< SparseMatrixType, Eigen::SparseMatrixBase>::registration() { bp::converter::registry::push_back( - reinterpret_cast(&eigen_from_py_impl::convertible), + reinterpret_cast(&eigen_from_py_impl::convertible), &eigen_from_py_impl::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -216,7 +216,7 @@ struct EigenFromPy> static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &EigenFromPy::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , diff --git a/include/eigenpy/std-array.hpp b/include/eigenpy/std-array.hpp index 7226a4ddf..44fcc757c 100644 --- a/include/eigenpy/std-array.hpp +++ b/include/eigenpy/std-array.hpp @@ -40,24 +40,24 @@ class array_indexing_suite static constexpr std::size_t Size = std::tuple_size{}; template - static void extension_def(Class &) {} + static void extension_def(Class&) {} // throws exception - static void delete_item(Container &, index_type) { + static void delete_item(Container&, index_type) { PyErr_SetString(PyExc_NotImplementedError, "Cannot delete item from std::array type."); bp::throw_error_already_set(); } // throws exception - static void delete_slice(Container &, index_type, index_type) { + static void delete_slice(Container&, index_type, index_type) { PyErr_SetString(PyExc_NotImplementedError, "Cannot delete slice from std::array type."); bp::throw_error_already_set(); } - static void set_slice(Container &container, index_type from, index_type to, - data_type const &v) { + static void set_slice(Container& container, index_type from, index_type to, + data_type const& v) { if (from >= to) { PyErr_SetString(PyExc_NotImplementedError, "Setting this slice would insert into an std::array, " @@ -69,7 +69,7 @@ class array_indexing_suite } template - static void set_slice(Container &container, index_type from, index_type to, + static void set_slice(Container& container, index_type from, index_type to, Iter first, Iter last) { if (from >= to) { PyErr_SetString(PyExc_NotImplementedError, @@ -88,7 +88,7 @@ class array_indexing_suite } } - static bp::object get_slice(Container &container, index_type from, + static bp::object get_slice(Container& container, index_type from, index_type to) { if (from > to) return bp::object(slice_vector_type()); slice_vector_type out; @@ -112,29 +112,29 @@ template ::run(self, deep_copy); } - static void expose(const std::string &class_name, - const std::string &doc_string = "") { + static void expose(const std::string& class_name, + const std::string& doc_string = "") { expose(class_name, doc_string, EmptyPythonVisitor()); } template - static void expose(const std::string &class_name, - const bp::def_visitor &visitor) { + static void expose(const std::string& class_name, + const bp::def_visitor& visitor) { expose(class_name, "", visitor); } template - static void expose(const std::string &class_name, - const std::string &doc_string, - const bp::def_visitor &visitor) { + static void expose(const std::string& class_name, + const std::string& doc_string, + const bp::def_visitor& visitor) { if (!register_symbolic_link_to_registered_type()) { bp::class_ cl(class_name.c_str(), doc_string.c_str()); - cl.def(bp::init(bp::args("self", "other"), - "Copy constructor")); + cl.def(bp::init(bp::args("self", "other"), + "Copy constructor")); cl.def(IdVisitor()); array_indexing_suite indexing_suite; @@ -149,7 +149,7 @@ struct StdArrayPythonVisitor { /// Exposes std::array template -void exposeStdArrayEigenSpecificType(const char *name) { +void exposeStdArrayEigenSpecificType(const char* name) { std::ostringstream oss; oss << "StdArr"; oss << Size << "_" << name; diff --git a/include/eigenpy/std-vector.hpp b/include/eigenpy/std-vector.hpp index f2cf821e0..91616cefd 100644 --- a/include/eigenpy/std-vector.hpp +++ b/include/eigenpy/std-vector.hpp @@ -1,5 +1,6 @@ /// -/// Copyright (c) 2016-2024 CNRS INRIA +/// Copyright (c) 2016-2025 CNRS INRIA +/// Copyright (c) 2025 Heriot-Watt University /// This file was taken from Pinocchio (header /// ) /// @@ -32,7 +33,7 @@ namespace details { /// \brief Check if a PyObject can be converted to an std::vector. template -bool from_python_list(PyObject *obj_ptr, T *) { +bool from_python_list(PyObject* obj_ptr, T*) { // Check if it is a list if (!PyList_Check(obj_ptr)) return false; @@ -52,7 +53,7 @@ bool from_python_list(PyObject *obj_ptr, T *) { template struct build_list { - static ::boost::python::list run(vector_type &vec, const bool deep_copy) { + static bp::list run(vector_type& vec, const bool deep_copy) { if (deep_copy) return build_list::run(vec, true); bp::list bp_list; @@ -65,7 +66,7 @@ struct build_list { template struct build_list { - static ::boost::python::list run(vector_type &vec, const bool) { + static bp::list run(vector_type& vec, const bool) { typedef bp::iterator iterator; return bp::list(iterator()(vec)); } @@ -76,20 +77,22 @@ struct build_list { /// them. template struct overload_base_get_item_for_std_vector - : public boost::python::def_visitor< - overload_base_get_item_for_std_vector> { + : public bp::def_visitor> { typedef typename Container::value_type value_type; typedef typename Container::value_type data_type; typedef size_t index_type; template - void visit(Class &cl) const { - cl.def("__getitem__", &base_get_item); + void visit(Class& cl) const { + cl.def("__getitem__", &base_get_item_int) + .def("__getitem__", &base_get_item_slice) + .def("__getitem__", &base_get_item_list_or_tuple) + .def("__getitem__", &base_get_item_list_or_tuple); } private: - static boost::python::object base_get_item( - boost::python::back_reference container, PyObject *i_) { + static bp::object base_get_item_int(bp::back_reference container, + PyObject* i_) { index_type idx = convert_index(container.get(), i_); typename Container::iterator i = container.get().begin(); std::advance(i, idx); @@ -98,13 +101,73 @@ struct overload_base_get_item_for_std_vector bp::throw_error_already_set(); } - typename bp::to_python_indirect convert; return bp::object(bp::handle<>(convert(*i))); } - static index_type convert_index(Container &container, PyObject *i_) { + static bp::object base_get_item_slice( + bp::back_reference container, bp::slice slice) { + bp::list out; + try { + auto rng = + slice.get_indices(container.get().begin(), container.get().end()); + // rng.start, rng.stop are iterators; rng.step is int; [start, stop] is + // closed + typename bp::to_python_indirect + convert; + // forward or backward + for (typename Container::iterator it = rng.start;; + std::advance(it, rng.step)) { + out.append(bp::object(bp::handle<>(convert(*it)))); + if (it == rng.stop) break; // closed interval, include stop + } + } catch (const std::invalid_argument&) { + // Boost.Python specifies empty ranges throw invalid_argument. + // Return [] (matches Python's behavior for empty slices). + return bp::list(); + } + return out; + } + + template + static bp::object base_get_item_list_or_tuple( + bp::back_reference c, list_or_tuple idxs) { + const Py_ssize_t m = bp::len(idxs); + bp::list out; + for (Py_ssize_t k = 0; k < m; ++k) { + bp::object obj = idxs[k]; + bp::extract ei(obj); + if (!ei.check()) { + PyErr_SetString(PyExc_TypeError, "Indices must be integers"); + bp::throw_error_already_set(); + } + auto idx = normalize_index(c.get().size(), ei()); + out.append(elem_ref(c.get(), idx)); + } + return out; + } + + static index_type normalize_index(std::size_t n, long i) { + long idx = i; + if (idx < 0) idx += static_cast(n); + if (idx < 0 || idx >= static_cast(n)) { + PyErr_SetString(PyExc_IndexError, "Index out of range"); + bp::throw_error_already_set(); + } + return static_cast(idx); + } + + static bp::object elem_ref(Container& c, index_type i) { + typename bp::to_python_indirect + conv; + return bp::object(bp::handle<>(conv(c[i]))); + } + + static index_type convert_index(Container& container, PyObject* i_) { bp::extract i(i_); if (i.check()) { long index = i(); @@ -140,53 +203,53 @@ struct extract_to_eigen_ref operator result_type() const { return (*this)(); } - extract_to_eigen_ref(PyObject *o) : base(o) {} - extract_to_eigen_ref(api::object const &o) : base(o.ptr()) {} + extract_to_eigen_ref(PyObject* o) : base(o) {} + extract_to_eigen_ref(api::object const& o) : base(o.ptr()) {} }; -/// \brief Specialization of the boost::python::extract struct for references to +/// \brief Specialization of the bp::extract struct for references to /// Eigen matrix objects. template -struct extract &> +struct extract&> : extract_to_eigen_ref< Eigen::Matrix> { typedef Eigen::Matrix MatrixType; typedef extract_to_eigen_ref base; - extract(PyObject *o) : base(o) {} - extract(api::object const &o) : base(o.ptr()) {} + extract(PyObject* o) : base(o) {} + extract(api::object const& o) : base(o.ptr()) {} }; template -struct extract &> +struct extract&> : extract_to_eigen_ref> { typedef Eigen::MatrixBase MatrixType; typedef extract_to_eigen_ref base; - extract(PyObject *o) : base(o) {} - extract(api::object const &o) : base(o.ptr()) {} + extract(PyObject* o) : base(o) {} + extract(api::object const& o) : base(o.ptr()) {} }; template -struct extract &> +struct extract&> : extract_to_eigen_ref> { typedef Eigen::RefBase MatrixType; typedef extract_to_eigen_ref base; - extract(PyObject *o) : base(o) {} - extract(api::object const &o) : base(o.ptr()) {} + extract(PyObject* o) : base(o) {} + extract(api::object const& o) : base(o.ptr()) {} }; namespace converter { template -struct reference_arg_from_python &> +struct reference_arg_from_python&> : arg_lvalue_from_python_base { typedef std::vector vector_type; - typedef vector_type &ref_vector_type; + typedef vector_type& ref_vector_type; typedef ref_vector_type result_type; - typedef extract extract_type; + typedef extract extract_type; - reference_arg_from_python(PyObject *py_obj) + reference_arg_from_python(PyObject* py_obj) : arg_lvalue_from_python_base(converter::get_lvalue_from_python( py_obj, registered::converters)), m_data(NULL), @@ -198,15 +261,15 @@ struct reference_arg_from_python &> // Check if py_obj is a py_list, which can then be converted to an // std::vector bool is_convertible = - ::eigenpy::details::from_python_list(py_obj, (Type *)(0)); + ::eigenpy::details::from_python_list(py_obj, (Type*)(0)); if (!is_convertible) return; typedef ::eigenpy::StdContainerFromPythonList Constructor; Constructor::construct(py_obj, &m_data.stage1); - void *&m_result = const_cast(result()); + void*& m_result = const_cast(result()); m_result = m_data.stage1.convertible; - vec_ptr = reinterpret_cast(m_data.storage.bytes); + vec_ptr = reinterpret_cast(m_data.storage.bytes); } result_type operator()() const { @@ -217,7 +280,7 @@ struct reference_arg_from_python &> ~reference_arg_from_python() { if (m_data.stage1.convertible == m_data.storage.bytes) { // Copy back the reference - const vector_type &vec = *vec_ptr; + const vector_type& vec = *vec_ptr; list bp_list(handle<>(borrowed(m_source))); for (size_t i = 0; i < vec.size(); ++i) { typename extract_type::result_type elt = extract_type(bp_list[i]); @@ -228,8 +291,8 @@ struct reference_arg_from_python &> private: rvalue_from_python_data m_data; - PyObject *m_source; - vector_type *vec_ptr; + PyObject* m_source; + vector_type* vec_ptr; }; } // namespace converter @@ -263,7 +326,7 @@ struct StdContainerFromPythonList { typedef typename details::container_traits::Allocator Allocator; /// \brief Check if obj_ptr can be converted - static void *convertible(PyObject *obj_ptr) { + static void* convertible(PyObject* obj_ptr) { namespace bp = boost::python; // Check if it is a list @@ -285,17 +348,16 @@ struct StdContainerFromPythonList { /// \brief Allocate the std::vector and fill it with the element contained in /// the list - static void construct( - PyObject *obj_ptr, - boost::python::converter::rvalue_from_python_stage1_data *memory) { + static void construct(PyObject* obj_ptr, + bp::converter::rvalue_from_python_stage1_data* memory) { // Extract the list bp::object bp_obj(bp::handle<>(bp::borrowed(obj_ptr))); bp::list bp_list(bp_obj); - void *storage = + void* storage = reinterpret_cast< - bp::converter::rvalue_from_python_storage *>( - reinterpret_cast(memory)) + bp::converter::rvalue_from_python_storage*>( + reinterpret_cast(memory)) ->storage.bytes; typedef bp::stl_input_iterator iterator; @@ -308,12 +370,11 @@ struct StdContainerFromPythonList { } static void register_converter() { - ::boost::python::converter::registry::push_back( - &convertible, &construct, ::boost::python::type_id()); + bp::converter::registry::push_back(&convertible, &construct, + bp::type_id()); } - static ::boost::python::list tolist(vector_type &self, - const bool deep_copy = false) { + static bp::list tolist(vector_type& self, const bool deep_copy = false) { return details::build_list::run(self, deep_copy); } }; @@ -328,7 +389,7 @@ struct contains_algo; template struct contains_algo { template - static bool run(const Container &container, key_type const &key) { + static bool run(const Container& container, key_type const& key) { return std::find(container.begin(), container.end(), key) != container.end(); } @@ -337,7 +398,7 @@ struct contains_algo { template struct contains_algo { template - static bool run(const Container &container, key_type const &key) { + static bool run(const Container& container, key_type const& key) { for (size_t k = 0; k < container.size(); ++k) { if (&container[k] == &key) return true; } @@ -347,12 +408,12 @@ struct contains_algo { template struct contains_vector_derived_policies - : public ::boost::python::vector_indexing_suite< + : public bp::vector_indexing_suite< Container, NoProxy, contains_vector_derived_policies> { typedef typename Container::value_type key_type; - static bool contains(Container &container, key_type const &key) { + static bool contains(Container& container, key_type const& key) { return contains_algo::run(container, key); } }; @@ -364,16 +425,16 @@ struct contains_vector_derived_policies /// template struct ExposeStdMethodToStdVector - : public boost::python::def_visitor< + : public bp::def_visitor< ExposeStdMethodToStdVector> { typedef StdContainerFromPythonList FromPythonListConverter; - ExposeStdMethodToStdVector(const CoVisitor &co_visitor) + ExposeStdMethodToStdVector(const CoVisitor& co_visitor) : m_co_visitor(co_visitor) {} template - void visit(Class &cl) const { + void visit(Class& cl) const { cl.def(m_co_visitor) .def("tolist", &FromPythonListConverter::tolist, (bp::arg("self"), bp::arg("deep_copy") = false), @@ -385,13 +446,13 @@ struct ExposeStdMethodToStdVector .def(CopyableVisitor()); } - const CoVisitor &m_co_visitor; + const CoVisitor& m_co_visitor; }; /// Helper to ease ExposeStdMethodToStdVector construction template static ExposeStdMethodToStdVector -createExposeStdMethodToStdVector(const CoVisitor &co_visitor) { +createExposeStdMethodToStdVector(const CoVisitor& co_visitor) { return ExposeStdMethodToStdVector(co_visitor); } @@ -400,12 +461,12 @@ createExposeStdMethodToStdVector(const CoVisitor &co_visitor) { namespace internal { template struct def_pickle_std_vector { - static void run(bp::class_ &) {} + static void run(bp::class_&) {} }; template struct def_pickle_std_vector { - static void run(bp::class_ &cl) { + static void run(bp::class_& cl) { cl.def_pickle(PickleVector()); } }; @@ -426,21 +487,21 @@ struct StdVectorPythonVisitor { typedef StdContainerFromPythonList FromPythonListConverter; - static void expose(const std::string &class_name, - const std::string &doc_string = "") { + static void expose(const std::string& class_name, + const std::string& doc_string = "") { expose(class_name, doc_string, EmptyPythonVisitor()); } template - static void expose(const std::string &class_name, - const bp::def_visitor &visitor) { + static void expose(const std::string& class_name, + const bp::def_visitor& visitor) { expose(class_name, "", visitor); } template - static void expose(const std::string &class_name, - const std::string &doc_string, - const bp::def_visitor &visitor) { + static void expose(const std::string& class_name, + const std::string& doc_string, + const bp::def_visitor& visitor) { // Apply visitor on already registered type or if type is not already // registered, we define and apply the visitor on it auto add_std_visitor = @@ -452,16 +513,16 @@ struct StdVectorPythonVisitor { cl.def(IdVisitor()); // Standard vector indexing definition - boost::python::vector_indexing_suite< + bp::vector_indexing_suite< vector_type, NoProxy, internal::contains_vector_derived_policies> vector_indexing; - cl.def(bp::init( + cl.def(bp::init( bp::args("self", "size", "value"), "Constructor from a given size and a given value.")) - .def(bp::init(bp::args("self", "other"), - "Copy constructor")) + .def(bp::init(bp::args("self", "other"), + "Copy constructor")) .def(vector_indexing) .def(add_std_visitor); @@ -481,7 +542,7 @@ struct StdVectorPythonVisitor { void EIGENPY_DLLAPI exposeStdVector(); template > -void exposeStdVectorEigenSpecificType(const char *name) { +void exposeStdVectorEigenSpecificType(const char* name) { typedef std::vector VecMatType; std::string full_name = "StdVec_"; full_name += name; diff --git a/include/eigenpy/tensor/eigen-from-python.hpp b/include/eigenpy/tensor/eigen-from-python.hpp index 1008fa34c..e364384ec 100644 --- a/include/eigenpy/tensor/eigen-from-python.hpp +++ b/include/eigenpy/tensor/eigen-from-python.hpp @@ -14,8 +14,8 @@ namespace eigenpy { template struct expected_pytype_for_arg> { - static PyTypeObject const *get_pytype() { - PyTypeObject const *py_type = eigenpy::getPyArrayType(); + static PyTypeObject const* get_pytype() { + PyTypeObject const* py_type = eigenpy::getPyArrayType(); return py_type; } }; @@ -33,17 +33,17 @@ struct expected_pytype_for_arg> template struct rvalue_from_python_data< - Eigen::Tensor const &> + Eigen::Tensor const&> : ::eigenpy::rvalue_from_python_data< - Eigen::Tensor const &> { + Eigen::Tensor const&> { typedef Eigen::Tensor T; - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(T const &) + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(T const&) }; template -struct rvalue_from_python_data const &> - : ::eigenpy::rvalue_from_python_data { - EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const &) +struct rvalue_from_python_data const&> + : ::eigenpy::rvalue_from_python_data { + EIGENPY_RVALUE_FROM_PYTHON_DATA_INIT(Derived const&) }; } // namespace converter @@ -54,19 +54,19 @@ namespace boost { namespace python { namespace detail { template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::TensorRef RefType; typedef ::eigenpy::details::referent_storage_eigen_ref StorageType; typedef typename ::eigenpy::aligned_storage< - referent_size::value>::type type; + referent_size::value>::type type; }; template -struct referent_storage &> { +struct referent_storage&> { typedef Eigen::TensorRef RefType; typedef ::eigenpy::details::referent_storage_eigen_ref StorageType; typedef typename ::eigenpy::aligned_storage< - referent_size::value>::type type; + referent_size::value>::type type; }; } // namespace detail } // namespace python @@ -79,25 +79,24 @@ struct eigen_from_py_impl> { typedef typename TensorType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj); + static void* convertible(PyObject* pyObj); /// \brief Allocate memory and copy pyObj in the new storage - static void construct(PyObject *pyObj, - bp::converter::rvalue_from_python_stage1_data *memory); + static void construct(PyObject* pyObj, + bp::converter::rvalue_from_python_stage1_data* memory); static void registration(); }; template -void * -eigen_from_py_impl>::convertible( - PyObject *pyObj) { - if (!call_PyArray_Check(reinterpret_cast(pyObj))) return 0; +void* eigen_from_py_impl< + TensorType, Eigen::TensorBase>::convertible(PyObject* pyObj) { + if (!call_PyArray_Check(reinterpret_cast(pyObj))) return 0; typedef typename Eigen::internal::traits::Index Index; static const Index NumIndices = TensorType::NumIndices; - PyArrayObject *pyArray = reinterpret_cast(pyObj); + PyArrayObject* pyArray = reinterpret_cast(pyObj); if (!np_type_is_convertible_into_scalar( EIGENPY_GET_PY_ARRAY_TYPE(pyArray))) @@ -120,7 +119,7 @@ eigen_from_py_impl>::convertible( template void eigen_from_py_impl>::construct( - PyObject *pyObj, bp::converter::rvalue_from_python_stage1_data *memory) { + PyObject* pyObj, bp::converter::rvalue_from_python_stage1_data* memory) { eigen_from_py_construct(pyObj, memory); } @@ -128,7 +127,7 @@ template void eigen_from_py_impl>::registration() { bp::converter::registry::push_back( - reinterpret_cast(&eigen_from_py_impl::convertible), + reinterpret_cast(&eigen_from_py_impl::convertible), &eigen_from_py_impl::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -163,7 +162,7 @@ struct EigenFromPy> : EigenFromPy { static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &EigenFromPy::construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -179,16 +178,16 @@ struct EigenFromPy> { typedef typename TensorType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj) { + static void* convertible(PyObject* pyObj) { if (!call_PyArray_Check(pyObj)) return 0; - PyArrayObject *pyArray = reinterpret_cast(pyObj); + PyArrayObject* pyArray = reinterpret_cast(pyObj); if (!PyArray_ISWRITEABLE(pyArray)) return 0; return EigenFromPy::convertible(pyObj); } static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &eigen_from_py_construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , @@ -204,13 +203,13 @@ struct EigenFromPy> { typedef typename TensorType::Scalar Scalar; /// \brief Determine if pyObj can be converted into a MatType object - static void *convertible(PyObject *pyObj) { + static void* convertible(PyObject* pyObj) { return EigenFromPy::convertible(pyObj); } static void registration() { bp::converter::registry::push_back( - reinterpret_cast(&EigenFromPy::convertible), + reinterpret_cast(&EigenFromPy::convertible), &eigen_from_py_construct, bp::type_id() #ifndef BOOST_PYTHON_NO_PY_SIGNATURES , diff --git a/include/eigenpy/ufunc.hpp b/include/eigenpy/ufunc.hpp index eeb0902bb..f37da424f 100644 --- a/include/eigenpy/ufunc.hpp +++ b/include/eigenpy/ufunc.hpp @@ -21,12 +21,12 @@ namespace internal { #endif template -void matrix_multiply(char **args, npy_intp const *dimensions, - npy_intp const *steps) { +void matrix_multiply(char** args, npy_intp const* dimensions, + npy_intp const* steps) { /* pointers to data for input and output arrays */ - char *ip1 = args[0]; - char *ip2 = args[1]; - char *op = args[2]; + char* ip1 = args[0]; + char* ip2 = args[1]; + char* op = args[2]; /* lengths of core dimensions */ npy_intp dm = dimensions[0]; @@ -65,10 +65,10 @@ void matrix_multiply(char **args, npy_intp const *dimensions, } template -void gufunc_matrix_multiply(char **args, - npy_intp EIGENPY_NPY_CONST_UFUNC_ARG *dimensions, - npy_intp EIGENPY_NPY_CONST_UFUNC_ARG *steps, - void *NPY_UNUSED(func)) { +void gufunc_matrix_multiply(char** args, + npy_intp EIGENPY_NPY_CONST_UFUNC_ARG* dimensions, + npy_intp EIGENPY_NPY_CONST_UFUNC_ARG* steps, + void* NPY_UNUSED(func)) { /* outer dimensions counter */ npy_intp N_; @@ -92,15 +92,15 @@ void gufunc_matrix_multiply(char **args, #define EIGENPY_REGISTER_BINARY_OPERATOR(name, op) \ template \ void binary_op_##name( \ - char **args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *dimensions, \ - EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *steps, void * /*data*/) { \ + char** args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* dimensions, \ + EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* steps, void* /*data*/) { \ npy_intp is0 = steps[0], is1 = steps[1], os = steps[2], n = *dimensions; \ char *i0 = args[0], *i1 = args[1], *o = args[2]; \ int k; \ for (k = 0; k < n; k++) { \ - T1 &x = *static_cast(static_cast(i0)); \ - T2 &y = *static_cast(static_cast(i1)); \ - R &res = *static_cast(static_cast(o)); \ + T1& x = *static_cast(static_cast(i0)); \ + T2& y = *static_cast(static_cast(i1)); \ + R& res = *static_cast(static_cast(o)); \ res = x op y; \ i0 += is0; \ i1 += is1; \ @@ -110,8 +110,8 @@ void gufunc_matrix_multiply(char **args, \ template \ void binary_op_##name( \ - char **args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *dimensions, \ - EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *steps, void *data) { \ + char** args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* dimensions, \ + EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* steps, void* data) { \ binary_op_##name(args, dimensions, steps, data); \ } @@ -126,39 +126,39 @@ EIGENPY_REGISTER_BINARY_OPERATOR(greater, >) EIGENPY_REGISTER_BINARY_OPERATOR(less_equal, <=) EIGENPY_REGISTER_BINARY_OPERATOR(greater_equal, >=) -#define EIGENPY_REGISTER_UNARY_OPERATOR(name, op) \ - template \ - void unary_op_##name( \ - char **args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *dimensions, \ - EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *steps, void * /*data*/) { \ - npy_intp is = steps[0], os = steps[1], n = *dimensions; \ - char *i = args[0], *o = args[1]; \ - int k; \ - for (k = 0; k < n; k++) { \ - T &x = *static_cast(static_cast(i)); \ - R &res = *static_cast(static_cast(o)); \ - res = op x; \ - i += is; \ - o += os; \ - } \ - } \ - \ - template \ - void unary_op_##name( \ - char **args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *dimensions, \ - EIGENPY_NPY_CONST_UFUNC_ARG npy_intp *steps, void *data) { \ - unary_op_##name(args, dimensions, steps, data); \ +#define EIGENPY_REGISTER_UNARY_OPERATOR(name, op) \ + template \ + void unary_op_##name( \ + char** args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* dimensions, \ + EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* steps, void* /*data*/) { \ + npy_intp is = steps[0], os = steps[1], n = *dimensions; \ + char *i = args[0], *o = args[1]; \ + int k; \ + for (k = 0; k < n; k++) { \ + T& x = *static_cast(static_cast(i)); \ + R& res = *static_cast(static_cast(o)); \ + res = op x; \ + i += is; \ + o += os; \ + } \ + } \ + \ + template \ + void unary_op_##name( \ + char** args, EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* dimensions, \ + EIGENPY_NPY_CONST_UFUNC_ARG npy_intp* steps, void* data) { \ + unary_op_##name(args, dimensions, steps, data); \ } EIGENPY_REGISTER_UNARY_OPERATOR(negative, -) -EIGENPY_REGISTER_UNARY_OPERATOR(square, x *) +EIGENPY_REGISTER_UNARY_OPERATOR(square, x*) } // namespace internal #define EIGENPY_REGISTER_BINARY_UFUNC(name, code, T1, T2, R) \ { \ - PyUFuncObject *ufunc = \ - (PyUFuncObject *)PyObject_GetAttrString(numpy, #name); \ + PyUFuncObject* ufunc = \ + (PyUFuncObject*)PyObject_GetAttrString(numpy, #name); \ int _types[3] = {Register::getTypeCode(), Register::getTypeCode(), \ Register::getTypeCode()}; \ if (!ufunc) { \ @@ -171,7 +171,7 @@ EIGENPY_REGISTER_UNARY_OPERATOR(square, x *) (unsigned long)(sizeof(_types) / sizeof(int))); \ Py_DECREF(ufunc); \ } \ - if (PyUFunc_RegisterLoopForType((PyUFuncObject *)ufunc, code, \ + if (PyUFunc_RegisterLoopForType((PyUFuncObject*)ufunc, code, \ internal::binary_op_##name, \ _types, 0) < 0) { \ /*Py_DECREF(ufunc);*/ \ @@ -182,8 +182,8 @@ EIGENPY_REGISTER_UNARY_OPERATOR(square, x *) #define EIGENPY_REGISTER_UNARY_UFUNC(name, code, T, R) \ { \ - PyUFuncObject *ufunc = \ - (PyUFuncObject *)PyObject_GetAttrString(numpy, #name); \ + PyUFuncObject* ufunc = \ + (PyUFuncObject*)PyObject_GetAttrString(numpy, #name); \ int _types[2] = {Register::getTypeCode(), Register::getTypeCode()}; \ if (!ufunc) { \ /*goto fail; \*/ \ @@ -195,7 +195,7 @@ EIGENPY_REGISTER_UNARY_OPERATOR(square, x *) (unsigned long)(sizeof(_types) / sizeof(int))); \ Py_DECREF(ufunc); \ } \ - if (PyUFunc_RegisterLoopForType((PyUFuncObject *)ufunc, code, \ + if (PyUFunc_RegisterLoopForType((PyUFuncObject*)ufunc, code, \ internal::unary_op_##name, _types, \ 0) < 0) { \ /*Py_DECREF(ufunc);*/ \ @@ -208,9 +208,9 @@ template void registerCommonUfunc() { const int type_code = Register::getTypeCode(); - PyObject *numpy_str; + PyObject* numpy_str; numpy_str = PyStr_FromString("numpy"); - PyObject *numpy; + PyObject* numpy; numpy = PyImport_Import(numpy_str); Py_DECREF(numpy_str); @@ -223,15 +223,15 @@ void registerCommonUfunc() { std::stringstream ss; ss << "return result of multiplying two matrices of "; ss << bp::type_info(typeid(Scalar)).name(); - PyUFuncObject *ufunc = - (PyUFuncObject *)PyObject_GetAttrString(numpy, "matmul"); + PyUFuncObject* ufunc = + (PyUFuncObject*)PyObject_GetAttrString(numpy, "matmul"); if (!ufunc) { std::stringstream ss; ss << "Impossible to define matrix_multiply for given type " << bp::type_info(typeid(Scalar)).name() << std::endl; eigenpy::Exception(ss.str()); } - if (PyUFunc_RegisterLoopForType((PyUFuncObject *)ufunc, type_code, + if (PyUFunc_RegisterLoopForType((PyUFuncObject*)ufunc, type_code, &internal::gufunc_matrix_multiply, types, 0) < 0) { std::stringstream ss; diff --git a/include/eigenpy/utils/empty-visitor.hpp b/include/eigenpy/utils/empty-visitor.hpp index 1c832500a..ef5507042 100644 --- a/include/eigenpy/utils/empty-visitor.hpp +++ b/include/eigenpy/utils/empty-visitor.hpp @@ -8,7 +8,7 @@ namespace eigenpy { struct EmptyPythonVisitor : public ::boost::python::def_visitor { template - void visit(classT &) const {} + void visit(classT&) const {} }; } // namespace eigenpy diff --git a/package.xml b/package.xml index 2344e2c6e..edf3666dd 100644 --- a/package.xml +++ b/package.xml @@ -1,7 +1,7 @@ eigenpy - 3.11.0 + 3.12.0 Bindings between Numpy and Eigen using Boost.Python Justin Carpentier Wolfgang Merkt diff --git a/pixi.lock b/pixi.lock index 4d04d06d0..7ff18f97c 100644 --- a/pixi.lock +++ b/pixi.lock @@ -7,282 +7,288 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.11-h9ccd52b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-hf689a15_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.11-hc22306f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1300.6.5-h03f4b80_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h892fb3f_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda all: @@ -292,40 +298,41 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda @@ -333,147 +340,148 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-hd0bcaf9_1007.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-hf036a51_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libamd-3.3.3-ha5840a7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libbtf-2.3.2-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcamd-3.3.3-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libccolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcholmod-5.3.1-h7ea7d7c_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxsparse-4.4.1-h3868ee3_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libklu-2.3.5-hc7f8671_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libldl-3.3.2-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libparu-1.0.0-hf1a04d7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/librbio-4.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspex-3.2.3-hc5c4b0d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspqr-4.3.4-h795628b_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libsuitesparseconfig-7.10.1-h00e5f87_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libumfpack-6.3.5-h0658b90_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/metis-5.1.0-h3023b02_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-haed47dc_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.11-h9ccd52b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-64/suitesparse-7.10.1-h033788e_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda @@ -481,94 +489,95 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libamd-3.3.3-h5087772_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbtf-2.3.2-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcamd-3.3.3-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcholmod-5.3.1-hbba04d7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxsparse-4.4.1-h9e79f82_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libklu-2.3.5-h4370aa4_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libldl-3.3.2-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparu-1.0.0-h317a14d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/librbio-4.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspex-3.2.3-h15d103f_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspqr-4.3.4-h775d698_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsuitesparseconfig-7.10.1-h4a8fc20_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libumfpack-6.3.5-h7c2c975_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/metis-5.1.0-h15f6cfe_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.11-hc22306f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/suitesparse-7.10.1-h3071b36_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1300.6.5-h03f4b80_0.conda @@ -577,76 +586,79 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-2_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/gmp-6.3.0-hfeafd45_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libamd-3.3.3-h60129d2_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libbtf-2.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcamd-3.3.3-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libccolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcholmod-5.3.1-hdf2ebef_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcxsparse-4.4.1-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_5.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libklu-2.3.5-h77a2eaa_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libldl-3.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libparu-1.0.0-hd80212b_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/librbio-4.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspex-3.2.3-h2f847cc_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspqr-4.3.4-h60c7c62_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libsuitesparseconfig-7.10.1-h0795de7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libumfpack-6.3.5-h4ca129d_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/metis-5.1.0-h17e2fc9_1007.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mpfr-4.2.1-hbc20e70_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/suitesparse-7.10.1-hfa24a04_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda all-clang-cl: @@ -655,76 +667,79 @@ environments: packages: win-64: - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-2_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/gmp-6.3.0-hfeafd45_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libamd-3.3.3-h60129d2_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libbtf-2.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcamd-3.3.3-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libccolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcholmod-5.3.1-hdf2ebef_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcxsparse-4.4.1-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_5.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libklu-2.3.5-h77a2eaa_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libldl-3.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libparu-1.0.0-hd80212b_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/librbio-4.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspex-3.2.3-h2f847cc_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspqr-4.3.4-h60c7c62_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libsuitesparseconfig-7.10.1-h0795de7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libumfpack-6.3.5-h4ca129d_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/metis-5.1.0-h17e2fc9_1007.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mpfr-4.2.1-hbc20e70_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/suitesparse-7.10.1-hfa24a04_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda all-py39: @@ -734,40 +749,41 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py39hf59e57a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py39he8689d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py39h040329f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py39hf0d4527_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda @@ -775,144 +791,145 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-hd0bcaf9_1007.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.0.2-py39h9cb892a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.9.23-hc30ae73_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.13.1-py39haf93ffa_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-hf036a51_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libamd-3.3.3-ha5840a7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py39h5c7665c_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py39h810aed5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hdda6694_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h385f146_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py39hc79836b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py39h7c53190_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libbtf-2.3.2-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcamd-3.3.3-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libccolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcholmod-5.3.1-h7ea7d7c_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxsparse-4.4.1-h3868ee3_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libklu-2.3.5-hc7f8671_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libldl-3.3.2-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libparu-1.0.0-hf1a04d7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/librbio-4.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspex-3.2.3-hc5c4b0d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspqr-4.3.4-h795628b_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libsuitesparseconfig-7.10.1-h00e5f87_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libumfpack-6.3.5-h0658b90_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/metis-5.1.0-h3023b02_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-haed47dc_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.0.2-py39h277832c_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.9.23-h8a7f3fd_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.13.1-py39h038d4f4_0.conda @@ -923,91 +940,92 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libamd-3.3.3-h5087772_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py39h7d68603_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py39h2beb185_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h1b56ccb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py39h76e75a2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py39hfa01887_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbtf-2.3.2-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcamd-3.3.3-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcholmod-5.3.1-hbba04d7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxsparse-4.4.1-h9e79f82_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libklu-2.3.5-h4370aa4_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libldl-3.3.2-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparu-1.0.0-h317a14d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/librbio-4.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspex-3.2.3-h15d103f_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspqr-4.3.4-h775d698_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsuitesparseconfig-7.10.1-h4a8fc20_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libumfpack-6.3.5-h7c2c975_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/metis-5.1.0-h15f6cfe_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.0.2-py39h3ba1154_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.9.23-h7139b31_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.13.1-py39h3d5391c_0.conda @@ -1019,76 +1037,79 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-2_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/gmp-6.3.0-hfeafd45_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libamd-3.3.3-h60129d2_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py39h8f1c5a3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py39hcb5f9c0_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py39h44eb426_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py39h5a5e355_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libbtf-2.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcamd-3.3.3-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libccolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcholmod-5.3.1-hdf2ebef_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcxsparse-4.4.1-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_5.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libklu-2.3.5-h77a2eaa_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libldl-3.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libparu-1.0.0-hd80212b_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/librbio-4.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspex-3.2.3-h2f847cc_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspqr-4.3.4-h60c7c62_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libsuitesparseconfig-7.10.1-h0795de7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libumfpack-6.3.5-h4ca129d_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/metis-5.1.0-h17e2fc9_1007.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mpfr-4.2.1-hbc20e70_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.0.2-py39h60232e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.9.23-h8c5b53a_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.13.1-py39h1a10956_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/suitesparse-7.10.1-hfa24a04_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda cholmod: @@ -1098,40 +1119,41 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda @@ -1139,147 +1161,148 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-hd0bcaf9_1007.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-hf036a51_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libamd-3.3.3-ha5840a7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libbtf-2.3.2-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcamd-3.3.3-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libccolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcholmod-5.3.1-h7ea7d7c_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxsparse-4.4.1-h3868ee3_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libklu-2.3.5-hc7f8671_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libldl-3.3.2-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libparu-1.0.0-hf1a04d7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/librbio-4.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspex-3.2.3-hc5c4b0d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspqr-4.3.4-h795628b_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libsuitesparseconfig-7.10.1-h00e5f87_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libumfpack-6.3.5-h0658b90_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/metis-5.1.0-h3023b02_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-haed47dc_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.11-h9ccd52b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-64/suitesparse-7.10.1-h033788e_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda @@ -1287,94 +1310,95 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libamd-3.3.3-h5087772_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbtf-2.3.2-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcamd-3.3.3-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcholmod-5.3.1-hbba04d7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxsparse-4.4.1-h9e79f82_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libklu-2.3.5-h4370aa4_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libldl-3.3.2-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparu-1.0.0-h317a14d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/librbio-4.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspex-3.2.3-h15d103f_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspqr-4.3.4-h775d698_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsuitesparseconfig-7.10.1-h4a8fc20_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libumfpack-6.3.5-h7c2c975_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/metis-5.1.0-h15f6cfe_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.11-hc22306f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/suitesparse-7.10.1-h3071b36_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1300.6.5-h03f4b80_0.conda @@ -1383,76 +1407,79 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-2_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/gmp-6.3.0-hfeafd45_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libamd-3.3.3-h60129d2_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libbtf-2.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcamd-3.3.3-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libccolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcholmod-5.3.1-hdf2ebef_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcxsparse-4.4.1-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_5.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libklu-2.3.5-h77a2eaa_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libldl-3.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libparu-1.0.0-hd80212b_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/librbio-4.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspex-3.2.3-h2f847cc_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspqr-4.3.4-h60c7c62_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libsuitesparseconfig-7.10.1-h0795de7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libumfpack-6.3.5-h4ca129d_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/metis-5.1.0-h17e2fc9_1007.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mpfr-4.2.1-hbc20e70_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/suitesparse-7.10.1-hfa24a04_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda clang: @@ -1462,84 +1489,86 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-20-20.1.7-default_h1df26ce_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-20.1.7-default_hfa515fb_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/clangxx-20.1.7-default_h0982aa1_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-21-21.1.2-default_h99862b1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-21.1.2-default_h36abe19_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/clangxx-21.1.2-default_h363a0c9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp20.1-20.1.7-default_h1df26ce_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp21.1-21.1.2-default_h99862b1_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm20-20.1.7-he9d0ab4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm21-21.1.2-hf7376ad_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.8-h4bc477f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.0-ha9997c6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.0-h26afc86_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda @@ -1550,282 +1579,288 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.11-h9ccd52b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-hf689a15_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.11-hc22306f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1300.6.5-h03f4b80_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h892fb3f_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda lint: @@ -1835,339 +1870,349 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py312h06ac9bb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py312h35888ee_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.12-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.14-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.8-pyhe01879c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.2.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.4.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py312h178313f_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py312h8a5da7c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py312h68727a3_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.31.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.34.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cffi-1.17.1-py312hf857d28_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cffi-2.0.0-py312hf9bc6d9_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.8-pyhe01879c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.2.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.4.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.11-h9ccd52b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.2-py312h3520af0_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.3-py312hacf3034_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-hf689a15_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.0.1-py312hc5c4d5f_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.31.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h0d85af4_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.34.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h4132b18_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.17.1-py312h0fad829_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-2.0.0-py312hb65edc0_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.8-pyhe01879c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.2.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.4.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.11-hc22306f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.2-py312h998013c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py312h5748b74_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1300.6.5-h03f4b80_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h892fb3f_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.0.1-py312h6142ec9_5.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.31.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.34.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h925e9cb_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cffi-1.17.1-py312h4389bb4_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cffi-2.0.0-py312he06e257_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.18.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.12-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.19.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.14-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.8-pyhe01879c_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.2.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.4.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.2-py312h31fea79_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py312h05f76fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.0.1-py312hd5eb7cc_5.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.31.2-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.34.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h8ffe710_2.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h6a83c73_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda new-version: channels: @@ -2176,40 +2221,41 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda @@ -2217,148 +2263,149 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-hd0bcaf9_1007.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.12.11-h9e4cc4f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/gmp-6.3.0-hf036a51_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libamd-3.3.3-ha5840a7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libbtf-2.3.2-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcamd-3.3.3-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libccolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcholmod-5.3.1-h7ea7d7c_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcolamd-3.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxsparse-4.4.1-h3868ee3_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libklu-2.3.5-hc7f8671_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libldl-3.3.2-hca54c18_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libparu-1.0.0-hf1a04d7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/librbio-4.3.4-hca54c18_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspex-3.2.3-hc5c4b0d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libspqr-4.3.4-h795628b_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libsuitesparseconfig-7.10.1-h00e5f87_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libumfpack-6.3.5-h0658b90_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/metis-5.1.0-h3023b02_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/mpfr-4.2.1-haed47dc_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.12.11-h9ccd52b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/sigtool-0.1.3-h88f4db0_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-64/suitesparse-7.10.1-h033788e_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda @@ -2367,94 +2414,95 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libamd-3.3.3-h5087772_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbtf-2.3.2-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcamd-3.3.3-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libccolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcholmod-5.3.1-hbba04d7_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcolamd-3.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxsparse-4.4.1-h9e79f82_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libklu-2.3.5-h4370aa4_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libldl-3.3.2-h99b4a89_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libparu-1.0.0-h317a14d_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/librbio-4.3.4-h99b4a89_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspex-3.2.3-h15d103f_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libspqr-4.3.4-h775d698_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsuitesparseconfig-7.10.1-h4a8fc20_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libumfpack-6.3.5-h7c2c975_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/metis-5.1.0-h15f6cfe_1007.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mpfr-4.2.1-hb693164_3.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.12.11-hc22306f_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-0.1.3-h44b9a77_0.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/suitesparse-7.10.1-h3071b36_7100102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1300.6.5-h03f4b80_0.conda @@ -2464,77 +2512,80 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-2_gnu.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/gmp-6.3.0-hfeafd45_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libamd-3.3.3-h60129d2_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libbtf-2.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcamd-3.3.3-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libccolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcholmod-5.3.1-hdf2ebef_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcolamd-3.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcxsparse-4.4.1-h8c1c262_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_5.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libklu-2.3.5-h77a2eaa_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libldl-3.3.2-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libparu-1.0.0-hd80212b_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/librbio-4.3.4-h8c1c262_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspex-3.2.3-h2f847cc_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libspqr-4.3.4-h60c7c62_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libsuitesparseconfig-7.10.1-h0795de7_7100102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libumfpack-6.3.5-h4ca129d_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/metis-5.1.0-h17e2fc9_1007.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mpfr-4.2.1-hbc20e70_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.12.11-h3f84c4b_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/suitesparse-7.10.1-hfa24a04_7100102.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda py39: @@ -2544,148 +2595,150 @@ environments: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py39hf59e57a_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py39he8689d4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py39h040329f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py39hf0d4527_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.0.2-py39h9cb892a_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/pkg-config-0.29.2-h4bc722e_1009.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.9.23-hc30ae73_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.13.1-py39haf93ffa_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda osx-64: - - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ccache-4.11.3-h33566b8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/eigen-3.4.0-h1c7c39f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-75.1-h120a0e1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py39h5c7665c_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py39h810aed5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hdda6694_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h385f146_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py39hc79836b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py39h7c53190_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libhiredis-1.0.2-h2beb688_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.0.2-py39h277832c_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/perl-5.32.1-7_h10d778d_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/pkg-config-0.29.2-hf7e621a_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.9.23-h8a7f3fd_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/rhash-1.4.6-h6e16a3a_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.13.1-py39h038d4f4_0.conda @@ -2695,73 +2748,74 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda osx-arm64: - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ccache-4.11.3-hd7c7cec_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/eigen-3.4.0-h1995070_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py39h7d68603_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py39h2beb185_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h1b56ccb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py39h76e75a2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py39hfa01887_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libhiredis-1.0.2-hbec66e7_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.0.2-py39h3ba1154_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/perl-5.32.1-7_h4614cfb_perl5.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pkg-config-0.29.2-hde07d2e_1009.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.9.23-h7139b31_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.13.1-py39h3d5391c_0.conda @@ -2771,55 +2825,58 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda win-64: - - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/ccache-4.11.3-h12b022e_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/eigen-3.4.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py39h8f1c5a3_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py39hcb5f9c0_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py39h44eb426_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py39h5a5e355_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhiredis-1.0.2-h0e60522_0.tar.bz2 - - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.0.2-py39h60232e0_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/pkg-config-0.29.2-h88c491f_1009.conda - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.9.23-h8c5b53a_0_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.13.1-py39h1a10956_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda packages: @@ -2856,73 +2913,73 @@ packages: license_family: BSD size: 49468 timestamp: 1718213032772 -- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.43-h4852527_5.conda - sha256: 2f2a9b6d1cb24eb1df0bd820f35e089fbecab15d8952075b53dc931d89bf98cb - md5: 4846404183ea94fd6652e9fb6ac5e16f +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.44-h4852527_2.conda + sha256: 1461b66ef4801c20dc39d7005eed559bfcd3a62c219dc030343ddd570b58a9e6 + md5: 7f77703af8f54071370e0bc3a4b225af depends: - - binutils_impl_linux-64 >=2.43,<2.44.0a0 + - binutils_impl_linux-64 >=2.44,<2.45.0a0 license: GPL-3.0-only license_family: GPL - size: 35281 - timestamp: 1749852911395 -- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.43-h4bf12b8_5.conda - sha256: 27ae158d415ff2942214b32ac7952e642f0f4c2a45ab683691e2a9a9159f868c - md5: 18852d82df8e5737e320a8731ace51b9 + size: 34957 + timestamp: 1758810956483 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.44-hdf8817f_2.conda + sha256: 014eda0be99345946706a8141ecf32f619c731152831b85e4a752b4917c4528c + md5: f0716b5f7e87e83678d50da21e7a54b4 depends: - - ld_impl_linux-64 2.43 h712a8e2_5 + - ld_impl_linux-64 2.44 ha97dd6f_2 - sysroot_linux-64 license: GPL-3.0-only license_family: GPL - size: 6376971 - timestamp: 1749852878015 -- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.43-h4852527_5.conda - sha256: fccbb1974d5557cd5bd4dfccc13c0d15ca198c6a45c2124341dea8c952538512 - md5: 327ef163ac88b57833c1c1a20a9e7e0d + size: 3797704 + timestamp: 1758810925961 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.44-h4852527_2.conda + sha256: fd73320b4b3df2b18a1c2a9e17ed8c1402e1530c03a7d5af8240469b389128dd + md5: 9102871743e92e2eea2f2b3bfef74ed0 depends: - - binutils_impl_linux-64 2.43 h4bf12b8_5 + - binutils_impl_linux-64 2.44 hdf8817f_2 license: GPL-3.0-only license_family: GPL - size: 36038 - timestamp: 1749852914153 -- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda - sha256: 5ced96500d945fb286c9c838e54fa759aa04a7129c59800f0846b4335cee770d - md5: 62ee74e96c5ebb0af99386de58cf9553 + size: 35965 + timestamp: 1758810959224 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda + sha256: c30daba32ddebbb7ded490f0e371eae90f51e72db620554089103b4a6934b0d5 + md5: 51a19bba1b8ebfb60df25cde030b7ebc depends: - __glibc >=2.17,<3.0.a0 - - libgcc-ng >=12 + - libgcc >=14 license: bzip2-1.0.6 license_family: BSD - size: 252783 - timestamp: 1720974456583 -- conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-hfdf4475_7.conda - sha256: cad153608b81fb24fc8c509357daa9ae4e49dfc535b2cb49b91e23dbd68fc3c5 - md5: 7ed4301d437b59045be7e051a0308211 + size: 260341 + timestamp: 1757437258798 +- conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda + sha256: 8f50b58efb29c710f3cecf2027a8d7325ba769ab10c746eff75cea3ac050b10c + md5: 97c4b3bd8a90722104798175a1bdddbf depends: - __osx >=10.13 license: bzip2-1.0.6 license_family: BSD - size: 134188 - timestamp: 1720974491916 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h99b78c6_7.conda - sha256: adfa71f158cbd872a36394c56c3568e6034aa55c623634b37a4836bd036e6b91 - md5: fc6948412dbbbe9a4c9ddbbcfe0a79ab + size: 132607 + timestamp: 1757437730085 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda + sha256: b456200636bd5fecb2bec63f7e0985ad2097cf1b83d60ce0b6968dffa6d02aa1 + md5: 58fd217444c2a5701a44244faf518206 depends: - __osx >=11.0 license: bzip2-1.0.6 license_family: BSD - size: 122909 - timestamp: 1720974522888 -- conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h2466b09_7.conda - sha256: 35a5dad92e88fdd7fc405e864ec239486f4f31eec229e31686e61a140a8e573b - md5: 276e7ffe9ffe39688abc665ef0f45596 + size: 125061 + timestamp: 1757437486465 +- conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + sha256: d882712855624641f48aa9dc3f5feea2ed6b4e6004585d3616386a18186fe692 + md5: 1077e9333c41ff0be8edd1a5ec0ddace depends: - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: bzip2-1.0.6 license_family: BSD - size: 54927 - timestamp: 1720974860185 + size: 55977 + timestamp: 1757437738856 - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda sha256: f8003bef369f57396593ccd03d08a8e21966157269426f71e943f96e4b579aeb md5: f7f0d6cc2dc986d42ac2689ec88192be @@ -2951,54 +3008,57 @@ packages: license_family: MIT size: 179696 timestamp: 1744128058734 -- conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.10.0-h2b85faf_0.conda - sha256: 70be54bfe92b72794f664ad95b6fcef74d508710a9b2d790bc9c69f5a40239c3 - md5: 9256b7e5e900a1b98aedc8d6ffe91bec +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda + sha256: 8e7a40f16400d7839c82581410aa05c1f8324a693c9d50079f8c50dc9fb241f0 + md5: abd85120de1187b0d1ec305c2173c71b depends: - binutils - gcc - - gcc_linux-64 13.* + - gcc_linux-64 14.* license: BSD-3-Clause - size: 6667 - timestamp: 1751115555092 -- conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.10.0-h09a7c41_0.conda - sha256: 6a3f6b72bf5ad154630f79bd600f6ccf0f5c6a4be5297e4831d63016f4220e62 - md5: 7b7c12e4774b83c18612c78073d12adc + license_family: BSD + size: 6693 + timestamp: 1753098721814 +- conda: https://conda.anaconda.org/conda-forge/osx-64/c-compiler-1.11.0-h7a00415_0.conda + sha256: 2bd1cf3d26789b7e1d04e914ccd169bd618fceed68abf7b6a305266b88dcf861 + md5: 2b23ec416cef348192a5a17737ddee60 depends: - cctools >=949.0.1 - - clang_osx-64 18.* + - clang_osx-64 19.* - ld64 >=530 - llvm-openmp license: BSD-3-Clause - size: 6773 - timestamp: 1751115657381 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.10.0-hdf49b6b_0.conda - sha256: efc71f2ae5901bea633c67468b3aa774b6bcf46c9433e1ab5d640e3faf1680b9 - md5: 7ca1bdcc45db75f54ed7b3ac969ed888 + license_family: BSD + size: 6695 + timestamp: 1753098825695 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda + sha256: b51bd1551cfdf41500f732b4bd1e4e70fb1e74557165804a648f32fa9c671eec + md5: 148516e0c9edf4e9331a4d53ae806a9b depends: - cctools >=949.0.1 - - clang_osx-arm64 18.* + - clang_osx-arm64 19.* - ld64 >=530 - llvm-openmp license: BSD-3-Clause - size: 6758 - timestamp: 1751115540465 -- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-h4c7d964_0.conda - sha256: 065241ba03ef3ee8200084c075cbff50955a7e711765395ff34876dbc51a6bb9 - md5: b01649832f7bc7ff94f8df8bd2ee6457 + license_family: BSD + size: 6697 + timestamp: 1753098737760 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-h4c7d964_0.conda + sha256: 3b82f62baad3fd33827b01b0426e8203a2786c8f452f633740868296bcbe8485 + md5: c9e0c0f82f6e63323827db462b40ede8 depends: - __win license: ISC - size: 151351 - timestamp: 1749990170707 -- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.6.15-hbd8a1cb_0.conda - sha256: 7cfec9804c84844ea544d98bda1d9121672b66ff7149141b8415ca42dfcd44f6 - md5: 72525f07d72806e3b639ad4504c30ce5 + size: 154489 + timestamp: 1754210967212 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.8.3-hbd8a1cb_0.conda + sha256: 837b795a2bb39b75694ba910c13c15fa4998d4bb2a622c214a6a5174b2ae53d1 + md5: 74784ee3d225fc3dca89edb635b4e5cc depends: - __unix license: ISC - size: 151069 - timestamp: 1749990087500 + size: 154402 + timestamp: 1754210968730 - conda: https://conda.anaconda.org/conda-forge/linux-64/ccache-4.11.3-h80c52d3_0.conda sha256: ac9464a60a7b085b5a999aaf33d882705390d7749b35e320f639614ae0cc9474 md5: eb517c6a2b960c3ccb6f1db1005f063a @@ -3054,121 +3114,121 @@ packages: license_family: GPL size: 663569 timestamp: 1746271514872 -- conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1010.6-ha66f10e_6.conda - sha256: c716942cddaaf6afb618da32020c5a8ab2aec547bd3f0766c40b95680b998f05 - md5: a126dcde2752751ac781b67238f7fac4 +- conda: https://conda.anaconda.org/conda-forge/osx-64/cctools-1024.3-h67a6458_4.conda + sha256: 3d234a6966159d2fa970be4855911d0dedd1d6bb7c316f83a2eb9a6f6bf65a2e + md5: ed030ac3d866a4824fbebf33cead857d depends: - - cctools_osx-64 1010.6 hd19c6af_6 - - ld64 951.9 h4e51db5_6 - - libllvm18 >=18.1.8,<18.2.0a0 + - cctools_osx-64 1024.3 h3b512aa_4 + - ld64 955.13 hc3792c1_4 + - libllvm19 >=19.1.7,<19.2.0a0 license: APSL-2.0 license_family: Other - size: 22135 - timestamp: 1743872208832 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1010.6-hb4fb6a3_6.conda - sha256: 393fc3bf21b0187384e652aa4fab184d633e57e3e63f2b10f16a3d5f7bb0717b - md5: e0ba8df6997102eb4d367e3e70f90778 - depends: - - cctools_osx-arm64 1010.6 h3b4f5d3_6 - - ld64 951.9 h4c6efb1_6 - - libllvm18 >=18.1.8,<18.2.0a0 + size: 21239 + timestamp: 1759183725199 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1024.3-hd01ab73_4.conda + sha256: c9d8809ac3f1030b38b74a9472eb2430035e1bcb54cfe20986de5ef76d033766 + md5: 8609bea7151278c0b233680d49bd477d + depends: + - cctools_osx-arm64 1024.3 h8c76c84_4 + - ld64 955.13 he86490a_4 + - libllvm19 >=19.1.7,<19.2.0a0 license: APSL-2.0 license_family: Other - size: 22254 - timestamp: 1743872374133 -- conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1010.6-hd19c6af_6.conda - sha256: 7b2b765be41040c749d10ba848c4afbaae89a9ebb168bbf809c8133486f39bcb - md5: 4694e9e497454a8ce5b9fb61e50d9c5d + size: 21277 + timestamp: 1759183704154 +- conda: https://conda.anaconda.org/conda-forge/osx-64/cctools_osx-64-1024.3-h3b512aa_4.conda + sha256: ce4d8a15c6ebb2eac9f03a81fe4343aacdc65e773baff42d3d40577b43163ddf + md5: cfc37f18c6bf2c4db835b3bed542f464 depends: - __osx >=10.13 - - ld64_osx-64 >=951.9,<951.10.0a0 + - ld64_osx-64 >=955.13,<955.14.0a0 - libcxx - - libllvm18 >=18.1.8,<18.2.0a0 + - libllvm19 >=19.1.7,<19.2.0a0 - libzlib >=1.3.1,<2.0a0 - - llvm-tools 18.1.* + - llvm-tools 19.1.* - sigtool constrains: - - clang 18.1.* - - cctools 1010.6.* - - ld64 951.9.* + - clang 19.1.* + - cctools 1024.3.* + - ld64 955.13.* license: APSL-2.0 license_family: Other - size: 1119992 - timestamp: 1743872180962 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1010.6-h3b4f5d3_6.conda - sha256: 6e9463499dddad0ee61c999031c84bd1b8233676bcd220aece1b754667c680d7 - md5: b876da50fbe92a19737933c7aa92fb02 + size: 739057 + timestamp: 1759183685294 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1024.3-h8c76c84_4.conda + sha256: 572980029a3d3ccfa741abdfe32d96dfb59852ec64056a58034e64a1b0a2f22e + md5: de0c423408ca3529fd4637870ef82638 depends: - __osx >=11.0 - - ld64_osx-arm64 >=951.9,<951.10.0a0 + - ld64_osx-arm64 >=955.13,<955.14.0a0 - libcxx - - libllvm18 >=18.1.8,<18.2.0a0 + - libllvm19 >=19.1.7,<19.2.0a0 - libzlib >=1.3.1,<2.0a0 - - llvm-tools 18.1.* + - llvm-tools 19.1.* - sigtool constrains: - - cctools 1010.6.* - - ld64 951.9.* - - clang 18.1.* + - ld64 955.13.* + - clang 19.1.* + - cctools 1024.3.* license: APSL-2.0 license_family: Other - size: 1103413 - timestamp: 1743872332962 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-1.17.1-py312h06ac9bb_0.conda - sha256: cba6ea83c4b0b4f5b5dc59cb19830519b28f95d7ebef7c9c5cf1c14843621457 - md5: a861504bbea4161a9170b85d4d2be840 + size: 744064 + timestamp: 1759183622260 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py312h35888ee_0.conda + sha256: f9e906b2cb9ae800b5818259472c3f781b14eb1952e867ac5c1f548e92bf02d9 + md5: 60b9cd087d22272885a6b8366b1d3d43 depends: - __glibc >=2.17,<3.0.a0 - - libffi >=3.4,<4.0a0 - - libgcc >=13 + - libffi >=3.4.6,<3.5.0a0 + - libgcc >=14 - pycparser - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 license: MIT license_family: MIT - size: 294403 - timestamp: 1725560714366 -- conda: https://conda.anaconda.org/conda-forge/osx-64/cffi-1.17.1-py312hf857d28_0.conda - sha256: 94fe49aed25d84997e2630d6e776a75ee2a85bd64f258702c57faa4fe2986902 - md5: 5bbc69b8194fedc2792e451026cac34f + size: 296986 + timestamp: 1758716192805 +- conda: https://conda.anaconda.org/conda-forge/osx-64/cffi-2.0.0-py312hf9bc6d9_0.conda + sha256: 74d987c4e7c50404b782ff05200c835e881bb37e47b00951693b3b92371f2b07 + md5: 60bd93639037ab61a11ed14955e53848 depends: - __osx >=10.13 - - libffi >=3.4,<4.0a0 + - libffi >=3.4.6,<3.5.0a0 - pycparser - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 license: MIT license_family: MIT - size: 282425 - timestamp: 1725560725144 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-1.17.1-py312h0fad829_0.conda - sha256: 8d91a0d01358b5c3f20297c6c536c5d24ccd3e0c2ddd37f9d0593d0f0070226f - md5: 19a5456f72f505881ba493979777b24e + size: 289913 + timestamp: 1758716346335 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-2.0.0-py312hb65edc0_0.conda + sha256: ad49c48044a5f12c7bcc6ae6a66b79f10e24e681e9f3ad4fa560b0f708a9393c + md5: 1b36501506f4ef414524891ca5f0a561 depends: - __osx >=11.0 - - libffi >=3.4,<4.0a0 + - libffi >=3.4.6,<3.5.0a0 - pycparser - python >=3.12,<3.13.0a0 - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: MIT license_family: MIT - size: 281206 - timestamp: 1725560813378 -- conda: https://conda.anaconda.org/conda-forge/win-64/cffi-1.17.1-py312h4389bb4_0.conda - sha256: ac007bf5fd56d13e16d95eea036433012f2e079dc015505c8a79efebbad1fcbc - md5: 08310c1a22ef957d537e547f8d484f92 + size: 287573 + timestamp: 1758716529098 +- conda: https://conda.anaconda.org/conda-forge/win-64/cffi-2.0.0-py312he06e257_0.conda + sha256: 16a68a4a3f6ec4feebe0447298b8d04ca58a3fde720c5e08dc2eed7f27a51f6c + md5: 21e34a0fa25e6675e73a18df78dde03b depends: - pycparser - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: MIT license_family: MIT - size: 288142 - timestamp: 1725560896359 + size: 290539 + timestamp: 1758716385244 - conda: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f md5: 57df494053e17dce2ac3a0b33e1b2a2e @@ -3178,202 +3238,202 @@ packages: license_family: MIT size: 12973 timestamp: 1734267180483 -- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-20.1.7-default_hfa515fb_0.conda - sha256: ebbf3ee5f9d30927f21f9edb1d957fe533056886c19b342a68c978ad8db7fb95 - md5: 56cd9e7a7138a85c1c7cd4d802aca483 +- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-21.1.2-default_h36abe19_0.conda + sha256: ea83dca0a9f2b38372a05394c2dddf61909cfa5d4e17e40a44ae64b4d9e5a0c7 + md5: ac71ad8b3bd77478e5cbb59131949ff0 depends: - binutils_impl_linux-64 - - clang-20 20.1.7 default_h1df26ce_0 + - clang-21 21.1.2 default_h99862b1_0 - libgcc-devel_linux-64 - sysroot_linux-64 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 24056 - timestamp: 1749876470004 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18.1.8-default_h576c50e_10.conda - sha256: 663d5c8d26e4f467075a49df26624a95efc69ba275cd0fb823979e06964f024f - md5: 350a10c62423982b0c80a043b9921c00 + size: 24280 + timestamp: 1758876115407 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19.1.7-default_h1323312_4.conda + sha256: 47f829929adc49eb947f523ed047d140f3024f500203bf3fd468746c20a25f4c + md5: a86c87d68fbeef92fb78f5d8dcadf84b depends: - - clang-18 18.1.8 default_h3571c67_10 + - clang-19 19.1.7 default_hc369343_4 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 75476 - timestamp: 1747763835551 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18.1.8-default_h474c9e2_10.conda - sha256: 2f8ad9fa2e345c62daaa0978b8ae578ff46b89c068d4666da1b95d77599a1de2 - md5: 1824da9753ade2d34291175377387bbe + size: 24395 + timestamp: 1757394049342 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_4.conda + sha256: 9b9046ae12782ac2123bb002e1528c8a4442213d1e3450791244ffc36776d0de + md5: f84d1c56fb6e26c7faeb1fbe00d9fcda depends: - - clang-18 18.1.8 default_hf90f093_10 + - clang-19 19.1.7 default_h73dfc95_4 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 75645 - timestamp: 1747715057267 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clang-18-18.1.8-default_h3571c67_10.conda - sha256: cb06e7522fdd4d3f42d8c09a6caad216e40ee650340e72e01ca30689fac4f862 - md5: 62e1cd0882dad47d6a6878ad037f7b9d + size: 24477 + timestamp: 1757396345230 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clang-19-19.1.7-default_hc369343_4.conda + sha256: 5bc81f3a5b2b8c8320b6045056239ed54dec0aff1f6a5ad892b082b790bbc449 + md5: 08400f0580d3a0f2c7cb04a2b5362437 depends: - __osx >=10.13 - - libclang-cpp18.1 18.1.8 default_h3571c67_10 - - libcxx >=18.1.8 - - libllvm18 >=18.1.8,<18.2.0a0 + - libclang-cpp19.1 19.1.7 default_hc369343_4 + - libcxx >=19.1.7 + - libllvm19 >=19.1.7,<19.2.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 811399 - timestamp: 1747763724121 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-18-18.1.8-default_hf90f093_10.conda - sha256: 64bbc372d2ab22a73deb6cbf7b2a3bade0572901b2639427a5f469b2ba6e438a - md5: 2cf44d7e80e11704eaa56eb823b5c821 + size: 763992 + timestamp: 1757393934104 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_h73dfc95_4.conda + sha256: 1ab9cc9da212166dfb81e9b32f5b4d74dc2155a171f0516839b8a53dc864a5d3 + md5: e30a31ab65bd2b1c399aa3247f6ea559 depends: - __osx >=11.0 - - libclang-cpp18.1 18.1.8 default_hf90f093_10 - - libcxx >=18.1.8 - - libllvm18 >=18.1.8,<18.2.0a0 + - libclang-cpp19.1 19.1.7 default_h73dfc95_4 + - libcxx >=19.1.7 + - libllvm19 >=19.1.7,<19.2.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 812786 - timestamp: 1747714916284 -- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-20-20.1.7-default_h1df26ce_0.conda - sha256: 7a58bbfc983d730b017c70aed7d72c7f93f75ff652bf49358d3edb9d910bc37b - md5: 53f1115ddc26fad057ade930016a357b + size: 763232 + timestamp: 1757396115383 +- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-21-21.1.2-default_h99862b1_0.conda + sha256: e5fbd04e70c6e5d73a91f4da613cc1fa31b753d23f42b0a971aac69c60bd63d2 + md5: 888c60b8514f39d92c17906acac0b2d6 depends: - __glibc >=2.17,<3.0.a0 - - libclang-cpp20.1 20.1.7 default_h1df26ce_0 - - libgcc >=13 - - libllvm20 >=20.1.7,<20.2.0a0 - - libstdcxx >=13 + - libclang-cpp21.1 21.1.2 default_h99862b1_0 + - libgcc >=14 + - libllvm21 >=21.1.2,<21.2.0a0 + - libstdcxx >=14 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 815405 - timestamp: 1749876411846 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-18.1.8-h6a44ed1_25.conda - sha256: fffb43ba2a04e6b25484840818628397be320f4ff0e5efcce8167f9d06216a94 - md5: bfc995f8ab9e8c22ebf365844da3383d + size: 828918 + timestamp: 1758876066009 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clang_impl_osx-64-19.1.7-hc73cdc9_25.conda + sha256: 88edc0b34affbfffcec5ffea59b432ee3dd114124fd4d5f992db6935421f4a64 + md5: 76954503be09430fb7f4683a61ffb7b0 depends: - cctools_osx-64 - - clang 18.1.8.* - - compiler-rt 18.1.8.* + - clang 19.1.7.* + - compiler-rt 19.1.7.* - ld64_osx-64 - - llvm-tools 18.1.8.* + - llvm-tools 19.1.7.* license: BSD-3-Clause license_family: BSD - size: 18256 - timestamp: 1748575659622 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-18.1.8-h2ae9ea5_25.conda - sha256: 35273ca91fb998f979402c76066af008ad3108a61a3b161d881fcb37700a48bb - md5: 9eb023cfc47dac4c22097b9344a943b4 + size: 18175 + timestamp: 1748575764900 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-h76e6a08_25.conda + sha256: ee3c0976bde0ac19f84d29213ea3d9c3fd9c56d56c33ee471a8680cf69307ce1 + md5: a4e2f211f7c3cf582a6cb447bee2cad9 depends: - cctools_osx-arm64 - - clang 18.1.8.* - - compiler-rt 18.1.8.* + - clang 19.1.7.* + - compiler-rt 19.1.7.* - ld64_osx-arm64 - - llvm-tools 18.1.8.* + - llvm-tools 19.1.7.* license: BSD-3-Clause license_family: BSD - size: 18331 - timestamp: 1748575702758 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-18.1.8-h7e5c614_25.conda - sha256: 7f6aea0def866f1664b3ddf730d91e1b94da734b585c3e49cd51d3c4c66a1a49 - md5: 1fea06d9ced6b87fe63384443bc2efaf + size: 18159 + timestamp: 1748575942374 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clang_osx-64-19.1.7-h7e5c614_25.conda + sha256: 6435fdeae76f72109bc9c7b41596104075a2a8a9df3ee533bd98bb06548bbc83 + md5: a526ba9df7e7d5448d57b33941614dae depends: - - clang_impl_osx-64 18.1.8 h6a44ed1_25 + - clang_impl_osx-64 19.1.7 hc73cdc9_25 license: BSD-3-Clause license_family: BSD - size: 21534 - timestamp: 1748575663505 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-18.1.8-h07b0088_25.conda - sha256: 4d1e695cd776783f6192fb8d4c7892c03e9f1f185dbb96cefdaab2f183430281 - md5: d9ee862b94f4049c9e121e6dd18cc874 + size: 21473 + timestamp: 1748575768567 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h07b0088_25.conda + sha256: 92a45a972af5eba3b7fca66880c3d5bdf73d0c69a3e21d1b3999fb9b5be1b323 + md5: 1b53cb5305ae53b5aeba20e58c625d96 depends: - - clang_impl_osx-arm64 18.1.8 h2ae9ea5_25 + - clang_impl_osx-arm64 19.1.7 h76e6a08_25 license: BSD-3-Clause license_family: BSD - size: 21563 - timestamp: 1748575706504 -- conda: https://conda.anaconda.org/conda-forge/linux-64/clangxx-20.1.7-default_h0982aa1_0.conda - sha256: 42f090552d889af097714daca6b6298dc918ee920f4c3842cc8ec4845df6cb9d - md5: b8297ec00083ed085ce998fb4011e030 + size: 21337 + timestamp: 1748575949016 +- conda: https://conda.anaconda.org/conda-forge/linux-64/clangxx-21.1.2-default_h363a0c9_0.conda + sha256: 533c228393e5ccbe2c2708ac95f9373a5b1280fb0da8cee1050670c78aeb9ee4 + md5: 7fca6e24e428e9bc9b2ed8934bc360e4 depends: - - clang 20.1.7 default_hfa515fb_0 + - clang 21.1.2 default_h36abe19_0 - libstdcxx-devel_linux-64 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 24217 - timestamp: 1749876480658 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-18.1.8-default_heb2e8d1_10.conda - sha256: 40e617f28eadab9e84c05d048a23934531847e0975b134a0a36ebb1816f8895a - md5: c39251c90faf5ba495d9f9ef88d7563e - depends: - - clang 18.1.8 default_h576c50e_10 - - libcxx-devel 18.1.8.* + size: 24482 + timestamp: 1758876126382 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx-19.1.7-default_h1c12a56_4.conda + sha256: b844767393ba104a826fc31deb12f4eac6605613b9c062d5fbe726cdbe4846bb + md5: 89b108a529dc2845d9e7ee52e55b1ea5 + depends: + - clang 19.1.7 default_h1323312_4 + - libcxx-devel 19.1.* license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 75639 - timestamp: 1747763857597 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-18.1.8-default_h1ffe849_10.conda - sha256: d6ebfaf4faf73a88cb4fbb20611fd01c646c2d5e742a11d59a702afef94d2246 - md5: 70e3f72ecc72f451524c3b5a4d50e383 - depends: - - clang 18.1.8 default_h474c9e2_10 - - libcxx-devel 18.1.8.* + size: 24507 + timestamp: 1757394067686 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_h36137df_4.conda + sha256: 1178a7edbc033601df6621b4c6fcd294b97faa373656660df511ebaada76e576 + md5: 78db7179f398d0bf9cec588f7d0c42c9 + depends: + - clang 19.1.7 default_hf9bcbb7_4 + - libcxx-devel 19.1.* license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 75736 - timestamp: 1747715078489 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-18.1.8-h4b7810f_25.conda - sha256: 1b2ee79318f37b356d36cbcfc46ff8a0a4e1d8e5fdaed1e5dbc5a2b58cacbad7 - md5: c03c94381d9ffbec45c98b800e7d3e86 - depends: - - clang_osx-64 18.1.8 h7e5c614_25 - - clangxx 18.1.8.* - - libcxx >=18 - - libllvm18 >=18.1.8,<18.2.0a0 + size: 24553 + timestamp: 1757396368233 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_impl_osx-64-19.1.7-hb295874_25.conda + sha256: 8a2571da4bd90e3fc4523e962d6562607df133694a409959ec9c7ac4292bd676 + md5: 9fe0247ba2650f90c650001f88a87076 + depends: + - clang_osx-64 19.1.7 h7e5c614_25 + - clangxx 19.1.7.* + - libcxx >=19 + - libllvm19 >=19.1.7,<19.2.0a0 license: BSD-3-Clause license_family: BSD - size: 18390 - timestamp: 1748575690740 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-18.1.8-h555f467_25.conda - sha256: d0fb67a4ed19e9b40db08fce19afb342dcebc3609374a1b86c0d7a40abaf655c - md5: 4d72782682bc7d61a3612fea2c93299f - depends: - - clang_osx-arm64 18.1.8 h07b0088_25 - - clangxx 18.1.8.* - - libcxx >=18 - - libllvm18 >=18.1.8,<18.2.0a0 + size: 18289 + timestamp: 1748575802444 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-h276745f_25.conda + sha256: b997d325da6ca60e71937b9e28f114893401ca7cf94c4007d744e402a25c2c52 + md5: 5eeaa7b2dd32f62eb3beb0d6ba1e664f + depends: + - clang_osx-arm64 19.1.7 h07b0088_25 + - clangxx 19.1.7.* + - libcxx >=19 + - libllvm19 >=19.1.7,<19.2.0a0 license: BSD-3-Clause license_family: BSD - size: 18459 - timestamp: 1748575734378 -- conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-18.1.8-h7e5c614_25.conda - sha256: 1a1a31eae8b491104d33d422b57578f041d34afafb4da0a7355ef16fd5174090 - md5: 2e5c84e93a3519d77a0d8d9b3ea664fd - depends: - - clang_osx-64 18.1.8 h7e5c614_25 - - clangxx_impl_osx-64 18.1.8 h4b7810f_25 + size: 18297 + timestamp: 1748576000726 +- conda: https://conda.anaconda.org/conda-forge/osx-64/clangxx_osx-64-19.1.7-h7e5c614_25.conda + sha256: 81365d98e1bb5f98a7acd1bde86ccf534b36c78bfae601e2c26a73d8de52da1e + md5: d0b5d9264d40ae1420e31c9066a1dcf0 + depends: + - clang_osx-64 19.1.7 h7e5c614_25 + - clangxx_impl_osx-64 19.1.7 hb295874_25 license: BSD-3-Clause license_family: BSD - size: 19947 - timestamp: 1748575697030 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-18.1.8-h07b0088_25.conda - sha256: aae6cad658c9899f13d5941bcadc942f1a471acdfc43cd86c3635d0e353babc9 - md5: 4280e791148c1f9a3f8c0660d7a54acb - depends: - - clang_osx-arm64 18.1.8 h07b0088_25 - - clangxx_impl_osx-arm64 18.1.8 h555f467_25 + size: 19873 + timestamp: 1748575806458 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h07b0088_25.conda + sha256: 93801e6e821ae703d03629b1b993dbae1920b80012818edd5fcd18a9055897ce + md5: 4e09188aa8def7d8b3ae149aa856c0e5 + depends: + - clang_osx-arm64 19.1.7 h07b0088_25 + - clangxx_impl_osx-arm64 19.1.7 h276745f_25 license: BSD-3-Clause license_family: BSD - size: 19924 - timestamp: 1748575738546 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.0.3-h74e3db0_0.conda - sha256: becb0030ae243c003367d11bdf2f66a1b5adc1693f11ecfddb90f5ee2521de5f - md5: 8e307cb10b262859a00667ce6a0fcf1f + size: 19709 + timestamp: 1748576006669 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.1.2-hc85cc9f_0.conda + sha256: 2176c4bce9f602cee0efbae86283a1a75733921ecc0916c8d2f49df2aee1a0f0 + md5: 3d5d0a07f07ba1fc43f52b5e33e3cd7c depends: - __glibc >=2.17,<3.0.a0 - bzip2 >=1.0.8,<2.0a0 - libcurl >=8.14.1,<9.0a0 - - libexpat >=2.7.0,<3.0a0 - - libgcc >=13 + - libexpat >=2.7.1,<3.0a0 + - libgcc >=14 - liblzma >=5.8.1,<6.0a0 - - libstdcxx >=13 + - libstdcxx >=14 - libuv >=1.51.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - ncurses >=6.5,<7.0a0 @@ -3381,17 +3441,17 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: BSD-3-Clause license_family: BSD - size: 20410493 - timestamp: 1749760929591 -- conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.0.3-h477996e_0.conda - sha256: 89746952e604fd19eb264bbe1446977c33cbe1b57e1089d39049f8701222ca57 - md5: 4321b08eee81ea52d1b605738f1b378b + size: 21290609 + timestamp: 1759261133874 +- conda: https://conda.anaconda.org/conda-forge/osx-64/cmake-4.1.2-h29fc008_0.conda + sha256: 29a0c428f0fc2c9146304bb390776d0cfb04093faeda2f6f2fe85099caf102f7 + md5: c8be0586640806d35e10ce7b95b74c9a depends: - __osx >=10.13 - bzip2 >=1.0.8,<2.0a0 - libcurl >=8.14.1,<9.0a0 - - libcxx >=18 - - libexpat >=2.7.0,<3.0a0 + - libcxx >=19 + - libexpat >=2.7.1,<3.0a0 - liblzma >=5.8.1,<6.0a0 - libuv >=1.51.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 @@ -3400,17 +3460,17 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: BSD-3-Clause license_family: BSD - size: 17745201 - timestamp: 1749761216087 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.0.3-ha25475f_0.conda - sha256: a478ee185a3821342dea04b2245a5ea6cc8f1c5d1711b7bea1799085f59c0856 - md5: 63dd87f763d7696fd92f1e5cf7f9c9de + size: 18050238 + timestamp: 1759262614942 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.1.2-h54ad630_0.conda + sha256: 717322060752f6c0eefe475ea4fb0b52597db5a87a20dcd573121df414f8fbef + md5: 1c3ef82a4e1549022f2f3db6880d7712 depends: - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - libcurl >=8.14.1,<9.0a0 - - libcxx >=18 - - libexpat >=2.7.0,<3.0a0 + - libcxx >=19 + - libexpat >=2.7.1,<3.0a0 - liblzma >=5.8.1,<6.0a0 - libuv >=1.51.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 @@ -3419,118 +3479,129 @@ packages: - zstd >=1.5.7,<1.6.0a0 license: BSD-3-Clause license_family: BSD - size: 16532294 - timestamp: 1749761424556 -- conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.0.3-hff78f93_0.conda - sha256: ffa51301a041a5e127cdc339bd4d6b3eae58fa9d69c4069dd4cab49de4a74d00 - md5: a67bbbe329235a6e0f10f88c246cbe93 + size: 16935599 + timestamp: 1759263309414 +- conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.1.2-hdcbee5b_0.conda + sha256: 2f0e2132c65b627c07c6d97eec8664c3849222dda89e871072df346ef4df205b + md5: b01b4bc10b2a81c40d239e2ffe8ad987 depends: - bzip2 >=1.0.8,<2.0a0 - libcurl >=8.14.1,<9.0a0 - - libexpat >=2.7.0,<3.0a0 + - libexpat >=2.7.1,<3.0a0 - liblzma >=5.8.1,<6.0a0 - libuv >=1.51.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - ucrt >=10.0.20348.0 - - vc14_runtime >=14.29.30139 + - vc14_runtime >=14.44.35208 - zstd >=1.5.7,<1.6.0a0 license: BSD-3-Clause license_family: BSD - size: 14452730 - timestamp: 1749761925553 -- conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-18.1.8-h1020d70_1.conda - sha256: 30bd259ad8909c02ee9da8b13bf7c9f6dc0f4d6fa3c5d1cd82213180ca5f9c03 - md5: bc1714a1e73be18e411cff30dc1fe011 + size: 14963641 + timestamp: 1759261950341 +- conda: https://conda.anaconda.org/conda-forge/osx-64/compiler-rt-19.1.7-he914875_1.conda + sha256: 28e5f0a6293acba68ebc54694a2fc40b1897202735e8e8cbaaa0e975ba7b235b + md5: e6b9e71e5cb08f9ed0185d31d33a074b depends: - __osx >=10.13 - - clang 18.1.8.* - - clangxx 18.1.8.* - - compiler-rt_osx-64 18.1.8.* + - clang 19.1.7.* + - compiler-rt_osx-64 19.1.7.* license: Apache-2.0 WITH LLVM-exception license_family: APACHE - size: 95345 - timestamp: 1725258125808 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-18.1.8-h856b3c1_1.conda - sha256: 41e47093d3a03f0f81f26f66e5652a5b5c58589eafe59fbf67e8d60a3b30cdf7 - md5: 1f40b72021aa770bb56ffefe298f02a7 + size: 96722 + timestamp: 1757412473400 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda + sha256: b58a481828aee699db7f28bfcbbe72fb133277ac60831dfe70ee2465541bcb93 + md5: 39451684370ae65667fa5c11222e43f7 depends: - __osx >=11.0 - - clang 18.1.8.* - - clangxx 18.1.8.* - - compiler-rt_osx-arm64 18.1.8.* + - clang 19.1.7.* + - compiler-rt_osx-arm64 19.1.7.* license: Apache-2.0 WITH LLVM-exception license_family: APACHE - size: 95451 - timestamp: 1725258159749 -- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-18.1.8-hf2b8a54_1.conda - sha256: 1230fe22d190002693ba77cf8af754416d6ea7121707b74a7cd8ddc537f98bdb - md5: 76f906e6bdc58976c5593f650290ae20 - depends: - - clang 18.1.8.* - - clangxx 18.1.8.* + size: 97085 + timestamp: 1757411887557 +- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-64-19.1.7-h138dee1_1.conda + sha256: e6effe89523fc6143819f7a68372b28bf0c176af5b050fe6cf75b62e9f6c6157 + md5: 32deecb68e11352deaa3235b709ddab2 + depends: + - clang 19.1.7.* constrains: - - compiler-rt 18.1.8 + - compiler-rt 19.1.7 + - clangxx 19.1.7 license: Apache-2.0 WITH LLVM-exception license_family: APACHE - size: 10420490 - timestamp: 1725258080385 -- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-18.1.8-h832e737_1.conda - sha256: 97cc5d6a54dd159ddd2789a68245c6651915071b79f674e83dbc660f3ed760a9 - md5: f158d25465221c90668482b69737fee6 - depends: - - clang 18.1.8.* - - clangxx 18.1.8.* + size: 10425780 + timestamp: 1757412396490 +- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda + sha256: 8c32a3db8adf18ed58197e8895ce4f24a83ed63c817512b9a26724753b116f2a + md5: 8d99c82e0f5fed6cc36fcf66a11e03f0 + depends: + - clang 19.1.7.* constrains: - - compiler-rt 18.1.8 + - compiler-rt 19.1.7 + - clangxx 19.1.7 license: Apache-2.0 WITH LLVM-exception license_family: APACHE - size: 10583287 - timestamp: 1725258124186 -- conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.10.0-h1a2810e_0.conda - sha256: 88ff4a72ad70a3b9a20a0296e395c0caaa6dc0a0e46a752aa683fb42be03facd - md5: 3cd322edac3d40904ff07355a8be8086 + size: 10490535 + timestamp: 1757411851093 +- conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-hb991d5c_5.conda + sha256: 88393820c3f6766be892fc1fe3443176340fc7ec40d5d2b95a54653df8dc8412 + md5: 084b74ba4cd799a4636da3c7686fc75e + depends: + - gcc_impl_linux-64 >=14.3.0,<14.3.1.0a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 33254 + timestamp: 1757039288773 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda + sha256: 3fcc97ae3e89c150401a50a4de58794ffc67b1ed0e1851468fcc376980201e25 + md5: 5da8c935dca9186673987f79cef0b2a5 depends: - - c-compiler 1.10.0 h2b85faf_0 + - c-compiler 1.11.0 h4d9bdce_0 - gxx - - gxx_linux-64 13.* + - gxx_linux-64 14.* license: BSD-3-Clause - size: 6633 - timestamp: 1751115555450 -- conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.10.0-h20888b2_0.conda - sha256: 15f6ea7258555b2e34d147d378f4e8e08343ca3e71a18bd98b89a3dbc43142a2 - md5: b3a935ade707c54ebbea5f8a7c6f4549 - depends: - - c-compiler 1.10.0 h09a7c41_0 - - clangxx_osx-64 18.* + license_family: BSD + size: 6635 + timestamp: 1753098722177 +- conda: https://conda.anaconda.org/conda-forge/osx-64/cxx-compiler-1.11.0-h307afc9_0.conda + sha256: d6976f8d8b51486072abfe1e76a733688380dcbd1a8e993a43d59b80f7288478 + md5: 463bb03bb27f9edc167fb3be224efe96 + depends: + - c-compiler 1.11.0 h7a00415_0 + - clangxx_osx-64 19.* license: BSD-3-Clause - size: 6785 - timestamp: 1751115659099 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.10.0-hba80287_0.conda - sha256: 52cbfc615a9727294fccdd507f11919ca01ff29bd928bb5aa0b211697a983e9f - md5: 7fca30a1585a85ec8ab63579afcac5d3 - depends: - - c-compiler 1.10.0 hdf49b6b_0 - - clangxx_osx-arm64 18.* + license_family: BSD + size: 6732 + timestamp: 1753098827160 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda + sha256: 99800d97a3a2ee9920dfc697b6d4c64e46dc7296c78b1b6c746ff1c24dea5e6c + md5: 043afed05ca5a0f2c18252ae4378bdee + depends: + - c-compiler 1.11.0 h61f9b84_0 + - clangxx_osx-arm64 19.* license: BSD-3-Clause - size: 6784 - timestamp: 1751115541888 -- conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.10.0-h1c1089f_0.conda - sha256: 123ef5fd4829b7c78d49df141bbdf6120fc63a17538b2209d56a6f4dc5eccf21 - md5: 1c4dad99c85e243e25828c6f12f28e0d + license_family: BSD + size: 6715 + timestamp: 1753098739952 +- conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda + sha256: c888f4fe9ec117c1c01bfaa4c722ca475ebbb341c92d1718afa088bb0d710619 + md5: 4d94d3c01add44dc9d24359edf447507 depends: - vs2022_win-64 license: BSD-3-Clause - size: 6987 - timestamp: 1751115642859 -- conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.3.9-pyhd8ed1ab_1.conda - sha256: 0e160c21776bd881b79ce70053e59736f51036784fa43a50da10a04f0c1b9c45 - md5: 8d88f4a2242e6b96f9ecff9a6a05b2f1 + license_family: BSD + size: 6957 + timestamp: 1753098809481 +- conda: https://conda.anaconda.org/conda-forge/noarch/distlib-0.4.0-pyhd8ed1ab_0.conda + sha256: 6d977f0b2fc24fee21a9554389ab83070db341af6d6f09285360b2e09ef8b26e + md5: 003b8ba0a94e2f1e117d0bd46aebc901 depends: - python >=3.9 license: Apache-2.0 license_family: APACHE - size: 274151 - timestamp: 1733238487461 + size: 275642 + timestamp: 1752823081585 - conda: https://conda.anaconda.org/conda-forge/linux-64/eigen-3.4.0-h00ab1b0_0.conda sha256: 53b15a98aadbe0704479bacaf7a5618fcb32d1577be320630674574241639b34 md5: b1b879d6d093f55dd40d58b5eb2f0699 @@ -3570,103 +3641,104 @@ packages: license_family: MOZILLA size: 1089706 timestamp: 1690273089254 -- conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.18.0-pyhd8ed1ab_0.conda - sha256: de7b6d4c4f865609ae88db6fa03c8b7544c2452a1aa5451eb7700aad16824570 - md5: 4547b39256e296bb758166893e909a7c +- conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.19.1-pyhd8ed1ab_0.conda + sha256: 7a2497c775cc7da43b5e32fc5cf9f4e8301ca723f0eb7f808bbe01c6094a3693 + md5: 9c418d067409452b2e87e0016257da68 depends: - python >=3.9 license: Unlicense - size: 17887 - timestamp: 1741969612334 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.3.0-h9576a4e_2.conda - sha256: 300f077029e7626d69cc250a69acd6018c1fced3f5bf76adf37854f3370d2c45 - md5: d92e51bf4b6bdbfe45e5884fb0755afe - depends: - - gcc_impl_linux-64 13.3.0.* + size: 18003 + timestamp: 1755216353218 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h76bdaa0_5.conda + sha256: 0311c74a0c0c68ed64b1ad829ad88996b4e29f0c492f73e0c5dff1313af53530 + md5: 177c3c1f234f4fc0a82c56d5062ca720 + depends: + - conda-gcc-specs + - gcc_impl_linux-64 14.3.0.* license: BSD-3-Clause license_family: BSD - size: 55246 - timestamp: 1740240578937 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.3.0-h1e990d8_2.conda - sha256: c3e9f243ea8292eecad78bb200d8f5b590e0f82bf7e7452a3a7c8df4eea6f774 - md5: f46cf0acdcb6019397d37df1e407ab91 + size: 31031 + timestamp: 1757039421021 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-hd9e9e21_5.conda + sha256: df1fcaa8a38f9e823b817718b8e41af2f09b420ba71c92f7de32212673ef921a + md5: 2a6e4f3e29eadca634a0dc28bb7d96d0 depends: - binutils_impl_linux-64 >=2.40 - - libgcc >=13.3.0 - - libgcc-devel_linux-64 13.3.0 hc03c837_102 - - libgomp >=13.3.0 - - libsanitizer 13.3.0 he8ea267_2 - - libstdcxx >=13.3.0 + - libgcc >=14.3.0 + - libgcc-devel_linux-64 14.3.0 h85bb3a7_105 + - libgomp >=14.3.0 + - libsanitizer 14.3.0 hd08acf3_5 + - libstdcxx >=14.3.0 - sysroot_linux-64 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 66770653 - timestamp: 1740240400031 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.3.0-h6f18a23_11.conda - sha256: b2533388ec510ef0fc95774f15fdfb89582623049494506ea27622333f90bc09 - md5: 639ef869618e311eee4888fcb40747e2 + size: 71625160 + timestamp: 1757039160514 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h1382650_11.conda + sha256: 0d7fe52c578ef99f03defe8cab5308124b388c694e88f5494716d11532a6d12a + md5: 2e650506e6371ac4289c9bf7fc207f3b depends: - binutils_linux-64 - - gcc_impl_linux-64 13.3.0.* + - gcc_impl_linux-64 14.3.0.* - sysroot_linux-64 license: BSD-3-Clause license_family: BSD - size: 32538 - timestamp: 1748905867619 -- conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.49.0-pl5321hc2ff736_2.conda - sha256: a92f89cf83b2010b2201df780f6db93595557faeefcb8f89b90cc2a75368f5b2 - md5: 79af03347d91a390ed07a0d76a35a047 + size: 32512 + timestamp: 1748905876846 +- conda: https://conda.anaconda.org/conda-forge/linux-64/git-2.51.0-pl5321h8305f47_1.conda + sha256: 44f2ba63f4f00ddb4bf681a1aeed41642833eacce5111c462ab03ed732d25514 + md5: 59b5aeeb61f1b2873b03905734b8d7b7 depends: - - __glibc >=2.17,<3.0.a0 + - __glibc >=2.28,<3.0.a0 - libcurl >=8.14.1,<9.0a0 - - libexpat >=2.7.0,<3.0a0 - - libgcc >=13 + - libexpat >=2.7.1,<3.0a0 + - libgcc >=14 - libiconv >=1.18,<2.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.0,<4.0a0 - - pcre2 >=10.45,<10.46.0a0 + - openssl >=3.5.2,<4.0a0 + - pcre2 >=10.46,<10.47.0a0 - perl 5.* license: GPL-2.0-or-later and LGPL-2.1-or-later - size: 11114939 - timestamp: 1751299061504 -- conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.49.0-pl5321h3bb66fe_2.conda - sha256: c02db96f084357481d5cbe7cc8d5d218de381a45711de6fe2c4d587ba4c53e97 - md5: 6d686f7a953197dec117d1d72a20ecf1 + size: 11174699 + timestamp: 1756811059129 +- conda: https://conda.anaconda.org/conda-forge/osx-64/git-2.51.0-pl5321h110a47f_1.conda + sha256: 90b1fe2316c433be8f4614b92a9cae6e3072ed95667fbee9bb035250be91919d + md5: 7e9ed6fd5de76c074bf474d4916513fc depends: - __osx >=10.10 - libcurl >=8.14.1,<9.0a0 - - libexpat >=2.7.0,<3.0a0 + - libexpat >=2.7.1,<3.0a0 - libiconv >=1.18,<2.0a0 - - libintl >=0.24.1,<1.0a0 + - libintl >=0.25.1,<1.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.0,<4.0a0 - - pcre2 >=10.45,<10.46.0a0 + - openssl >=3.5.2,<4.0a0 + - pcre2 >=10.46,<10.47.0a0 - perl 5.* license: GPL-2.0-or-later and LGPL-2.1-or-later - size: 12023941 - timestamp: 1751299319184 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.49.0-pl5321ha659579_2.conda - sha256: 001e31db2e69bdfdf716c0d0d401f4b7e362b4bcb88e343fc591ef61855478e4 - md5: 1da495d68b24e3b23f32d6404cc4433a + size: 11602637 + timestamp: 1756811185103 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/git-2.51.0-pl5321h6ee1a4f_1.conda + sha256: d6149d4791a765e478f9eb4f97b3703690eb8bd4eee0eba8c26fe5c656f4c0de + md5: 5d2bb27d4f45013f3acf108af1d7a97a depends: - __osx >=11.0 - libcurl >=8.14.1,<9.0a0 - - libexpat >=2.7.0,<3.0a0 + - libexpat >=2.7.1,<3.0a0 - libiconv >=1.18,<2.0a0 - - libintl >=0.24.1,<1.0a0 + - libintl >=0.25.1,<1.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.5.0,<4.0a0 - - pcre2 >=10.45,<10.46.0a0 + - openssl >=3.5.2,<4.0a0 + - pcre2 >=10.46,<10.47.0a0 - perl 5.* license: GPL-2.0-or-later and LGPL-2.1-or-later - size: 11705021 - timestamp: 1751299276656 -- conda: https://conda.anaconda.org/conda-forge/win-64/git-2.49.0-h57928b3_2.conda - sha256: cb47f71ce69a7394d70c78fd714941d3c69b02e0835f886215c090aec69a0fb5 - md5: 3581fc9b18a93aa91f3752ee695f20d5 + size: 11812476 + timestamp: 1756811409331 +- conda: https://conda.anaconda.org/conda-forge/win-64/git-2.51.0-h57928b3_1.conda + sha256: c7ff9cbe801b60ad790dd2cff0fda0eb052e1d4f3a69b2fbf7e655a3c40d33b7 + md5: 4e2b2c6759e8d30378b8f24a4646fd95 license: GPL-2.0-or-later and LGPL-2.1-or-later - size: 127469096 - timestamp: 1751299058316 + size: 123093629 + timestamp: 1756811084933 - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hac33072_2.conda sha256: 309cf4f04fec0c31b6771a5809a1909b4b3154a2208f52351e1ada006f4c750c md5: c94a5994ef49749880a8139cf9afcbe1 @@ -3706,40 +3778,40 @@ packages: license: GPL-2.0-or-later OR LGPL-3.0-or-later size: 567053 timestamp: 1718982076982 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.3.0-h9576a4e_2.conda - sha256: fa9d0171c17e4c4203a4199fcc35571a25c1f16c0ad992080d4f0ced53bf5aa5 - md5: 07e8df00b7cd3084ad3ef598ce32a71c +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_5.conda + sha256: 14c6913bbf3cb4fd1f4ac3a6a1be01b1ea53f3de60a99d8ac9972f751c8d284b + md5: 2d25dffaf139070fa4f7fff5effb78b2 depends: - - gcc 13.3.0.* - - gxx_impl_linux-64 13.3.0.* + - gcc 14.3.0.* + - gxx_impl_linux-64 14.3.0.* license: BSD-3-Clause license_family: BSD - size: 54718 - timestamp: 1740240712365 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.3.0-hae580e1_2.conda - sha256: 7cb36526a5c3e75ae07452aee5c9b6219f62fad9f85cc6d1dab5b21d1c4cc996 - md5: b55f02540605c322a47719029f8404cc - depends: - - gcc_impl_linux-64 13.3.0 h1e990d8_2 - - libstdcxx-devel_linux-64 13.3.0 hc03c837_102 + size: 30293 + timestamp: 1757039456662 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-he663afc_5.conda + sha256: 26346c3ca25648a059e234142ff5609b926aa501891344d1a5c88234fb0f889d + md5: 6c5067bf7e2539b8b44b1088ce54c25f + depends: + - gcc_impl_linux-64 14.3.0 hd9e9e21_5 + - libstdcxx-devel_linux-64 14.3.0 h85bb3a7_105 - sysroot_linux-64 - tzdata license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 13362974 - timestamp: 1740240672045 -- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.3.0-hb14504d_11.conda - sha256: dda6a2765249c40168defea26aa67ff37d4d9fd214fb6e8d4fe0f434033bef87 - md5: 2ca7575e4f2da39c5ee260e022ab1a6f + size: 14734843 + timestamp: 1757039390196 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-ha7acb78_11.conda + sha256: 6c06752e4773dfd61a1928e9f7e9d21c3b97068daf27b84696c33057a091fe27 + md5: d4af016b3511135302a19f2a58544fcd depends: - binutils_linux-64 - - gcc_linux-64 13.3.0 h6f18a23_11 - - gxx_impl_linux-64 13.3.0.* + - gcc_linux-64 14.3.0 h1382650_11 + - gxx_impl_linux-64 14.3.0.* - sysroot_linux-64 license: BSD-3-Clause license_family: BSD - size: 30844 - timestamp: 1748905886442 + size: 30802 + timestamp: 1748905895571 - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda sha256: 71e750d509f5fa3421087ba88ef9a7b9be11c53174af3aa4d06aff4c18b38e8e md5: 8b189310083baabfb622af68fd9d3ae3 @@ -3769,40 +3841,45 @@ packages: license_family: MIT size: 11857802 timestamp: 1720853997952 -- conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.12-pyhd8ed1ab_0.conda - sha256: 4debbae49a183d61f0747a5f594fca2bf5121e8508a52116f50ccd0eb2f7bb55 - md5: 84463b10c1eb198541cd54125c7efe90 +- conda: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda + sha256: 1d04369a1860a1e9e371b9fc82dd0092b616adcf057d6c88371856669280e920 + md5: 8579b6bb8d18be7c0b27fb08adeeeb40 depends: - - python >=3.9 + - ucrt >=10.0.20348.0 + - vc >=14.2,<15 + - vc14_runtime >=14.29.30139 + license: MIT + license_family: MIT + size: 14544252 + timestamp: 1720853966338 +- conda: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.14-pyhd8ed1ab_0.conda + sha256: b7fc614777da38244ff36da51f9417822d6507a7b6a8da27aba579490941d160 + md5: 34a8172d191193030438d7b30bcdeaf5 + depends: + - python >=3.10 - ukkonen license: MIT license_family: MIT - size: 78926 - timestamp: 1748049754416 -- conda: https://conda.anaconda.org/conda-forge/win-64/intel-openmp-2024.2.1-h57928b3_1083.conda - sha256: 0fd2b0b84c854029041b0ede8f4c2369242ee92acc0092f8407b1fe9238a8209 - md5: 2d89243bfb53652c182a7c73182cce4f - license: LicenseRef-IntelSimplifiedSoftwareOct2022 - license_family: Proprietary - size: 1852356 - timestamp: 1723739573141 -- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda - sha256: a922841ad80bd7b222502e65c07ecb67e4176c4fa5b03678a005f39fcc98be4b - md5: ad8527bf134a90e1c9ed35fa0b64318c + size: 79065 + timestamp: 1757209085517 +- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_8.conda + sha256: 305c22a251db227679343fd73bfde121e555d466af86e537847f4c8b9436be0d + md5: ff007ab0f0fdc53d245972bba8a6d40c constrains: - - sysroot_linux-64 ==2.17 - license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 + - sysroot_linux-64 ==2.28 + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL - size: 943486 - timestamp: 1729794504440 -- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 - sha256: 150c05a6e538610ca7c43beb3a40d65c90537497a4f6a5f4d15ec0451b6f5ebb - md5: 30186d27e2c9fa62b45fb1476b7200e3 + size: 1272697 + timestamp: 1752669126073 +- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + sha256: 0960d06048a7185d3542d850986d807c6e37ca2e644342dd0c72feefcf26c2a4 + md5: b38117a3c920364aff79f870c984b4a3 depends: - - libgcc-ng >=10.3.0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 license: LGPL-2.1-or-later - size: 117831 - timestamp: 1646151697040 + size: 134088 + timestamp: 1754905959823 - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda sha256: 99df692f7a8a5c27cd14b5fb1374ee55e756631b9c3d659ed3ee60830249b238 md5: 3f43953b7d3fb3aaa1d0d0723d91e368 @@ -3855,79 +3932,79 @@ packages: license_family: MIT size: 712034 timestamp: 1719463874284 -- conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-951.9-h4e51db5_6.conda - sha256: e40a618bfa56eba6f18bc30ec45e5b63797e5be0c64b632a09e13853b216ed8c - md5: 45bf526d53b1bc95bc0b932a91a41576 +- conda: https://conda.anaconda.org/conda-forge/osx-64/ld64-955.13-hc3792c1_4.conda + sha256: 0886ef877aac5a759301f2ec5088747037287e2733a46fb5007e952a3665eb74 + md5: b1fbefacdcbf350c3663903ced3edd7f depends: - - ld64_osx-64 951.9 h33512f0_6 - - libllvm18 >=18.1.8,<18.2.0a0 + - ld64_osx-64 955.13 h466f870_4 + - libllvm19 >=19.1.7,<19.2.0a0 constrains: - - cctools_osx-64 1010.6.* - - cctools 1010.6.* + - cctools_osx-64 1024.3.* + - cctools 1024.3.* license: APSL-2.0 license_family: Other - size: 19401 - timestamp: 1743872196322 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-951.9-h4c6efb1_6.conda - sha256: 2c796872c89dee18c8455bd5e4d7dcc6c4f8544c873856d12a64585ac60e315f - md5: f756d0a0ffba157687a29077f3408016 - depends: - - ld64_osx-arm64 951.9 hb6b49e2_6 - - libllvm18 >=18.1.8,<18.2.0a0 + size: 18619 + timestamp: 1759183705871 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-955.13-he86490a_4.conda + sha256: d29b9b9aeb9e9c26889869f61e5f5ad394ed394b6d24660edc70ca0d59fddb37 + md5: d13722873d4aecf2cba460bd4ca19e1e + depends: + - ld64_osx-arm64 955.13 h6922315_4 + - libllvm19 >=19.1.7,<19.2.0a0 constrains: - - cctools 1010.6.* - - cctools_osx-arm64 1010.6.* + - cctools_osx-arm64 1024.3.* + - cctools 1024.3.* license: APSL-2.0 license_family: Other - size: 19446 - timestamp: 1743872353403 -- conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-951.9-h33512f0_6.conda - sha256: e048342a05e77440f355c46a47871dc71d9d8884a4bf73dedf1a16c84aabb834 - md5: 6cd120f5c9dae65b858e1fad2b7959a0 + size: 18697 + timestamp: 1759183665035 +- conda: https://conda.anaconda.org/conda-forge/osx-64/ld64_osx-64-955.13-h466f870_4.conda + sha256: bfe344971c95a46ddb669819e9087f7c205ff6c782e3cb887e7da43c71b86aae + md5: ec31de01e2a0b0fcf478635da69308eb depends: - __osx >=10.13 - libcxx - - libllvm18 >=18.1.8,<18.2.0a0 + - libllvm19 >=19.1.7,<19.2.0a0 - sigtool - tapi >=1300.6.5,<1301.0a0 constrains: - - cctools_osx-64 1010.6.* - - ld 951.9.* - - clang >=18.1.8,<19.0a0 - - cctools 1010.6.* + - cctools_osx-64 1024.3.* + - clang 19.1.* + - cctools 1024.3.* + - ld64 955.13.* license: APSL-2.0 license_family: Other - size: 1099095 - timestamp: 1743872136626 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-951.9-hb6b49e2_6.conda - sha256: 5ab2c15358d0ebfe26bafd2f768f524962f1a785c81d42518afb4f5d397e83f9 - md5: 61743b006633f5e1f9aa9e707f44fcb1 + size: 1109592 + timestamp: 1759183614332 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-955.13-h6922315_4.conda + sha256: a7c52f5d07685f3550560e9114dc93f52a306ff3ffc10299fcb85e9889f3b981 + md5: d3fbd7d07169072d405a565d7ce7458c depends: - __osx >=11.0 - libcxx - - libllvm18 >=18.1.8,<18.2.0a0 + - libllvm19 >=19.1.7,<19.2.0a0 - sigtool - tapi >=1300.6.5,<1301.0a0 constrains: - - ld 951.9.* - - clang >=18.1.8,<19.0a0 - - cctools_osx-arm64 1010.6.* - - cctools 1010.6.* + - ld64 955.13.* + - cctools_osx-arm64 1024.3.* + - clang 19.1.* + - cctools 1024.3.* license: APSL-2.0 license_family: Other - size: 1022641 - timestamp: 1743872275249 -- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_5.conda - sha256: de097284f497b391fe9d000c75b684583c30aad172d9508ed05df23ce39d75cb - md5: acd9213a63cb62521290e581ef82de80 + size: 1036012 + timestamp: 1759183550182 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + sha256: 707dfb8d55d7a5c6f95c772d778ef07a7ca85417d9971796f7d3daad0b615de8 + md5: 14bae321b8127b63cba276bd53fac237 depends: - __glibc >=2.17,<3.0.a0 constrains: - - binutils_impl_linux-64 2.43 + - binutils_impl_linux-64 2.44 license: GPL-3.0-only license_family: GPL - size: 670525 - timestamp: 1749852860076 + size: 747158 + timestamp: 1758810907507 - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda sha256: 5fc32a5497c9919ffde729a604b0acfa97c403ce5b2b27b28ca261cf0c4643aa md5: a067596d679bcde85375143e7c374738 @@ -3980,268 +4057,415 @@ packages: license_family: BSD size: 43938 timestamp: 1742288893863 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-32_h59b9bed_openblas.conda - build_number: 32 - sha256: 1540bf739feb446ff71163923e7f044e867d163c50b605c8b421c55ff39aa338 - md5: 2af9f3d5c2e39f417ce040f5a35c40c6 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-36_h4a7cf45_openblas.conda + build_number: 36 + sha256: a1670eb8c9293f37a245e313bd9d72a301c79e8668a6a5d418c90335719fbaff + md5: 2a6122504dc8ea139337046d34a110cb depends: - libopenblas >=0.3.30,<0.3.31.0a0 - libopenblas >=0.3.30,<1.0a0 constrains: - - libcblas 3.9.0 32*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas + - liblapack 3.9.0 36*_openblas - mkl <2025 - - liblapacke 3.9.0 32*_openblas - - blas 2.132 openblas - - liblapack 3.9.0 32*_openblas + - libcblas 3.9.0 36*_openblas license: BSD-3-Clause license_family: BSD - size: 17330 - timestamp: 1750388798074 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-32_h7f60823_openblas.conda - build_number: 32 - sha256: e441fcc46858a9a073e4344c80e267aee3b95ec01b02e37205c36be79eec0694 - md5: 0f7197e3b4ecfa8aa24a371c3eaabb8a + size: 17421 + timestamp: 1758396490057 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.9.0-36_he492b99_openblas.conda + build_number: 36 + sha256: 9777a98bc129d5036bbcc6924fd42c7f9012813ff591053ccdb3f8b94071da54 + md5: 81067fbe6234231aa66b35de4c5230f5 depends: - libopenblas >=0.3.30,<0.3.31.0a0 - libopenblas >=0.3.30,<1.0a0 constrains: - - liblapack 3.9.0 32*_openblas - - blas 2.132 openblas - mkl <2025 - - liblapacke 3.9.0 32*_openblas - - libcblas 3.9.0 32*_openblas + - liblapack 3.9.0 36*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas + - libcblas 3.9.0 36*_openblas license: BSD-3-Clause license_family: BSD - size: 17571 - timestamp: 1750389030403 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-32_h10e41b3_openblas.conda - build_number: 32 - sha256: 2775472dd81d43dc20804b484028560bfecd5ab4779e39f1fb95684da3ff2029 - md5: d4a1732d2b330c9d5d4be16438a0ac78 + size: 17726 + timestamp: 1758397387194 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.9.0-36_h51639a9_openblas.conda + build_number: 36 + sha256: acedf4c86be500172ed84a1bf37425e5c538f0494341ebdc829001cd37707564 + md5: 3bf1e49358861ce86825eaa47c092f29 depends: - libopenblas >=0.3.30,<0.3.31.0a0 - libopenblas >=0.3.30,<1.0a0 constrains: - - blas 2.132 openblas - - liblapack 3.9.0 32*_openblas + - liblapacke 3.9.0 36*_openblas + - libcblas 3.9.0 36*_openblas + - liblapack 3.9.0 36*_openblas - mkl <2025 - - libcblas 3.9.0 32*_openblas - - liblapacke 3.9.0 32*_openblas + - blas 2.136 openblas license: BSD-3-Clause license_family: BSD - size: 17520 - timestamp: 1750388963178 -- conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-32_h641d27c_mkl.conda - build_number: 32 - sha256: 809d78b096e70fed7ebb17c867dd5dde2f9f4ed8564967a6e10c65b3513b0c31 - md5: 49b36a01450e96c516bbc5486d4a0ea0 - depends: - - mkl 2024.2.2 h66d3029_15 + size: 17733 + timestamp: 1758397710974 +- conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.9.0-35_h5709861_mkl.conda + build_number: 35 + sha256: 4180e7ab27ed03ddf01d7e599002fcba1b32dcb68214ee25da823bac371ed362 + md5: 45d98af023f8b4a7640b1f713ce6b602 + depends: + - mkl >=2024.2.2,<2025.0a0 constrains: - - libcblas 3.9.0 32*_mkl - - liblapack 3.9.0 32*_mkl - - liblapacke 3.9.0 32*_mkl - - blas 2.132 mkl + - blas 2.135 mkl + - liblapack 3.9.0 35*_mkl + - libcblas 3.9.0 35*_mkl + - liblapacke 3.9.0 35*_mkl license: BSD-3-Clause license_family: BSD - size: 3735390 - timestamp: 1750389080409 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.88.0-h6c02f8c_0.conda - sha256: 0f51eada581974dbaab5c763c2f26664d7c41fce441083c87d2204d55cb767da - md5: e0afbff39e5218b5ccdac40ad3cbc5cf + size: 66044 + timestamp: 1757003486248 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_0.conda + sha256: f04911640020b63035d732448df5b6f0e3e7bb6ae86cc5f417d763a302c4e2f7 + md5: ee83d47081139326aac702f989abe8d4 depends: - __glibc >=2.17,<3.0.a0 - bzip2 >=1.0.8,<2.0a0 - icu >=75.1,<76.0a0 - - libgcc >=13 + - libgcc >=14 - liblzma >=5.8.1,<6.0a0 - - libstdcxx >=13 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 3195295 + timestamp: 1755592150830 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.89.0-hed09d94_2.conda + sha256: d3d61dcd3bfe9975992f25553862af44c136a13b2c373a5155397d043345c43f + md5: c1ad4a7893dd5f1e162b296c6bebd0d9 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - icu >=75.1,<76.0a0 + - libgcc >=14 + - liblzma >=5.8.1,<6.0a0 + - libstdcxx >=14 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 3011043 - timestamp: 1744432286447 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.88.0-hf0da243_0.conda - sha256: 82a707f6e4c39a74265cd2d93ddd0ac5fbfe3f8585f181ce97391a1331daa747 - md5: 855b564913b2d5cfc5fbca6703138760 + size: 3178090 + timestamp: 1756934380571 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hdda6694_0.conda + sha256: 67eb4a0aa4a178545ee24e5f78f8428fa28589786b71c2b069692777a8f4e573 + md5: bf0a46150308ea1575471bb2df8e18d2 depends: - __osx >=10.13 - bzip2 >=1.0.8,<2.0a0 - icu >=75.1,<76.0a0 - - libcxx >=18 + - libcxx >=17 - liblzma >=5.8.1,<6.0a0 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 2096289 - timestamp: 1744432439256 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.88.0-hc9fb7c5_0.conda - sha256: 9e8de5fe4f13e25926225bc63fb71105acb466fc6e962c5c7e47f62dc361fec4 - md5: edf8618e63adf0f2e38f646a16514032 + size: 2270013 + timestamp: 1755593176314 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-1.89.0-hf9ddd82_2.conda + sha256: b4d335db82cda171efcc59a3b4a91a66d4f80854d4c727971ffc70c8bfd26e7b + md5: 3d22d1e48979178b7ea7fcbfd0f098a5 + depends: + - __osx >=10.13 + - bzip2 >=1.0.8,<2.0a0 + - icu >=75.1,<76.0a0 + - libcxx >=19 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 2201573 + timestamp: 1756936474139 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h18cd856_2.conda + sha256: 9b6959a0bad4506dd47049663402344142864cacd607d5804930b67b4f7c60e1 + md5: 0049957e682102d38b06830fdf11b2b2 depends: - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - icu >=75.1,<76.0a0 - - libcxx >=18 + - libcxx >=19 - liblzma >=5.8.1,<6.0a0 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 1945701 - timestamp: 1744432470394 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.88.0-hb0986bb_0.conda - sha256: 4573e92c3d1b6fdd30d4c359a718b61f62167ee61addffe8f176c8f364477ee1 - md5: e610d2209ecf0c257db0d18bc2ece30a + size: 2061909 + timestamp: 1756936499326 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-1.89.0-h1b56ccb_0.conda + sha256: 9b513d96a4528ccb2ffeb673854d603dbf3216ed9c9f35fd610119ed2072898e + md5: 3b5f9220ed2890141b6077d8f5a72fa1 + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - icu >=75.1,<76.0a0 + - libcxx >=17 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 2093519 + timestamp: 1755593120770 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_0.conda + sha256: f67d934366e16b9866b9233d63bc8cb71160544014912d0d729d0090ec17e6aa + md5: 8e657bddeab394d478caa315660f202e depends: - bzip2 >=1.0.8,<2.0a0 - libiconv >=1.18,<2.0a0 - liblzma >=5.8.1,<6.0a0 - libzlib >=1.3.1,<2.0a0 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - boost-cpp <0.0a0 + - __win >=10 + license: BSL-1.0 + size: 2572983 + timestamp: 1755594334763 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-1.89.0-h9dfe17d_2.conda + sha256: ed0db549e5bcfa1d3b9e2970eaa0ae4e0ebea89cb09e11968dd1bc81eb3a41ab + md5: fddeeed8e8316497b44bb146a606828f + depends: + - bzip2 >=1.0.8,<2.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 - zstd >=1.5.7,<1.6.0a0 constrains: - - __win ==0|>=10 + - __win >=10 + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 2453986 + timestamp: 1756936527030 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_0.conda + sha256: d88c29c7da88c7f4e2206f4c6a0c7e72f7d8862a757cf7ee478978f1385410f1 + md5: 62d544f4797b4317eafb3fe84a0beca9 + depends: + - libboost 1.89.0 hed09d94_0 + - libboost-headers 1.89.0 ha770c72_0 + constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 2501415 - timestamp: 1744433758716 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.88.0-h1a2810e_0.conda - sha256: ac95138550eeec69257d09d2f3d775f80c7389bcad0c9e1c2279db3a9022765a - md5: 5716bcc21136f7815a24b0fa92212582 - depends: - - libboost 1.88.0 h6c02f8c_0 - - libboost-headers 1.88.0 ha770c72_0 + size: 38271 + timestamp: 1755592257033 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.89.0-hfcd1e18_2.conda + sha256: 247d223b6f6e33aa952fa0d21328a996807a2bfed94b0c23023b6d191fcb0743 + md5: 693a8c0a9f27f373a57a0e8b7896a23f + depends: + - libboost 1.89.0 hed09d94_2 + - libboost-headers 1.89.0 ha770c72_2 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 38071 - timestamp: 1744432439724 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.88.0-h20888b2_0.conda - sha256: 2e983785364437c3418d29037b916b28e6167a895eb337f5949a7701f485b6b0 - md5: 421d7b57b1e595da53901f0ad3e92123 - depends: - - libboost 1.88.0 hf0da243_0 - - libboost-headers 1.88.0 h694c41f_0 + size: 38883 + timestamp: 1756934492558 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h385f146_0.conda + sha256: 396da62bae72433cade8b4998dae42f644c4f5d4a4548e2d4811c8047c563282 + md5: dc1d4729648ea6d4f3770162ba462039 + depends: + - libboost 1.89.0 hdda6694_0 + - libboost-headers 1.89.0 h694c41f_0 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 39444 - timestamp: 1744432584847 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.88.0-hf450f58_0.conda - sha256: 35958f53863a8b97379c82ae1b6b1ed99209b46be5131a760d204ff892f38bb2 - md5: caa1898b431a8b820b0384c0717db845 - depends: - - libboost 1.88.0 hc9fb7c5_0 - - libboost-headers 1.88.0 hce30654_0 + size: 38937 + timestamp: 1755593324874 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-devel-1.89.0-h7a7523a_2.conda + sha256: cdc3d2e05964afbcc132d26790efc868ed2347da0eca165c90a84dcca2c19da2 + md5: b14aef780bfacfdf68d6316c9cab990d + depends: + - libboost 1.89.0 hf9ddd82_2 + - libboost-headers 1.89.0 h694c41f_2 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 37962 - timestamp: 1744432597384 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.88.0-h91493d7_0.conda - sha256: eed43d352d5cb8fb734badedae2e75558e252cbcd454aa219040421c7b850aab - md5: 1ddb17677d0e962b278a251cb0f67fa0 - depends: - - libboost 1.88.0 hb0986bb_0 - - libboost-headers 1.88.0 h57928b3_0 + size: 39466 + timestamp: 1756936708723 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_0.conda + sha256: 1515a86a18d16732f87f5e877f5371c9aeaf8cd1f1e6a7cdd8c03ab80eae7eb4 + md5: ee2ff82ec4b454c7f0994a53d700af40 + depends: + - libboost 1.89.0 h1b56ccb_0 + - libboost-headers 1.89.0 hce30654_0 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 40765 - timestamp: 1744434002172 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.88.0-ha770c72_0.conda - sha256: 0dd66c472fd6ece3fba754c45a893e8d818ff16635664a3502f60bf457ca6811 - md5: a7cc18340af8dc486c7c3e8bd709ff35 + size: 38039 + timestamp: 1755593272903 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-devel-1.89.0-hf450f58_2.conda + sha256: 1ebc80fb4556a2db5139bb0e9373c91868c7352077c8316b26d50e0957380064 + md5: 9b9e4c8d524995ace1993160d9244d86 + depends: + - libboost 1.89.0 h18cd856_2 + - libboost-headers 1.89.0 hce30654_2 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 14511954 - timestamp: 1744432304949 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.88.0-h694c41f_0.conda - sha256: 45ba6e40e63739898b9c54e1a63a8a1574684d4e4726076171226270364203a6 - md5: 72cdd5ed951b047e982ea6e1c57bf8d5 + size: 38442 + timestamp: 1756936731069 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_0.conda + sha256: 287e40507e038fc4830a08250f452b364a53da61c300d49ff7647b494308ca99 + md5: 321894a90d4b183673627ff5d97fde5b + depends: + - libboost 1.89.0 h9dfe17d_0 + - libboost-headers 1.89.0 h57928b3_0 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 14649657 - timestamp: 1744432468540 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.88.0-hce30654_0.conda - sha256: 5c8e805f027257dc53c810d1c94ec36b2af3f9e87e9a63b76e892c29e34441b9 - md5: c095f0350fba0f7f6ec3ef8a446af6d1 + size: 40720 + timestamp: 1755594584451 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-devel-1.89.0-h1c1089f_2.conda + sha256: e796c613834b419564421dd62fc7a4ef46d5d3f414740ddb4fc4c7e0f522c6bb + md5: d8f0430869724c32bcb549638c97fe55 + depends: + - libboost 1.89.0 h9dfe17d_2 + - libboost-headers 1.89.0 h57928b3_2 constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 14601844 - timestamp: 1744432500701 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.88.0-h57928b3_0.conda - sha256: 3949c7954dae2c826e22f0bd4a029fd4d1304ae271f467d61cbcdaa206ab9eaa - md5: 3d86222c3e967125ab2c8862edc7cb3a + size: 41495 + timestamp: 1756936709429 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_0.conda + sha256: e41ffb499735485510a4a5d69e99c248d220339aedeccfd1ece3ae2db4e88bf0 + md5: 86bce1a9560aff4a22c6731a1ffe2a4f constrains: - boost-cpp <0.0a0 license: BSL-1.0 - size: 14614498 - timestamp: 1744433827387 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py312hc39e661_0.conda - sha256: 4a371fb970c209d6e9a5fac3b00f62f6606aa4fbbea61d223405da7fab37ace4 - md5: 74e2df839d6a645ce13d98897c3f7e46 + size: 14464389 + timestamp: 1755592165819 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.89.0-ha770c72_2.conda + sha256: d5bf4b3e62cecf5a6170f3bc077331a90e1924c657daeda6ca08099dbbf70455 + md5: 73d2d54b800f429c337858bd22712abc + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14518901 + timestamp: 1756934396472 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_0.conda + sha256: 79ea95b6c1239f4f831b8628eccf78998f1ae7d9c2724c063e287508273bbd2b + md5: 3dce795714645d0a78c899b63a8420b2 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14569027 + timestamp: 1755593210755 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-headers-1.89.0-h694c41f_2.conda + sha256: bedc4fdeb521d312fb58bde0a1ea7a9628f5ac5ed9a158d987f577a90876f1db + md5: 0716ca38197d73cec47fb10e62216c03 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14657203 + timestamp: 1756936517110 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_0.conda + sha256: 8ea5ad8f72f0a0b39e1d7630c9492e4ad38339eeaf1f1e78e71d296bb96ae8b8 + md5: 15005db9de664d2ce12b16b81318c0a9 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14589017 + timestamp: 1755593161008 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-headers-1.89.0-hce30654_2.conda + sha256: 73fc1052f12aebaa6b6c06d8a8c42c05c345e051dacdeeae217620ef3f9a1f57 + md5: b4864bd19550f1e026c5d99f9d871da8 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14604642 + timestamp: 1756936548985 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_0.conda + sha256: 9c88edf7d8aa00a5fd9268e3ba3fabd6a2ca9497786517385ab467beb9d748ee + md5: d771599137c004e0abfe8aec65f2b69a + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14633668 + timestamp: 1755594410398 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-headers-1.89.0-h57928b3_2.conda + sha256: c6834ebee44436243d1ec6285cf6b8cc9cf57e9995017fa8d593ad86eccad881 + md5: a0ff7c1737d2c7fa7ea541bc582fc798 + constrains: + - boost-cpp <0.0a0 + license: BSL-1.0 + size: 14709985 + timestamp: 1756936579187 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py312hf890105_2.conda + sha256: 5b8d5f10204f3ef78b35a19491d2ee46e2a96aebd1d945555677332954b68b1f + md5: 3e9a7bdab2544232e2e935dbb3b8a952 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libstdcxx >=13 - - numpy >=1.19,<3 + - libboost 1.89.0 hed09d94_2 + - libgcc >=14 + - libstdcxx >=14 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 128170 - timestamp: 1744432898470 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.88.0-py39hf59e57a_0.conda - sha256: 13e2851ac63d786d4aa48d047704435ba12f52aa00fa0ecfd4d5d955da825138 - md5: 2cb51bae26661a21957eaf0c8d255259 + size: 129132 + timestamp: 1756934571095 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-1.89.0-py39h040329f_0.conda + sha256: df8978b83f3745382b20c1947f8dc773a7647f0eed42cf50286533d112e10643 + md5: 5d57ec126fd9a57b8d61769256fba54e depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libstdcxx >=13 + - libboost 1.89.0 hed09d94_0 + - libgcc >=14 + - libstdcxx >=14 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 constrains: - - boost <0.0a0 - py-boost <0.0a0 + - boost <0.0a0 license: BSL-1.0 - size: 125627 - timestamp: 1744432531500 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py312hdf63323_0.conda - sha256: 1384b075715632a25aae704418b5888ea75e1f965a1ebdaa9796120d94461ad3 - md5: e37b891485c20fb78913f95591532c92 + size: 125394 + timestamp: 1755592702543 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py312h83679cb_2.conda + sha256: 2e2cc4fbadb245f897b208f91c6fc3927eace72a940570916ed4e6c911ef2ad3 + md5: deb6d2c79ec167481bfa3468615e1ab1 depends: - __osx >=10.13 - - libcxx >=18 - - numpy >=1.19,<3 + - libboost 1.89.0 hf9ddd82_2 + - libcxx >=19 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 106897 - timestamp: 1744433100729 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.88.0-py39h5c7665c_0.conda - sha256: 502657bd955050f83a1d42cb7a58f1f93c4ddf94cae4363d2a52e2acca7a6cc1 - md5: 1692e2d18bedabdc5263a43db4a24952 + size: 106647 + timestamp: 1756937078537 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-1.89.0-py39hc79836b_0.conda + sha256: 306a1cad1d0b586e792cd215bafcc43dafd2591203ab477087d09f6de0b12d4f + md5: e58ec8fb9fb7ee0a3931f7813ed83791 depends: - __osx >=10.13 - - libcxx >=18 + - libboost 1.89.0 hdda6694_0 + - libcxx >=17 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 @@ -4249,30 +4473,32 @@ packages: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 105351 - timestamp: 1744432686112 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py312h72cd453_0.conda - sha256: 30d2af5e72fa9b95cb2cd339fc554bdbddb5d7c5f236bf361a1034553c88464c - md5: 74253a08e0bf3be2a2be66c86d3a7d99 + size: 106858 + timestamp: 1755593429355 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py312h4c080bd_2.conda + sha256: 4da0fbcec30e0c1db6785e137e00500f5353e1738ac0bdc9ea4c04f29a14d287 + md5: a669b8c377bb3630712e6d4a1cbc35bd depends: - __osx >=11.0 - - libcxx >=18 - - numpy >=1.19,<3 + - libboost 1.89.0 h18cd856_2 + - libcxx >=19 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 constrains: - - py-boost <0.0a0 - boost <0.0a0 + - py-boost <0.0a0 license: BSL-1.0 - size: 105741 - timestamp: 1744432712825 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.88.0-py39h7d68603_0.conda - sha256: ded5b60a0093cd52730b65d44e45994c2e0db76d0837efa851d09c063b5b710e - md5: 5571c36f95aecece200a0b2105509e7d + size: 105932 + timestamp: 1756936967691 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-1.89.0-py39h76e75a2_0.conda + sha256: 2a4035124908d2a256f8610b7942fd6f5da45d1811e82787358da42202194940 + md5: 296861085978c586956a80f879b44a67 depends: - __osx >=11.0 - - libcxx >=18 + - libboost 1.89.0 h1b56ccb_0 + - libcxx >=17 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python >=3.9,<3.10.0a0 *_cpython @@ -4281,91 +4507,93 @@ packages: - py-boost <0.0a0 - boost <0.0a0 license: BSL-1.0 - size: 105356 - timestamp: 1744433037917 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py312hbaa7e33_0.conda - sha256: b799922dc8cc8ee165fc78b52499588f8d64edc6960a4a0862bb30da621e3f56 - md5: 8ddcdbc06b29d702fb4a53b944f4fdb1 + size: 105282 + timestamp: 1755593770913 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py312h9b46583_2.conda + sha256: 4b01b92cd7f8b053f761091c6c9f1ddae63f597ef13eaae1c2b4b2e08d872e3c + md5: c1c5e742415b1729101c23db589377c1 depends: - - numpy >=1.19,<3 + - libboost 1.89.0 h9dfe17d_2 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 constrains: - - boost <0.0a0 - py-boost <0.0a0 + - boost <0.0a0 license: BSL-1.0 - size: 113334 - timestamp: 1744434539528 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.88.0-py39h8f1c5a3_0.conda - sha256: 928497de03a02e69eac92e6d21456aa4332a29faeccafcbfe3e25320149dfff3 - md5: 305043123c0772ad1efda2beab091a96 + size: 113516 + timestamp: 1756937188270 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-1.89.0-py39h44eb426_0.conda + sha256: 958235792a2ea0f5a14d036b7c03933e8603291b9bd0c73ff859292c1aebaaea + md5: c3e97c10c8cad1b7fe8c9f6a1f0c578a depends: + - libboost 1.89.0 h9dfe17d_0 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 constrains: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 112478 - timestamp: 1744434364406 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py312h9cebb41_0.conda - sha256: cb4e2886f2ba6efbad3395ec1d634fb7b13a904daa4f13b193bef420326c8f76 - md5: 231fd2e78031d4a4a356da726722cd07 - depends: - - libboost-devel 1.88.0 h1a2810e_0 - - libboost-python 1.88.0 py312hc39e661_0 - - numpy >=1.19,<3 + size: 112944 + timestamp: 1755594801655 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py312h26dfbe5_2.conda + sha256: b46585e858d5f0847beafc32e0f56b0708c9879b61d2cc96636b4052e00acb44 + md5: 276ea0bb97220582b4ef3dea88f4db73 + depends: + - libboost-devel 1.89.0 hfcd1e18_2 + - libboost-python 1.89.0 py312hf890105_2 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 17157 - timestamp: 1744432990345 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.88.0-py39he8689d4_0.conda - sha256: ea4d94011a3883c74bea29d85c6418a495b2adb4f7a4c5a77f1b1fdfa2a648b1 - md5: 69aaa433ee792149893e4365cbcb7f10 - depends: - - libboost-devel 1.88.0 h1a2810e_0 - - libboost-python 1.88.0 py39hf59e57a_0 + size: 17633 + timestamp: 1756934905015 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-python-devel-1.89.0-py39hf0d4527_0.conda + sha256: ba3bdbd4bfb406f2dace16432d98b6dac76f1a72f16d96cf710fa8440e03d28d + md5: 2c5e8db779349e2df12cc9ceb8dbec86 + depends: + - libboost-devel 1.89.0 hfcd1e18_0 + - libboost-python 1.89.0 py39h040329f_0 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 constrains: - - boost <0.0a0 - py-boost <0.0a0 + - boost <0.0a0 license: BSL-1.0 - size: 17153 - timestamp: 1744432916555 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py312h0be7463_0.conda - sha256: 1a6e5f7e0b2736eb03c33b3bc20a5215d6e698fcab6cd1b7efd5d9c4117fce59 - md5: c41e36ad1470d0fe6b3229ee72953519 - depends: - - libboost-devel 1.88.0 h20888b2_0 - - libboost-python 1.88.0 py312hdf63323_0 - - numpy >=1.19,<3 + size: 17322 + timestamp: 1755592775770 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py312h3e18098_2.conda + sha256: 5652ebc8271003174a87a37451c16eba8a731638d110ae4dd4ee5476f8f7fdc7 + md5: 52937e7009bea075b60d161ec58486de + depends: + - libboost-devel 1.89.0 h7a7523a_2 + - libboost-python 1.89.0 py312h83679cb_2 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 17332 - timestamp: 1744433302405 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.88.0-py39h810aed5_0.conda - sha256: de1388ebe314217581dbaf0e84fc7042165ae9f0f6cbcaec686d79083e763c5b - md5: bf961d77cb79dcb1e9f42f565f1e40c8 - depends: - - libboost-devel 1.88.0 h20888b2_0 - - libboost-python 1.88.0 py39h5c7665c_0 + size: 17857 + timestamp: 1756937748797 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libboost-python-devel-1.89.0-py39h7c53190_0.conda + sha256: c68cecf9f6d223d021491ad46038d0c5da9e535e95dc1b8653b9b657317e4d21 + md5: dea17d136ea908f3cd8d9bceed19fa94 + depends: + - libboost-devel 1.89.0 h385f146_0 + - libboost-python 1.89.0 py39hc79836b_0 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 @@ -4373,29 +4601,29 @@ packages: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 17289 - timestamp: 1744433140605 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py312ha814d7c_0.conda - sha256: db1d2a7a269ab81df2e41a60de6fccd26997742f26fafb33e4afcbb1fbd7d1d1 - md5: 498f9b640c95805118119b463111b41d - depends: - - libboost-devel 1.88.0 hf450f58_0 - - libboost-python 1.88.0 py312h72cd453_0 - - numpy >=1.19,<3 + size: 17439 + timestamp: 1755593898706 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py312h652a6e0_2.conda + sha256: a820e05910252a17f8142d279d07bc29cf6421abc87d5456759d2d45dfe336c0 + md5: 9a01306e5d3ce435caec9d59017b6341 + depends: + - libboost-devel 1.89.0 hf450f58_2 + - libboost-python 1.89.0 py312h4c080bd_2 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: - - py-boost <0.0a0 - boost <0.0a0 + - py-boost <0.0a0 license: BSL-1.0 - size: 17306 - timestamp: 1744433195708 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.88.0-py39h2beb185_0.conda - sha256: 05813b056ca0241cd91b252c1cfbeb1ab0eea07edadf228f41480e027411a000 - md5: ed7065eaf00a505c6e697fe7d0f7fd68 - depends: - - libboost-devel 1.88.0 hf450f58_0 - - libboost-python 1.88.0 py39h7d68603_0 + size: 17838 + timestamp: 1756937924585 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libboost-python-devel-1.89.0-py39hfa01887_0.conda + sha256: 7202ea6e2bc988a29a4b2f79875d5604f96fa1ea0e7bcba7f0656fb1d8838826 + md5: 10cfc05d3509fa526f35a9501c62ec9d + depends: + - libboost-devel 1.89.0 hf450f58_0 + - libboost-python 1.89.0 py39h76e75a2_0 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 @@ -4403,29 +4631,29 @@ packages: - py-boost <0.0a0 - boost <0.0a0 license: BSL-1.0 - size: 17332 - timestamp: 1744433297870 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py312h7e22eef_0.conda - sha256: ef69ab10970e4895d2b49eb97b321865b3b831e9009d8bb074e92124b1586e8d - md5: 71a2024dd8f5779020082cec28b63524 - depends: - - libboost-devel 1.88.0 h91493d7_0 - - libboost-python 1.88.0 py312hbaa7e33_0 - - numpy >=1.19,<3 + size: 17434 + timestamp: 1755594110274 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py312h6d21bc8_2.conda + sha256: be77cc537f47950dd710650eca818d69e5460f43399526970890bff555a8b1e5 + md5: 671d465e22cad86e0947075ccccc276c + depends: + - libboost-devel 1.89.0 h1c1089f_2 + - libboost-python 1.89.0 py312h9b46583_2 + - numpy >=1.23,<3 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 constrains: - - boost <0.0a0 - py-boost <0.0a0 + - boost <0.0a0 license: BSL-1.0 - size: 17742 - timestamp: 1744435057518 -- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.88.0-py39hcb5f9c0_0.conda - sha256: f126dc6f691453f094f6b430488c451686d403a3c8288bd1d36ae707ee570792 - md5: 135b95eaf7b9ec26660998bd621cdeb6 - depends: - - libboost-devel 1.88.0 h91493d7_0 - - libboost-python 1.88.0 py39h8f1c5a3_0 + size: 18239 + timestamp: 1756937634491 +- conda: https://conda.anaconda.org/conda-forge/win-64/libboost-python-devel-1.89.0-py39h5a5e355_0.conda + sha256: 49593156ce2a3b88421989c5d418b7ab3e50da514080e92180b86368845cbe20 + md5: 0f4ffec01bca8972836b30a6aeca4066 + depends: + - libboost-devel 1.89.0 h1c1089f_0 + - libboost-python 1.89.0 py39h44eb426_0 - numpy >=1.19,<3 - python >=3.9,<3.10.0a0 - python_abi 3.9.* *_cp39 @@ -4433,8 +4661,8 @@ packages: - boost <0.0a0 - py-boost <0.0a0 license: BSL-1.0 - size: 17714 - timestamp: 1744435005417 + size: 17925 + timestamp: 1755595636728 - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda sha256: fe36f414f48ab87251f02aeef1fcbb6f3929322316842dada0f8142db2710264 md5: 6f4aec52002defbdf3e24eb79e56a209 @@ -4523,62 +4751,62 @@ packages: license_family: BSD size: 40061 timestamp: 1742288893863 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-32_he106b2a_openblas.conda - build_number: 32 - sha256: 92a001fc181e6abe4f4a672b81d9413ca2f22609f8a95327dfcc6eee593ffeb9 - md5: 3d3f9355e52f269cd8bc2c440d8a5263 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-36_h0358290_openblas.conda + build_number: 36 + sha256: 45110023d1661062288168c6ee01510bcb472ba2f5184492acdcdd3d1af9b58d + md5: 13a3fe5f9812ac8c5710ef8c03105121 depends: - - libblas 3.9.0 32_h59b9bed_openblas + - libblas 3.9.0 36_h4a7cf45_openblas constrains: - - blas 2.132 openblas - - liblapack 3.9.0 32*_openblas - - liblapacke 3.9.0 32*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas + - liblapack 3.9.0 36*_openblas license: BSD-3-Clause license_family: BSD - size: 17308 - timestamp: 1750388809353 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-32_hff6cab4_openblas.conda - build_number: 32 - sha256: 745f6dd420389809c333734df6edc99d75caa3633e4778158c7549c6844af440 - md5: 2c1e774d4546cf542eaee5781eb8940b - depends: - - libblas 3.9.0 32_h7f60823_openblas + size: 17401 + timestamp: 1758396499759 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.9.0-36_h9b27e0a_openblas.conda + build_number: 36 + sha256: d3b3d21ac4fd3850e6d1c67392ebe0625831cf30d44ea812aa07e285f352f634 + md5: b85f4bbdbc15902078cab28615e872d2 + depends: + - libblas 3.9.0 36_he492b99_openblas constrains: - - blas 2.132 openblas - - liblapack 3.9.0 32*_openblas - - liblapacke 3.9.0 32*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas + - liblapack 3.9.0 36*_openblas license: BSD-3-Clause license_family: BSD - size: 17574 - timestamp: 1750389040732 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-32_hb3479ef_openblas.conda - build_number: 32 - sha256: 25d46ace14c3ac45d4aa18b5f7a0d3d30cec422297e900f8b97a66334232061c - md5: d8e8ba717ae863b13a7495221f2b5a71 - depends: - - libblas 3.9.0 32_h10e41b3_openblas + size: 17693 + timestamp: 1758397405253 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.9.0-36_hb0561ab_openblas.conda + build_number: 36 + sha256: ee8b3386c9fe8668eb9013ffea5c60f7546d0d298931f7ec0637b08d796029de + md5: 46aefc2fcef5f1f128d0549cb0fad584 + depends: + - libblas 3.9.0 36_h51639a9_openblas constrains: - - blas 2.132 openblas - - liblapack 3.9.0 32*_openblas - - liblapacke 3.9.0 32*_openblas + - liblapack 3.9.0 36*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas license: BSD-3-Clause license_family: BSD - size: 17485 - timestamp: 1750388970626 -- conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-32_h5e41251_mkl.conda - build_number: 32 - sha256: d0f81145ae795592f3f3b5d7ff641c1019a99d6b308bfaf2a4cc5ba24b067bb0 - md5: 054b9b4b48296e4413cf93e6ece7b27d - depends: - - libblas 3.9.0 32_h641d27c_mkl + size: 17717 + timestamp: 1758397731650 +- conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.9.0-35_h2a3cdd5_mkl.conda + build_number: 35 + sha256: 88939f6c1b5da75bd26ce663aa437e1224b26ee0dab5e60cecc77600975f397e + md5: 9639091d266e92438582d0cc4cfc8350 + depends: + - libblas 3.9.0 35_h5709861_mkl constrains: - - liblapack 3.9.0 32*_mkl - - liblapacke 3.9.0 32*_mkl - - blas 2.132 mkl + - blas 2.135 mkl + - liblapack 3.9.0 35*_mkl + - liblapacke 3.9.0 35*_mkl license: BSD-3-Clause license_family: BSD - size: 3735392 - timestamp: 1750389122586 + size: 66398 + timestamp: 1757003514529 - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda sha256: cc90aa5e0ad1f7ae9a29d9a42aacd7f7f02aba0bf5467513bfda7e6b18a4cbc8 md5: e5107e02dc4c2f9f41eef72d72c23517 @@ -4698,40 +4926,40 @@ packages: license: LGPL-2.1-or-later AND GPL-2.0-or-later AND Apache-2.0 size: 916709 timestamp: 1742288893864 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp18.1-18.1.8-default_h3571c67_10.conda - sha256: f30dd87230aadda44f566b79782a61fbf7214e0099741c822045cc91d085e0ce - md5: bf6753267e6f848f369c5bc2373dddd6 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libclang-cpp19.1-19.1.7-default_hc369343_4.conda + sha256: 667e9cc12a9e118302245a8dfd904b4106c1015cc0a0b661c863f494106c576a + md5: fec88978ef30a127235f9f0e67cf6725 depends: - __osx >=10.13 - - libcxx >=18.1.8 - - libllvm18 >=18.1.8,<18.2.0a0 + - libcxx >=19.1.7 + - libllvm19 >=19.1.7,<19.2.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 13907371 - timestamp: 1747763588968 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp18.1-18.1.8-default_hf90f093_10.conda - sha256: c1eee43ffc0c229bd222a3a56e99c5d6689ed0402cb69c1f5ea2f96e18e5d984 - md5: af31a578be7de7b05a067a57f2d059e5 + size: 14856804 + timestamp: 1757393797338 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_h73dfc95_4.conda + sha256: 0de5a6c507bce790ae2182e4f1f2cd095eed5638911ac03a8ba55776dd7ae0df + md5: dbd13529e140b10f1985496034d45cf0 depends: - __osx >=11.0 - - libcxx >=18.1.8 - - libllvm18 >=18.1.8,<18.2.0a0 + - libcxx >=19.1.7 + - libllvm19 >=19.1.7,<19.2.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 13330110 - timestamp: 1747714807051 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp20.1-20.1.7-default_h1df26ce_0.conda - sha256: 4194c75a91a9c790cbe96c3c33fc2f388274d1be85ec884ce7c88d7e8f9d96f2 - md5: f9ef7bce54a7673cdbc2fadd8bca1956 + size: 14062690 + timestamp: 1757395907504 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp21.1-21.1.2-default_h99862b1_0.conda + sha256: 61aa5bb5f2e61cfdb2a3d66ea72f829a1a7056674acd002f5bf0de1c0e39b29e + md5: 4ddb1793f7c9493e24f2034ff0a19cff depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libllvm20 >=20.1.7,<20.2.0a0 - - libstdcxx >=13 + - libgcc >=14 + - libllvm21 >=21.1.2,<21.2.0a0 + - libstdcxx >=14 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 20925717 - timestamp: 1749876303353 + size: 21082467 + timestamp: 1758875974778 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda sha256: 00d1b976b914f0c20ae6f81f4e4713fa87717542eba8757b9a3c9e8abcc29858 md5: 56d4c5542887e8955f21f8546ad75d9d @@ -4883,42 +5111,42 @@ packages: license: LGPL-2.1-or-later size: 70656 timestamp: 1742288893863 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-20.1.7-hf95d169_0.conda - sha256: f6e088a2e0e702a4908d1fc9f1a17b080bdcf63e1f8a9cb35dd158fc1d1eb2f5 - md5: 8b47ade37d4e75417b4e993179c09f5d +- conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + sha256: c3feab716740baa6193a1bc5c948c47c913e28f6e52d418bb67123cb92b9761e + md5: 34cd9d03a8f27081a556cb397a19f6cd depends: - __osx >=10.13 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 562573 - timestamp: 1749846921724 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-20.1.7-ha82da77_0.conda - sha256: a3fd34773f1252a4f089e74a075ff5f0f6b878aede097e83a405f35687c36f24 - md5: 881de227abdddbe596239fa9e82eb3ab + size: 572006 + timestamp: 1758698149906 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + sha256: 3de00998c8271f599d6ed9aea60dc0b3e5b1b7ff9f26f8eac95f86f135aa9beb + md5: edfa256c5391f789384e470ce5c9f340 depends: - __osx >=11.0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 567189 - timestamp: 1749847129529 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-18.1.8-h7c275be_8.conda - sha256: cb3cce2b312aa1fb7391672807001bbab4d6e2deb16d912caecf6219f58ee1f4 - md5: a9513c41f070a9e2d5c370ba5d6c0c00 + size: 568154 + timestamp: 1758698306949 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-devel-19.1.7-h7c275be_1.conda + sha256: d1ee08b0614d8f9bca84aa91b4015c5efa96162fd865590a126544243699dfc6 + md5: 0f3f15e69e98ce9b3307c1d8309d1659 depends: - - libcxx >=18.1.8 + - libcxx >=19.1.7 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 794361 - timestamp: 1742451346844 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-18.1.8-h6dc3340_8.conda - sha256: ff83d001603476033eca155ce77f7ba614d9dc70c5811e2ce9915a3cadacb56f - md5: fdf0850d6d1496f33e3996e377f605ed + size: 826706 + timestamp: 1742451299167 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_1.conda + sha256: 6dd08a65b8ef162b058dc931aba3bdb6274ba5f05b6c86fbd0c23f2eafc7cc47 + md5: 1399af81db60d441e7c6577307d5cf82 depends: - - libcxx >=18.1.8 + - libcxx >=19.1.7 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 794791 - timestamp: 1742451369695 + size: 825628 + timestamp: 1742451285589 - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724 md5: c277e0a4d549b03ac1e9d6cbbe3d017b @@ -4976,53 +5204,53 @@ packages: license_family: BSD size: 107458 timestamp: 1702146414478 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda - sha256: 33ab03438aee65d6aa667cf7d90c91e5e7d734c19a67aa4c7040742c0a13d505 - md5: db0bfbe7dd197b68ad5f30333bae6ce0 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda + sha256: da2080da8f0288b95dd86765c801c6e166c4619b910b11f9a8446fb852438dc2 + md5: 4211416ecba1866fab0c6470986c22d6 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - libgcc >=14 constrains: - - expat 2.7.0.* + - expat 2.7.1.* license: MIT license_family: MIT - size: 74427 - timestamp: 1743431794976 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.0-h240833e_0.conda - sha256: 976f2e23ad2bb2b8e92c99bfa2ead3ad557b17a129b170f7e2dfcf233193dd7e - md5: 026d0a1056ba2a3dbbea6d4b08188676 + size: 74811 + timestamp: 1752719572741 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda + sha256: 689862313571b62ee77ee01729dc093f2bf25a2f99415fcfe51d3a6cd31cce7b + md5: 9fdeae0b7edda62e989557d645769515 depends: - __osx >=10.13 constrains: - - expat 2.7.0.* + - expat 2.7.1.* license: MIT license_family: MIT - size: 71894 - timestamp: 1743431912423 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.0-h286801f_0.conda - sha256: ee550e44765a7bbcb2a0216c063dcd53ac914a7be5386dd0554bd06e6be61840 - md5: 6934bbb74380e045741eb8637641a65b + size: 72450 + timestamp: 1752719744781 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda + sha256: 8fbb17a56f51e7113ed511c5787e0dec0d4b10ef9df921c4fd1cccca0458f648 + md5: b1ca5f21335782f71a8bd69bdc093f67 depends: - __osx >=11.0 constrains: - - expat 2.7.0.* + - expat 2.7.1.* license: MIT license_family: MIT - size: 65714 - timestamp: 1743431789879 -- conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.0-he0c23c2_0.conda - sha256: 1a227c094a4e06bd54e8c2f3ec40c17ff99dcf3037d812294f842210aa66dbeb - md5: b6f5352fdb525662f4169a0431d2dd7a + size: 65971 + timestamp: 1752719657566 +- conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda + sha256: 8432ca842bdf8073ccecf016ccc9140c41c7114dc4ec77ca754551c01f780845 + md5: 3608ffde260281fa641e70d6e34b1b96 depends: - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 constrains: - - expat 2.7.0.* + - expat 2.7.1.* license: MIT license_family: MIT - size: 140896 - timestamp: 1743432122520 + size: 141322 + timestamp: 1752719767870 - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda sha256: 764432d32db45466e87f10621db5b74363a9f847d2b8b1f9743746cd160f06ab md5: ede4673863426c0883c0063d853bbd85 @@ -5062,167 +5290,175 @@ packages: license_family: MIT size: 44978 timestamp: 1743435053850 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_3.conda - sha256: 59a87161212abe8acc57d318b0cc8636eb834cdfdfddcf1f588b5493644b39a3 - md5: 9e60c55e725c20d23125a5f0dd69af5d +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.1.0-h767d61c_5.conda + sha256: 0caed73aac3966bfbf5710e06c728a24c6c138605121a3dacb2e03440e8baa6a + md5: 264fbfba7fb20acf3b29cde153e345ce depends: - __glibc >=2.17,<3.0.a0 - _openmp_mutex >=4.5 constrains: - - libgcc-ng ==15.1.0=*_3 - - libgomp 15.1.0 h767d61c_3 + - libgomp 15.1.0 h767d61c_5 + - libgcc-ng ==15.1.0=*_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 824921 - timestamp: 1750808216066 -- conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_3.conda - sha256: 05978c4e8c826dd3b727884e009a19ceee75b0a530c18fc14f0ba56b090f2ea3 - md5: d8314be93c803e2e2b430f6389d6ce6a + license_family: GPL + size: 824191 + timestamp: 1757042543820 +- conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.1.0-h1383e82_5.conda + sha256: 9b997baa85ba495c04e1b30f097b80420c02dcaca6441c4bf2c6bb4b2c5d2114 + md5: c84381a01ede0e28d632fdbeea2debb2 depends: - _openmp_mutex >=4.5 - libwinpthread >=12.0.0.r4.gg4f2fc60ca constrains: - - libgomp 15.1.0 h1383e82_3 + - libgomp 15.1.0 h1383e82_5 - msys2-conda-epoch <0.0a0 - - libgcc-ng ==15.1.0=*_3 + - libgcc-ng ==15.1.0=*_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 669602 - timestamp: 1750808309041 -- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.3.0-hc03c837_102.conda - sha256: 538544a2e0651bfeb0348ca6469b6b608606f6080a0b5a531af3a3852fec0215 - md5: 4c1d6961a6a54f602ae510d9bf31fa60 + license_family: GPL + size: 668284 + timestamp: 1757042801517 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-h85bb3a7_105.conda + sha256: 74a6df8c3c93112dd6102a5774c68074ffeba6aacf0333c77feff2eed21b4465 + md5: 24c5b3d0cf4c560bb2bad01dda68cfbf depends: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 2597400 - timestamp: 1740240211859 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_3.conda - sha256: b0b0a5ee6ce645a09578fc1cb70c180723346f8a45fdb6d23b3520591c6d6996 - md5: e66f2b8ad787e7beb0f846e4bd7e8493 + size: 2732190 + timestamp: 1757038947822 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.1.0-h69a702a_5.conda + sha256: f54bb9c3be12b24be327f4c1afccc2969712e0b091cdfbd1d763fb3e61cda03f + md5: 069afdf8ea72504e48d23ae1171d951c depends: - - libgcc 15.1.0 h767d61c_3 + - libgcc 15.1.0 h767d61c_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 29033 - timestamp: 1750808224854 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_3.conda - sha256: 77dd1f1efd327e6991e87f09c7c97c4ae1cfbe59d9485c41d339d6391ac9c183 - md5: bfbca721fd33188ef923dfe9ba172f29 + license_family: GPL + size: 29187 + timestamp: 1757042549554 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.1.0-h69a702a_5.conda + sha256: 4c1a526198d0d62441549fdfd668cc8e18e77609da1e545bdcc771dd8dc6a990 + md5: 0c91408b3dec0b97e8a3c694845bd63b depends: - - libgfortran5 15.1.0 hcea5267_3 + - libgfortran5 15.1.0 hcea5267_5 constrains: - - libgfortran-ng ==15.1.0=*_3 + - libgfortran-ng ==15.1.0=*_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 29057 - timestamp: 1750808257258 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-5.0.0-14_2_0_h51e75f0_103.conda - sha256: 124dcd89508bd16f562d9d3ce6a906336a7f18e963cd14f2877431adee14028e - md5: 090b3c9ae1282c8f9b394ac9e4773b10 + license_family: GPL + size: 29169 + timestamp: 1757042575979 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.1.0-h5f6db21_1.conda + sha256: 844500c9372d455f6ae538ffd3cdd7fda5f53d25a2a6b3ba33060a302c37bc3e + md5: 07cfad6b37da6e79349c6e3a0316a83b depends: - - libgfortran5 14.2.0 h51e75f0_103 + - libgfortran5 15.1.0 hfa3c126_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 156202 - timestamp: 1743862427451 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-5.0.0-14_2_0_h6c33f7e_103.conda - sha256: 8628746a8ecd311f1c0d14bb4f527c18686251538f7164982ccbe3b772de58b5 - md5: 044a210bc1d5b8367857755665157413 + size: 133973 + timestamp: 1756239628906 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.1.0-hfdf1602_1.conda + sha256: 981e3fac416e80b007a2798d6c1d4357ebebeb72a039aca1fb3a7effe9dcae86 + md5: c98207b6e2b1a309abab696d229f163e depends: - - libgfortran5 14.2.0 h6c33f7e_103 + - libgfortran5 15.1.0 hb74de2c_1 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 156291 - timestamp: 1743863532821 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_3.conda - sha256: 2d961f9748d994a4dc9891feae60e182ae9cdce4b0780caaa643e9e3757c7b43 - md5: 6e5d0574e57a38c36e674e9a18eee2b4 + size: 134383 + timestamp: 1756239485494 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-ng-15.1.0-h69a702a_5.conda + sha256: c57134f04fec99dca25a44d90b9ee9494b022650ede931a7d237c65706c67052 + md5: 41a5893c957ffed7f82b4005bc24866c depends: - - libgfortran 15.1.0 h69a702a_3 + - libgfortran 15.1.0 h69a702a_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 29089 - timestamp: 1750808529101 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_3.conda - sha256: eea6c3cf22ad739c279b4d665e6cf20f8081f483b26a96ddd67d4df3c88dfa0a - md5: 530566b68c3b8ce7eec4cd047eae19fe + license_family: GPL + size: 29199 + timestamp: 1757042744369 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.1.0-hcea5267_5.conda + sha256: 9d06adc6d8e8187ddc1cad87525c690bc8202d8cb06c13b76ab2fc80a35ed565 + md5: fbd4008644add05032b6764807ee2cba depends: - __glibc >=2.17,<3.0.a0 - libgcc >=15.1.0 constrains: - libgfortran 15.1.0 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 1565627 - timestamp: 1750808236464 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-14.2.0-h51e75f0_103.conda - sha256: d2ac5e09587e5b21b7bb5795d24f33257e44320749c125448611211088ef8795 - md5: 6183f7e9cd1e7ba20118ff0ca20a05e5 + license_family: GPL + size: 1564589 + timestamp: 1757042559498 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.1.0-hfa3c126_1.conda + sha256: c4bb79d9e9be3e3a335282b50d18a7965e2a972b95508ea47e4086f1fd699342 + md5: 696e408f36a5a25afdb23e862053ca82 depends: - llvm-openmp >=8.0.0 constrains: - - libgfortran 5.0.0 14_2_0_*_103 + - libgfortran 15.1.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 1225013 - timestamp: 1743862382377 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-14.2.0-h6c33f7e_103.conda - sha256: 8599453990bd3a449013f5fa3d72302f1c68f0680622d419c3f751ff49f01f17 - md5: 69806c1e957069f1d515830dcc9f6cbb + size: 1225193 + timestamp: 1756238834726 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.1.0-hb74de2c_1.conda + sha256: 1f8f5b2fdd0d2559d0f3bade8da8f57e9ee9b54685bd6081c6d6d9a2b0239b41 + md5: 4281bd1c654cb4f5cab6392b3330451f depends: - llvm-openmp >=8.0.0 constrains: - - libgfortran 5.0.0 14_2_0_*_103 + - libgfortran 15.1.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 806566 - timestamp: 1743863491726 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.84.2-hbec27ea_0.conda - sha256: 5fcc5e948706cc64e45e2454267f664ed5a1e84f15345aae04a41d852a879c0e - md5: 7bbb8961dca1b4b9f2b01b6e722111a7 + size: 759679 + timestamp: 1756238772083 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.86.0-h1bb475b_0.conda + sha256: 92d17f998e14218810493c9190c8721bf7f7f006bfc5c00dbba1cede83c02f1a + md5: 9e065148e6013b7d7cae64ed01ab7081 depends: - __osx >=11.0 - libffi >=3.4.6,<3.5.0a0 - libiconv >=1.18,<2.0a0 - - libintl >=0.24.1,<1.0a0 + - libintl >=0.25.1,<1.0a0 - libzlib >=1.3.1,<2.0a0 - - pcre2 >=10.45,<10.46.0a0 + - pcre2 >=10.46,<10.47.0a0 constrains: - - glib 2.84.2 *_0 + - glib 2.86.0 *_0 license: LGPL-2.1-or-later - size: 3666180 - timestamp: 1747837044507 -- conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.84.2-hbc94333_0.conda - sha256: 457e297389609ff6886fef88ae7f1f6ea4f4f3febea7dd690662a50983967d6d - md5: fee05801cc5db97bec20a5e78fb3905b + size: 3701880 + timestamp: 1757404501093 +- conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.0-h5f26cbf_0.conda + sha256: 02c2dcf1818d2614ad4472b196a2a7bb06490cd32fd0f43a30997097afca3a12 + md5: 30a7c2c9d7ba29bb1354cd68fcca9cda depends: - libffi >=3.4.6,<3.5.0a0 - libiconv >=1.18,<2.0a0 - libintl >=0.22.5,<1.0a0 - libzlib >=1.3.1,<2.0a0 - - pcre2 >=10.45,<10.46.0a0 + - pcre2 >=10.46,<10.47.0a0 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 constrains: - - glib 2.84.2 *_0 + - glib 2.86.0 *_0 license: LGPL-2.1-or-later - size: 3771466 - timestamp: 1747837394297 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_3.conda - sha256: 43710ab4de0cd7ff8467abff8d11e7bb0e36569df04ce1c099d48601818f11d1 - md5: 3cd1a7238a0dd3d0860fdefc496cc854 + size: 3794081 + timestamp: 1757403780432 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.1.0-h767d61c_5.conda + sha256: 125051d51a8c04694d0830f6343af78b556dd88cc249dfec5a97703ebfb1832d + md5: dcd5ff1940cd38f6df777cac86819d60 depends: - __glibc >=2.17,<3.0.a0 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 447068 - timestamp: 1750808138400 -- conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_3.conda - sha256: 2e6e286c817d2274b109c448f63d804dcc85610c5abf97e183440aa2d84b8c72 - md5: 94545e52b3d21a7ab89961f7bda3da0d + license_family: GPL + size: 447215 + timestamp: 1757042483384 +- conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.1.0-h1383e82_5.conda + sha256: 65fd558d8f3296e364b8ae694932a64642fdd26d8eb4cf7adf08941e449be926 + md5: eae9a32a85152da8e6928a703a514d35 depends: - libwinpthread >=12.0.0.r4.gg4f2fc60ca constrains: - msys2-conda-epoch <0.0a0 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 535456 - timestamp: 1750808243424 + license_family: GPL + size: 535560 + timestamp: 1757042749206 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhiredis-1.0.2-h2cc385e_0.tar.bz2 sha256: ee39c69df4fb39cfe1139ac4f7405bb066eba773e11ba3ab7c33835be00c2e48 md5: b34907d3a81a3cd8095ee83d174c074a @@ -5267,72 +5503,73 @@ packages: license_family: BSD size: 56988 timestamp: 1633982299028 -- conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.11.2-default_ha69328c_1001.conda - sha256: 850e255997f538d5fb6ed651321141155a33bb781d43d326fc4ff62114dd2842 - md5: b87a0ac5ab6495d8225db5dc72dd21cd +- conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.12.1-default_h64bd3f2_1002.conda + sha256: 266dfe151066c34695dbdc824ba1246b99f016115ef79339cbcf005ac50527c1 + md5: b0cac6e5b06ca5eeb14b4f7cf908619f depends: - libwinpthread >=12.0.0.r4.gg4f2fc60ca - - libxml2 >=2.13.4,<2.14.0a0 + - libxml2 + - libxml2-16 >=2.14.6 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD - size: 2390021 - timestamp: 1731375651179 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda - sha256: 18a4afe14f731bfb9cf388659994263904d20111e42f841e9eea1bb6f91f4ab4 - md5: e796ff8ddc598affdf7c173d6145f087 + size: 2414731 + timestamp: 1757624335056 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + sha256: c467851a7312765447155e071752d7bf9bf44d610a5687e32706f480aad2833f + md5: 915f5995e94f60e9a4826e0b0920ee88 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - libgcc >=14 license: LGPL-2.1-only - size: 713084 - timestamp: 1740128065462 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h4b5e92a_1.conda - sha256: c2a9c65a245c7bcb8c17c94dd716dad2d42b7c98e0c17cc5553a5c60242c4dda - md5: 6283140d7b2b55b6b095af939b71b13f + size: 790176 + timestamp: 1754908768807 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + sha256: a1c8cecdf9966921e13f0ae921309a1f415dfbd2b791f2117cf7e8f5e61a48b6 + md5: 210a85a1119f97ea7887188d176db135 depends: - __osx >=10.13 license: LGPL-2.1-only - size: 669052 - timestamp: 1740128415026 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-hfe07756_1.conda - sha256: d30780d24bf3a30b4f116fca74dedb4199b34d500fe6c52cced5f8cc1e926f03 - md5: 450e6bdc0c7d986acf7b8443dce87111 + size: 737846 + timestamp: 1754908900138 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + sha256: de0336e800b2af9a40bdd694b03870ac4a848161b35c8a2325704f123f185f03 + md5: 4d5a7445f0b25b6a3ddbb56e790f5251 depends: - __osx >=11.0 license: LGPL-2.1-only - size: 681804 - timestamp: 1740128227484 -- conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-h135ad9c_1.conda - sha256: ea5ed2b362b6dbc4ba7188eb4eaf576146e3dfc6f4395e9f0db76ad77465f786 - md5: 21fc5dba2cbcd8e5e26ff976a312122c + size: 750379 + timestamp: 1754909073836 +- conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda + sha256: 0dcdb1a5f01863ac4e8ba006a8b0dc1a02d2221ec3319b5915a1863254d7efa7 + md5: 64571d1dd6cdcfa25d0664a5950fdaa2 depends: - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: LGPL-2.1-only - size: 638142 - timestamp: 1740128665984 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.24.1-h27064b9_0.conda - sha256: f0a759b35784d5a31aeaf519f8f24019415321e62e52579a3ec854a413a1509d - md5: b3f498d87404090f731cb6a474045150 + size: 696926 + timestamp: 1754909290005 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + sha256: 8c352744517bc62d24539d1ecc813b9fdc8a785c780197c5f0b84ec5b0dfe122 + md5: a8e54eefc65645193c46e8b180f62d22 depends: - __osx >=10.13 - libiconv >=1.18,<2.0a0 license: LGPL-2.1-or-later - size: 97229 - timestamp: 1746229336518 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.24.1-h493aca8_0.conda - sha256: fb6d211d9e75e6becfbf339d255ea01f7bd3a61fe6237b3dad740de1b74b3b81 - md5: 0dca9914f2722b773c863508723dfe6e + size: 96909 + timestamp: 1753343977382 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + sha256: 99d2cebcd8f84961b86784451b010f5f0a795ed1c08f1e7c76fbb3c22abf021a + md5: 5103f6a6b210a3912faf8d7db516918c depends: - __osx >=11.0 - libiconv >=1.18,<2.0a0 license: LGPL-2.1-or-later - size: 90547 - timestamp: 1746229257769 + size: 90957 + timestamp: 1751558394144 - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda sha256: c7e4600f28bcada8ea81456a6530c2329312519efcf0c886030ada38976b0511 md5: 2cf0cf76cc15d360dfa2f17fd6cf9772 @@ -5426,62 +5663,62 @@ packages: license: LGPL-2.1-or-later size: 132681 timestamp: 1742288893864 -- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-32_h7ac8fdf_openblas.conda - build_number: 32 - sha256: 5b55a30ed1b3f8195dad9020fe1c6d0f514829bfaaf0cf5e393e93682af009f2 - md5: 6c3f04ccb6c578138e9f9899da0bd714 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-36_h47877c9_openblas.conda + build_number: 36 + sha256: 1bbd142b34dfc8cb55e1e37c00e78ebba909542ac1054d22fc54843a94797337 + md5: 55daaac7ecf8ebd169cdbe34dc79549e depends: - - libblas 3.9.0 32_h59b9bed_openblas + - libblas 3.9.0 36_h4a7cf45_openblas constrains: - - libcblas 3.9.0 32*_openblas - - blas 2.132 openblas - - liblapacke 3.9.0 32*_openblas + - liblapacke 3.9.0 36*_openblas + - libcblas 3.9.0 36*_openblas + - blas 2.136 openblas license: BSD-3-Clause license_family: BSD - size: 17316 - timestamp: 1750388820745 -- conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-32_h236ab99_openblas.conda - build_number: 32 - sha256: 1e26450b80525b3f656e9c75fd26a10ebaa1d339fe4ca9c7affbebd9acbeac03 - md5: ccdca0c0730ad795e064d81dbe540723 - depends: - - libblas 3.9.0 32_h7f60823_openblas + size: 17409 + timestamp: 1758396509549 +- conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.9.0-36_h859234e_openblas.conda + build_number: 36 + sha256: 55032855709253ab2dddb9f125091b944de20ab30a6d399c12d0188ed06f3057 + md5: 5614cabd1b003b5287183b3e0f149c7e + depends: + - libblas 3.9.0 36_he492b99_openblas constrains: - - blas 2.132 openblas - - liblapacke 3.9.0 32*_openblas - - libcblas 3.9.0 32*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas + - libcblas 3.9.0 36*_openblas license: BSD-3-Clause license_family: BSD - size: 17553 - timestamp: 1750389051033 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-32_hc9a63f6_openblas.conda - build_number: 32 - sha256: 5e1cfa3581d1dec6b07a75084ff6cfa4b4465c646c6884a71c78a28543f83b61 - md5: bf9ead3fa92fd75ad473c6a1d255ffcb - depends: - - libblas 3.9.0 32_h10e41b3_openblas + size: 17704 + timestamp: 1758397422264 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.9.0-36_hd9741b5_openblas.conda + build_number: 36 + sha256: ffadfc04f5fb9075715fc4db0b6f2e88c23931eb06a193531ee3ba936dedc433 + md5: e0b918b8232902da02c2c5b4eb81f4d5 + depends: + - libblas 3.9.0 36_h51639a9_openblas constrains: - - blas 2.132 openblas - - libcblas 3.9.0 32*_openblas - - liblapacke 3.9.0 32*_openblas + - libcblas 3.9.0 36*_openblas + - liblapacke 3.9.0 36*_openblas + - blas 2.136 openblas license: BSD-3-Clause license_family: BSD - size: 17507 - timestamp: 1750388977861 -- conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-32_h1aa476e_mkl.conda - build_number: 32 - sha256: 5629e592137114b24bfdea71e1c4b6bee11379631409ed91dfe2f83b32a8b298 - md5: 1652285573db93afc3ba9b3b9356e3d3 - depends: - - libblas 3.9.0 32_h641d27c_mkl + size: 17728 + timestamp: 1758397741587 +- conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.9.0-35_hf9ab0e9_mkl.conda + build_number: 35 + sha256: 56e0992fb58eed8f0d5fa165b8621fa150b84aa9af1467ea0a7a9bb7e2fced4f + md5: 0c6ed9d722cecda18f50f17fb3c30002 + depends: + - libblas 3.9.0 35_h5709861_mkl constrains: - - libcblas 3.9.0 32*_mkl - - liblapacke 3.9.0 32*_mkl - - blas 2.132 mkl + - blas 2.135 mkl + - libcblas 3.9.0 35*_mkl + - liblapacke 3.9.0 35*_mkl license: BSD-3-Clause license_family: BSD - size: 3735534 - timestamp: 1750389164366 + size: 78485 + timestamp: 1757003541803 - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda sha256: 590232cd302047023ab31b80458833a71b10aeabee7474304dc65db322b5cd70 md5: 19b71122fea7f6b1c4815f385b2da419 @@ -5524,46 +5761,49 @@ packages: license: LGPL-2.1-or-later size: 25314 timestamp: 1742288893862 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm18-18.1.8-default_h3571c67_5.conda - sha256: 6ea08f3343727d171981be54e92117bea0da4199f227efe47c605e0ee345cf33 - md5: 01dd8559b569ad39b64fef0a61ded1e9 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libllvm19-19.1.7-h56e7563_2.conda + sha256: 375a634873b7441d5101e6e2a9d3a42fec51be392306a03a2fa12ae8edecec1a + md5: 05a54b479099676e75f80ad0ddd38eff depends: - __osx >=10.13 - - libcxx >=18 - - libxml2 >=2.14.0,<2.15.0a0 + - libcxx >=19 + - libxml2 + - libxml2-16 >=2.14.5 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 27768928 - timestamp: 1743989832901 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm18-18.1.8-default_hb458b26_5.conda - sha256: fbc2dd45ef620fd6282a5ad6a25260df921760d717ac727bf62e7702279ec9cc - md5: ce107cf167da0a1abbccc0c8f979ef59 + size: 28801374 + timestamp: 1757354631264 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda + sha256: 46f8ff3d86438c0af1bebe0c18261ce5de9878d58b4fe399a3a125670e4f0af5 + md5: d1d9b233830f6631800acc1e081a9444 depends: - __osx >=11.0 - - libcxx >=18 - - libxml2 >=2.14.0,<2.15.0a0 + - libcxx >=19 + - libxml2 + - libxml2-16 >=2.14.5 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 25982718 - timestamp: 1743989933062 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm20-20.1.7-he9d0ab4_0.conda - sha256: 5c51416c10e84ac6a73560c82e20f99788b1395ce431c450391966d07a444fa6 - md5: 63f1accca4913e6b66a2d546c30ff4db + size: 26914852 + timestamp: 1757353228286 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm21-21.1.2-hf7376ad_0.conda + sha256: 8a18dc5e1d46cb2be46658c3c8c5afba2a3ca9866c679d4a310084d257d7c24f + md5: 85ccb5afca5e1fa67364ea19154e8148 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 - - libstdcxx >=13 - - libxml2 >=2.13.8,<2.14.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libxml2 + - libxml2-16 >=2.14.6 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 43026762 - timestamp: 1749836200754 + size: 44347174 + timestamp: 1758823362425 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda sha256: f2591c0069447bbe28d4d696b7fcb0c5bd0b4ac582769b89addbcf26fb3430d8 md5: 1a580f7796c7bf6393fddb8bbbde58dc @@ -5607,52 +5847,52 @@ packages: license: 0BSD size: 104935 timestamp: 1749230611612 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.64.0-h161d5f1_0.conda - sha256: b0f2b3695b13a989f75d8fd7f4778e1c7aabe3b36db83f0fe80b2cd812c0e975 - md5: 19e57602824042dfd0446292ef90488b +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda + sha256: a4a7dab8db4dc81c736e9a9b42bdfd97b087816e029e221380511960ac46c690 + md5: b499ce4b026493a13774bcf0f4c33849 depends: - __glibc >=2.17,<3.0.a0 - - c-ares >=1.32.3,<2.0a0 + - c-ares >=1.34.5,<2.0a0 - libev >=4.33,<4.34.0a0 - libev >=4.33,<5.0a0 - - libgcc >=13 - - libstdcxx >=13 + - libgcc >=14 + - libstdcxx >=14 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.2,<4.0a0 + - openssl >=3.5.2,<4.0a0 license: MIT license_family: MIT - size: 647599 - timestamp: 1729571887612 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.64.0-hc7306c3_0.conda - sha256: 0dcfdcf3a445d2d7de4f3b186ab0a794dc872f4ea21622f9b997be72712c027f - md5: ab21007194b97beade22ceb7a3f6fee5 + size: 666600 + timestamp: 1756834976695 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + sha256: c48d7e1cc927aef83ff9c48ae34dd1d7495c6ccc1edc4a3a6ba6aff1624be9ac + md5: e7630cef881b1174d40f3e69a883e55f depends: - __osx >=10.13 - - c-ares >=1.34.2,<2.0a0 - - libcxx >=17 + - c-ares >=1.34.5,<2.0a0 + - libcxx >=19 - libev >=4.33,<4.34.0a0 - libev >=4.33,<5.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.2,<4.0a0 + - openssl >=3.5.2,<4.0a0 license: MIT license_family: MIT - size: 606663 - timestamp: 1729572019083 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.64.0-h6d7220d_0.conda - sha256: 00cc685824f39f51be5233b54e19f45abd60de5d8847f1a56906f8936648b72f - md5: 3408c02539cee5f1141f9f11450b6a51 + size: 605680 + timestamp: 1756835898134 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + sha256: a07cb53b5ffa2d5a18afc6fd5a526a5a53dd9523fbc022148bd2f9395697c46d + md5: a4b4dd73c67df470d091312ab87bf6ae depends: - __osx >=11.0 - - c-ares >=1.34.2,<2.0a0 - - libcxx >=17 + - c-ares >=1.34.5,<2.0a0 + - libcxx >=19 - libev >=4.33,<4.34.0a0 - libev >=4.33,<5.0a0 - libzlib >=1.3.1,<2.0a0 - - openssl >=3.3.2,<4.0a0 + - openssl >=3.5.2,<4.0a0 license: MIT license_family: MIT - size: 566719 - timestamp: 1729572385640 + size: 575454 + timestamp: 1756835746393 - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda sha256: 927fe72b054277cde6cb82597d0fcf6baf127dcbce2e0a9d8925a68f1265eef5 md5: d864d34357c3b65a4b731f78c0801dc4 @@ -5663,9 +5903,9 @@ packages: license_family: GPL size: 33731 timestamp: 1750274110928 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_0.conda - sha256: 225f4cfdb06b3b73f870ad86f00f49a9ca0a8a2d2afe59440521fafe2b6c23d9 - md5: 323dc8f259224d13078aaf7ce96c3efe +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.30-pthreads_h94d23a6_2.conda + sha256: 1b51d1f96e751dc945cc06f79caa91833b0c3326efe24e9b506bd64ef49fc9b0 + md5: dfc5aae7b043d9f56ba99514d5e60625 depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 @@ -5675,36 +5915,36 @@ packages: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD - size: 5916819 - timestamp: 1750379877844 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_hbf64a52_0.conda - sha256: 933eb95a778657649a66b0e3cf638d591283159954c5e92b3918d67347ed47a1 - md5: 29c54869a3c7d33b6a0add39c5a325fe + size: 5938936 + timestamp: 1755474342204 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.30-openmp_h83c2472_2.conda + sha256: 341dd45c2e88261f1f9ff76c3410355b4b0e894abe6ac89f7cbf64a3d10f0f01 + md5: 89edf77977f520c4245567460d065821 depends: - __osx >=10.13 - - libgfortran 5.* - - libgfortran5 >=13.3.0 - - llvm-openmp >=18.1.8 + - libgfortran + - libgfortran5 >=14.3.0 + - llvm-openmp >=19.1.7 constrains: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD - size: 6179547 - timestamp: 1750380498501 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_hf332438_0.conda - sha256: 501c8c64f1a6e6b671e49835e6c483bc25f0e7147f3eb4bbb19a4c3673dcaf28 - md5: 5d7dbaa423b4c253c476c24784286e4b + size: 6262457 + timestamp: 1755473612572 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.30-openmp_h60d53f8_2.conda + sha256: 7b8551a4d21cf0b19f9a162f1f283a201b17f1bd5a6579abbd0d004788c511fa + md5: d004259fd8d3d2798b16299d6ad6c9e9 depends: - __osx >=11.0 - - libgfortran 5.* - - libgfortran5 >=13.3.0 - - llvm-openmp >=18.1.8 + - libgfortran + - libgfortran5 >=14.3.0 + - llvm-openmp >=19.1.7 constrains: - openblas >=0.3.30,<0.3.31.0a0 license: BSD-3-Clause license_family: BSD - size: 4163399 - timestamp: 1750378829050 + size: 4284696 + timestamp: 1755471861128 - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda sha256: 50144e87b95d1309d2043aa5bf02035b948b1ae9ec6ec44ee97b7aec1cccd70a md5: fd1d3e26c1b12c70f7449369ae3d9c1a @@ -5812,17 +6052,17 @@ packages: license_family: GPL size: 45026 timestamp: 1742288893862 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.3.0-he8ea267_2.conda - sha256: 27c4c8bf8e2dd60182d47274389be7c70446df6ed5344206266321ee749158b4 - md5: 2b6cdf7bb95d3d10ef4e38ce0bc95dba +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-hd08acf3_5.conda + sha256: 84dc9679d9a228d32f56b2117a32e1c8066b6245cb60278474bda1346a87f228 + md5: 0ec8de71704e3621823a8146d93b71db depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13.3.0 - - libstdcxx >=13.3.0 + - libgcc >=14.3.0 + - libstdcxx >=14.3.0 license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 4155341 - timestamp: 1740240344242 + size: 5133195 + timestamp: 1757039097894 - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda sha256: 24dffff614943c547ba094f8eb03b412a18cc4654663202f1aab9158bfa875ba md5: 63323b258079a75133ccecbb0902614d @@ -5950,44 +6190,45 @@ packages: license_family: GPL size: 181693 timestamp: 1742288893864 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h6cd9bfd_0.conda - sha256: 07649c7c19b916179926006df5c38074618d35bf36cd33ab3fe8b22182bbd258 - md5: b04c7eda6d7dab1e6503135e7fad4d25 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda + sha256: 6d9c32fc369af5a84875725f7ddfbfc2ace795c28f246dc70055a79f9b2003da + md5: 0b367fad34931cb79e0d6b7e5c06bb1c depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - libgcc >=14 - libzlib >=1.3.1,<2.0a0 - license: Unlicense - size: 918887 - timestamp: 1751135622316 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.2-he7d56d0_0.conda - sha256: bd3ab15e14d7e88851c962034d97519a135d86f79f88b3237fbfb34194c114cb - md5: 678284738efc450afcf90f70365f7318 + license: blessing + size: 932581 + timestamp: 1753948484112 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda + sha256: 466366b094c3eb4b1d77320530cbf5400e7a10ab33e4824c200147488eebf7a6 + md5: 156bfb239b6a67ab4a01110e6718cbc4 depends: - __osx >=10.13 - libzlib >=1.3.1,<2.0a0 - license: Unlicense - size: 980106 - timestamp: 1751135725501 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.2-h6fb428d_0.conda - sha256: 6b51a9e7366d6cd26e50d1d0646331d457999ebb88af258f06a74f075e95bf68 - md5: b2dc1707166040e738df2d514f8a1d22 + license: blessing + size: 980121 + timestamp: 1753948554003 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda + sha256: 802ebe62e6bc59fc26b26276b793e0542cfff2d03c086440aeaf72fb8bbcec44 + md5: 1dcb0468f5146e38fae99aef9656034b depends: - __osx >=11.0 + - icu >=75.1,<76.0a0 - libzlib >=1.3.1,<2.0a0 - license: Unlicense - size: 901519 - timestamp: 1751135765345 -- conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.2-hf5d6505_0.conda - sha256: d136ecf423f83208156daa6a8c1de461a7e9780e8e4423c23c7e136be3c2ff0a - md5: e1e6cac409e95538acdc3d33a0f34d6a + license: blessing + size: 902645 + timestamp: 1753948599139 +- conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda + sha256: 5dc4f07b2d6270ac0c874caec53c6984caaaa84bc0d3eb593b0edf3dc8492efa + md5: ccb20d946040f86f0c05b644d5eadeca depends: - ucrt >=10.0.20348.0 - vc >=14.3,<15 - vc14_runtime >=14.44.35208 - license: Unlicense - size: 1285981 - timestamp: 1751135695346 + license: blessing + size: 1288499 + timestamp: 1753948889360 - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda sha256: fa39bfd69228a13e553bd24601332b7cfeb30ca11a3ca50bb028108fe90a7661 md5: eecce068c7e4eddeb169591baac20ac4 @@ -6034,32 +6275,34 @@ packages: license_family: BSD size: 292785 timestamp: 1745608759342 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_3.conda - sha256: 7650837344b7850b62fdba02155da0b159cf472b9ab59eb7b472f7bd01dff241 - md5: 6d11a5edae89fe413c0569f16d308f5a +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.1.0-h8f9b012_5.conda + sha256: 0f5f61cab229b6043541c13538d75ce11bd96fb2db76f94ecf81997b1fde6408 + md5: 4e02a49aaa9d5190cb630fa43528fbe6 depends: - __glibc >=2.17,<3.0.a0 - - libgcc 15.1.0 h767d61c_3 + - libgcc 15.1.0 h767d61c_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 3896407 - timestamp: 1750808251302 -- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.3.0-hc03c837_102.conda - sha256: abc89056d4ca7debe938504b3b6d9ccc6d7a0f0b528fe3409230636a21e81002 - md5: aa38de2738c5f4a72a880e3d31ffe8b4 + license_family: GPL + size: 3896432 + timestamp: 1757042571458 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h85bb3a7_105.conda + sha256: 615854047a257b1cb55e6052dfc9770bfe4c9ddb13343c5cd11cb833afa4596e + md5: 11b288dbf8b62753f7e7fc9d033bcd82 depends: - __unix license: GPL-3.0-only WITH GCC-exception-3.1 license_family: GPL - size: 12873130 - timestamp: 1740240239655 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_3.conda - sha256: bbaea1ecf973a7836f92b8ebecc94d3c758414f4de39d2cc6818a3d10cb3216b - md5: 57541755b5a51691955012b8e197c06c + size: 14584026 + timestamp: 1757038976267 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.1.0-h4852527_5.conda + sha256: 7b8cabbf0ab4fe3581ca28fe8ca319f964078578a51dd2ca3f703c1d21ba23ff + md5: 8bba50c7f4679f08c861b597ad2bda6b depends: - - libstdcxx 15.1.0 h8f9b012_3 + - libstdcxx 15.1.0 h8f9b012_5 license: GPL-3.0-only WITH GCC-exception-3.1 - size: 29093 - timestamp: 1750808292700 + license_family: GPL + size: 29233 + timestamp: 1757042603319 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda sha256: d8f32a0b0ee17fbace7af4bd34ad554cc855b9c18e0aeccf8395e1478c161f37 md5: 57ae1dd979da7aa88a9b38bfa2e1d6b2 @@ -6170,54 +6413,55 @@ packages: license_family: GPL size: 361450 timestamp: 1742288893864 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda - sha256: 787eb542f055a2b3de553614b25f09eefb0a0931b0c87dbcce6efdfd92f04f18 - md5: 40b61aab5c7ba9ff276c41cfffe6b80b +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + sha256: e5ec6d2ad7eef538ddcb9ea62ad4346fde70a4736342c4ad87bd713641eb9808 + md5: 80c07c68d2f6870250959dcc95b209d1 depends: - - libgcc-ng >=12 + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 license: BSD-3-Clause license_family: BSD - size: 33601 - timestamp: 1680112270483 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb9d3cd8_0.conda - sha256: 770ca175d64323976c9fe4303042126b2b01c1bd54c8c96cafeaba81bdb481b8 - md5: 1349c022c92c5efd3fd705a79a5804d8 + size: 37135 + timestamp: 1758626800002 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.51.0-hb03c661_1.conda + sha256: c180f4124a889ac343fc59d15558e93667d894a966ec6fdb61da1604481be26b + md5: 0f03292cc56bf91a077a134ea8747118 depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - libgcc >=14 license: MIT license_family: MIT - size: 890145 - timestamp: 1748304699136 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h4cb831e_0.conda - sha256: 2c820c8e26d680f74035f58c3d46593461bb8aeefa00faafa5ca39d8a51c87fa - md5: 8afd5432c2e6776d145d94f4ea4d4db5 + size: 895108 + timestamp: 1753948278280 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libuv-1.51.0-h58003a5_1.conda + sha256: d90dd0eee6f195a5bd14edab4c5b33be3635b674b0b6c010fb942b956aa2254c + md5: fbfc6cf607ae1e1e498734e256561dc3 depends: - - __osx >=11.0 + - __osx >=10.13 license: MIT license_family: MIT - size: 420355 - timestamp: 1748304826637 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h5505292_0.conda - sha256: 41c1230a3f4e0d265e5053c671f112a16be4405b9047d3da5581e03e9d53de65 - md5: 230a885fe67a3e945a4586b944b6020a + size: 422612 + timestamp: 1753948458902 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.51.0-h6caf38d_1.conda + sha256: 042c7488ad97a5629ec0a991a8b2a3345599401ecc75ad6a5af73b60e6db9689 + md5: c0d87c3c8e075daf1daf6c31b53e8083 depends: - __osx >=11.0 license: MIT license_family: MIT - size: 420654 - timestamp: 1748304893204 -- conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-h2466b09_0.conda - sha256: b03ca3d0cfbf8b3911757411a10fbbaa7edae62bb81972ae44360e7ac347aac2 - md5: 9756651456477241b0226fb0ee051c58 + size: 421195 + timestamp: 1753948426421 +- conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.51.0-hfd05255_1.conda + sha256: f03dc82e6fb1725788e73ae97f0cd3d820d5af0d351a274104a0767035444c59 + md5: 31e1545994c48efc3e6ea32ca02a8724 depends: - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: MIT license_family: MIT - size: 293576 - timestamp: 1748305181284 + size: 297087 + timestamp: 1753948490874 - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_9.conda sha256: 373f2973b8a358528b22be5e8d84322c165b4c5577d24d94fd67ad1bb0a0f261 md5: 08bfa5da6e242025304b206d152479ef @@ -6237,59 +6481,128 @@ packages: license: LGPL-2.1-or-later size: 100393 timestamp: 1702724383534 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.8-h4bc477f_0.conda - sha256: b0b3a96791fa8bb4ec030295e8c8bf2d3278f33c0f9ad540e73b5e538e6268e7 - md5: 14dbe05b929e329dbaa6f2d0aa19466d +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.0-h26afc86_1.conda + sha256: 4310577d7eea817d35a1c05e1e54575b06ce085d73e6dd59aa38523adf50168f + md5: 8337b675e0cad517fbcb3daf7588087a depends: - __glibc >=2.17,<3.0.a0 - icu >=75.1,<76.0a0 - - libgcc >=13 + - libgcc >=14 - libiconv >=1.18,<2.0a0 - liblzma >=5.8.1,<6.0a0 + - libxml2-16 2.15.0 ha9997c6_1 - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT - size: 690864 - timestamp: 1746634244154 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.14.4-h8c082e5_0.conda - sha256: ea776f5c322f520dfefe375b8919e758f2f0cbac2669460e6b91281f1ecb3c69 - md5: d8cb1f6b03a0a52667d32094b67ed612 + size: 45363 + timestamp: 1758640621036 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h7b7ecba_1.conda + sha256: 6b8afb05b49363bf96c949c3b2307352a45c3114d78ab26cf1d8ea5306a3521d + md5: e17e6af7b422e930283583498bed58fc depends: - __osx >=10.13 - icu >=75.1,<76.0a0 - libiconv >=1.18,<2.0a0 - liblzma >=5.8.1,<6.0a0 + - libxml2-16 2.15.0 ha1d9b0f_1 - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT - size: 593480 - timestamp: 1750114404508 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.14.4-h19f518e_0.conda - sha256: a170b146f4e319abb575f6154126902c5d8dab1880711003ab6a9e8f47b12947 - md5: 56ecaa1d873bd99f5734ab10914e8232 + size: 40330 + timestamp: 1758640928591 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda + sha256: 5714b6c1fdd7a981a027d4951e111b1826cc746a02405a0c15b0f95f984e274c + md5: 738e842efb251f6efd430f47432bf0ee depends: - __osx >=11.0 - icu >=75.1,<76.0a0 - libiconv >=1.18,<2.0a0 - liblzma >=5.8.1,<6.0a0 + - libxml2-16 2.15.0 h0ff4647_1 - libzlib >=1.3.1,<2.0a0 license: MIT license_family: MIT - size: 566440 - timestamp: 1750114417177 -- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.13.8-h442d1da_0.conda - sha256: 473b8a53c8df714d676ab41711551c8d250f8d799f2db5cb7cb2b177a0ce13f6 - md5: 833c2dbc1a5020007b520b044c713ed3 + size: 40624 + timestamp: 1758641317371 +- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda + sha256: 8890c03908a407649ac99257b63176b61d10dfa3468aa3db1994ac0973dc2803 + md5: 1d6e5fbbe84eebcd62e7cdccec799ce8 depends: + - icu >=75.1,<76.0a0 - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libxml2-16 2.15.0 h06f855e_1 - libzlib >=1.3.1,<2.0a0 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: MIT + license_family: MIT + size: 43274 + timestamp: 1758641414853 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.0-ha9997c6_1.conda + sha256: 5420ea77505a8d5ca7b5351ddb2da7e8a178052fccf8fca00189af7877608e89 + md5: b24dd2bd61cd8e4f8a13ee2a945a723c + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=75.1,<76.0a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + constrains: + - libxml2 2.15.0 + license: MIT + license_family: MIT + size: 556276 + timestamp: 1758640612398 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-ha1d9b0f_1.conda + sha256: 49d847ef187734b8f4e771483803f55f5f41d4855b62e9d16968b2024298fb2b + md5: 2512444ac2678ed260abe03d1c17713c + depends: + - __osx >=10.13 + - icu >=75.1,<76.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + constrains: + - libxml2 2.15.0 + license: MIT + license_family: MIT + size: 494295 + timestamp: 1758640913673 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + sha256: 37e85b5a2df4fbd213c5cdf803c57e244722c2dc47300951645c22a2bff6dfe8 + md5: 6b4f950d2dc566afd7382d2380eb2136 + depends: + - __osx >=11.0 + - icu >=75.1,<76.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + constrains: + - libxml2 2.15.0 license: MIT license_family: MIT - size: 1513627 - timestamp: 1746634633560 + size: 464871 + timestamp: 1758641298001 +- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + sha256: f29159eef5af2adffe2fef2d89ff2f6feda07e194883f47a4cf366e9608fb91b + md5: a5d1a1f8745fcd93f39a4b80f389962f + depends: + - icu >=75.1,<76.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - libxml2 2.15.0 + license: MIT + license_family: MIT + size: 518883 + timestamp: 1758641386772 - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda sha256: d4bfe88d7cb447768e31650f06257995601f89076080e76df55e3112d4e47dc4 md5: edb0dca6bc32e4f4789199455a1dbeb8 @@ -6337,92 +6650,99 @@ packages: license_family: Other size: 55476 timestamp: 1727963768015 -- conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-20.1.7-ha54dae1_0.conda - sha256: 18d3b64965c1f5f7cd24a140b3e4f49191dd579cc8ca6d3db220830caf8aae3d - md5: e240159643214102dc88395c4ecee9cf +- conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-21.1.2-h472b3d1_1.conda + sha256: 942957d7542245bfec07a260b417d857a5e6ef7f1cd69a225ce8b422332e854b + md5: b5254429fe03d4ea04e24e6b0f832b82 depends: - __osx >=10.13 constrains: - - openmp 20.1.7|20.1.7.* + - openmp 21.1.2|21.1.2.* + - intel-openmp <0.0a0 license: Apache-2.0 WITH LLVM-exception - license_family: APACHE - size: 306443 - timestamp: 1749892271445 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-20.1.7-hdb05f8b_0.conda - sha256: e7d95b50a90cdc9e0fc38bc37f493a61b9d08164114b562bbd9ff0034f45eca2 - md5: 741e1da0a0798d32e13e3724f2ca2dcf + size: 311200 + timestamp: 1759257822995 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-21.1.2-h4a912ad_1.conda + sha256: 67c7df2cdc08b5a13e72647fbc1294b1288508faf8150a66a48c68154d86fa56 + md5: bff90cf0868f902007fba7a2296f8b92 depends: - __osx >=11.0 constrains: - - openmp 20.1.7|20.1.7.* + - intel-openmp <0.0a0 + - openmp 21.1.2|21.1.2.* license: Apache-2.0 WITH LLVM-exception - license_family: APACHE - size: 281996 - timestamp: 1749892286735 -- conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18.1.8-default_h3571c67_5.conda - sha256: 084f1504b38608542f6ff816f9ff7e7ae9ec38b454604144e8ac0d0ec0415f82 - md5: cc07ff74d2547da1f1452c42b67bafd6 + size: 285742 + timestamp: 1759257497379 +- conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-21.1.2-hfa2b4ca_1.conda + sha256: 9716a6f62a32cd2eff9024a8c3c37e4e1ae426933581fa80880d5560d1e5b19f + md5: 0ebc3911a71866c1458a01f7746b8bc9 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - openmp 21.1.2|21.1.2.* + - intel-openmp <0.0a0 + license: Apache-2.0 WITH LLVM-exception + size: 348138 + timestamp: 1759257834479 +- conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19.1.7-hb0207f0_2.conda + sha256: 8d042ee522bc9eb12c061f5f7e53052aeb4f13e576e624c8bebaf493725b95a0 + md5: 0f79b23c03d80f22ce4fe0022d12f6d2 depends: - __osx >=10.13 - - libllvm18 18.1.8 default_h3571c67_5 - - libxml2 >=2.14.0,<2.15.0a0 - - libzlib >=1.3.1,<2.0a0 - - llvm-tools-18 18.1.8 default_h3571c67_5 - - zstd >=1.5.7,<1.6.0a0 + - libllvm19 19.1.7 h56e7563_2 + - llvm-tools-19 19.1.7 h879f4bc_2 constrains: - - llvm 18.1.8 - - clang-tools 18.1.8 - - llvmdev 18.1.8 - - clang 18.1.8 + - llvmdev 19.1.7 + - llvm 19.1.7 + - clang 19.1.7 + - clang-tools 19.1.7 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 92923 - timestamp: 1743990036185 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18.1.8-default_hb458b26_5.conda - sha256: caa3f3fcc12b84e815a431706634eb850f05eaafc073ca1216e3fd87ec93134c - md5: 704b3d78d5cd327f3ce1372d07be01fd + size: 87962 + timestamp: 1757355027273 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda + sha256: 09750c33b5d694c494cad9eafda56c61a62622264173d760341b49fb001afe82 + md5: 3e3ac06efc5fdc1aa675ca30bf7d53df depends: - __osx >=11.0 - - libllvm18 18.1.8 default_hb458b26_5 - - libxml2 >=2.14.0,<2.15.0a0 - - libzlib >=1.3.1,<2.0a0 - - llvm-tools-18 18.1.8 default_hb458b26_5 - - zstd >=1.5.7,<1.6.0a0 + - libllvm19 19.1.7 h8e0c9ce_2 + - llvm-tools-19 19.1.7 h91fd4e7_2 constrains: - - llvm 18.1.8 - - llvmdev 18.1.8 - - clang-tools 18.1.8 - - clang 18.1.8 + - llvm 19.1.7 + - llvmdev 19.1.7 + - clang-tools 19.1.7 + - clang 19.1.7 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 92544 - timestamp: 1743990114058 -- conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-18-18.1.8-default_h3571c67_5.conda - sha256: 80e64944776325ebf5c30d3bd588bb29768c589418286ddfb277818a32161128 - md5: 4391981e855468ced32ca1940b3d7613 + size: 88390 + timestamp: 1757353535760 +- conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-tools-19-19.1.7-h879f4bc_2.conda + sha256: fd281acb243323087ce672139f03a1b35ceb0e864a3b4e8113b9c23ca1f83bf0 + md5: bf644c6f69854656aa02d1520175840e depends: - __osx >=10.13 - - libllvm18 18.1.8 default_h3571c67_5 - - libxml2 >=2.14.0,<2.15.0a0 + - libcxx >=19 + - libllvm19 19.1.7 h56e7563_2 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 25076183 - timestamp: 1743989960006 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-18-18.1.8-default_hb458b26_5.conda - sha256: 5e12079d864b5ab523cb18e3b9f37dd4764d67a2dfc4450b49b3ad8ebd9cd4d8 - md5: c8734b82ae16cf86b7f74140f09f9121 + size: 17198870 + timestamp: 1757354915882 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda + sha256: 73f9506f7c32a448071340e73a0e8461e349082d63ecc4849e3eb2d1efc357dd + md5: 8237b150fcd7baf65258eef9a0fc76ef depends: - __osx >=11.0 - - libllvm18 18.1.8 default_hb458b26_5 - - libxml2 >=2.14.0,<2.15.0a0 + - libcxx >=19 + - libllvm19 19.1.7 h8e0c9ce_2 - libzlib >=1.3.1,<2.0a0 - zstd >=1.5.7,<1.6.0a0 license: Apache-2.0 WITH LLVM-exception license_family: Apache - size: 23239573 - timestamp: 1743990043950 + size: 16376095 + timestamp: 1757353442671 - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-hd0bcaf9_1007.conda sha256: e8a00971e6d00bd49f375c5d8d005b37a9abba0b1768533aed0f90a422bf5cc7 md5: 28eb714416de4eb83e2cbc47e99a1b45 @@ -6463,16 +6783,16 @@ packages: license_family: APACHE size: 4139214 timestamp: 1728064718935 -- conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h66d3029_15.conda - sha256: 20e52b0389586d0b914a49cd286c5ccc9c47949bed60ca6df004d1d295f2edbd - md5: 302dff2807f2927b3e9e0d19d60121de +- conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2024.2.2-h57928b3_16.conda + sha256: ce841e7c3898764154a9293c0f92283c1eb28cdacf7a164c94b632a6af675d91 + md5: 5cddc979c74b90cf5e5cda4f97d5d8bb depends: - - intel-openmp 2024.* + - llvm-openmp >=20.1.8 - tbb 2021.* license: LicenseRef-IntelSimplifiedSoftwareOct2022 license_family: Proprietary - size: 103106385 - timestamp: 1730232843711 + size: 103088799 + timestamp: 1753975600547 - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.1-h90cbb55_3.conda sha256: f25d2474dd557ca66c6231c8f5ace5af312efde1ba8290a6ea5e1732a4e669c0 md5: 2eeb50cab6652538eee8fc0bc3340c81 @@ -6541,51 +6861,51 @@ packages: license: X11 AND BSD-3-Clause size: 797030 timestamp: 1738196177597 -- conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.0-h7aa8ee6_0.conda - sha256: 8cf09470430b5aba5165c7aefed070d2c8f998f69fede01197ef838bf17fa81a - md5: 2f67cb5c5ec172faeba94348ae8af444 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.1-h171cf75_0.conda + sha256: 1522b6d4a55af3b5a4475db63a608aad4c250af9f05050064298dcebe5957d38 + md5: 6567fa1d9ca189076d9443a0b125541c depends: + - libstdcxx >=14 + - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - libstdcxx >=13 - - libgcc >=13 license: Apache-2.0 license_family: APACHE - size: 180917 - timestamp: 1750273173789 -- conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.0-h46ed394_0.conda - sha256: 54c54518255a263a2ce5a6baf607eca3b27f2748e2a14f49c75c2d510523d8b1 - md5: 848bfbf62bdff777ff8343250f36a117 + size: 186326 + timestamp: 1752218296032 +- conda: https://conda.anaconda.org/conda-forge/osx-64/ninja-1.13.1-h0ba0a54_0.conda + sha256: e920fc52ab18d8bd03d26e9ffe6a44ae1683d2811eaef8289051a34b738a799a + md5: 71576ca895305a20c73304fcb581ae1a depends: - - libcxx >=18 - __osx >=10.13 + - libcxx >=19 license: Apache-2.0 license_family: APACHE - size: 179898 - timestamp: 1750273170709 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.0-ha024513_0.conda - sha256: 2715f956c17f4c4240972567f710dea93f0ffe3073fb9bd0d636eba15c3ab2e6 - md5: 91f96a6daf4c14e45b3bbc71e3b8e1f8 + size: 177958 + timestamp: 1752218300571 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.1-h4f10f1e_0.conda + sha256: 6a8648c1079c3fd23f330b1b8657ae9ed8df770a228829dbf02ae5df382d0c3d + md5: 3d1eafa874408ac6a75cf1d40506cf77 depends: - - libcxx >=18 + - libcxx >=19 - __osx >=11.0 license: Apache-2.0 license_family: APACHE - size: 165419 - timestamp: 1750273167832 -- conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.0-h79cd779_0.conda - sha256: acc01920be9a0d3d1363843601353d5c41322fe47bb719065cfe01095ef51bbc - md5: fb5cb20bc807076f05ac18a628322fd7 + size: 164392 + timestamp: 1752218330593 +- conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.1-h477610d_0.conda + sha256: c5d1da3a21e1749286dba462e05be817bfb9ff50597e6f13645c98138a50cd56 + md5: b8a603d4b32e113e3551b257b677de67 depends: - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 license: Apache-2.0 license_family: APACHE - size: 305926 - timestamp: 1750273199104 + size: 309517 + timestamp: 1752218329097 - conda: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 md5: 7ba3f09fceae6a120d664217e58fe686 @@ -6614,23 +6934,24 @@ packages: license_family: BSD size: 7925462 timestamp: 1732314760363 -- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py312h6cf2f7f_0.conda - sha256: 731325aea31b3825c8c1b371f4314c096f7981de1c2cc276a7931f889b5bb6d8 - md5: 7e086a30150af2536a1059885368dcf0 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.3-py312h33ff503_0.conda + sha256: 8443315a60500ea8e3d7ecd9756cee07a60b8c3497e0fc98884963c3108f8bef + md5: 261a82ff799db441c7122f6a83ade061 depends: + - python + - libstdcxx >=14 + - libgcc >=14 - __glibc >=2.17,<3.0.a0 - - libblas >=3.9.0,<4.0a0 - - libcblas >=3.9.0,<4.0a0 - - libgcc >=13 - liblapack >=3.9.0,<4.0a0 - - libstdcxx >=13 - - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 constrains: - numpy-base <0a0 license: BSD-3-Clause - size: 8364184 - timestamp: 1751342617648 + license_family: BSD + size: 8786490 + timestamp: 1757505242032 - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.0.2-py39h277832c_1.conda sha256: 3b787112f7da8036c8aeac8ef6c4352496e168ad17f7564224dbab234cbdf8ba md5: d6c114b0d8987c209359b8eb1887a92a @@ -6648,22 +6969,23 @@ packages: license_family: BSD size: 6972004 timestamp: 1732314789731 -- conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.1-py312h3b44349_0.conda - sha256: b06383b035b13ad7edaa307c56591604af4bc65c3c8ef8654534b376a82b7bd0 - md5: 81571392e3badcb8df4d02f143c59326 +- conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.3.3-py312ha3982b3_0.conda + sha256: 4253684725f2725fcbeec6560fda764d7ac41dd729dd4366ffcb0e286279bf51 + md5: 7d3ce4cfccebc8d461cec11ad5f26f21 depends: + - python - __osx >=10.13 + - libcxx >=19 + - python_abi 3.12.* *_cp312 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libcxx >=18 - liblapack >=3.9.0,<4.0a0 - - python >=3.12,<3.13.0a0 - - python_abi 3.12.* *_cp312 constrains: - numpy-base <0a0 license: BSD-3-Clause - size: 7644002 - timestamp: 1751342736297 + license_family: BSD + size: 7945767 + timestamp: 1757504911495 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.0.2-py39h3ba1154_1.conda sha256: f5f4b8cad78dd961e763d7850c338004b57dd5fdad2a0bce7da25e2a9bad45cb md5: 786fc37a306970ceee8d3654be4cf936 @@ -6682,23 +7004,24 @@ packages: license_family: BSD size: 5796232 timestamp: 1732314910635 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.1-py312h113b91d_0.conda - sha256: b9c79d31c214964614e6c70606ff99c7993a1eb1b8743cba484b268a386a5c46 - md5: 84048f61fe33762c214055fb2df161f0 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.3-py312h85ea64e_0.conda + sha256: 432c7f3a62404b72273d04261b9533c450afc753a5375e7c3b99fd6a8ffb4ae6 + md5: 8af18e1aff42c65725ed39f831317099 depends: + - python - __osx >=11.0 - - libblas >=3.9.0,<4.0a0 + - python 3.12.* *_cpython + - libcxx >=19 - libcblas >=3.9.0,<4.0a0 - - libcxx >=18 - liblapack >=3.9.0,<4.0a0 - - python >=3.12,<3.13.0a0 - - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 + - libblas >=3.9.0,<4.0a0 constrains: - numpy-base <0a0 license: BSD-3-Clause - size: 6504304 - timestamp: 1751342649896 + license_family: BSD + size: 6659824 + timestamp: 1757504947913 - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.0.2-py39h60232e0_1.conda sha256: 2c007a74ec5d1ee991e8960b527fab8e67dfc81a3676e41adf03acde75a6565b md5: d8801e13476c0ae89e410307fbc5a612 @@ -6717,113 +7040,117 @@ packages: license_family: BSD size: 6325759 timestamp: 1732315239998 -- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.1-py312h12c3145_0.conda - sha256: 2b0081eedda950026080f5e93fba915f73e75cf0c1c8e483a08cde82b3cf0a27 - md5: f11fc3fd4a1d4615cc84e50046c661ed +- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.3-py312ha72d056_0.conda + sha256: 7e27c95af8414c1068933528d54be2441ec0414a9397f3cfea916d00d56fd860 + md5: e3ac06748b6249e42c3cf4d670b7adcb depends: - - libblas >=3.9.0,<4.0a0 - - libcblas >=3.9.0,<4.0a0 - - liblapack >=3.9.0,<4.0a0 - - python >=3.12,<3.13.0a0 - - python_abi 3.12.* *_cp312 + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 - ucrt >=10.0.20348.0 - vc >=14.3,<15 - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.12.* *_cp312 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 constrains: - numpy-base <0a0 license: BSD-3-Clause - size: 7070261 - timestamp: 1751342914306 -- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.0-h7b32b05_1.conda - sha256: b4491077c494dbf0b5eaa6d87738c22f2154e9277e5293175ec187634bd808a0 - md5: de356753cfdbffcde5bb1e86e3aa6cd0 + license_family: BSD + size: 7376440 + timestamp: 1757504921203 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.3-h26f9b46_1.conda + sha256: 0572be1b7d3c4f4c288bb8ab1cb6007b5b8b9523985b34b862b5222dea3c45f5 + md5: 4fc6c4c88da64c0219c0c6c0408cedd4 depends: - __glibc >=2.17,<3.0.a0 - ca-certificates - - libgcc >=13 + - libgcc >=14 license: Apache-2.0 license_family: Apache - size: 3117410 - timestamp: 1746223723843 -- conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.0-hc426f3f_1.conda - sha256: bcac94cb82a458b4e3164da8d9bced08cc8c3da2bc3bd7330711a3689c1464a5 - md5: 919faa07b9647beb99a0e7404596a465 + size: 3128517 + timestamp: 1758597915858 +- conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.3-h230baf5_1.conda + sha256: 8eeb0d7e01784c1644c93947ba5e6e55d79f9f9c8dd53b33a6523efb93afd56c + md5: f601470d724024fec8dbb98a2dd5b39c depends: - __osx >=10.13 - ca-certificates license: Apache-2.0 license_family: Apache - size: 2739181 - timestamp: 1746224401118 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.0-h81ee809_1.conda - sha256: 73d366c1597a10bcd5f3604b5f0734b31c23225536e03782c6a13f9be9d01bff - md5: 5c7aef00ef60738a14e0e612cfc5bcde + size: 2742974 + timestamp: 1758599496115 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.3-h5503f6c_1.conda + sha256: d5499ee2611a0ca9d84e9d60a5978d1f17350e94915c89026f5d9346ccf0a987 + md5: 4b23b1e2aa9d81b16204e1304241ccae depends: - __osx >=11.0 - ca-certificates license: Apache-2.0 license_family: Apache - size: 3064197 - timestamp: 1746223530698 -- conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.0-ha4e3fda_1.conda - sha256: 02846553d2a4c9bde850c60824d0f02803eb9c9b674d5c1a8cce25bc387e748f - md5: 72c07e46b6766bb057018a9a74861b89 + size: 3069376 + timestamp: 1758598263612 +- conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.3-h725018a_1.conda + sha256: 72dc204b0d59a7262bc77ca0e86cba11cbc6706cb9b4d6656fe7fab9593347c9 + md5: c84884e2c1f899de9a895a1f0b7c9cd8 depends: - ca-certificates - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: Apache - size: 9025176 - timestamp: 1746227349882 -- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda - sha256: 27c4014f616326240dcce17b5f3baca3953b6bc5f245ceb49c3fa1e6320571eb - md5: b90bece58b4c2bf25969b70f3be42d25 + size: 9276051 + timestamp: 1758599639304 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda + sha256: 5c7380c8fd3ad5fc0f8039069a45586aa452cf165264bc5a437ad80397b32934 + md5: 7fa07cb0fb1b625a089ccc01218ee5b1 depends: - __glibc >=2.17,<3.0.a0 - bzip2 >=1.0.8,<2.0a0 - - libgcc >=13 + - libgcc >=14 - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD - size: 1197308 - timestamp: 1745955064657 -- conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.45-hf733adb_0.conda - sha256: 5b2c93ee8714c17682cd926127f1e712efef00441a79732635a80b24f5adc212 - md5: d9f1976154f2f45588251dcfc48bcdda + size: 1209177 + timestamp: 1756742976157 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.46-ha3e7e28_0.conda + sha256: cb262b7f369431d1086445ddd1f21d40003bb03229dfc1d687e3a808de2663a6 + md5: 3b504da3a4f6d8b2b1f969686a0bf0c0 depends: - __osx >=10.13 - bzip2 >=1.0.8,<2.0a0 - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD - size: 1086588 - timestamp: 1745955211398 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.45-ha881caa_0.conda - sha256: e9ecb706b58b5a2047c077b3a1470e8554f3aad02e9c3c00cfa35d537420fea3 - md5: a52385b93558d8e6bbaeec5d61a21cd7 + size: 1097626 + timestamp: 1756743061564 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.46-h7125dd6_0.conda + sha256: 5bf2eeaa57aab6e8e95bea6bd6bb2a739f52eb10572d8ed259d25864d3528240 + md5: 0e6e82c3cc3835f4692022e9b9cd5df8 depends: - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - libzlib >=1.3.1,<2.0a0 license: BSD-3-Clause license_family: BSD - size: 837826 - timestamp: 1745955207242 -- conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.45-h99c9b8b_0.conda - sha256: 165d6f76e7849615cfa5fe5f0209b90103102db17a7b4632f933fa9c0e8d8bfe - md5: f4c483274001678e129f5cbaf3a8d765 + size: 835080 + timestamp: 1756743041908 +- conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.46-h3402e2f_0.conda + sha256: 29c2ed44a8534d27faad96bdce16efe29c2788f556f4c5409d4ae8ae074681ec + md5: 889053e920d15353c2665fa6310d7a7a depends: - bzip2 >=1.0.8,<2.0a0 - libzlib >=1.3.1,<2.0a0 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD - size: 1040584 - timestamp: 1745955875845 + size: 1034703 + timestamp: 1756743085974 - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-7_hd590300_perl5.conda build_number: 7 sha256: 9ec32b6936b0e37bcb0ed34f22ec3116e75b3c0964f9f50ecea5f58734ed6ce9 @@ -6891,19 +7218,19 @@ packages: license_family: GPL size: 36118 timestamp: 1720806338740 -- conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.8-pyhe01879c_0.conda - sha256: 0f48999a28019c329cd3f6fd2f01f09fc32cc832f7d6bbe38087ddac858feaa3 - md5: 424844562f5d337077b445ec6b1398a7 +- conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.4.0-pyhcf101f3_0.conda + sha256: dfe0fa6e351d2b0cef95ac1a1533d4f960d3992f9e0f82aeb5ec3623a699896b + md5: cc9d9a3929503785403dbfad9f707145 depends: - - python >=3.9 + - python >=3.10 - python license: MIT license_family: MIT - size: 23531 - timestamp: 1746710438805 -- conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.2.0-pyha770c72_0.conda - sha256: d0bd8cce5f31ae940934feedec107480c00f67e881bf7db9d50c6fc0216a2ee0 - md5: 17e487cc8b5507cd3abc09398cf27949 + size: 23653 + timestamp: 1756227402815 +- conda: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: bc6c44af2a9e6067dd7e949ef10cdfba depends: - cfgv >=2.0.0 - identify >=1.0.0 @@ -6913,8 +7240,8 @@ packages: - virtualenv >=20.10.0 license: MIT license_family: MIT - size: 195854 - timestamp: 1742475656293 + size: 195839 + timestamp: 1754831350570 - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda sha256: 79db7928d13fab2d892592223d7570f5061c192f27b9febd1a418427b719acc6 md5: 12c566707c80111f9799308d9e265aef @@ -7103,42 +7430,42 @@ packages: license: Python-2.0 size: 16971365 timestamp: 1749059542957 -- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-7_cp312.conda - build_number: 7 - sha256: a1bbced35e0df66cc713105344263570e835625c28d1bdee8f748f482b2d7793 - md5: 0dfcdc155cf23812a0c9deada86fb723 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.12-8_cp312.conda + build_number: 8 + sha256: 80677180dd3c22deb7426ca89d6203f1c7f1f256f2d5a94dc210f6e758229809 + md5: c3efd25ac4d74b1584d2f7a57195ddf1 constrains: - python 3.12.* *_cpython license: BSD-3-Clause license_family: BSD - size: 6971 - timestamp: 1745258861359 -- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-7_cp39.conda - build_number: 7 - sha256: c536863bdc2d7e551b589ddfe105fe5bcd496c554528c577c4ab253c427b944d - md5: 6235ab8d07149f25a0be52f1708aef04 + size: 6958 + timestamp: 1752805918820 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.9-8_cp39.conda + build_number: 8 + sha256: c3cffff954fea53c254f1a3aad1b1fccd4cc2a781efd383e6b09d1b06348c67b + md5: c2f0c4bf417925c27b62ab50264baa98 constrains: - python 3.9.* *_cpython license: BSD-3-Clause license_family: BSD - size: 6980 - timestamp: 1745258876036 -- conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.2-py312h178313f_2.conda - sha256: 159cba13a93b3fe084a1eb9bda0a07afc9148147647f0d437c3c3da60980503b - md5: cf2485f39740de96e2a7f2bb18ed2fee + size: 6999 + timestamp: 1752805917390 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py312h8a5da7c_0.conda + sha256: 1b3dc4c25c83093fff08b86a3574bc6b94ba355c8eba1f35d805c5e256455fc7 + md5: fba10c2007c8b06f77c5a23ce3a635ad depends: - __glibc >=2.17,<3.0.a0 - - libgcc >=13 + - libgcc >=14 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT - size: 206903 - timestamp: 1737454910324 -- conda: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.2-py312h3520af0_2.conda - sha256: de96d83b805dba03422d39e855fb33cbeedc8827235d6f76407a3b42dc085910 - md5: 4a2d83ac55752681d54f781534ddd209 + size: 204539 + timestamp: 1758892248166 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.3-py312hacf3034_0.conda + sha256: 28814df783a5581758d197262d773c92a72c8cedbec3ccadac90adf22daecd25 + md5: dbc6cfbec3095d84d9f3baab0c6a5c24 depends: - __osx >=10.13 - python >=3.12,<3.13.0a0 @@ -7146,11 +7473,11 @@ packages: - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT - size: 193577 - timestamp: 1737454858212 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.2-py312h998013c_2.conda - sha256: ad225ad24bfd60f7719709791345042c3cb32da1692e62bd463b084cf140e00d - md5: 68149ed4d4e9e1c42d2ba1f27f08ca96 + size: 192483 + timestamp: 1758892060370 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py312h5748b74_0.conda + sha256: 690943c979a5bf014348933a68cd39e3bb9114d94371c4c5d846d2daaa82c7d9 + md5: 6a2d7f8a026223c2fa1027c96c615752 depends: - __osx >=11.0 - python >=3.12,<3.13.0a0 @@ -7159,22 +7486,22 @@ packages: - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT - size: 192148 - timestamp: 1737454886351 -- conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.2-py312h31fea79_2.conda - sha256: 76fec03ef7e67e37724873e1f805131fb88efb57f19e9a77b4da616068ef5c28 - md5: ba00a2e5059c1fde96459858537cc8f5 + size: 190579 + timestamp: 1758891996097 +- conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py312h05f76fc_0.conda + sha256: 54d04e61d17edffeba1e5cad45f10f272a016b6feec1fa8fa6af364d84a7b4fc + md5: 4a68f80fbf85499f093101cc17ffbab7 depends: - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 - yaml >=0.2.5,<0.3.0a0 license: MIT license_family: MIT - size: 181734 - timestamp: 1737455207230 + size: 180635 + timestamp: 1758891847871 - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda sha256: 2d6d0c026902561ed77cd646b5021aef2d4db22e57a5b0178dfc669231e06d2c md5: 283b96675859b20a825f8fa30f311446 @@ -7250,26 +7577,27 @@ packages: license_family: BSD size: 16523290 timestamp: 1716471188947 -- conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py312hf734454_0.conda - sha256: 8406e26bf853e699b1ea97792f63987808783ff4ab6ddeff9cf1ec0b9d1aa342 - md5: 7513ac56209d27a85ffa1582033f10a8 +- conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.2-py312h7a1785b_0.conda + sha256: 2e1f0d26b0a716f8b7e92e87a83c697220034e5e74e86494f7d71cd4a6640026 + md5: 86a0cf3ba594247a8c44bd2111d7549c depends: - __glibc >=2.17,<3.0.a0 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libgcc >=13 + - libgcc >=14 - libgfortran - - libgfortran5 >=13.3.0 + - libgfortran5 >=14.3.0 - liblapack >=3.9.0,<4.0a0 - - libstdcxx >=13 + - libstdcxx >=14 - numpy <2.6 - numpy >=1.23,<3 - numpy >=1.25.2 - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 license: BSD-3-Clause - size: 16847456 - timestamp: 1751148548291 + license_family: BSD + size: 17114633 + timestamp: 1757682871398 - conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.13.1-py39h038d4f4_0.conda sha256: f5dc2ae1c0149c41275c25f8977b9b4bc26db27300a50db803ad0ee0ce3565ce md5: 97931299de8eea2fc8b66e2b49447eda @@ -7290,17 +7618,17 @@ packages: license_family: BSD size: 15635286 timestamp: 1716471538660 -- conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.0-py312hd0c0319_0.conda - sha256: 4aab814a523927c14062a008fd2c42b91961a6e9d9adc54a18f9b49ffc058caf - md5: 713d61abff10ba1c063cf931ca5bac7d +- conda: https://conda.anaconda.org/conda-forge/osx-64/scipy-1.16.2-py312he2acf2f_0.conda + sha256: c7bb958e321ec5978e655fff3eb70b465951a22d9a8db68a942890292948b18e + md5: a56bb207ed2165de58c12389c3402647 depends: - __osx >=10.13 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libcxx >=18 - - libgfortran 5.* - - libgfortran5 >=13.3.0 - - libgfortran5 >=14.2.0 + - libcxx >=19 + - libgfortran + - libgfortran5 >=14.3.0 + - libgfortran5 >=15.1.0 - liblapack >=3.9.0,<4.0a0 - numpy <2.6 - numpy >=1.23,<3 @@ -7308,8 +7636,9 @@ packages: - python >=3.12,<3.13.0a0 - python_abi 3.12.* *_cp312 license: BSD-3-Clause - size: 15221024 - timestamp: 1751148523429 + license_family: BSD + size: 15307087 + timestamp: 1757682932036 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.13.1-py39h3d5391c_0.conda sha256: 757850d99c81df9b5a36b201ee1ef850298669facb4e475f1d77cd3e8b10092d md5: 29a07d75356ca619b3cfc8304a9ce6e5 @@ -7331,17 +7660,17 @@ packages: license_family: BSD size: 14699719 timestamp: 1716472126212 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.0-py312hcedbd36_0.conda - sha256: d0033c0414910c2bb6005e005e0df266a6c21e1928efec2df3251736245c1258 - md5: b3ab5755feaabeaf889063663790eb25 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/scipy-1.16.2-py312ha6bbf71_0.conda + sha256: ed1640046c738b65f7faa40a8a54c70254724484b279eee4dce3f1dcc4be8fa7 + md5: 9c714f94231e2f9a1a170d6cb32a8197 depends: - __osx >=11.0 - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - - libcxx >=18 - - libgfortran 5.* - - libgfortran5 >=13.3.0 - - libgfortran5 >=14.2.0 + - libcxx >=19 + - libgfortran + - libgfortran5 >=14.3.0 + - libgfortran5 >=15.1.0 - liblapack >=3.9.0,<4.0a0 - numpy <2.6 - numpy >=1.23,<3 @@ -7350,8 +7679,9 @@ packages: - python >=3.12,<3.13.0a0 *_cpython - python_abi 3.12.* *_cp312 license: BSD-3-Clause - size: 13846609 - timestamp: 1751148522848 + license_family: BSD + size: 13952359 + timestamp: 1757683121927 - conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.13.1-py39h1a10956_0.conda sha256: dc694e034d1223266de3224c3fe60d36865eebd2f7e43cb1cf06dfdf983f7f3e md5: 9f8e571406af04d2f5fdcbecec704505 @@ -7370,9 +7700,9 @@ packages: license_family: BSD size: 14854560 timestamp: 1716472552464 -- conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.0-py312h1416ca1_0.conda - sha256: 81dfa8ab6ab7c7570175bd1d3007c7197e98f95b2c5751797ccab116f53cd1aa - md5: ddb9926010a879852022bb9152ab3298 +- conda: https://conda.anaconda.org/conda-forge/win-64/scipy-1.16.2-py312h33376e8_0.conda + sha256: dd4ee42225875681e6b219d7ac4c23db812d4922f9022fc6754a5371145a61c7 + md5: 9343c8772e877011dfdef91035b11755 depends: - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 @@ -7386,8 +7716,9 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 license: BSD-3-Clause - size: 14932332 - timestamp: 1751161759720 + license_family: BSD + size: 15180381 + timestamp: 1757683079834 - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 md5: 4de79c071274a53dcaf2a8c749d1499e @@ -7503,16 +7834,17 @@ packages: license: LGPL-2.1-or-later AND BSD-3-Clause AND GPL-2.0-or-later AND Apache-2.0 size: 12345 timestamp: 1742288893865 -- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda - sha256: 69ab5804bdd2e8e493d5709eebff382a72fab3e9af6adf93a237ccf8f7dbd624 - md5: 460eba7851277ec1fd80a1a24080787a +- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_8.conda + sha256: 0053c17ffbd9f8af1a7f864995d70121c292e317804120be4667f37c92805426 + md5: 1bad93f0aa428d618875ef3a588a889e depends: - - kernel-headers_linux-64 3.10.0 he073ed8_18 + - __glibc >=2.28 + - kernel-headers_linux-64 4.18.0 he073ed8_8 - tzdata - license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later license_family: GPL - size: 15166921 - timestamp: 1735290488259 + size: 24210909 + timestamp: 1752669140965 - conda: https://conda.anaconda.org/conda-forge/osx-64/tapi-1300.6.5-h390ca13_0.conda sha256: f97372a1c75b749298cb990405a690527e8004ff97e452ed2c59e4bc6a35d132 md5: c6ee25eb54accb3f1c8fc39203acfaf1 @@ -7535,18 +7867,18 @@ packages: license_family: MIT size: 207679 timestamp: 1725491499758 -- conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h62715c5_1.conda - sha256: 03cc5442046485b03dd1120d0f49d35a7e522930a2ab82f275e938e17b07b302 - md5: 9190dd0a23d925f7602f9628b3aed511 +- conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2021.13.0-h18a62a1_3.conda + sha256: 30e82640a1ad9d9b5bee006da7e847566086f8fdb63d15b918794a7ef2df862c + md5: 72226638648e494aaafde8155d50dab2 depends: - - libhwloc >=2.11.2,<2.11.3.0a0 + - libhwloc >=2.12.1,<2.12.2.0a0 - ucrt >=10.0.20348.0 - - vc >=14.2,<15 - - vc14_runtime >=14.29.30139 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: Apache-2.0 license_family: APACHE - size: 151460 - timestamp: 1732982860332 + size: 150266 + timestamp: 1755776172092 - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda sha256: a84ff687119e6d8752346d1d408d5cf360dee0badd487a472aa8ddedfdc219e1 md5: a0116df4f4ed05c303811a837d5b39d8 @@ -7598,20 +7930,31 @@ packages: license_family: MIT size: 38777 timestamp: 1749127286558 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + sha256: 032271135bca55aeb156cee361c81350c6f3fb203f57d024d7e5a1fc9ef18731 + md5: 0caa1af407ecff61170c9437a808404d + depends: + - python >=3.10 + - python + license: PSF-2.0 + license_family: PSF + size: 51692 + timestamp: 1756220668932 - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 md5: 4222072737ccff51314b5ece9c7d6f5a license: LicenseRef-Public-Domain size: 122968 timestamp: 1742727099393 -- conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.22621.0-h57928b3_1.conda - sha256: db8dead3dd30fb1a032737554ce91e2819b43496a0db09927edf01c32b577450 - md5: 6797b005cd0f439c4c5c9ac565783700 +- conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + sha256: 3005729dce6f3d3f5ec91dfc49fc75a0095f9cd23bab49efb899657297ac91a5 + md5: 71b24316859acd00bdb8b38f5e2ce328 constrains: + - vc14_runtime >=14.29.30037 - vs2015_runtime >=14.29.30037 license: LicenseRef-MicrosoftWindowsSDK10 - size: 559710 - timestamp: 1728377334097 + size: 694692 + timestamp: 1756385147981 - conda: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py312h68727a3_5.conda sha256: 9fb020083a7f4fee41f6ece0f4840f59739b3e249f157c8a407bb374ffb733b5 md5: f9664ee31aed96c85b7319ab0a693341 @@ -7667,52 +8010,65 @@ packages: license_family: MIT size: 17213 timestamp: 1725784449622 -- conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_26.conda - sha256: b388d88e04aa0257df4c1d28f8d85d985ad07c1e5645aa62335673c98704c4c6 - md5: 18b6bf6f878501547786f7bf8052a34d +- conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + sha256: cb357591d069a1e6cb74199a8a43a7e3611f72a6caed9faa49dbb3d7a0a98e0b + md5: 28f4ca1e0337d0f27afb8602663c5723 depends: - vc14_runtime >=14.44.35208 track_features: - vc14 license: BSD-3-Clause license_family: BSD - size: 17914 - timestamp: 1750371462857 -- conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_26.conda - sha256: 7bad6e25a7c836d99011aee59dcf600b7f849a6fa5caa05a406255527e80a703 - md5: 14d65350d3f5c8ff163dc4f76d6e2830 + size: 18249 + timestamp: 1753739241465 +- conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + sha256: af4b4b354b87a9a8d05b8064ff1ea0b47083274f7c30b4eb96bc2312c9b5f08f + md5: 603e41da40a765fd47995faa021da946 depends: - ucrt >=10.0.20348.0 + - vcomp14 14.44.35208 h818238b_31 constrains: - - vs2015_runtime 14.44.35208.* *_26 + - vs2015_runtime 14.44.35208.* *_31 license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime license_family: Proprietary - size: 756109 - timestamp: 1750371459116 -- conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.31.2-pyhd8ed1ab_0.conda - sha256: 763dc774200b2eebdf5437b112834c5455a1dd1c9b605340696950277ff36729 - md5: c0600c1b374efa7a1ff444befee108ca + size: 682424 + timestamp: 1753739239305 +- conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + sha256: 67b317b64f47635415776718d25170a9a6f9a1218c0f5a6202bfd687e07b6ea4 + md5: a6b1d5c1fc3cb89f88f7179ee6a9afe3 + depends: + - ucrt >=10.0.20348.0 + constrains: + - vs2015_runtime 14.44.35208.* *_31 + license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime + license_family: Proprietary + size: 113963 + timestamp: 1753739198723 +- conda: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.34.0-pyhd8ed1ab_0.conda + sha256: 398f40090e80ec5084483bb798555d0c5be3d1bb30f8bb5e4702cd67cdb595ee + md5: 2bd6c0c96cfc4dbe9bde604a122e3e55 depends: - distlib >=0.3.7,<1 - filelock >=3.12.2,<4 - platformdirs >=3.9.1,<5 - python >=3.9 + - typing_extensions >=4.13.2 license: MIT license_family: MIT - size: 4133755 - timestamp: 1746781585998 -- conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_26.conda - sha256: d18d77c8edfbad37fa0e0bb0f543ad80feb85e8fe5ced0f686b8be463742ec0b - md5: 312f3a0a6b3c5908e79ce24002411e32 + size: 4381624 + timestamp: 1755111905876 +- conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.44.35208-h38c0c73_31.conda + sha256: 8b20152d00e1153ccb1ed377a160110482f286a6d85a82b57ffcd60517d523a7 + md5: d75abcfbc522ccd98082a8c603fce34c depends: - vc14_runtime >=14.44.35208 license: BSD-3-Clause license_family: BSD - size: 17888 - timestamp: 1750371463202 -- conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_26.conda - sha256: 43c833a91c04bf53c85deff4bea505fa5173a79981909dc8116e7b6709bae39c - md5: 3b88259844a981083c4efab022071768 + size: 18249 + timestamp: 1753739241918 +- conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_31.conda + sha256: c0a380608afc9ad98b1e261fe55702b72e33f80d372f358075c5dea3d185816f + md5: 0bf228856c72261e5bbd9530002176f2 depends: - vswhere constrains: @@ -7721,8 +8077,8 @@ packages: - vc14 license: BSD-3-Clause license_family: BSD - size: 20679 - timestamp: 1750371462464 + size: 21054 + timestamp: 1753739201422 - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda sha256: b72270395326dc56de9bd6ca82f63791b3c8c9e2b98e25242a9869a4ca821895 md5: f622897afff347b715d046178ad745a5 @@ -7732,39 +8088,48 @@ packages: license_family: MIT size: 238764 timestamp: 1745560912727 -- conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h7f98852_2.tar.bz2 - sha256: a4e34c710eeb26945bdbdaba82d3d74f60a78f54a874ec10d373811a5d217535 - md5: 4cb3ad778ec2d5a7acbdf254eb1c42ae +- conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda + sha256: 6d9ea2f731e284e9316d95fa61869fe7bbba33df7929f82693c121022810f4ad + md5: a77f85f77be52ff59391544bfe73390a depends: - - libgcc-ng >=9.4.0 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 license: MIT license_family: MIT - size: 89141 - timestamp: 1641346969816 -- conda: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h0d85af4_2.tar.bz2 - sha256: 5301417e2c8dea45b401ffee8df3957d2447d4ce80c83c5ff151fc6bfe1c4148 - md5: d7e08fcf8259d742156188e8762b4d20 + size: 85189 + timestamp: 1753484064210 +- conda: https://conda.anaconda.org/conda-forge/osx-64/yaml-0.2.5-h4132b18_3.conda + sha256: a335161bfa57b64e6794c3c354e7d49449b28b8d8a7c4ed02bf04c3f009953f9 + md5: a645bb90997d3fc2aea0adf6517059bd + depends: + - __osx >=10.13 license: MIT license_family: MIT - size: 84237 - timestamp: 1641347062780 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h3422bc3_2.tar.bz2 - sha256: 93181a04ba8cfecfdfb162fc958436d868cc37db504c58078eab4c1a3e57fbb7 - md5: 4bb3f014845110883a3c5ee811fd84b4 + size: 79419 + timestamp: 1753484072608 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h925e9cb_3.conda + sha256: b03433b13d89f5567e828ea9f1a7d5c5d697bf374c28a4168d71e9464f5dafac + md5: 78a0fe9e9c50d2c381e8ee47e3ea437d + depends: + - __osx >=11.0 license: MIT license_family: MIT - size: 88016 - timestamp: 1641347076660 -- conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h8ffe710_2.tar.bz2 - sha256: 4e2246383003acbad9682c7c63178e2e715ad0eb84f03a8df1fbfba455dfedc5 - md5: adbfb9f45d1004a26763652246a33764 + size: 83386 + timestamp: 1753484079473 +- conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h6a83c73_3.conda + sha256: 80ee68c1e7683a35295232ea79bcc87279d31ffeda04a1665efdb43cbd50a309 + md5: 433699cba6602098ae8957a323da2664 depends: - - vc >=14.1,<15.0a0 - - vs2015_runtime >=14.16.27012 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 license: MIT license_family: MIT - size: 63274 - timestamp: 1641347623319 + size: 63944 + timestamp: 1753484092156 - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda sha256: a4166e3d8ff4e35932510aaff7aa90772f84b4d07e9f6f83c614cba7ceefe0eb md5: 6432cb5d4ac0046c3ac0a8a0f95842f9 diff --git a/pixi.toml b/pixi.toml index 9675aabb7..9915f90db 100644 --- a/pixi.toml +++ b/pixi.toml @@ -1,6 +1,6 @@ [project] name = "eigenpy" -version = "3.11.0" +version = "3.12.0" description = "Bindings between Numpy and Eigen using Boost.Python" platforms = ["linux-64", "osx-64", "osx-arm64", "win-64"] channels = ["conda-forge"] diff --git a/python/main.cpp b/python/main.cpp index 19a643d99..763868b15 100644 --- a/python/main.cpp +++ b/python/main.cpp @@ -31,9 +31,9 @@ void exposeIsApprox() { Eigen::NumTraits::dummy_precision(); bp::def("is_approx", - (bool (*)(const Eigen::MatrixBase &, - const Eigen::MatrixBase &, - const RealScalar &))&is_approx, + (bool (*)(const Eigen::MatrixBase&, + const Eigen::MatrixBase&, + const RealScalar&))&is_approx, (bp::arg("A"), bp::arg("B"), bp::arg("prec") = dummy_precision), "Returns True if A is approximately equal to B, within the " "precision determined by prec."); diff --git a/src/decompositions/accelerate.cpp b/src/decompositions/accelerate.cpp index 8f2f05c16..ae688a2e0 100644 --- a/src/decompositions/accelerate.cpp +++ b/src/decompositions/accelerate.cpp @@ -5,7 +5,7 @@ #include "eigenpy/fwd.hpp" #include "eigenpy/decompositions/decompositions.hpp" -#include "eigenpy/decompositions/sparse/accelerate/accelerate.hpp" +#include "eigenpy/decompositions/sparse/accelerate/Accelerate.hpp" namespace eigenpy { diff --git a/src/decompositions/bdcsvd-solver.cpp b/src/decompositions/bdcsvd-solver.cpp new file mode 100644 index 000000000..2fda1b3fb --- /dev/null +++ b/src/decompositions/bdcsvd-solver.cpp @@ -0,0 +1,12 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/BDCSVD.hpp" + +namespace eigenpy { +void exposeBDCSVDSolver() { + using namespace Eigen; + BDCSVDVisitor::expose("BDCSVD"); +} +} // namespace eigenpy diff --git a/src/decompositions/complex-eigen-solver.cpp b/src/decompositions/complex-eigen-solver.cpp new file mode 100644 index 000000000..99df394ad --- /dev/null +++ b/src/decompositions/complex-eigen-solver.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/ComplexEigenSolver.hpp" + +namespace eigenpy { +void exposeComplexEigenSolver() { + using namespace Eigen; + ComplexEigenSolverVisitor::expose("ComplexEigenSolver"); +} +} // namespace eigenpy diff --git a/src/decompositions/complex-schur.cpp b/src/decompositions/complex-schur.cpp new file mode 100644 index 000000000..555e345c2 --- /dev/null +++ b/src/decompositions/complex-schur.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/ComplexSchur.hpp" + +namespace eigenpy { +void exposeComplexSchur() { + using namespace Eigen; + ComplexSchurVisitor::expose("ComplexSchur"); +} +} // namespace eigenpy diff --git a/src/decompositions/decompositions.cpp b/src/decompositions/decompositions.cpp index 77ae22f29..85fb81061 100644 --- a/src/decompositions/decompositions.cpp +++ b/src/decompositions/decompositions.cpp @@ -3,30 +3,60 @@ */ #include "eigenpy/decompositions/decompositions.hpp" +#include "eigenpy/solvers/MINRES.hpp" #include "eigenpy/fwd.hpp" namespace eigenpy { void exposeEigenSolver(); +void exposeGeneralizedEigenSolver(); void exposeSelfAdjointEigenSolver(); +void exposeGeneralizedSelfAdjointEigenSolver(); +void exposeHessenbergDecomposition(); +void exposeRealQZ(); +void exposeRealSchur(); +void exposeTridiagonalization(); +void exposeComplexEigenSolver(); +void exposeComplexSchur(); void exposeLLTSolver(); void exposeLDLTSolver(); +void exposeFullPivLUSolver(); +void exposePartialPivLUSolver(); void exposeQRSolvers(); -void exposeMINRESSolver(); void exposeSimplicialLLTSolver(); void exposeSimplicialLDLTSolver(); +void exposeSparseLUSolver(); +void exposeSparseQRSolver(); void exposePermutationMatrix(); +void exposeBDCSVDSolver(); +void exposeJacobiSVDSolver(); + +void exposeBackwardCompatibilityAliases() { + typedef Eigen::MatrixXd MatrixXd; + MINRESSolverVisitor::expose("MINRES"); +} void exposeDecompositions() { using namespace Eigen; exposeEigenSolver(); + exposeGeneralizedEigenSolver(); exposeSelfAdjointEigenSolver(); + exposeGeneralizedSelfAdjointEigenSolver(); + exposeHessenbergDecomposition(); + exposeRealQZ(); + exposeRealSchur(); + exposeTridiagonalization(); + exposeComplexEigenSolver(); + exposeComplexSchur(); exposeLLTSolver(); exposeLDLTSolver(); + exposeFullPivLUSolver(); + exposePartialPivLUSolver(); exposeQRSolvers(); - exposeMINRESSolver(); + exposeBDCSVDSolver(); + exposeJacobiSVDSolver(); { bp::enum_("DecompositionOptions") @@ -44,6 +74,8 @@ void exposeDecompositions() { // Expose sparse decompositions exposeSimplicialLLTSolver(); exposeSimplicialLDLTSolver(); + exposeSparseLUSolver(); + exposeSparseQRSolver(); exposePermutationMatrix(); @@ -54,5 +86,7 @@ void exposeDecompositions() { #ifdef EIGENPY_WITH_ACCELERATE_SUPPORT exposeAccelerate(); #endif + + exposeBackwardCompatibilityAliases(); } } // namespace eigenpy diff --git a/src/decompositions/fullpivlu-solver.cpp b/src/decompositions/fullpivlu-solver.cpp new file mode 100644 index 000000000..44fcaa07d --- /dev/null +++ b/src/decompositions/fullpivlu-solver.cpp @@ -0,0 +1,12 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/FullPivLU.hpp" + +namespace eigenpy { +void exposeFullPivLUSolver() { + using namespace Eigen; + FullPivLUSolverVisitor::expose("FullPivLU"); +} +} // namespace eigenpy diff --git a/src/decompositions/generalized-eigen-solver.cpp b/src/decompositions/generalized-eigen-solver.cpp new file mode 100644 index 000000000..424393a70 --- /dev/null +++ b/src/decompositions/generalized-eigen-solver.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/GeneralizedEigenSolver.hpp" + +namespace eigenpy { +void exposeGeneralizedEigenSolver() { + using namespace Eigen; + GeneralizedEigenSolverVisitor::expose("GeneralizedEigenSolver"); +} +} // namespace eigenpy diff --git a/src/decompositions/generalized-self-adjoint-eigen-solver.cpp b/src/decompositions/generalized-self-adjoint-eigen-solver.cpp new file mode 100644 index 000000000..9dd254604 --- /dev/null +++ b/src/decompositions/generalized-self-adjoint-eigen-solver.cpp @@ -0,0 +1,14 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/GeneralizedSelfAdjointEigenSolver.hpp" + +namespace eigenpy { +void exposeGeneralizedSelfAdjointEigenSolver() { + using namespace Eigen; + GeneralizedSelfAdjointEigenSolverVisitor::expose( + "GeneralizedSelfAdjointEigenSolver"); +} +} // namespace eigenpy diff --git a/src/decompositions/hessenberg-decomposition.cpp b/src/decompositions/hessenberg-decomposition.cpp new file mode 100644 index 000000000..6daebfc83 --- /dev/null +++ b/src/decompositions/hessenberg-decomposition.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/HessenbergDecomposition.hpp" + +namespace eigenpy { +void exposeHessenbergDecomposition() { + using namespace Eigen; + HessenbergDecompositionVisitor::expose("HessenbergDecomposition"); +} +} // namespace eigenpy diff --git a/src/decompositions/jacobisvd-solver.cpp b/src/decompositions/jacobisvd-solver.cpp new file mode 100644 index 000000000..a59538ca9 --- /dev/null +++ b/src/decompositions/jacobisvd-solver.cpp @@ -0,0 +1,29 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/JacobiSVD.hpp" + +namespace eigenpy { +void exposeJacobiSVDSolver() { + using namespace Eigen; + using Eigen::JacobiSVD; + + using Eigen::ColPivHouseholderQRPreconditioner; + using Eigen::FullPivHouseholderQRPreconditioner; + using Eigen::HouseholderQRPreconditioner; + using Eigen::NoQRPreconditioner; + + using ColPivHhJacobiSVD = + JacobiSVD; + using FullPivHhJacobiSVD = + JacobiSVD; + using HhJacobiSVD = JacobiSVD; + using NoPrecondJacobiSVD = JacobiSVD; + + JacobiSVDVisitor::expose("ColPivHhJacobiSVD"); + JacobiSVDVisitor::expose("FullPivHhJacobiSVD"); + JacobiSVDVisitor::expose("HhJacobiSVD"); + JacobiSVDVisitor::expose("NoPrecondJacobiSVD"); +} +} // namespace eigenpy diff --git a/src/decompositions/partialpivlu-solver.cpp b/src/decompositions/partialpivlu-solver.cpp new file mode 100644 index 000000000..c6ee7f9be --- /dev/null +++ b/src/decompositions/partialpivlu-solver.cpp @@ -0,0 +1,12 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/PartialPivLU.hpp" + +namespace eigenpy { +void exposePartialPivLUSolver() { + using namespace Eigen; + PartialPivLUSolverVisitor::expose("PartialPivLU"); +} +} // namespace eigenpy diff --git a/src/decompositions/real-qz.cpp b/src/decompositions/real-qz.cpp new file mode 100644 index 000000000..0ed7561e8 --- /dev/null +++ b/src/decompositions/real-qz.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/RealQZ.hpp" + +namespace eigenpy { +void exposeRealQZ() { + using namespace Eigen; + RealQZVisitor::expose("RealQZ"); +} +} // namespace eigenpy diff --git a/src/decompositions/real-schur.cpp b/src/decompositions/real-schur.cpp new file mode 100644 index 000000000..dbfe0bd7b --- /dev/null +++ b/src/decompositions/real-schur.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/RealSchur.hpp" + +namespace eigenpy { +void exposeRealSchur() { + using namespace Eigen; + RealSchurVisitor::expose("RealSchur"); +} +} // namespace eigenpy diff --git a/src/decompositions/seigen-solver.cpp b/src/decompositions/seigen-solver.cpp deleted file mode 100644 index 8fdfbf4af..000000000 --- a/src/decompositions/seigen-solver.cpp +++ /dev/null @@ -1,13 +0,0 @@ - -/* - * Copyright 2024 INRIA - */ - -#include "eigenpy/decompositions/EigenSolver.hpp" - -namespace eigenpy { -void exposeEigenSolver() { - using namespace Eigen; - EigenSolverVisitor::expose("EigenSolver"); -} -} // namespace eigenpy diff --git a/src/decompositions/simplicial-ldlt-solver.cpp b/src/decompositions/simplicial-ldlt-solver.cpp index c9a3e7b98..1d090afeb 100644 --- a/src/decompositions/simplicial-ldlt-solver.cpp +++ b/src/decompositions/simplicial-ldlt-solver.cpp @@ -2,7 +2,7 @@ * Copyright 2024 INRIA */ -#include "eigenpy/decompositions/sparse/LDLT.hpp" +#include "eigenpy/decompositions/sparse/SimplicialLDLT.hpp" namespace eigenpy { void exposeSimplicialLDLTSolver() { diff --git a/src/decompositions/simplicial-llt-solver.cpp b/src/decompositions/simplicial-llt-solver.cpp index f46e36f25..70f069970 100644 --- a/src/decompositions/simplicial-llt-solver.cpp +++ b/src/decompositions/simplicial-llt-solver.cpp @@ -2,7 +2,7 @@ * Copyright 2024 INRIA */ -#include "eigenpy/decompositions/sparse/LLT.hpp" +#include "eigenpy/decompositions/sparse/SimplicialLLT.hpp" namespace eigenpy { void exposeSimplicialLLTSolver() { diff --git a/src/decompositions/sparse-lu-solver.cpp b/src/decompositions/sparse-lu-solver.cpp new file mode 100644 index 000000000..44eca4fa4 --- /dev/null +++ b/src/decompositions/sparse-lu-solver.cpp @@ -0,0 +1,33 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/sparse/SparseLU.hpp" + +namespace eigenpy { +void exposeSparseLUSolver() { + using namespace Eigen; + + typedef SparseMatrix ColMajorSparseMatrix; + typedef typename ColMajorSparseMatrix::StorageIndex StorageIndex; + typedef COLAMDOrdering Ordering; + typedef SparseLU SparseLUType; + + typedef typename SparseLUType::Scalar Scalar; + typedef typename SparseLUType::SCMatrix SCMatrix; + +#if EIGEN_VERSION_AT_LEAST(3, 4, 90) + typedef Eigen::Map> + MappedSparseMatrix; +#else + typedef Eigen::MappedSparseMatrix + MappedSparseMatrix; +#endif + + SparseLUMatrixLReturnTypeVisitor::expose( + ("SparseLUMatrixLReturnType")); + SparseLUMatrixUReturnTypeVisitor::expose( + ("SparseLUMatrixUReturnType")); + SparseLUVisitor::expose("SparseLU"); +} +} // namespace eigenpy diff --git a/src/decompositions/sparse-qr-solver.cpp b/src/decompositions/sparse-qr-solver.cpp new file mode 100644 index 000000000..0bac14197 --- /dev/null +++ b/src/decompositions/sparse-qr-solver.cpp @@ -0,0 +1,22 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/sparse/SparseQR.hpp" + +namespace eigenpy { +void exposeSparseQRSolver() { + using namespace Eigen; + + typedef SparseMatrix ColMajorSparseMatrix; + typedef typename ColMajorSparseMatrix::StorageIndex StorageIndex; + typedef COLAMDOrdering Ordering; + typedef SparseQR SparseQRType; + + SparseQRMatrixQTransposeReturnTypeVisitor::expose( + "SparseQRMatrixQTransposeReturnType"); + SparseQRMatrixQReturnTypeVisitor::expose( + "SparseQRMatrixQReturnType"); + SparseQRVisitor::expose("SparseQR"); +} +} // namespace eigenpy diff --git a/src/decompositions/tridiagonalization.cpp b/src/decompositions/tridiagonalization.cpp new file mode 100644 index 000000000..52febadd2 --- /dev/null +++ b/src/decompositions/tridiagonalization.cpp @@ -0,0 +1,13 @@ + +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/decompositions/Tridiagonalization.hpp" + +namespace eigenpy { +void exposeTridiagonalization() { + using namespace Eigen; + TridiagonalizationVisitor::expose("Tridiagonalization"); +} +} // namespace eigenpy diff --git a/src/solvers/bicgstab.cpp b/src/solvers/bicgstab.cpp new file mode 100644 index 000000000..f2fb0876f --- /dev/null +++ b/src/solvers/bicgstab.cpp @@ -0,0 +1,17 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/solvers/BiCGSTAB.hpp" + +namespace eigenpy { +void exposeBiCGSTAB() { + using namespace Eigen; + using Eigen::BiCGSTAB; + using Eigen::IdentityPreconditioner; + using IdentityBiCGSTAB = BiCGSTAB; + + BiCGSTABVisitor>::expose("BiCGSTAB"); + BiCGSTABVisitor::expose("IdentityBiCGSTAB"); +} +} // namespace eigenpy diff --git a/src/solvers/conjugate-gradient.cpp b/src/solvers/conjugate-gradient.cpp new file mode 100644 index 000000000..a64cce257 --- /dev/null +++ b/src/solvers/conjugate-gradient.cpp @@ -0,0 +1,21 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/solvers/ConjugateGradient.hpp" + +namespace eigenpy { +void exposeConjugateGradient() { + using namespace Eigen; + using Eigen::ConjugateGradient; + using Eigen::IdentityPreconditioner; + using Eigen::Lower; + using IdentityConjugateGradient = + ConjugateGradient; + + ConjugateGradientVisitor>::expose( + "ConjugateGradient"); + ConjugateGradientVisitor::expose( + "IdentityConjugateGradient"); +} +} // namespace eigenpy diff --git a/src/solvers/incomplete-cholesky.cpp b/src/solvers/incomplete-cholesky.cpp new file mode 100644 index 000000000..b6b2274de --- /dev/null +++ b/src/solvers/incomplete-cholesky.cpp @@ -0,0 +1,13 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/solvers/IncompleteCholesky.hpp" + +namespace eigenpy { +void exposeIncompleteCholesky() { + using namespace Eigen; + typedef SparseMatrix ColMajorSparseMatrix; + IncompleteCholeskyVisitor::expose("IncompleteCholesky"); +} +} // namespace eigenpy diff --git a/src/solvers/incomplete-lut.cpp b/src/solvers/incomplete-lut.cpp new file mode 100644 index 000000000..640fe6178 --- /dev/null +++ b/src/solvers/incomplete-lut.cpp @@ -0,0 +1,12 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/solvers/IncompleteLUT.hpp" + +namespace eigenpy { +void exposeIncompleteLUT() { + typedef Eigen::SparseMatrix ColMajorSparseMatrix; + IncompleteLUTVisitor::expose("IncompleteLUT"); +} +} // namespace eigenpy diff --git a/src/solvers/least-squares-conjugate-gradient.cpp b/src/solvers/least-squares-conjugate-gradient.cpp new file mode 100644 index 000000000..5fefbf67a --- /dev/null +++ b/src/solvers/least-squares-conjugate-gradient.cpp @@ -0,0 +1,29 @@ +/* + * Copyright 2025 INRIA + */ + +#include "eigenpy/solvers/LeastSquaresConjugateGradient.hpp" + +namespace eigenpy { +void exposeLeastSquaresConjugateGradient() { + using namespace Eigen; + using Eigen::LeastSquaresConjugateGradient; + + using Eigen::DiagonalPreconditioner; + using Eigen::IdentityPreconditioner; + using Eigen::LeastSquareDiagonalPreconditioner; + + using IdentityLeastSquaresConjugateGradient = + LeastSquaresConjugateGradient; + using DiagonalLeastSquaresConjugateGradient = LeastSquaresConjugateGradient< + MatrixXd, DiagonalPreconditioner>; + + LeastSquaresConjugateGradientVisitor>>:: + expose("LeastSquaresConjugateGradient"); + LeastSquaresConjugateGradientVisitor:: + expose("IdentityLeastSquaresConjugateGradient"); + LeastSquaresConjugateGradientVisitor:: + expose("DiagonalLeastSquaresConjugateGradient"); +} +} // namespace eigenpy diff --git a/src/decompositions/minres-solver.cpp b/src/solvers/minres.cpp similarity index 57% rename from src/decompositions/minres-solver.cpp rename to src/solvers/minres.cpp index 44a12cea1..06f8ff63e 100644 --- a/src/decompositions/minres-solver.cpp +++ b/src/solvers/minres.cpp @@ -1,11 +1,11 @@ /* - * Copyright 2024 INRIA + * Copyright 2025 INRIA */ -#include "eigenpy/decompositions/minres.hpp" +#include "eigenpy/solvers/MINRES.hpp" namespace eigenpy { -void exposeMINRESSolver() { +void exposeMINRES() { using namespace Eigen; MINRESSolverVisitor::expose("MINRES"); } diff --git a/src/solvers/solvers.cpp b/src/solvers/solvers.cpp index 207eb6e76..e9a0d7fd2 100644 --- a/src/solvers/solvers.cpp +++ b/src/solvers/solvers.cpp @@ -1,36 +1,26 @@ /* - * Copyright 2017-2020 CNRS INRIA + * Copyright 2017-2025 CNRS INRIA */ -#include - -#if EIGEN_VERSION_AT_LEAST(3, 2, 0) - -#include "eigenpy/solvers/ConjugateGradient.hpp" #include "eigenpy/solvers/solvers.hpp" -#if EIGEN_VERSION_AT_LEAST(3, 3, 5) -#include "eigenpy/solvers/LeastSquaresConjugateGradient.hpp" -#endif +#include "eigenpy/fwd.hpp" namespace eigenpy { -void exposeSolvers() { - using namespace Eigen; - ConjugateGradientVisitor< - ConjugateGradient>::expose(); -#if EIGEN_VERSION_AT_LEAST(3, 3, 5) - LeastSquaresConjugateGradientVisitor>>::expose(); -#endif - // Conjugate gradient with limited BFGS preconditioner - ConjugateGradientVisitor< - ConjugateGradient>:: - expose("IdentityConjugateGradient"); - // ConjugateGradientVisitor< - // ConjugateGradient - // > >::expose("LimitedBFGSConjugateGradient"); +void exposeBiCGSTAB(); +void exposeMINRES(); +void exposeConjugateGradient(); +void exposeLeastSquaresConjugateGradient(); +void exposeIncompleteCholesky(); +void exposeIncompleteLUT(); + +void exposeSolvers() { + exposeBiCGSTAB(); + exposeMINRES(); + exposeConjugateGradient(); + exposeLeastSquaresConjugateGradient(); + exposeIncompleteCholesky(); + exposeIncompleteLUT(); } } // namespace eigenpy - -#endif diff --git a/src/type_info.cpp b/src/type_info.cpp index 482370cea..9c0d5661a 100644 --- a/src/type_info.cpp +++ b/src/type_info.cpp @@ -40,7 +40,7 @@ void exposeStdTypeIndex() { "and change between invocations of the same program.") .def( "pretty_name", - +[](const Self &value) -> std::string { + +[](const Self& value) -> std::string { return boost::core::demangle(value.name()); }, bp::arg("self"), "Human readible name."); diff --git a/unittest/CMakeLists.txt b/unittest/CMakeLists.txt index 98485fbed..130b3e1e2 100644 --- a/unittest/CMakeLists.txt +++ b/unittest/CMakeLists.txt @@ -117,7 +117,7 @@ add_python_lib_unit_test("py-multiple-registration" "unittest/python/test_multiple_registration.py") add_python_lib_unit_test("py-tensor" "unittest/python/test_tensor.py") -add_python_lib_unit_test("py-geometry" "unittest/python/test_geometry.py") +add_python_lib_unit_test("py-Geometry" "unittest/python/test_Geometry.py") add_python_lib_unit_test("py-complex" "unittest/python/test_complex.py") add_python_lib_unit_test("py-deprecation-policy" "unittest/python/test_deprecation_policy.py") @@ -134,21 +134,56 @@ add_python_eigenpy_lib_unit_test("py-dimensions" add_python_eigenpy_lib_unit_test("py-version" "unittest/python/test_version.py") -add_python_eigenpy_lib_unit_test("py-eigen-solver" - "unittest/python/test_eigen_solver.py") +add_python_eigenpy_lib_unit_test("py-EigenSolver" + "unittest/python/test_EigenSolver.py") add_python_eigenpy_lib_unit_test( - "py-self-adjoint-eigen-solver" - "unittest/python/test_self_adjoint_eigen_solver.py") + "py-GeneralizedEigenSolver" "unittest/python/test_GeneralizedEigenSolver.py") + +add_python_eigenpy_lib_unit_test( + "py-GeneralizedSelfAdjointEigenSolver" + "unittest/python/test_GeneralizedSelfAdjointEigenSolver.py") + +add_python_eigenpy_lib_unit_test("py-ComplexEigenSolver" + "unittest/python/test_ComplexEigenSolver.py") + +add_python_eigenpy_lib_unit_test("py-ComplexSchur" + "unittest/python/test_ComplexSchur.py") + +add_python_eigenpy_lib_unit_test( + "py-SelfAdjointEigenSolver" "unittest/python/test_SelfAdjointEigenSolver.py") + +add_python_eigenpy_lib_unit_test( + "py-HessenbergDecomposition" + "unittest/python/test_HessenbergDecomposition.py") + +add_python_eigenpy_lib_unit_test("py-RealQZ" "unittest/python/test_RealQZ.py") + +add_python_eigenpy_lib_unit_test("py-RealSchur" + "unittest/python/test_RealSchur.py") + +add_python_eigenpy_lib_unit_test("py-Tridiagonalization" + "unittest/python/test_Tridiagonalization.py") add_python_eigenpy_lib_unit_test("py-LLT" "unittest/python/test_LLT.py") add_python_eigenpy_lib_unit_test("py-LDLT" "unittest/python/test_LDLT.py") +add_python_eigenpy_lib_unit_test("py-FullPivLU" + "unittest/python/test_FullPivLU.py") + +add_python_eigenpy_lib_unit_test("py-PartialPivLU" + "unittest/python/test_PartialPivLU.py") + add_python_eigenpy_lib_unit_test("py-id" "unittest/python/test_id.py") add_python_eigenpy_lib_unit_test("py-QR" "unittest/python/test_QR.py") +add_python_eigenpy_lib_unit_test("py-BDCSVD" "unittest/python/test_BDCSVD.py") + +add_python_eigenpy_lib_unit_test("py-JacobiSVD" + "unittest/python/test_JacobiSVD.py") + if(NOT WIN32) add_python_eigenpy_lib_unit_test("py-MINRES" "unittest/python/test_MINRES.py") endif(NOT WIN32) @@ -182,6 +217,14 @@ if(BUILD_TESTING_SCIPY) add_python_eigenpy_unit_test( "py-SimplicialLDLT" "unittest/python/decompositions/sparse/test_SimplicialLDLT.py") + add_python_eigenpy_unit_test("py-IncompleteCholesky" + "unittest/python/test_IncompleteCholesky.py") + add_python_eigenpy_unit_test("py-IncompleteLUT" + "unittest/python/test_IncompleteLUT.py") + add_python_eigenpy_unit_test( + "py-SparseLU" "unittest/python/decompositions/sparse/test_SparseLU.py") + add_python_eigenpy_unit_test( + "py-SparseQR" "unittest/python/decompositions/sparse/test_SparseQR.py") if(BUILD_WITH_CHOLMOD_SUPPORT) add_python_eigenpy_unit_test( diff --git a/unittest/bind_virtual_factory.cpp b/unittest/bind_virtual_factory.cpp index d142e3657..a2b561d36 100644 --- a/unittest/bind_virtual_factory.cpp +++ b/unittest/bind_virtual_factory.cpp @@ -14,9 +14,9 @@ struct MyVirtualClass { virtual ~MyVirtualClass() {} // polymorphic fn taking arg by shared_ptr - virtual void doSomethingPtr(shared_ptr const &data) const = 0; + virtual void doSomethingPtr(shared_ptr const& data) const = 0; // polymorphic fn taking arg by reference - virtual void doSomethingRef(MyVirtualData &data) const = 0; + virtual void doSomethingRef(MyVirtualData& data) const = 0; virtual shared_ptr createData() const { return std::make_shared(*this); @@ -24,20 +24,20 @@ struct MyVirtualClass { }; struct MyVirtualData { - MyVirtualData(MyVirtualClass const &) {} + MyVirtualData(MyVirtualClass const&) {} virtual ~MyVirtualData() {} // virtual dtor to mark class as polymorphic }; -shared_ptr callDoSomethingPtr(const MyVirtualClass &obj) { +shared_ptr callDoSomethingPtr(const MyVirtualClass& obj) { auto d = obj.createData(); - printf("Created MyVirtualData with address %p\n", (void *)d.get()); + printf("Created MyVirtualData with address %p\n", (void*)d.get()); obj.doSomethingPtr(d); return d; } -shared_ptr callDoSomethingRef(const MyVirtualClass &obj) { +shared_ptr callDoSomethingRef(const MyVirtualClass& obj) { auto d = obj.createData(); - printf("Created MyVirtualData with address %p\n", (void *)d.get()); + printf("Created MyVirtualData with address %p\n", (void*)d.get()); obj.doSomethingRef(*d); return d; } @@ -48,7 +48,7 @@ void throw_virtual_not_implemented_error() { /// Wrapper classes struct VirtualClassWrapper : MyVirtualClass, bp::wrapper { - void doSomethingPtr(shared_ptr const &data) const override { + void doSomethingPtr(shared_ptr const& data) const override { if (bp::override fo = this->get_override("doSomethingPtr")) { /// shared_ptr HAS to be passed by value. /// Boost.Python's argument converter has the wrong behaviour for @@ -63,7 +63,7 @@ struct VirtualClassWrapper : MyVirtualClass, bp::wrapper { /// and wrapped in a @c boost::reference_wrapper when passed to the override. /// Otherwise, Boost.Python's argument converter will convert to Python by /// value and create a copy. - void doSomethingRef(MyVirtualData &data) const override { + void doSomethingRef(MyVirtualData& data) const override { if (bp::override fo = this->get_override("doSomethingRef")) { fo(boost::ref(data)); return; @@ -98,25 +98,25 @@ struct DataWrapper : MyVirtualData, bp::wrapper { }; /// Take and return a const reference -const MyVirtualData &iden_ref(const MyVirtualData &d) { +const MyVirtualData& iden_ref(const MyVirtualData& d) { // try cast to holder return d; } /// Take a shared_ptr (by const reference or value, doesn't matter), return by /// const reference -const MyVirtualData &iden_shared(const shared_ptr &d) { +const MyVirtualData& iden_shared(const shared_ptr& d) { // get boost.python's custom deleter // boost.python hides the handle to the original object in there // dter being nonzero indicates shared_ptr was wrapped by Boost.Python - auto *dter = std::get_deleter(d); + auto* dter = std::get_deleter(d); if (dter != 0) printf("> input shared_ptr has a deleter\n"); return *d; } /// Take and return a shared_ptr -shared_ptr copy_shared(const shared_ptr &d) { - auto *dter = std::get_deleter(d); +shared_ptr copy_shared(const shared_ptr& d) { + auto* dter = std::get_deleter(d); if (dter != 0) printf("> input shared_ptr has a deleter\n"); return d; } @@ -141,7 +141,7 @@ BOOST_PYTHON_MODULE(bind_virtual_factory) { /// otherwise if passed as "HeldType", we need to define /// the constructor and call initializer manually. bp::class_("MyVirtualData", bp::no_init) - .def(bp::init(bp::args("self", "model"))); + .def(bp::init(bp::args("self", "model"))); bp::def("callDoSomethingPtr", callDoSomethingPtr, bp::args("obj")); bp::def("callDoSomethingRef", callDoSomethingRef, bp::args("obj")); diff --git a/unittest/complex.cpp b/unittest/complex.cpp index f4420cae5..cefc622ca 100644 --- a/unittest/complex.cpp +++ b/unittest/complex.cpp @@ -40,7 +40,7 @@ template typename Eigen::Matrix -real(const Eigen::MatrixBase &complex_mat) { +real(const Eigen::MatrixBase& complex_mat) { return complex_mat.real(); } @@ -48,13 +48,13 @@ template typename Eigen::Matrix -imag(const Eigen::MatrixBase &complex_mat) { +imag(const Eigen::MatrixBase& complex_mat) { return complex_mat.imag(); } template Eigen::Matrix, Rows, Cols, Options> ascomplex( - const Eigen::Matrix &mat) { + const Eigen::Matrix& mat) { typedef Eigen::Matrix, Rows, Cols, Options> ReturnType; return ReturnType(mat.template cast>()); } @@ -70,18 +70,18 @@ BOOST_PYTHON_MODULE(complex) { ascomplex); bp::def("real", - (MatrixXf (*)(const Eigen::MatrixBase &))&real); + (MatrixXf (*)(const Eigen::MatrixBase&))&real); bp::def("real", - (MatrixXd (*)(const Eigen::MatrixBase &))&real); + (MatrixXd (*)(const Eigen::MatrixBase&))&real); bp::def( "real", - (MatrixXld (*)(const Eigen::MatrixBase &))&real); + (MatrixXld (*)(const Eigen::MatrixBase&))&real); bp::def("imag", - (MatrixXf (*)(const Eigen::MatrixBase &))&imag); + (MatrixXf (*)(const Eigen::MatrixBase&))&imag); bp::def("imag", - (MatrixXd (*)(const Eigen::MatrixBase &))&imag); + (MatrixXd (*)(const Eigen::MatrixBase&))&imag); bp::def( "imag", - (MatrixXld (*)(const Eigen::MatrixBase &))&imag); + (MatrixXld (*)(const Eigen::MatrixBase&))&imag); } diff --git a/unittest/python/decompositions/sparse/test_SparseLU.py b/unittest/python/decompositions/sparse/test_SparseLU.py new file mode 100644 index 000000000..ee0cd7f3e --- /dev/null +++ b/unittest/python/decompositions/sparse/test_SparseLU.py @@ -0,0 +1,64 @@ +import numpy as np +import scipy.sparse as spa + +import eigenpy + +dim = 100 +rng = np.random.default_rng() + +A_fac = spa.random(dim, dim, density=0.25, random_state=rng) +A = A_fac.T @ A_fac +A += spa.diags(10.0 * rng.standard_normal(dim) ** 2) +A = A.tocsc(True) +A.check_format() + +splu = eigenpy.SparseLU(A) + +assert splu.info() == eigenpy.ComputationInfo.Success + +X = rng.random((dim, 20)) +B = A.dot(X) +X_est = splu.solve(B) +assert isinstance(X_est, np.ndarray) +assert eigenpy.is_approx(X, X_est) +assert eigenpy.is_approx(A.dot(X_est), B) + +splu.analyzePattern(A) +splu.factorize(A) + +X_sparse = spa.random(dim, 10, random_state=rng) +B_sparse = A.dot(X_sparse) +B_sparse: spa.csc_matrix = B_sparse.tocsc(True) +if not B_sparse.has_sorted_indices: + B_sparse.sort_indices() + +X_est = splu.solve(B_sparse) +assert isinstance(X_est, spa.csc_matrix) +assert eigenpy.is_approx(X_est.toarray(), X_sparse.toarray()) +assert eigenpy.is_approx(A.dot(X_est.toarray()), B_sparse.toarray()) + +assert splu.nnzL() > 0 +assert splu.nnzU() > 0 + +L = splu.matrixL() +U = splu.matrixU() + +assert L.rows() == dim +assert L.cols() == dim +assert U.rows() == dim +assert U.cols() == dim + +x_true = rng.random(dim) +b_true = A.dot(x_true) +P_rows_indices = splu.rowsPermutation().indices() +P_cols_indices = splu.colsPermutation().indices() + +b_permuted = b_true[P_rows_indices] +z = b_permuted.copy() +L.solveInPlace(z) +y = z.copy() +U.solveInPlace(y) +x_reconstructed = np.zeros(dim) +x_reconstructed[P_cols_indices] = y + +assert eigenpy.is_approx(x_reconstructed, x_true, prec=1e-6) diff --git a/unittest/python/decompositions/sparse/test_SparseQR.py b/unittest/python/decompositions/sparse/test_SparseQR.py new file mode 100644 index 000000000..f6b6d070c --- /dev/null +++ b/unittest/python/decompositions/sparse/test_SparseQR.py @@ -0,0 +1,95 @@ +import numpy as np +import scipy.sparse as spa + +import eigenpy + +dim = 100 +rng = np.random.default_rng() + +A_fac = spa.random(dim, dim, density=0.25, random_state=rng) +A = A_fac.T @ A_fac +A += spa.diags(10.0 * rng.standard_normal(dim) ** 2) +A = A.tocsc(True) +A.check_format() + +spqr = eigenpy.SparseQR(A) + +assert spqr.info() == eigenpy.ComputationInfo.Success + +X = rng.random((dim, 20)) +B = A.dot(X) +X_est = spqr.solve(B) +assert isinstance(X_est, np.ndarray) +assert eigenpy.is_approx(X, X_est) +assert eigenpy.is_approx(A.dot(X_est), B) + +spqr.analyzePattern(A) +spqr.factorize(A) + +X_sparse = spa.random(dim, 10, random_state=rng) +B_sparse = A.dot(X_sparse) +B_sparse: spa.csc_matrix = B_sparse.tocsc(True) +if not B_sparse.has_sorted_indices: + B_sparse.sort_indices() + +X_est = spqr.solve(B_sparse) +assert isinstance(X_est, spa.csc_matrix) +assert eigenpy.is_approx(X_est.toarray(), X_sparse.toarray()) +assert eigenpy.is_approx(A.dot(X_est.toarray()), B_sparse.toarray()) + +Q = spqr.matrixQ() +R = spqr.matrixR() +P = spqr.colsPermutation() + +assert spqr.matrixQ().rows() == dim +assert spqr.matrixQ().cols() == dim +assert R.shape[0] == dim +assert R.shape[1] == dim +assert P.indices().size == dim + +test_vec = rng.random(dim) +test_matrix = rng.random((dim, 20)) + +Qv = Q @ test_vec +QM = Q @ test_matrix +Qt = Q.transpose() +QtV = Qt @ test_vec +QtM = Qt @ test_matrix + +assert Qv.shape == (dim,) +assert QM.shape == (dim, 20) +assert QtV.shape == (dim,) +assert QtM.shape == (dim, 20) + +Qa_real_mat = Q.adjoint() +QaV = Qa_real_mat @ test_vec +assert eigenpy.is_approx(QtV, QaV) + +A_dense = A.toarray() +P_indices = np.array([P.indices()[i] for i in range(dim)]) +A_permuted = A_dense[:, P_indices] + +QtAP = Qt @ A_permuted +R_dense = spqr.matrixR().toarray() +assert eigenpy.is_approx(QtAP, R_dense) + +Q_sparse = Q.toSparse() +R_sparse = R + +assert Q_sparse.shape == (dim, dim) + +QtQ_sparse = Q_sparse.T @ Q_sparse +QQt_sparse = Q_sparse @ Q_sparse.T +I_sparse = spa.identity(dim, format="csc") + +assert eigenpy.is_approx(QtQ_sparse.toarray(), I_sparse.toarray()) +assert eigenpy.is_approx(QQt_sparse.toarray(), I_sparse.toarray()) + +Q_sparse_test_vec = Q_sparse @ test_vec +assert eigenpy.is_approx(Qv, Q_sparse_test_vec) + +Q_sparse_test_matrix = Q_sparse @ test_matrix +assert eigenpy.is_approx(QM, Q_sparse_test_matrix) + +QR_sparse = Q_sparse @ R_sparse.toarray() +assert eigenpy.is_approx(QR_sparse, A_permuted) diff --git a/unittest/python/test_BDCSVD.py b/unittest/python/test_BDCSVD.py new file mode 100644 index 000000000..72c8e51c8 --- /dev/null +++ b/unittest/python/test_BDCSVD.py @@ -0,0 +1,138 @@ +import numpy as np + +import eigenpy + +_options = [ + 0, + eigenpy.DecompositionOptions.ComputeThinU, + eigenpy.DecompositionOptions.ComputeThinV, + eigenpy.DecompositionOptions.ComputeFullU, + eigenpy.DecompositionOptions.ComputeFullV, + eigenpy.DecompositionOptions.ComputeThinU + | eigenpy.DecompositionOptions.ComputeThinV, + eigenpy.DecompositionOptions.ComputeFullU + | eigenpy.DecompositionOptions.ComputeFullV, + eigenpy.DecompositionOptions.ComputeThinU + | eigenpy.DecompositionOptions.ComputeFullV, + eigenpy.DecompositionOptions.ComputeFullU + | eigenpy.DecompositionOptions.ComputeThinV, +] + + +def test_bdcsvd(options): + dim = 100 + rng = np.random.default_rng() + A = rng.random((dim, dim)) + A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim)) + + bdcsvd = eigenpy.BDCSVD(A, options) + assert bdcsvd.info() == eigenpy.ComputationInfo.Success + + if options & ( + eigenpy.DecompositionOptions.ComputeThinU + | eigenpy.DecompositionOptions.ComputeFullU + ) and options & ( + eigenpy.DecompositionOptions.ComputeThinV + | eigenpy.DecompositionOptions.ComputeFullV + ): + X = rng.random((dim, 20)) + B = A @ X + X_est = bdcsvd.solve(B) + assert eigenpy.is_approx(X, X_est) + assert eigenpy.is_approx(A @ X_est, B) + + x = rng.random(dim) + b = A @ x + x_est = bdcsvd.solve(b) + assert eigenpy.is_approx(x, x_est) + assert eigenpy.is_approx(A @ x_est, b) + + rows = bdcsvd.rows() + cols = bdcsvd.cols() + assert cols == dim + assert rows == dim + + _bdcsvd_compute = bdcsvd.compute(A) + _bdcsvd_compute_options = bdcsvd.compute(A, options) + + rank = bdcsvd.rank() + singularvalues = bdcsvd.singularValues() + nonzerosingularvalues = bdcsvd.nonzeroSingularValues() + assert rank == nonzerosingularvalues + assert len(singularvalues) == dim + assert all( + singularvalues[i] >= singularvalues[i + 1] + for i in range(len(singularvalues) - 1) + ) + + compute_u = bdcsvd.computeU() + compute_v = bdcsvd.computeV() + expected_compute_u = bool( + options + & ( + eigenpy.DecompositionOptions.ComputeThinU + | eigenpy.DecompositionOptions.ComputeFullU + ) + ) + expected_compute_v = bool( + options + & ( + eigenpy.DecompositionOptions.ComputeThinV + | eigenpy.DecompositionOptions.ComputeFullV + ) + ) + assert compute_u == expected_compute_u + assert compute_v == expected_compute_v + + if compute_u: + matrixU = bdcsvd.matrixU() + if options & eigenpy.DecompositionOptions.ComputeFullU: + assert matrixU.shape == (dim, dim) + elif options & eigenpy.DecompositionOptions.ComputeThinU: + assert matrixU.shape == (dim, dim) + assert eigenpy.is_approx(matrixU.T @ matrixU, np.eye(matrixU.shape[1])) + + if compute_v: + matrixV = bdcsvd.matrixV() + if options & eigenpy.DecompositionOptions.ComputeFullV: + assert matrixV.shape == (dim, dim) + elif options & eigenpy.DecompositionOptions.ComputeThinV: + assert matrixV.shape == (dim, dim) + assert eigenpy.is_approx(matrixV.T @ matrixV, np.eye(matrixV.shape[1])) + + if compute_u and compute_v: + U = bdcsvd.matrixU() + V = bdcsvd.matrixV() + S = bdcsvd.singularValues() + S_matrix = np.diag(S) + A_reconstructed = U @ S_matrix @ V.T + assert eigenpy.is_approx(A, A_reconstructed) + + bdcsvd.setSwitchSize(5) + bdcsvd.setSwitchSize(16) + bdcsvd.setSwitchSize(32) + + bdcsvd.setThreshold() + _default_threshold = bdcsvd.threshold() + bdcsvd.setThreshold(1e-8) + assert bdcsvd.threshold() == 1e-8 + + decomp1 = eigenpy.BDCSVD() + decomp2 = eigenpy.BDCSVD() + id1 = decomp1.id() + id2 = decomp2.id() + assert id1 != id2 + assert id1 == decomp1.id() + assert id2 == decomp2.id() + + decomp3 = eigenpy.BDCSVD(dim, dim, options) + decomp4 = eigenpy.BDCSVD(dim, dim, options) + id3 = decomp3.id() + id4 = decomp4.id() + assert id3 != id4 + assert id3 == decomp3.id() + assert id4 == decomp4.id() + + +for opt in _options: + test_bdcsvd(opt) diff --git a/unittest/python/test_ComplexEigenSolver.py b/unittest/python/test_ComplexEigenSolver.py new file mode 100644 index 000000000..8157a7221 --- /dev/null +++ b/unittest/python/test_ComplexEigenSolver.py @@ -0,0 +1,28 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) + +es = eigenpy.ComplexEigenSolver(A) +assert es.info() == eigenpy.ComputationInfo.Success + +V = es.eigenvectors() +D = es.eigenvalues() +assert V.shape == (dim, dim) +assert D.shape == (dim,) + +AV = A @ V +VD = V @ np.diag(D) +assert eigenpy.is_approx(AV.real, VD.real) +assert eigenpy.is_approx(AV.imag, VD.imag) + +ces5 = eigenpy.ComplexEigenSolver(A) +ces6 = eigenpy.ComplexEigenSolver(A) +id5 = ces5.id() +id6 = ces6.id() +assert id5 != id6 +assert id5 == ces5.id() +assert id6 == ces6.id() diff --git a/unittest/python/test_ComplexSchur.py b/unittest/python/test_ComplexSchur.py new file mode 100644 index 000000000..f777dc930 --- /dev/null +++ b/unittest/python/test_ComplexSchur.py @@ -0,0 +1,48 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) + +cs = eigenpy.ComplexSchur(A) +assert cs.info() == eigenpy.ComputationInfo.Success + +U = cs.matrixU() +T = cs.matrixT() + +A_complex = A.astype(complex) +assert eigenpy.is_approx(A_complex, U @ T @ U.conj().T) +assert eigenpy.is_approx(U @ U.conj().T, np.eye(dim)) + +for row in range(1, dim): + for col in range(row): + assert abs(T[row, col]) < 1e-12 + +A_triangular = np.triu(A) +cs_triangular = eigenpy.ComplexSchur(dim) +cs_triangular.setMaxIterations(1) +result_triangular = cs_triangular.compute(A_triangular) +assert result_triangular.info() == eigenpy.ComputationInfo.Success + +T_triangular = cs_triangular.matrixT() +U_triangular = cs_triangular.matrixU() + +A_triangular_complex = A_triangular.astype(complex) +assert eigenpy.is_approx(T_triangular, A_triangular_complex) +assert eigenpy.is_approx(U_triangular, np.eye(dim, dtype=complex)) + +hess = eigenpy.HessenbergDecomposition(A) +H = hess.matrixH() +Q_hess = hess.matrixQ() + +cs_from_hess = eigenpy.ComplexSchur(dim) +result_from_hess = cs_from_hess.computeFromHessenberg(H, Q_hess, True) +assert result_from_hess.info() == eigenpy.ComputationInfo.Success + +T_from_hess = cs_from_hess.matrixT() +U_from_hess = cs_from_hess.matrixU() + +A_complex = A.astype(complex) +assert eigenpy.is_approx(A_complex, U_from_hess @ T_from_hess @ U_from_hess.conj().T) diff --git a/unittest/python/test_eigen_solver.py b/unittest/python/test_EigenSolver.py similarity index 100% rename from unittest/python/test_eigen_solver.py rename to unittest/python/test_EigenSolver.py diff --git a/unittest/python/test_FullPivLU.py b/unittest/python/test_FullPivLU.py new file mode 100644 index 000000000..cdbbc4ad4 --- /dev/null +++ b/unittest/python/test_FullPivLU.py @@ -0,0 +1,109 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) +A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim)) +fullpivlu = eigenpy.FullPivLU(A) + +X = rng.random((dim, 20)) +B = A.dot(X) +X_est = fullpivlu.solve(B) +assert eigenpy.is_approx(X, X_est) +assert eigenpy.is_approx(A.dot(X_est), B) + +x = rng.random(dim) +b = A.dot(x) +x_est = fullpivlu.solve(b) +assert eigenpy.is_approx(x, x_est) +assert eigenpy.is_approx(A.dot(x_est), b) + +rows = fullpivlu.rows() +cols = fullpivlu.cols() +assert cols == dim +assert rows == dim + +fullpivlu_compute = fullpivlu.compute(A) +A_reconstructed = fullpivlu.reconstructedMatrix() +assert eigenpy.is_approx(A_reconstructed, A) + +nonzeropivots = fullpivlu.nonzeroPivots() +maxpivot = fullpivlu.maxPivot() +assert nonzeropivots == dim +assert maxpivot > 0 + +LU = fullpivlu.matrixLU() +P_perm = fullpivlu.permutationP() +Q_perm = fullpivlu.permutationQ() +P = P_perm.toDenseMatrix() +Q = Q_perm.toDenseMatrix() + +U = np.triu(LU) +L = np.eye(dim) + np.tril(LU, -1) +assert eigenpy.is_approx(P @ A @ Q, L @ U) + +rank = fullpivlu.rank() +dimkernel = fullpivlu.dimensionOfKernel() +injective = fullpivlu.isInjective() +surjective = fullpivlu.isSurjective() +invertible = fullpivlu.isInvertible() +assert rank == dim +assert dimkernel == 0 +assert injective +assert surjective +assert invertible + +kernel = fullpivlu.kernel() +assert eigenpy.is_approx(A @ kernel, np.zeros((dim, 1)), 1e-10) +image = fullpivlu.image(A) +assert image.shape[1] == rank + +inverse = fullpivlu.inverse() +assert eigenpy.is_approx(A @ inverse, np.eye(dim)) +assert eigenpy.is_approx(inverse @ A, np.eye(dim)) + +rcond = fullpivlu.rcond() +determinant = fullpivlu.determinant() +det_numpy = np.linalg.det(A) +assert rcond > 0 +assert abs(determinant - det_numpy) / abs(det_numpy) < 1e-10 + +fullpivlu.setThreshold() +default_threshold = fullpivlu.threshold() +fullpivlu.setThreshold(1e-8) +assert fullpivlu.threshold() == 1e-8 + +P_inv = P_perm.inverse().toDenseMatrix() +Q_inv = Q_perm.inverse().toDenseMatrix() +assert eigenpy.is_approx(P @ P_inv, np.eye(dim)) +assert eigenpy.is_approx(Q @ Q_inv, np.eye(dim)) +assert eigenpy.is_approx(P_inv @ P, np.eye(dim)) +assert eigenpy.is_approx(Q_inv @ Q, np.eye(dim)) + +rows_rect = 4 +cols_rect = 6 +A_rect = rng.random((rows_rect, cols_rect)) +fullpivlu_rect = eigenpy.FullPivLU(A_rect) +assert fullpivlu_rect.rows() == rows_rect +assert fullpivlu_rect.cols() == cols_rect +rank_rect = fullpivlu_rect.rank() +assert rank_rect <= min(rows_rect, cols_rect) +assert fullpivlu_rect.dimensionOfKernel() == cols_rect - rank_rect + +decomp1 = eigenpy.FullPivLU() +decomp2 = eigenpy.FullPivLU() +id1 = decomp1.id() +id2 = decomp2.id() +assert id1 != id2 +assert id1 == decomp1.id() +assert id2 == decomp2.id() + +decomp3 = eigenpy.FullPivLU(dim, dim) +decomp4 = eigenpy.FullPivLU(dim, dim) +id3 = decomp3.id() +id4 = decomp4.id() +assert id3 != id4 +assert id3 == decomp3.id() +assert id4 == decomp4.id() diff --git a/unittest/python/test_GeneralizedEigenSolver.py b/unittest/python/test_GeneralizedEigenSolver.py new file mode 100644 index 000000000..66748e5fb --- /dev/null +++ b/unittest/python/test_GeneralizedEigenSolver.py @@ -0,0 +1,41 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) +B = rng.random((dim, dim)) +B = (B + B.T) * 0.5 + np.diag(10.0 + rng.random(dim)) + +ges_matrices = eigenpy.GeneralizedEigenSolver(A, B) +assert ges_matrices.info() == eigenpy.ComputationInfo.Success + +alphas = ges_matrices.alphas() +betas = ges_matrices.betas() +eigenvectors = ges_matrices.eigenvectors() +eigenvalues = ges_matrices.eigenvalues() + +for k in range(dim): + v = eigenvectors[:, k] + lambda_k = eigenvalues[k] + + Av = A @ v + lambda_Bv = lambda_k * (B @ v) + assert eigenpy.is_approx(Av.real, lambda_Bv.real, 1e-6) + assert eigenpy.is_approx(Av.imag, lambda_Bv.imag, 1e-6) + +for k in range(dim): + v = eigenvectors[:, k] + alpha = alphas[k] + beta = betas[k] + + alpha_Bv = alpha * (B @ v) + beta_Av = beta * (A @ v) + assert eigenpy.is_approx(alpha_Bv.real, beta_Av.real, 1e-6) + assert eigenpy.is_approx(alpha_Bv.imag, beta_Av.imag, 1e-6) + +for k in range(dim): + if abs(betas[k]) > 1e-12: + expected_eigenvalue = alphas[k] / betas[k] + assert abs(eigenvalues[k] - expected_eigenvalue) < 1e-12 diff --git a/unittest/python/test_GeneralizedSelfAdjointEigenSolver.py b/unittest/python/test_GeneralizedSelfAdjointEigenSolver.py new file mode 100644 index 000000000..78ea15564 --- /dev/null +++ b/unittest/python/test_GeneralizedSelfAdjointEigenSolver.py @@ -0,0 +1,79 @@ +import numpy as np + +import eigenpy + +_options = [ + eigenpy.DecompositionOptions.ComputeEigenvectors + | eigenpy.DecompositionOptions.Ax_lBx, + eigenpy.DecompositionOptions.EigenvaluesOnly | eigenpy.DecompositionOptions.Ax_lBx, + eigenpy.DecompositionOptions.ComputeEigenvectors + | eigenpy.DecompositionOptions.ABx_lx, + eigenpy.DecompositionOptions.EigenvaluesOnly | eigenpy.DecompositionOptions.ABx_lx, + eigenpy.DecompositionOptions.ComputeEigenvectors + | eigenpy.DecompositionOptions.BAx_lx, + eigenpy.DecompositionOptions.EigenvaluesOnly | eigenpy.DecompositionOptions.BAx_lx, +] + + +def test_generalized_selfadjoint_eigensolver(options): + dim = 100 + rng = np.random.default_rng() + A = rng.random((dim, dim)) + A = (A + A.T) * 0.5 + B = rng.random((dim, dim)) + B = B @ B.T + 0.1 * np.eye(dim) + + gsaes = eigenpy.GeneralizedSelfAdjointEigenSolver(A, B, options) + assert gsaes.info() == eigenpy.ComputationInfo.Success + + D = gsaes.eigenvalues() + assert D.shape == (dim,) + assert all(abs(D[i].imag) < 1e-12 for i in range(dim)) + assert all(D[i] <= D[i + 1] + 1e-12 for i in range(dim - 1)) + + compute_eigenvectors = bool( + options & eigenpy.DecompositionOptions.ComputeEigenvectors + ) + + if compute_eigenvectors: + V = gsaes.eigenvectors() + assert V.shape == (dim, dim) + + if options & eigenpy.DecompositionOptions.Ax_lBx: + for i in range(dim): + v = V[:, i] + lam = D[i] + Av = A @ v + lam_Bv = lam * (B @ v) + assert eigenpy.is_approx(Av, lam_Bv, 1e-6) + + VT_B_V = V.T @ B @ V + assert eigenpy.is_approx(VT_B_V, np.eye(dim), 1e-6) + + elif options & eigenpy.DecompositionOptions.ABx_lx: + AB = A @ B + for i in range(dim): + v = V[:, i] + lam = D[i] + ABv = AB @ v + lam_v = lam * v + assert eigenpy.is_approx(ABv, lam_v, 1e-6) + + elif options & eigenpy.DecompositionOptions.BAx_lx: + BA = B @ A + for i in range(dim): + v = V[:, i] + lam = D[i] + BAv = BA @ v + lam_v = lam * v + assert eigenpy.is_approx(BAv, lam_v, 1e-6) + + _gsaes_compute = gsaes.compute(A, B) + _gsaes_compute_options = gsaes.compute(A, B, options) + + rank = len([d for d in D if abs(d) > 1e-12]) + assert rank <= dim + + +for opt in _options: + test_generalized_selfadjoint_eigensolver(opt) diff --git a/unittest/python/test_geometry.py b/unittest/python/test_Geometry.py similarity index 100% rename from unittest/python/test_geometry.py rename to unittest/python/test_Geometry.py diff --git a/unittest/python/test_HessenbergDecomposition.py b/unittest/python/test_HessenbergDecomposition.py new file mode 100644 index 000000000..095ac7105 --- /dev/null +++ b/unittest/python/test_HessenbergDecomposition.py @@ -0,0 +1,71 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) + +hess = eigenpy.HessenbergDecomposition(A) + +Q = hess.matrixQ() +H = hess.matrixH() + +if np.iscomplexobj(A): + A_reconstructed = Q @ H @ Q.conj().T +else: + A_reconstructed = Q @ H @ Q.T +assert eigenpy.is_approx(A, A_reconstructed) + +for row in range(2, dim): + for col in range(row - 1): + assert abs(H[row, col]) < 1e-12 + +if np.iscomplexobj(Q): + QQ_conj = Q @ Q.conj().T +else: + QQ_conj = Q @ Q.T +assert eigenpy.is_approx(QQ_conj, np.eye(dim)) + +A_test = rng.random((dim, dim)) +hess1 = eigenpy.HessenbergDecomposition(dim) +hess1.compute(A_test) +hess2 = eigenpy.HessenbergDecomposition(A_test) + +H1 = hess1.matrixH() +H2 = hess2.matrixH() +Q1 = hess1.matrixQ() +Q2 = hess2.matrixQ() + +assert eigenpy.is_approx(H1, H2) +assert eigenpy.is_approx(Q1, Q2) + +hCoeffs = hess.householderCoefficients() +packed = hess.packedMatrix() + +assert hCoeffs.shape == (dim - 1,) +assert packed.shape == (dim, dim) + +for i in range(dim): + for j in range(i - 1, dim): + if j >= 0: + assert abs(H[i, j] - packed[i, j]) < 1e-12 + +hess_default = eigenpy.HessenbergDecomposition(dim) +hess_matrix = eigenpy.HessenbergDecomposition(A) + +hess1_id = eigenpy.HessenbergDecomposition(dim) +hess2_id = eigenpy.HessenbergDecomposition(dim) +id1 = hess1_id.id() +id2 = hess2_id.id() +assert id1 != id2 +assert id1 == hess1_id.id() +assert id2 == hess2_id.id() + +hess3_id = eigenpy.HessenbergDecomposition(A) +hess4_id = eigenpy.HessenbergDecomposition(A) +id3 = hess3_id.id() +id4 = hess4_id.id() +assert id3 != id4 +assert id3 == hess3_id.id() +assert id4 == hess4_id.id() diff --git a/unittest/python/test_IncompleteCholesky.py b/unittest/python/test_IncompleteCholesky.py new file mode 100644 index 000000000..b634f8b90 --- /dev/null +++ b/unittest/python/test_IncompleteCholesky.py @@ -0,0 +1,71 @@ +import numpy as np +from scipy.sparse import csc_matrix + +import eigenpy + +dim = 100 +rng = np.random.default_rng() + +A = rng.random((dim, dim)) +A = (A + A.T) * 0.5 + np.diag(5.0 + rng.random(dim)) +A = csc_matrix(A) + +ichol = eigenpy.solvers.IncompleteCholesky(A) +assert ichol.info() == eigenpy.ComputationInfo.Success +assert ichol.rows() == dim +assert ichol.cols() == dim + +X = rng.random((dim, 20)) +B = A.dot(X) +X_est = ichol.solve(B) +assert isinstance(X_est, np.ndarray) +residual = np.linalg.norm(B - A.dot(X_est)) / np.linalg.norm(B) +assert residual < 0.1 + +x = rng.random(dim) +b = A.dot(x) +x_est = ichol.solve(b) +assert isinstance(x_est, np.ndarray) +residual = np.linalg.norm(b - A.dot(x_est)) / np.linalg.norm(b) +assert residual < 0.1 + +X_sparse = csc_matrix(rng.random((dim, 10))) +B_sparse = A.dot(X_sparse).tocsc() +if not B_sparse.has_sorted_indices: + B_sparse.sort_indices() +X_est_sparse = ichol.solve(B_sparse) +assert isinstance(X_est_sparse, csc_matrix) + +ichol.analyzePattern(A) +ichol.factorize(A) +ichol.compute(A) +assert ichol.info() == eigenpy.ComputationInfo.Success + +L = ichol.matrixL() +S_diag = ichol.scalingS() +perm = ichol.permutationP() +P = perm.toDenseMatrix() + +assert isinstance(L, csc_matrix) +assert isinstance(S_diag, np.ndarray) +assert L.shape == (dim, dim) +assert S_diag.shape == (dim,) + +L_dense = L.toarray() +upper_part = np.triu(L_dense, k=1) +assert np.allclose(upper_part, 0, atol=1e-12) + +assert np.all(S_diag > 0) + +S = csc_matrix((S_diag, (range(dim), range(dim))), shape=(dim, dim)) + +PA = P @ A +PAP = PA @ P.T +SPAP = S @ PAP +SPAPS = SPAP @ S + +LLT = L @ L.T + +diff = SPAPS - LLT +relative_error = np.linalg.norm(diff.data) / np.linalg.norm(SPAPS.data) +assert relative_error < 0.5 diff --git a/unittest/python/test_IncompleteLUT.py b/unittest/python/test_IncompleteLUT.py new file mode 100644 index 000000000..0ff820ef7 --- /dev/null +++ b/unittest/python/test_IncompleteLUT.py @@ -0,0 +1,50 @@ +import numpy as np +from scipy.sparse import csc_matrix + +import eigenpy + +dim = 100 +rng = np.random.default_rng() + +A = rng.random((dim, dim)) +A = (A + A.T) * 0.5 + np.diag(5.0 + rng.random(dim)) +A = csc_matrix(A) + +ilut = eigenpy.solvers.IncompleteLUT(A) +assert ilut.info() == eigenpy.ComputationInfo.Success +assert ilut.rows() == dim +assert ilut.cols() == dim + +X = rng.random((dim, 100)) +B = A.dot(X) +X_est = ilut.solve(B) +assert isinstance(X_est, np.ndarray) +residual = np.linalg.norm(B - A.dot(X_est)) / np.linalg.norm(B) +assert residual < 0.1 + +x = rng.random(dim) +b = A.dot(x) +x_est = ilut.solve(b) +assert isinstance(x_est, np.ndarray) +residual = np.linalg.norm(b - A.dot(x_est)) / np.linalg.norm(b) +assert residual < 0.1 + +X_sparse = csc_matrix(rng.random((dim, 10))) +B_sparse = A.dot(X_sparse).tocsc() +if not B_sparse.has_sorted_indices: + B_sparse.sort_indices() +X_est_sparse = ilut.solve(B_sparse) +assert isinstance(X_est_sparse, csc_matrix) + +ilut.analyzePattern(A) +ilut.factorize(A) +assert ilut.info() == eigenpy.ComputationInfo.Success + +ilut_params = eigenpy.solvers.IncompleteLUT(A, 1e-4, 15) +assert ilut_params.info() == eigenpy.ComputationInfo.Success + +ilut_set = eigenpy.solvers.IncompleteLUT() +ilut_set.setDroptol(1e-3) +ilut_set.setFillfactor(20) +ilut_set.compute(A) +assert ilut_set.info() == eigenpy.ComputationInfo.Success diff --git a/unittest/python/test_JacobiSVD.py b/unittest/python/test_JacobiSVD.py new file mode 100644 index 000000000..a9c975c90 --- /dev/null +++ b/unittest/python/test_JacobiSVD.py @@ -0,0 +1,114 @@ +import numpy as np + +import eigenpy + +THIN_U = eigenpy.DecompositionOptions.ComputeThinU +THIN_V = eigenpy.DecompositionOptions.ComputeThinV +FULL_U = eigenpy.DecompositionOptions.ComputeFullU +FULL_V = eigenpy.DecompositionOptions.ComputeFullV + +_options = [ + 0, + # THIN_U, + # THIN_V, + # FULL_U, + # FULL_V, + THIN_U | THIN_V, + FULL_U | FULL_V, + # THIN_U | FULL_V, + # FULL_U | THIN_V, +] + +_classes = [ + eigenpy.ColPivHhJacobiSVD, + # eigenpy.FullPivHhJacobiSVD, + # eigenpy.HhJacobiSVD, + # eigenpy.NoPrecondJacobiSVD, +] + +# Rationale: Tets only few cases to gain computation time +# User can test all of them by uncommenting the corresponding lines + + +def is_valid_combination(cls, opt): + if cls == eigenpy.FullPivHhJacobiSVD: + has_thin_u = bool(opt & THIN_U) + has_thin_v = bool(opt & THIN_V) + + if has_thin_u or has_thin_v: + return False + + return True + + +def test_jacobi(cls, opt): + dim = 100 + rng = np.random.default_rng() + A = rng.random((dim, dim)) + A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim)) + + jacobisvd = cls(A, opt) + assert jacobisvd.info() == eigenpy.ComputationInfo.Success + + has_u = opt & (THIN_U | FULL_U) + has_v = opt & (THIN_V | FULL_V) + + if has_u and has_v: + X = rng.random((dim, 20)) + B = A @ X + X_est = jacobisvd.solve(B) + assert eigenpy.is_approx(X, X_est) + assert eigenpy.is_approx(A @ X_est, B) + + x = rng.random(dim) + b = A @ x + x_est = jacobisvd.solve(b) + assert eigenpy.is_approx(x, x_est) + assert eigenpy.is_approx(A @ x_est, b) + + assert jacobisvd.rows() == dim + assert jacobisvd.cols() == dim + + _jacobisvd_compute = jacobisvd.compute(A) + _jacobisvd_compute_options = jacobisvd.compute(A, opt) + + rank = jacobisvd.rank() + singularvalues = jacobisvd.singularValues() + nonzerosingularvalues = jacobisvd.nonzeroSingularValues() + assert rank == nonzerosingularvalues + assert len(singularvalues) == dim + assert all( + singularvalues[i] >= singularvalues[i + 1] + for i in range(len(singularvalues) - 1) + ) + + compute_u = jacobisvd.computeU() + compute_v = jacobisvd.computeV() + expected_compute_u = bool(has_u) + expected_compute_v = bool(has_v) + assert compute_u == expected_compute_u + assert compute_v == expected_compute_v + + if compute_u: + matrixU = jacobisvd.matrixU() + assert matrixU.shape == (dim, dim) + assert eigenpy.is_approx(matrixU.T @ matrixU, np.eye(matrixU.shape[1])) + + if compute_v: + matrixV = jacobisvd.matrixV() + assert matrixV.shape == (dim, dim) + assert eigenpy.is_approx(matrixV.T @ matrixV, np.eye(matrixV.shape[1])) + + if compute_u and compute_v: + U = jacobisvd.matrixU() + V = jacobisvd.matrixV() + S = jacobisvd.singularValues() + S_matrix = np.diag(S) + A_reconstructed = U @ S_matrix @ V.T + assert eigenpy.is_approx(A, A_reconstructed) + + +for cls in _classes: + for opt in _options: + if is_valid_combination(cls, opt): + test_jacobi(cls, opt) diff --git a/unittest/python/test_MINRES.py b/unittest/python/test_MINRES.py index b630ad4bc..c830a4f77 100644 --- a/unittest/python/test_MINRES.py +++ b/unittest/python/test_MINRES.py @@ -6,11 +6,16 @@ rng = np.random.default_rng() A = np.eye(dim) -minres = eigenpy.MINRES(A) +minres = eigenpy.solvers.MINRES(A) X = rng.random((dim, 20)) B = A.dot(X) X_est = minres.solve(B) -print("A.dot(X_est):", A.dot(X_est)) -print("B:", B) +assert eigenpy.is_approx(A.dot(X_est), B, 1e-6) + +minres_back = eigenpy.MINRES(A) + +X = rng.random((dim, 20)) +B = A.dot(X) +X_est = minres_back.solve(B) assert eigenpy.is_approx(A.dot(X_est), B, 1e-6) diff --git a/unittest/python/test_PartialPivLU.py b/unittest/python/test_PartialPivLU.py new file mode 100644 index 000000000..487a515f5 --- /dev/null +++ b/unittest/python/test_PartialPivLU.py @@ -0,0 +1,76 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) +A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim)) +partialpivlu = eigenpy.PartialPivLU(A) + +X = rng.random((dim, 20)) +B = A.dot(X) +X_est = partialpivlu.solve(B) +assert eigenpy.is_approx(X, X_est) +assert eigenpy.is_approx(A.dot(X_est), B) + +x = rng.random(dim) +b = A.dot(x) +x_est = partialpivlu.solve(b) +assert eigenpy.is_approx(x, x_est) +assert eigenpy.is_approx(A.dot(x_est), b) + +rows = partialpivlu.rows() +cols = partialpivlu.cols() +assert cols == dim +assert rows == dim + +partialpivlu_compute = partialpivlu.compute(A) +A_reconstructed = partialpivlu.reconstructedMatrix() +assert eigenpy.is_approx(A_reconstructed, A) + +LU = partialpivlu.matrixLU() +P_perm = partialpivlu.permutationP() +P = P_perm.toDenseMatrix() + +U = np.triu(LU) +L = np.eye(dim) + np.tril(LU, -1) +assert eigenpy.is_approx(P @ A, L @ U) + +inverse = partialpivlu.inverse() +assert eigenpy.is_approx(A @ inverse, np.eye(dim)) +assert eigenpy.is_approx(inverse @ A, np.eye(dim)) + +rcond = partialpivlu.rcond() +determinant = partialpivlu.determinant() +det_numpy = np.linalg.det(A) +assert rcond > 0 +assert abs(determinant - det_numpy) / abs(det_numpy) < 1e-10 + +P_inv = P_perm.inverse().toDenseMatrix() +assert eigenpy.is_approx(P @ P_inv, np.eye(dim)) +assert eigenpy.is_approx(P_inv @ P, np.eye(dim)) + +decomp1 = eigenpy.PartialPivLU() +decomp2 = eigenpy.PartialPivLU() +id1 = decomp1.id() +id2 = decomp2.id() +assert id1 != id2 +assert id1 == decomp1.id() +assert id2 == decomp2.id() + +decomp3 = eigenpy.PartialPivLU(dim) +decomp4 = eigenpy.PartialPivLU(dim) +id3 = decomp3.id() +id4 = decomp4.id() +assert id3 != id4 +assert id3 == decomp3.id() +assert id4 == decomp4.id() + +decomp5 = eigenpy.PartialPivLU(A) +decomp6 = eigenpy.PartialPivLU(A) +id5 = decomp5.id() +id6 = decomp6.id() +assert id5 != id6 +assert id5 == decomp5.id() +assert id6 == decomp6.id() diff --git a/unittest/python/test_RealQZ.py b/unittest/python/test_RealQZ.py new file mode 100644 index 000000000..df6262d43 --- /dev/null +++ b/unittest/python/test_RealQZ.py @@ -0,0 +1,38 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) +B = rng.random((dim, dim)) + +realqz = eigenpy.RealQZ(A, B) +assert realqz.info() == eigenpy.ComputationInfo.Success + +Q = realqz.matrixQ() +S = realqz.matrixS() +Z = realqz.matrixZ() +T = realqz.matrixT() + +assert eigenpy.is_approx(A, Q @ S @ Z) +assert eigenpy.is_approx(B, Q @ T @ Z) + +assert eigenpy.is_approx(Q @ Q.T, np.eye(dim)) +assert eigenpy.is_approx(Z @ Z.T, np.eye(dim)) + +for i in range(dim): + for j in range(i): + assert abs(T[i, j]) < 1e-12 + +for i in range(dim): + for j in range(i - 1): + assert abs(S[i, j]) < 1e-12 + +realqz3_id = eigenpy.RealQZ(A, B) +realqz4_id = eigenpy.RealQZ(A, B) +id3 = realqz3_id.id() +id4 = realqz4_id.id() +assert id3 != id4 +assert id3 == realqz3_id.id() +assert id4 == realqz4_id.id() diff --git a/unittest/python/test_RealSchur.py b/unittest/python/test_RealSchur.py new file mode 100644 index 000000000..069d41394 --- /dev/null +++ b/unittest/python/test_RealSchur.py @@ -0,0 +1,49 @@ +import numpy as np + +import eigenpy + + +def verify_is_quasi_triangular(T): + size = T.shape[0] + + for row in range(2, size): + for col in range(row - 1): + assert abs(T[row, col]) < 1e-12 + + for row in range(1, size): + if abs(T[row, row - 1]) > 1e-12: + if row < size - 1: + assert abs(T[row + 1, row]) < 1e-12 + + tr = T[row - 1, row - 1] + T[row, row] + det = T[row - 1, row - 1] * T[row, row] - T[row - 1, row] * T[row, row - 1] + assert 4 * det > tr * tr + + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) + +rs = eigenpy.RealSchur(A) +assert rs.info() == eigenpy.ComputationInfo.Success + +U = rs.matrixU() +T = rs.matrixT() + +assert eigenpy.is_approx(A, U @ T @ U.T) +assert eigenpy.is_approx(U @ U.T, np.eye(dim)) + +verify_is_quasi_triangular(T) + +hess = eigenpy.HessenbergDecomposition(A) +H = hess.matrixH() +Q_hess = hess.matrixQ() + +rs_from_hess = eigenpy.RealSchur(dim) +result_from_hess = rs_from_hess.computeFromHessenberg(H, Q_hess, True) +assert result_from_hess.info() == eigenpy.ComputationInfo.Success + +T_from_hess = rs_from_hess.matrixT() +U_from_hess = rs_from_hess.matrixU() + +assert eigenpy.is_approx(A, U_from_hess @ T_from_hess @ U_from_hess.T) diff --git a/unittest/python/test_self_adjoint_eigen_solver.py b/unittest/python/test_SelfAdjointEigenSolver.py similarity index 100% rename from unittest/python/test_self_adjoint_eigen_solver.py rename to unittest/python/test_SelfAdjointEigenSolver.py diff --git a/unittest/python/test_Tridiagonalization.py b/unittest/python/test_Tridiagonalization.py new file mode 100644 index 000000000..1270c778d --- /dev/null +++ b/unittest/python/test_Tridiagonalization.py @@ -0,0 +1,104 @@ +import numpy as np + +import eigenpy + +dim = 100 +rng = np.random.default_rng() +A = rng.random((dim, dim)) +A = (A + A.T) * 0.5 + +tri = eigenpy.Tridiagonalization(A) + +Q = tri.matrixQ() +T = tri.matrixT() + +assert eigenpy.is_approx(A, Q @ T @ Q.T) +assert eigenpy.is_approx(Q @ Q.T, np.eye(dim)) + +for i in range(dim): + for j in range(dim): + if abs(i - j) > 1: + assert abs(T[i, j]) < 1e-12 + +assert eigenpy.is_approx(T, T.T) + +diag = tri.diagonal() +sub_diag = tri.subDiagonal() + +for i in range(dim): + assert abs(diag[i] - T[i, i]) < 1e-12 + +for i in range(dim - 1): + assert abs(sub_diag[i] - T[i + 1, i]) < 1e-12 + +A_test = rng.random((dim, dim)) +A_test = (A_test + A_test.T) * 0.5 + +tri1 = eigenpy.Tridiagonalization(dim) +tri1.compute(A_test) +tri2 = eigenpy.Tridiagonalization(A_test) + +Q1 = tri1.matrixQ() +T1 = tri1.matrixT() +Q2 = tri2.matrixQ() +T2 = tri2.matrixT() + +assert eigenpy.is_approx(Q1, Q2) +assert eigenpy.is_approx(T1, T2) + +h_coeffs = tri.householderCoefficients() +packed = tri.packedMatrix() + +assert h_coeffs.shape == (dim - 1,) +assert packed.shape == (dim, dim) + +for i in range(dim): + for j in range(i + 1, dim): + assert abs(packed[i, j] - A[i, j]) < 1e-12 + +for i in range(dim): + assert abs(packed[i, i] - T[i, i]) < 1e-12 + if i < dim - 1: + assert abs(packed[i + 1, i] - T[i + 1, i]) < 1e-12 + +A_diag = np.diag(rng.random(dim)) +tri_diag = eigenpy.Tridiagonalization(A_diag) +Q_diag = tri_diag.matrixQ() +T_diag = tri_diag.matrixT() + +assert eigenpy.is_approx(A_diag, Q_diag @ T_diag @ Q_diag.T) +for i in range(dim): + for j in range(dim): + if i != j: + assert abs(T_diag[i, j]) < 1e-10 + +A_tridiag = np.zeros((dim, dim)) +for i in range(dim): + A_tridiag[i, i] = rng.random() + if i < dim - 1: + val = rng.random() + A_tridiag[i, i + 1] = val + A_tridiag[i + 1, i] = val + +tri_tridiag = eigenpy.Tridiagonalization(A_tridiag) +Q_tridiag = tri_tridiag.matrixQ() +T_tridiag = tri_tridiag.matrixT() + +assert eigenpy.is_approx(A_tridiag, Q_tridiag @ T_tridiag @ Q_tridiag.T) + + +tri1_id = eigenpy.Tridiagonalization(dim) +tri2_id = eigenpy.Tridiagonalization(dim) +id1 = tri1_id.id() +id2 = tri2_id.id() +assert id1 != id2 +assert id1 == tri1_id.id() +assert id2 == tri2_id.id() + +tri3_id = eigenpy.Tridiagonalization(A) +tri4_id = eigenpy.Tridiagonalization(A) +id3 = tri3_id.id() +id4 = tri4_id.id() +assert id3 != id4 +assert id3 == tri3_id.id() +assert id4 == tri4_id.id() diff --git a/unittest/python/test_std_vector.py b/unittest/python/test_std_vector.py index 1b0ace614..3af9723cf 100644 --- a/unittest/python/test_std_vector.py +++ b/unittest/python/test_std_vector.py @@ -98,3 +98,20 @@ def checkZero(v): # Test mutable __getitem__ l5[0][:] = 0.0 assert np.allclose(l5[0], 0.0) + +# Test slicing +l6 = eigenpy.StdVec_VectorXd() +for _ in range(4): + l6.append(rng.random(3)) +checkAllValues(l6[:1], l6.tolist()[:1]) +checkAllValues(l6[1:], l6.tolist()[1:]) +checkAllValues(l6[:-1], l6.tolist()[:-1]) +checkAllValues(l6[::2], l6.tolist()[::2]) +L = [0, 2] +L6_copy = l6[L] +for k, i in enumerate(L): + checkAllValues(L6_copy[k], l6[i]) +T = (0, 2) +L6_copy = l6[T] +for k, i in enumerate(L): + checkAllValues(L6_copy[k], l6[i]) diff --git a/unittest/std_vector.cpp b/unittest/std_vector.cpp index 75a660b7f..f8deffbf5 100644 --- a/unittest/std_vector.cpp +++ b/unittest/std_vector.cpp @@ -9,7 +9,7 @@ template void printVectorOfMatrix( - const std::vector> &Ms) { + const std::vector>& Ms) { const std::size_t n = Ms.size(); for (std::size_t i = 0; i < n; i++) { std::cout << "el[" << i << "] =\n" << Ms[i] << '\n'; @@ -18,20 +18,20 @@ void printVectorOfMatrix( template std::vector> copy( - const std::vector> &Ms) { + const std::vector>& Ms) { std::vector> out = Ms; return out; } template -void setZero(std::vector> &Ms) { +void setZero(std::vector>& Ms) { for (std::size_t i = 0; i < Ms.size(); i++) { Ms[i].setZero(); } } struct CustomTestStruct { - bool operator==(const CustomTestStruct &) const { return true; } + bool operator==(const CustomTestStruct&) const { return true; } }; BOOST_PYTHON_MODULE(std_vector) {