pyVolutionary 2.4.1__tar.gz → 2.5.0__tar.gz

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/PKG-INFO

@@ -1,30 +1,23 @@
 Metadata-Version: 2.1
 Name: pyVolutionary
-Version: 2.4.1
+Version: 2.5.0
 Summary: pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems.
 Home-page: https://github.com/matteocacciola/pyvolutionary
 License: MIT
 Author: Matteo Cacciola
 Author-email: matteo.cacciola@gmail.com
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.10
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
-Requires-Dist: coverage (>=7.3.2,<8.0.0)
-Requires-Dist: install (>=1.3.5,<2.0.0)
-Requires-Dist: matplotlib (>=3.8.1,<4.0.0)
-Requires-Dist: numpy (>=1.26.1,<2.0.0)
-Requires-Dist: opfunu (>=1.0.1,<2.0.0)
+Requires-Dist: numpy (>=2.1.1,<3.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
-Requires-Dist: pydantic (>=2.4.2,<3.0.0)
+Requires-Dist: pydantic (>=2.9.0,<3.0.0)
 Requires-Dist: scipy (>=1.12.0,<2.0.0)
-Requires-Dist: sphynx (>=0.0.3,<0.0.4)
 Project-URL: Repository, https://github.com/matteocacciola/pyvolutionary
 Description-Content-Type: text/markdown
 
@@ -40,11 +33,13 @@ Description-Content-Type: text/markdown
 ![GitHub last commit (branch)](https://img.shields.io/github/last-commit/matteocacciola/pyvolutionary/master)
 ![GitHub issues](https://img.shields.io/github/issues/matteocacciola/pyvolutionary)
 [![Wheel](https://img.shields.io/pypi/wheel/gensim.svg)](https://pypi.python.org/pypi/pyvolutionary) 
-[![PyPI version](https://badge.fury.io/py/pyvolutionary.svg)](https://badge.fury.io/py/pyvolutionary)
+![PyPI - Version](https://img.shields.io/pypi/v/pyvolutionary)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyvolutionary)
 ![PyPI - Status](https://img.shields.io/pypi/status/pyvolutionary)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/pyvolutionary.svg)
 [![Downloads](https://static.pepy.tech/badge/pyvolutionary)](https://pepy.tech/project/pyvolutionary)
+[![Downloads](https://static.pepy.tech/badge/pyvolutionary/month)](https://pepy.tech/project/pyvolutionary)
+[![Downloads](https://static.pepy.tech/badge/pyvolutionary/week)](https://pepy.tech/project/pyvolutionary)
 ![GitHub Release Date](https://img.shields.io/github/release-date/matteocacciola/pyvolutionary.svg)
 ![GitHub contributors](https://img.shields.io/github/contributors/matteocacciola/pyvolutionary.svg)
 [![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/matteocacciola/pyvolutionary.svg)](http://isitmaintained.com/project/matteocacciola/pyvolutionary "Average time to resolve an issue")
@@ -712,6 +707,7 @@ The following algorithms are currently implemented in **pyVolutionary**:
 | Electromagnetic Field Optimization                     | `ElectromagneticFieldOptimization`       | 2016 | [paper](https://doi.org/10.1016/j.swevo.2015.07.002)                                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/efo.py)     |
 | Elephant Herd Optimization                             | `ElephantHerdOptimization`               | 2015 | [paper](https://ieeexplore.ieee.org/document/7383528)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/eho.py)     |
 | Energy Valley Optimization                             | `EnergyValleyOptimization`               | 2023 | [paper](https://www.nature.com/articles/s41598-022-27344-y)                                                                                                                                                                   | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/evo.py)     |
+| Fick's Law Optimization                                | `FicksLawOptimization`                   | 2023 | [paper](https://www.mathworks.com/matlabcentral/fileexchange/121033-fick-s-law-algorithm-fla)                                                                                                                                 | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/flao.py)    |
 | Firefly Swarm Optimization                             | `FireflySwarmOptimization`               | 2009 | [paper](https://doi.org/10.1504/IJBIC.2010.032124)                                                                                                                                                                            | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/fso.py)     |
 | Fire Hawk Optimization                                 | `FireHawkOptimization`                   | 2022 | [paper](https://link.springer.com/article/10.1007/s10462-022-10173-w)                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/fho.py)     |
 | Fireworks Optimization                                 | `FireworksOptimization`                  | 2010 | [paper](https://doi.org/10.1504/IJBIC.2010.037285)                                                                                                                                                                            | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/fwa.py)     |
@@ -730,6 +726,8 @@ The following algorithms are currently implemented in **pyVolutionary**:
 | Grey Wolf Optimization                                 | `GreyWolfOptimization`                   | 2014 | [paper](https://doi.org/10.1016/j.advengsoft.2013.12.007)                                                                                                                                                                     | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/gwo.py)     |
 | Harmony Search Optimization                            | `HarmonySearchOptimization`              | 2001 | [paper](https://doi.org/10.1177/003754970107600201)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hso.py)     |
 | Heap Based Optimization                                | `HeapBasedOptimization`                  | 2020 | [paper](https://www.sciencedirect.com/science/article/abs/pii/S0957417420305261#!)                                                                                                                                            | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hbo.py)     |
+| Henry Gas Solubility Optimization                      | `HenryGasSolubilityOptimization`         | 2019 | [paper](https://www.sciencedirect.com/science/article/abs/pii/S0167739X19306557)                                                                                                                                              | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hgsop.py)   |
+| Hunger Games Search Optimization                       | `HungerGamesSearchOptimization`          | 2021 | [paper](https://aliasgharheidari.com/HGS.html)                                                                                                                                                                                | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hgso.py)    |
 | Imperialist Competitive Optimization                   | `ImperialistCompetitiveOptimization`     | 2013 | [paper](https://doi.org/10.1109/ICCKE.2013.6687751)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/ico.py)     |
 | Invasive Weed Optimization                             | `InvasiveWeedOptimization`               | 2006 | [paper](https://doi.org/10.1016/j.ecoinf.2006.07.003)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/iwo.py)     |
 | Krill Herd Optimization                                | `KrillHerdOptimization`                  | 2012 | [paper](https://doi.org/10.1016/j.cnsns.2012.05.010)                                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/kho.py)     |
@@ -738,11 +736,13 @@ The following algorithms are currently implemented in **pyVolutionary**:
 | Monarch Butterfly Optimization                         | `MonarchButterflyOptimization`           | 2019 | [paper](https://link.springer.com/article/10.1007/s00521-015-1923-y)                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mbo.py)     |
 | Moth-Flame Optimization                                | `MothFlameOptimization`                  | 2015 | [paper](https://doi.org/10.1016/j.knosys.2015.07.006)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mfo.py)     |
 | Mountain Gazelle Optimization                          | `MountainGazelleOptimization`            | 2022 | [paper](https://doi.org/10.1016/j.advengsoft.2022.103282)                                                                                                                                                                     | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mgo.py)     |
+| Multi-verse Optimization                               | `MultiverseOptimization`                 | 2016 | [paper](https://dx.doi.org/10.1007/s00521-015-1870-7)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mvo.py)     |
 | Nuclear Reaction Optimization                          | `NuclearReactionOptimization`            | 2019 | [paper](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=8720256)                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/nro.py)     |
 | Osprey Optimization                                    | `OspreyOptimization`                     | 2023 | [paper](https://www.frontiersin.org/articles/10.3389/fmech.2022.1126450/full)                                                                                                                                                 | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/ooa.py)     |
 | Particle Swarm Optimization                            | `ParticleSwarmOptimization`              | 1995 | [paper](https://ieeexplore.ieee.org/document/488968)                                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/pso.py)     |
 | Pathfinder Algorithm Optimization                      | `PathfinderAlgorithmOptimization`        | 2019 | [paper](https://doi.org/10.1016/j.asoc.2019.03.012)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/pfao.py)    |
 | Pelican Optimization                                   | `PelicanOptimization`                    | 2022 | [paper](https://www.mdpi.com/1424-8220/22/3/855)                                                                                                                                                                              | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/poa.py)     |
+| Runge Kutta Optimization                               | `RungeKuttaOptimization`                 | 2021 | [paper](https://doi.org/10.1016/j.eswa.2021.115079)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/rko.py)     |
 | Salp Swarm Optimization                                | `SalpSwarmOptimization`                  | 2017 | [paper](https://doi.org/10.1016/j.advengsoft.2017.07.002)                                                                                                                                                                     | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/sso.py)     |
 | Seagull Optimization                                   | `SeagullOptimization`                    | 2019 | [paper](https://doi.org/10.1016/j.knosys.2018.11.024)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/so.py)      |
 | Serval Optimization                                    | `ServalOptimization`                     | 2022 | [paper](https://www.mdpi.com/2313-7673/7/4/204)                                                                                                                                                                               | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/servo.py)   |

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/README.md

@@ -10,11 +10,13 @@
 ![GitHub last commit (branch)](https://img.shields.io/github/last-commit/matteocacciola/pyvolutionary/master)
 ![GitHub issues](https://img.shields.io/github/issues/matteocacciola/pyvolutionary)
 [![Wheel](https://img.shields.io/pypi/wheel/gensim.svg)](https://pypi.python.org/pypi/pyvolutionary) 
-[![PyPI version](https://badge.fury.io/py/pyvolutionary.svg)](https://badge.fury.io/py/pyvolutionary)
+![PyPI - Version](https://img.shields.io/pypi/v/pyvolutionary)
 ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyvolutionary)
 ![PyPI - Status](https://img.shields.io/pypi/status/pyvolutionary)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/pyvolutionary.svg)
 [![Downloads](https://static.pepy.tech/badge/pyvolutionary)](https://pepy.tech/project/pyvolutionary)
+[![Downloads](https://static.pepy.tech/badge/pyvolutionary/month)](https://pepy.tech/project/pyvolutionary)
+[![Downloads](https://static.pepy.tech/badge/pyvolutionary/week)](https://pepy.tech/project/pyvolutionary)
 ![GitHub Release Date](https://img.shields.io/github/release-date/matteocacciola/pyvolutionary.svg)
 ![GitHub contributors](https://img.shields.io/github/contributors/matteocacciola/pyvolutionary.svg)
 [![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/matteocacciola/pyvolutionary.svg)](http://isitmaintained.com/project/matteocacciola/pyvolutionary "Average time to resolve an issue")
@@ -682,6 +684,7 @@ The following algorithms are currently implemented in **pyVolutionary**:
 | Electromagnetic Field Optimization                     | `ElectromagneticFieldOptimization`       | 2016 | [paper](https://doi.org/10.1016/j.swevo.2015.07.002)                                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/efo.py)     |
 | Elephant Herd Optimization                             | `ElephantHerdOptimization`               | 2015 | [paper](https://ieeexplore.ieee.org/document/7383528)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/eho.py)     |
 | Energy Valley Optimization                             | `EnergyValleyOptimization`               | 2023 | [paper](https://www.nature.com/articles/s41598-022-27344-y)                                                                                                                                                                   | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/evo.py)     |
+| Fick's Law Optimization                                | `FicksLawOptimization`                   | 2023 | [paper](https://www.mathworks.com/matlabcentral/fileexchange/121033-fick-s-law-algorithm-fla)                                                                                                                                 | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/flao.py)    |
 | Firefly Swarm Optimization                             | `FireflySwarmOptimization`               | 2009 | [paper](https://doi.org/10.1504/IJBIC.2010.032124)                                                                                                                                                                            | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/fso.py)     |
 | Fire Hawk Optimization                                 | `FireHawkOptimization`                   | 2022 | [paper](https://link.springer.com/article/10.1007/s10462-022-10173-w)                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/fho.py)     |
 | Fireworks Optimization                                 | `FireworksOptimization`                  | 2010 | [paper](https://doi.org/10.1504/IJBIC.2010.037285)                                                                                                                                                                            | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/fwa.py)     |
@@ -700,6 +703,8 @@ The following algorithms are currently implemented in **pyVolutionary**:
 | Grey Wolf Optimization                                 | `GreyWolfOptimization`                   | 2014 | [paper](https://doi.org/10.1016/j.advengsoft.2013.12.007)                                                                                                                                                                     | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/gwo.py)     |
 | Harmony Search Optimization                            | `HarmonySearchOptimization`              | 2001 | [paper](https://doi.org/10.1177/003754970107600201)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hso.py)     |
 | Heap Based Optimization                                | `HeapBasedOptimization`                  | 2020 | [paper](https://www.sciencedirect.com/science/article/abs/pii/S0957417420305261#!)                                                                                                                                            | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hbo.py)     |
+| Henry Gas Solubility Optimization                      | `HenryGasSolubilityOptimization`         | 2019 | [paper](https://www.sciencedirect.com/science/article/abs/pii/S0167739X19306557)                                                                                                                                              | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hgsop.py)   |
+| Hunger Games Search Optimization                       | `HungerGamesSearchOptimization`          | 2021 | [paper](https://aliasgharheidari.com/HGS.html)                                                                                                                                                                                | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/hgso.py)    |
 | Imperialist Competitive Optimization                   | `ImperialistCompetitiveOptimization`     | 2013 | [paper](https://doi.org/10.1109/ICCKE.2013.6687751)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/ico.py)     |
 | Invasive Weed Optimization                             | `InvasiveWeedOptimization`               | 2006 | [paper](https://doi.org/10.1016/j.ecoinf.2006.07.003)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/iwo.py)     |
 | Krill Herd Optimization                                | `KrillHerdOptimization`                  | 2012 | [paper](https://doi.org/10.1016/j.cnsns.2012.05.010)                                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/kho.py)     |
@@ -708,11 +713,13 @@ The following algorithms are currently implemented in **pyVolutionary**:
 | Monarch Butterfly Optimization                         | `MonarchButterflyOptimization`           | 2019 | [paper](https://link.springer.com/article/10.1007/s00521-015-1923-y)                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mbo.py)     |
 | Moth-Flame Optimization                                | `MothFlameOptimization`                  | 2015 | [paper](https://doi.org/10.1016/j.knosys.2015.07.006)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mfo.py)     |
 | Mountain Gazelle Optimization                          | `MountainGazelleOptimization`            | 2022 | [paper](https://doi.org/10.1016/j.advengsoft.2022.103282)                                                                                                                                                                     | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mgo.py)     |
+| Multi-verse Optimization                               | `MultiverseOptimization`                 | 2016 | [paper](https://dx.doi.org/10.1007/s00521-015-1870-7)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/mvo.py)     |
 | Nuclear Reaction Optimization                          | `NuclearReactionOptimization`            | 2019 | [paper](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=8720256)                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/nro.py)     |
 | Osprey Optimization                                    | `OspreyOptimization`                     | 2023 | [paper](https://www.frontiersin.org/articles/10.3389/fmech.2022.1126450/full)                                                                                                                                                 | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/ooa.py)     |
 | Particle Swarm Optimization                            | `ParticleSwarmOptimization`              | 1995 | [paper](https://ieeexplore.ieee.org/document/488968)                                                                                                                                                                          | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/pso.py)     |
 | Pathfinder Algorithm Optimization                      | `PathfinderAlgorithmOptimization`        | 2019 | [paper](https://doi.org/10.1016/j.asoc.2019.03.012)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/pfao.py)    |
 | Pelican Optimization                                   | `PelicanOptimization`                    | 2022 | [paper](https://www.mdpi.com/1424-8220/22/3/855)                                                                                                                                                                              | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/poa.py)     |
+| Runge Kutta Optimization                               | `RungeKuttaOptimization`                 | 2021 | [paper](https://doi.org/10.1016/j.eswa.2021.115079)                                                                                                                                                                           | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/rko.py)     |
 | Salp Swarm Optimization                                | `SalpSwarmOptimization`                  | 2017 | [paper](https://doi.org/10.1016/j.advengsoft.2017.07.002)                                                                                                                                                                     | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/sso.py)     |
 | Seagull Optimization                                   | `SeagullOptimization`                    | 2019 | [paper](https://doi.org/10.1016/j.knosys.2018.11.024)                                                                                                                                                                         | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/so.py)      |
 | Serval Optimization                                    | `ServalOptimization`                     | 2022 | [paper](https://www.mdpi.com/2313-7673/7/4/204)                                                                                                                                                                               | [example](https://github.com/matteocacciola/pyvolutionary/tree/master/demos/servo.py)   |

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyVolutionary"
-version = "2.4.1"
+version = "2.5.0"
 description = "pyVolutionary is a package collecting metaheuristic algorithms, available for free usage and able to solve a wide range of optimization problems."
 authors = ["Matteo Cacciola <matteo.cacciola@gmail.com>"]
 license = "MIT"
@@ -15,19 +15,15 @@ classifiers = [
 
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.13"
-pydantic = "^2.4.2"
-numpy = "^1.26.1"
-install = "^1.3.5"
-coverage = "^7.3.2"
-matplotlib = "^3.8.1"
-sphynx = "^0.0.3"
+python = ">=3.10"
+pydantic = "^2.9.0"
+numpy = "^2.1.1"
 pandas = "^2.2.0"
-opfunu = "^1.0.1"
 scipy = "^1.12.0"
 
 
 [tool.poetry.group.test.dependencies]
+coverage = "^7.3.2"
 pytest = "^7.4.3"
 requests-mock = "^1.11.0"
 
@@ -40,6 +36,15 @@ sphinx = "^7.2.6"
 sphinx-rtd-theme = "^1.3.0"
 myst-parser = "^2.0.0"
 
+
+[tool.poetry.group.demo.dependencies]
+matplotlib = "^3.7.5"
+
+
+[tool.poetry.group.examples.dependencies]
+opfunu = "^1.0.1"
+
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/pyvolutionary/__init__.py

@@ -26,6 +26,7 @@ from .egret_swarm import *
 from .electromagnetic_field import *
 from .elephant_herd import *
 from .energy_valley import *
+from .ficks_law import *
 from .firefly_swarm import *
 from .fireworks import *
 from .fish_school_search import *
@@ -44,6 +45,8 @@ from .grasshopper import *
 from .grey_wolf import *
 from .harmony_search import *
 from .heap_based import *
+from .henry_gas_solubility import *
+from .hunger_games_search import *
 from .imperialist_competitive import *
 from .invasive_weed import *
 from .krill_herd import *
@@ -52,11 +55,13 @@ from .marine_predators import *
 from .monarch_butterfly import *
 from .moth_flame import *
 from .mountain_gazelle import *
+from .multi_verse import *
 from .nuclear_reaction import *
 from .osprey import *
 from .particle_swarm import *
 from .pathfinder_algorithm import *
 from .pelican import *
+from .runge_kutta import *
 from .salp_swarm import *
 from .seagull import *
 from .serval import *

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/pyvolutionary/abstract.py

@@ -221,12 +221,13 @@ class OptimizationAbstract(ABC, Generic[T]):
         self._task = task
 
         self.before_initialization()
-        self._init_population()
-        self.after_initialization()
 
+        self._init_population()
         evolution.append(Population(agents=self._population, task_type=task.minmax))
         (self._best_agent, ), (self._worst_agent, ) = special_agents(self._population, n_best=1, n_worst=1)
 
+        self.after_initialization()
+
         errors: list[float] = []
         while True:
             self.optimization_step()

pyvolutionary-2.5.0/pyvolutionary/ficks_law/__init__.py

@@ -0,0 +1,2 @@
+from .models import Molecule, FicksLawOptimizationConfig
+from .ficks_law_optimization import FicksLawOptimization

pyvolutionary-2.5.0/pyvolutionary/ficks_law/ficks_law_optimization.py

@@ -0,0 +1,131 @@
+from typing import Any
+import numpy as np
+
+from ..helpers import (
+    best_agent,
+    parse_obj_doc,  # type: ignore
+)
+from ..abstract import OptimizationAbstract
+from .models import Molecule, FicksLawOptimizationConfig
+
+
+class FicksLawOptimization(OptimizationAbstract):
+    """
+    Implementation of the Fick's Law Optimization algorithm.
+
+    Args:
+        config (FicksLawOptimizationConfig): an instance of FicksLawOptimizationConfig class.
+            {parse_obj_doc(FicksLawOptimizationConfig)}
+
+    Bibliography
+    ----------
+    [1] Hashim, F. A., Mostafa, R. R., Hussien, A. G., Mirjalili, S., & Sallam, K. M. (2023). Fick’s Law Algorithm: A
+        physical law-based algorithm for numerical optimization. Knowledge-Based Systems, 260, 110146.
+
+    Side Notes
+    ----------
+    Despite the complexity of the algorithm, the performances are not so good, since the agents can potentially be stuck
+    in local minima. The algorithm is not recommended for complex optimization problems.
+    """
+    def __init__(self, config: FicksLawOptimizationConfig | None = None, debug: bool | None = False):
+        super().__init__(config, debug)
+        self.__n1: int = 0
+        self.__n2: int = 0
+        self.__pop1: list[Molecule] = []
+        self.__pop2: list[Molecule] = []
+        self.__best1: Molecule | None = None
+        self.__best2: Molecule | None = None
+        self.__fsss: float = 0.0
+
+    def set_config_parameters(self, parameters: dict[str, Any]):
+        self._config = FicksLawOptimizationConfig(**parameters)
+
+    def after_initialization(self):
+        self.__n1 = int(np.round(self._config.population_size / 2))
+        self.__n2 = self._config.population_size - self.__n1
+        self.__pop1 = self._population[:self.__n1].copy()
+        self.__pop2 = self._population[self.__n1:].copy()
+        self.__best1 = best_agent(self.__pop1)
+        self.__best2 = best_agent(self.__pop2)
+        self.__fsss = min(self.__best1.cost, self.__best2.cost)
+
+    def optimization_step(self):
+        def non_equilibrium_operator_1(molecule: Molecule, xm_factor: int, best_pos: np.ndarray) -> Molecule:
+            pos = np.array(molecule.position)
+            dfg = np.random.randint(1, 3)
+            jj = -DD * xm_factor * (xm2 - xm1) / np.linalg.norm(best_pos - pos + self.EPS)
+            return Molecule(**self._init_agent(
+                best_pos + dfg * dof * np.random.random(n_dims) * (jj * best_pos - pos)
+            ).model_dump())
+
+        def non_equilibrium_operator_2(molecule: Molecule, best_pos: np.ndarray) -> Molecule:
+            pos = np.array(molecule.position)
+            tt = pos + dof * (np.random.random(n_dims) * bandwidth + lb)
+            pp = np.random.random(n_dims)
+            return Molecule(**self._init_agent(np.where(pp < 0.8, best_pos, np.where(pp >= 0.9, pos, tt))).model_dump())
+
+        def equilibrium_operator(
+            molecule: Molecule, best_pos: np.ndarray, best_cost: float, xm_: np.ndarray
+        ) -> Molecule:
+            pos = np.array(molecule.position)
+            dfg = np.random.randint(1, 3)
+            tttt = np.linalg.norm(best_pos - pos)
+            jj = 0 if tttt == 0 else -DD * (best_pos - xm_) / tttt
+            drf = np.exp(-jj / tf)
+            ms = np.exp(-best_cost / molecule.cost + self.EPS)
+            qeo = dfg * drf * np.random.random(n_dims)
+            return Molecule(**self._init_agent(best_pos + qeo * pos + qeo * (ms * best_pos - pos)).model_dump())
+
+        def steady_state_operator(molecule: Molecule, best_pos: np.ndarray, xm_: np.ndarray) -> Molecule:
+            pos = np.array(molecule.position)
+            dfg = np.random.randint(1, 3)
+            tttt = np.linalg.norm(best_pos - pos)
+            jj = 0 if tttt == 0 else -DD * (xm - xm_) / tttt
+            drf = np.exp(-jj / tf)
+            ms = np.exp(-fsss / molecule.cost + self.EPS)
+            qg = dfg * drf * np.random.random(n_dims)
+            return Molecule(**self._init_agent(g_best + qg * pos + qg * (ms * best_pos - pos)).model_dump())
+
+        C1, C2, C3, C4, C5 = self._config.C1, self._config.C2, self._config.C3, self._config.C4, self._config.C5
+        DD = self._config.DD
+        
+        n1, n2, fsss = self.__n1, self.__n2, self.__fsss
+        g_best = np.array(self._best_agent.position)
+        pop1, pop2, best1, best2 = self.__pop1, self.__pop2, self.__best1, self.__best2
+        best1_pos, best2_pos = np.array(best1.position), np.array(best2.position)
+
+        epoch, epochs = self._current_cycle, self._config.max_cycles
+        n_dims = self._task.space_dimension
+        lb, ub = self._task.get_bounds()
+        bandwidth = self._task.bandwidth()
+
+        xm1 = np.mean(np.array([agent.position for agent in self.__pop1]), axis=0)
+        xm2 = np.mean(np.array([agent.position for agent in self.__pop2]), axis=0)
+        xm = np.mean(np.array([agent.position for agent in self._population]), axis=0)
+        tf = np.sinh((epoch + 1) / epochs) ** C1
+        if tf < 0.9:
+            dof = np.exp(-(C2 * tf - np.random.random())) ** C2
+            tdo = C5 * tf - np.random.random()
+            if tdo < np.random.random():
+                m1n, m2n = C3 * n1, C4 * n1
+                nt12 = int(np.round((m2n - m1n) * np.random.random() + m1n))
+                pop_new = [non_equilibrium_operator_1(molecule, 1, best2_pos) for molecule in pop1[:nt12]] + (
+                    [non_equilibrium_operator_2(molecule, best1_pos) for molecule in pop1[nt12:n1]]
+                ) + [self._init_agent(best2_pos + dof * (np.random.random(n_dims) * bandwidth + lb)) for _ in range(n2)]
+            else:
+                m1n, m2n = 0.1 * n2, 0.2 * n2
+                nt12 = int(np.round((m2n - m1n) * np.random.random() + m1n))
+                pop_new = [non_equilibrium_operator_1(molecule, -1, best1_pos) for molecule in pop2[:nt12]] + (
+                    [non_equilibrium_operator_2(molecule, best2_pos) for molecule in pop2[nt12:n2]]
+                ) + [self._init_agent(best1_pos + dof * (np.random.random(n_dims) * bandwidth + lb)) for _ in range(n1)]
+        elif tf <= 1:  # Equilibrium operator (EO)
+            pop_new = [equilibrium_operator(molecule, best1_pos, best1.cost, xm1) for molecule in pop1[:n1]] + (
+                [equilibrium_operator(molecule, best2_pos, best2.cost, xm2) for molecule in pop2[:n2]]
+            )
+        else:  # Steady state operator (SSO)
+            pop_new = [steady_state_operator(molecule, best1_pos, xm1) for molecule in pop1[:n1]] + (
+                [steady_state_operator(molecule, g_best, xm2) for molecule in pop2[:n2]]
+            )
+
+        self._greedy_select_population(pop_new)
+        self.after_initialization()

pyvolutionary-2.5.0/pyvolutionary/ficks_law/models.py

@@ -0,0 +1,61 @@
+from pydantic import field_validator
+
+from ..models import Agent, BaseOptimizationConfig
+
+
+class Molecule(Agent):
+    pass
+
+
+class FicksLawOptimizationConfig(BaseOptimizationConfig):
+    """
+    Configuration class of the Fick's Law Optimization algorithm.
+        + C1 (float): (-100., 100.), factor C1.\n
+        + C2 (float): (-100., 100.), factor C2.\n
+        + C3 (float): (-100., 100.), factor C3.\n
+        + C4 (float): (-100., 100.), factor C4.\n
+        + C5 (float): (-100., 100.), factor C5.\n
+        + DD (float): (-100., 100.), factor D in the paper.
+    """
+    C1: float
+    C2: float
+    C3: float
+    C4: float
+    C5: float
+    DD: float
+
+    @field_validator("C1")
+    def correct_C1(cls, v):
+        if not -100 < v < 100:
+            raise ValueError(f"\"C1\" must be a float in (-100., 100.). Got {v}")
+        return v
+
+    @field_validator("C2")
+    def correct_C2(cls, v):
+        if not -100 < v < 100:
+            raise ValueError(f"\"C2\" must be a float in (-100., 100.). Got {v}")
+        return v
+
+    @field_validator("C3")
+    def correct_C3(cls, v):
+        if not -100 < v < 100:
+            raise ValueError(f"\"C3\" must be a float in (-100., 100.). Got {v}")
+        return v
+
+    @field_validator("C4")
+    def correct_C4(cls, v):
+        if not -100 < v < 100:
+            raise ValueError(f"\"C4\" must be a float in (-100., 100.). Got {v}")
+        return v
+
+    @field_validator("C5")
+    def correct_C5(cls, v):
+        if not -100 < v < 100:
+            raise ValueError(f"\"C5\" must be a float in (-100., 100.). Got {v}")
+        return v
+
+    @field_validator("DD")
+    def correct_DD(cls, v):
+        if not -100 < v < 100:
+            raise ValueError(f"\"DD\" must be a float in (-100., 100.). Got {v}")
+        return v

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/pyvolutionary/grey_wolf/grey_wolf_optimization.py

@@ -38,6 +38,8 @@ class GreyWolfOptimization(OptimizationAbstract):
     def optimization_step(self):
         def evolve(wolf: GreyWolf) -> GreyWolf:
             pos = np.array(wolf.position)
+            a1, a2, a3 = (a * (2 * np.random.random(3) - 1)).tolist()
+            c1, c2, c3 = (2 * np.random.random(3)).tolist()
             x1 = np.array(self.__alpha_wolf.position) - a1 * np.abs(c1 * np.array(self.__alpha_wolf.position) - pos)
             x2 = np.array(self.__beta_wolf.position) - a2 * np.abs(c2 * np.array(self.__beta_wolf.position) - pos)
             x3 = np.array(self.__gamma_wolf.position) - a3 * np.abs(c3 * np.array(self.__gamma_wolf.position) - pos)
@@ -46,8 +48,6 @@ class GreyWolfOptimization(OptimizationAbstract):
 
         # linearly decreased from 2 to 0
         a = 2 * (1 - self._current_cycle / self._config.max_cycles)
-        a1, a2, a3 = (a * (2 * np.random.random(3) - 1)).tolist()
-        c1, c2, c3 = (2 * np.random.random(3)).tolist()
 
         # updating each population member with the help of best three members
         self._population = [evolve(wolf) for wolf in self._population]

{pyvolutionary-2.4.1 → pyvolutionary-2.5.0}/pyvolutionary/helpers.py

@@ -86,15 +86,32 @@ def calculate_fitness(value: float, task_type: TaskType) -> float:
 def sort_by_cost(population: list[T], task_type: TaskType | None = TaskType.MIN) -> list[T]:
     """
     Sort the population by the cost value of each agent (the lower the cost, the best the agent). The sorting is done
-    in-place. If reverse is True, the sorting is done in descending order (the higher the cost, the worst the agent).
+    in-place. If task_type is 'max', the sorting is done in descending order (the higher the cost, the worst the agent).
     :param population: the population
     :param task_type: the type of task (minimization or maximization)
+    :return: the sorted population
+    :rtype: list[Agent]
     """
     pop_new = population.copy()
     pop_new.sort(key=lambda agent: agent.cost, reverse=(task_type == TaskType.MAX))
     return pop_new
 
 
+def sort_by_cost_indexes(population: list[T], task_type: TaskType | None = TaskType.MIN) -> list[int]:
+    """
+    Sort the population by the cost value of each agent (the lower the cost, the best the agent). The sorting is done
+    in-place. If task_type is 'max', the sorting is done in descending order (the higher the cost, the worst the agent).
+    :param population: the population
+    :param task_type: the type of task (minimization or maximization)
+    :return: the indexes of the sorted population
+    :rtype: list[int]
+    """
+    result = np.argsort([agent.cost for agent in population], axis=0)
+    if task_type == TaskType.MAX:
+        result = result[::-1]
+    return result.tolist()
+
+
 def sort_and_trim(population: list[T], population_size: int) -> list[T]:
     """
     Sort the population according to the cost in ascending order and trim the population to the population size if
@@ -119,6 +136,17 @@ def best_agent(population: list[T], task_type: TaskType | None = TaskType.MIN) -
     return b_agent
 
 
+def best_agent_index(population: list[T], task_type: TaskType | None = TaskType.MIN) -> int:
+    """
+    Get the index of the best agent of the population based on its cost value (the lower the cost, the best the agent).
+    :param population: the population
+    :param task_type: the type of task (minimization or maximization)
+    :return: the index of the best agent
+    :rtype: int
+    """
+    return best_agents_indexes(population, 1, task_type)[0]
+
+
 def worst_agent(population: list[T], task_type: TaskType | None = TaskType.MIN) -> T:
     """
     Get the worst agent of the population based on its cost value (the higher the cost, the worst the agent).
@@ -131,6 +159,17 @@ def worst_agent(population: list[T], task_type: TaskType | None = TaskType.MIN)
     return w_agent
 
 
+def worst_agent_index(population: list[T], task_type: TaskType | None = TaskType.MIN) -> int:
+    """
+    Get the index of the worst agent of the population based on its cost value (the lower the cost, the best the agent).
+    :param population: the population
+    :param task_type: the type of task (minimization or maximization)
+    :return: the index of the worst agent
+    :rtype: int
+    """
+    return worst_agents_indexes(population, 1, task_type)[0]
+
+
 def best_agents(population: list[T], n_best: int | None = 3, task_type: TaskType | None = TaskType.MIN) -> list[T]:
     """
     Get the best agents of the population based on their cost value (the lower the cost, the best the agent).
@@ -143,6 +182,21 @@ def best_agents(population: list[T], n_best: int | None = 3, task_type: TaskType
     return sort_by_cost(population, task_type=task_type)[:n_best]
 
 
+def best_agents_indexes(
+    population: list[T], n_best: int | None = 3, task_type: TaskType | None = TaskType.MIN
+) -> list[int]:
+    """
+    Get the indexes of the best agents of the population based on their cost value (the lower the cost, the best the
+    agent).
+    :param population: the population
+    :param n_best: the number of best agents to return
+    :param task_type: the type of task (minimization or maximization)
+    :return: the indexes of the best agents
+    :rtype: list[int]
+    """
+    return sort_by_cost_indexes(population, task_type=task_type)[:n_best]
+
+
 def worst_agents(population: list[T], n_worst: int | None = 3, task_type: TaskType | None = TaskType.MIN) -> list[T]:
     """
     Get the worst agents of the population based on their cost value (the higher the cost, the worst the agent).
@@ -155,6 +209,19 @@ def worst_agents(population: list[T], n_worst: int | None = 3, task_type: TaskTy
     return sort_by_cost(population, task_type=task_type)[len(population)-n_worst:]
 
 
+def worst_agents_indexes(population: list[T], n_worst: int | None = 3, task_type: TaskType | None = TaskType.MIN) -> list[int]:
+    """
+    Get the indexes of the worst agents of the population based on their cost value (the higher the cost, the worst the
+    agent).
+    :param population: the population
+    :param n_worst: the number of worst agents to return
+    :param task_type: the type of task (minimization or maximization)
+    :return: the indexes of the worst agents
+    :rtype: list[int]
+    """
+    return sort_by_cost_indexes(population, task_type=task_type)[len(population)-n_worst:]
+
+
 def special_agents(
     population: list[T],
     n_best: int | None = None,
@@ -296,3 +363,15 @@ def get_pool_results(executors: list[parallel.Future]) -> list:
 
 def find_centers(pop_groups: list[list[T]]) -> list[T]:
     return [best_agent(pop_group).model_copy() for pop_group in pop_groups]
+
+
+def runge_kutta(xb: np.ndarray, xw: np.ndarray, delta_x: np.ndarray) -> np.ndarray:
+    dim = len(xb)
+    C = np.random.randint(1, 3) * (1 - np.random.random())
+    r1 = np.random.random(dim)
+    r2 = np.random.random(dim)
+    K1 = 0.5 * (np.random.random() * xw - C * xb)
+    K2 = 0.5 * (np.random.random() * (xw + r2 * K1 * delta_x / 2) - (C * xb + r1 * K1 * delta_x / 2))
+    K3 = 0.5 * (np.random.random() * (xw + r2 * K2 * delta_x / 2) - (C * xb + r1 * K2 * delta_x / 2))
+    K4 = 0.5 * (np.random.random() * (xw + r2 * K3 * delta_x) - (C * xb + r1 * K3 * delta_x))
+    return (K1 + 2 * K2 + 2 * K3 + K4) / 6

pyvolutionary-2.5.0/pyvolutionary/henry_gas_solubility/__init__.py

@@ -0,0 +1,2 @@
+from .models import Gas, HenryGasSolubilityOptimizationConfig
+from .henry_gas_solubility_optimization import HenryGasSolubilityOptimization