mealpy.physics_based package

mealpy.physics_based.ASO module

class mealpy.physics_based.ASO.OriginalASO(epoch: int = 10000, pop_size: int = 100, alpha: int = 10, beta: float = 0.2, **kwargs: object)[source]

Bases: Optimizer

The original version of: Atom Search Optimization (ASO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • alpha (int) – Depth weight, in range [1, 100]. Default is 10.

  • beta (float) – Multiplier weight, in range (0.0, 1.0). Default is 0.2.

Links

  1. https://doi.org/10.1016/j.knosys.2018.08.030

  2. https://www.mathworks.com/matlabcentral/fileexchange/67011-atom-search-optimization-aso-algorithm

References

  1. Zhao, W., Wang, L. and Zhang, Z., 2019. Atom search optimization and its application to solve a hydrogeologic parameter estimation problem. Knowledge-Based Systems, 163, pp.283-304.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, ASO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = ASO.OriginalASO(epoch=1000, pop_size=50, alpha = 50, beta = 0.2)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='hard', kind='original', name='Atom Search Optimization', year=2019, family=None, scientific_status='normal', concerns=(), evidence_urls=())
acceleration__(population, g_best, iteration)[source]
amend_solution(solution: ndarray) → ndarray[source]

This function is based on optimizer’s strategy. In each optimizer, this function can be overridden

Parameters

solution – The position

Returns

The valid solution based on optimizer’s strategy

evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

find_LJ_potential__(iteration, average_dist, radius)[source]
generate_empty_agent(solution: Optional[ndarray] = None) → Agent[source]

Generate new agent with solution

Parameters

solution (np.ndarray) – The solution

update_mass__(population)[source]

mealpy.physics_based.ArchOA module

class mealpy.physics_based.ArchOA.OriginalArchOA(epoch: int = 10000, pop_size: int = 100, c1: float = 2, c2: float = 6, c3: float = 2, c4: float = 0.5, acc_max: float = 0.9, acc_min: float = 0.1, **kwargs: object)[source]

Bases: Optimizer

The original version of: Archimedes Optimization Algorithm (ArchOA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • c1 (float) – Factor, in range [1.0, 3.0]. Default is 2.0.

  • c2 (float) – Factor, in range [2.0, 6.0]. Default is 6.0.

  • c3 (float) – Factor, in range [1.0, 3.0]. Default is 2.0.

  • c4 (float) – Factor, in range (0.0, 1.0). Default is 0.5.

  • acc_max (float) – Acceleration max, in range (0.3, 1.0). Default is 0.9.

  • acc_min (float) – Acceleration min, in range (0.0, 0.3). Default is 0.1.

References

  1. Hashim, F.A., Hussain, K., Houssein, E.H., Mabrouk, M.S. and Al-Atabany, W., 2021. Archimedes optimization algorithm: a new metaheuristic algorithm for solving optimization problems. Applied Intelligence, 51(3), pp.1531-1551. https://doi.org/10.1007/s10489-020-01893-z

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, ArchOA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = ArchOA.OriginalArchOA(epoch=1000, pop_size=50, c1 = 2, c2 = 5, c3 = 2, c4 = 0.5, acc_max = 0.9, acc_min = 0.1)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Archimedes Optimization Algorithm', year=2021, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

generate_empty_agent(solution: Optional[ndarray] = None) → Agent[source]

Generate new agent with solution

Parameters

solution (np.ndarray) – The solution

mealpy.physics_based.CDO module

class mealpy.physics_based.CDO.OriginalCDO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Chernobyl Disaster Optimizer (CDO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

Links

  1. https://doi.org/10.1007/s00521-023-08261-1

  2. https://www.mathworks.com/matlabcentral/fileexchange/124351-chernobyl-disaster-optimizer-cdo

References

  1. Shehadeh, H. A. (2023). Chernobyl disaster optimizer (CDO): a novel meta-heuristic method for global optimization. Neural Computing and Applications, 1-17.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, CDO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = CDO.OriginalCDO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Chernobyl Disaster Optimizer', year=2023, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.CEO module

class mealpy.physics_based.CEO.OriginalCEO(epoch: int = 1000, pop_size: int = 50, w1: float = 0.1, p_base: float = 0.2, alpha: float = 0.7, **kwargs: object)[source]

Bases: Optimizer

The original version of: Cosmic Evolution Optimization (CEO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 1000.

  • pop_size (int) – Number of population size, in range [10, 10000]. Default is 50.

  • w1 (float) – Expansion weight, in range (0.0, 1.0). Default is 0.1.

  • p_base (float) – Base collision probability, in range (0.0, 1.0). Default is 0.2.

  • alpha (float) – Alignment parameter, in range (0.0, 1.0). Default is 0.7.

References

  1. Wang, Rui, Zhengxuan Jiang, and Guowen Ding. “Cosmic Evolution Optimization: A Novel Metaheuristic Algorithm for Numerical Optimization and Engineering Design.” Mathematics 13.15 (2025): 2499. https://doi.org/10.3390/math13152499

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, CEO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = CEO.OriginalCEO(epoch=1000, pop_size=50, w1=0.1, p_base=0.2, alpha=0.7)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='hard', kind='original', name='Cosmic Evolution Optimization', year=2025, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.EFO module

class mealpy.physics_based.EFO.DevEFO(epoch: int = 10000, pop_size: int = 100, r_rate: float = 0.3, ps_rate: float = 0.85, p_field: float = 0.1, n_field: float = 0.45, **kwargs: object)[source]

Bases: Optimizer

Our developed version: Electromagnetic Field Optimization (EFO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • r_rate (float) – Like mutation parameter in GA but for one variable, in range (0.0, 1.0). Default is 0.3.

  • ps_rate (float) – Like crossover parameter in GA, in range (0.0, 1.0). Default is 0.85.

  • p_field (float) – Portion of population, positive field, in range (0.0, 1.0). Default is 0.1.

  • n_field (float) – Portion of population, negative field, in range (0.0, 1.0). Default is 0.45.

References

  1. Abedinpourshotorban, H., Shamsuddin, S.M., Beheshti, Z. and Jawawi, D.N., 2016. Electromagnetic field optimization: a physics-inspired metaheuristic optimization algorithm. Swarm and Evolutionary Computation, 26, pp.8-22.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, EFO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = EFO.DevEFO(epoch=1000, pop_size=50, r_rate = 0.3, ps_rate = 0.85, p_field = 0.1, n_field = 0.45)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Electromagnetic Field Optimization', year=None, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.EFO.OriginalEFO(epoch: int = 10000, pop_size: int = 100, r_rate: float = 0.3, ps_rate: float = 0.85, p_field: float = 0.1, n_field: float = 0.45, **kwargs: object)[source]

Bases: DevEFO

The original version of: Electromagnetic Field Optimization (EFO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • r_rate (float) – Like mutation parameter in GA but for one variable, in range (0.0, 1.0). Default is 0.3.

  • ps_rate (float) – Like crossover parameter in GA, in range (0.0, 1.0). Default is 0.85.

  • p_field (float) – Portion of population, positive field, in range (0.0, 1.0). Default is 0.1.

  • n_field (float) – Portion of population, negative field, in range (0.0, 1.0). Default is 0.45.

Links

  1. https://doi.org/10.1016/j.swevo.2015.07.002

  2. https://www.mathworks.com/matlabcentral/fileexchange/52744-electromagnetic-field-optimization-a-physics-inspired-metaheuristic-optimization-algorithm

References

  1. Abedinpourshotorban, H., Shamsuddin, S.M., Beheshti, Z. and Jawawi, D.N., 2016. Electromagnetic field optimization: a physics-inspired metaheuristic optimization algorithm. Swarm and Evolutionary Computation, 26, pp.8-22.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, EFO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = EFO.OriginalEFO(epoch=1000, pop_size=50, r_rate = 0.3, ps_rate = 0.85, p_field = 0.1, n_field = 0.45)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Electromagnetic Field Optimization', year=2016, family=None, scientific_status='normal', concerns=(), evidence_urls=())
amend_solution(solution: ndarray) → ndarray[source]

This function is based on optimizer’s strategy. In each optimizer, this function can be overridden

Parameters

solution – The position

Returns

The valid solution based on optimizer’s strategy

evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialization()[source]

mealpy.physics_based.EO module

class mealpy.physics_based.EO.AdaptiveEO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: OriginalEO

The original version of: Adaptive Equilibrium Optimization (AEO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

References

  1. Wunnava, A., Naik, M.K., Panda, R., Jena, B. and Abraham, A., 2020. A novel interdependence based multilevel thresholding technique using adaptive equilibrium optimizer. Engineering Applications of Artificial Intelligence, 94, p.103836. https://doi.org/10.1016/j.engappai.2020.103836

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, EO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = EO.AdaptiveEO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='variant', name='Adaptive Equilibrium Optimization', year=2020, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.EO.ModifiedEO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: OriginalEO

The original version of: Modified Equilibrium Optimizer (MEO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

References

  1. Gupta, S., Deep, K. and Mirjalili, S., 2020. An efficient equilibrium optimizer with mutation strategy for numerical optimization. Applied Soft Computing, 96, p.106542. https://doi.org/10.1016/j.asoc.2020.106542

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, EO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = EO.ModifiedEO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='variant', name='Modified Equilibrium Optimizer', year=2020, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.EO.OriginalEO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Equilibrium Optimizer (EO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

Links

  1. https://doi.org/10.1016/j.knosys.2019.105190

  2. https://www.mathworks.com/matlabcentral/fileexchange/73352-equilibrium-optimizer-eo

References

  1. Faramarzi, A., Heidarinejad, M., Stephens, B. and Mirjalili, S., 2020. Equilibrium optimizer: A novel optimization algorithm. Knowledge-Based Systems, 191, p.105190.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, EO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = EO.OriginalEO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Equilibrium Optimizer', year=2020, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

make_equilibrium_pool__(list_equilibrium=None)[source]

mealpy.physics_based.ESO module

class mealpy.physics_based.ESO.OriginalESO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Electrical Storm Optimization (ESO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

References

  1. Soto Calvo, Manuel, and Han Soo Lee. 2025. “Electrical Storm Optimization (ESO) Algorithm: Theoretical Foundations, Analysis, and Application to Engineering Problems” Machine Learning and Knowledge Extraction 7, no. 1: 24. https://doi.org/10.3390/make7010024

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, ESO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = ESO.OriginalESO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='hard', kind='original', name='Electrical Storm Optimization', year=2025, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.EVO module

class mealpy.physics_based.EVO.OriginalEVO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Energy Valley Optimizer (EVO)

Links

  1. https://doi.org/10.1038/s41598-022-27344-y

  2. https://www.mathworks.com/matlabcentral/fileexchange/123130-energy-valley-optimizer-a-novel-metaheuristic-algorithm

Note

  1. The algorithm is straightforward and does not require any specialized knowledge or techniques.

  2. The algorithm may not perform optimally due to slow convergence and no good operations, which could be improved by implementing better strategies and operations.

  3. The problem is that it is stuck at a local optimal around 1/2 of the max generations because fitness distance is being used as a factor in the equations.

References

  1. Azizi, M., Aickelin, U., A. Khorshidi, H., & Baghalzadeh Shishehgarkhaneh, M. (2023). Energy valley optimizer: a novel metaheuristic algorithm for global and engineering optimization. Scientific Reports, 13(1), 226.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, EVO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = EVO.OriginalEVO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Energy Valley Optimizer', year=2023, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.FLA module

class mealpy.physics_based.FLA.OriginalFLA(epoch: int = 10000, pop_size: int = 100, C1: float = 0.5, C2: float = 2.0, C3: float = 0.1, C4: float = 0.2, C5: float = 2.0, DD: float = 0.01, **kwargs: object)[source]

Bases: Optimizer

The original version of: Fick’s Law Algorithm (FLA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [10, 10000]. Default is 100.

  • C1 (float) – Factor C1, in range (-100.0, 100.0). Default is 0.5.

  • C2 (float) – Factor C2, in range (-100.0, 100.0). Default is 2.0.

  • C3 (float) – Factor C3, in range (-100.0, 100.0). Default is 0.1.

  • C4 (float) – Factor C4, in range (-100.0, 100.0). Default is 0.2.

  • C5 (float) – Factor C5, in range (-100.0, 100.0). Default is 2.0.

  • DD (float) – Factor D in the paper, in range (-100.0, 100.0). Default is 0.01.

Note

  1. The algorithm contains a high number of parameters, some of which may be unnecessary.

  2. Despite the complexity of the algorithms, they may not perform optimally and could potentially become trapped in local optima.

  3. Division by the fitness value may cause overflow issues to arise.

  4. https://www.mathworks.com/matlabcentral/fileexchange/121033-fick-s-law-algorithm-fla

References

  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. https://doi.org/10.1016/j.knosys.2022.110146

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, FLA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = FLA.OriginalFLA(epoch=1000, pop_size=50, C1 = 0.5, C2 = 2.0, C3 = 0.1, C4 = 0.2, C5 = 2.0, DD = 0.01)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='nightmare', kind='original', name="Fick's Law Algorithm", year=2023, family=None, scientific_status='normal', concerns=(), evidence_urls=())
before_main_loop()[source]
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.GRSA module

class mealpy.physics_based.GRSA.OriginalGRSA(epoch: int = 10000, pop_size: int = 100, n_geometry: int = 5, w_max: float = 0.9, w_min: float = 0.4, g_max: float = 0.5, g_min: float = 0.1, **kwargs: object)[source]

Bases: Optimizer

The original version of: General Relativity Search Algorithm (GRSA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [10, 10000]. Default is 100.

  • n_geometry (int) – Number of geometries used to partition the population, in range [1, int(pop_size / 2)]. Default is 5.

  • w_max (float) – Maximum weight factor for kinetic energy calculation, in range (0.0, 1.0). Default is 0.9.

  • w_min (float) – Minimum weight factor for kinetic energy calculation, in range (0.0, 1.0). Default is 0.4.

  • g_max (float) – Maximum kinetic energy coefficient, in range (0.0, 1.0). Default is 0.5.

  • g_min (float) – Minimum kinetic energy coefficient, in range (0.0, 1.0). Default is 0.1.

Links

  1. https://doi.org/10.1142/S1469026815500170

  2. https://www.mathworks.com/matlabcentral/fileexchange/57520-general-relativity-search-algorithm

References

  1. Beiranvand, Hamzeh, and Esmaeel Rokrok. “General relativity search algorithm: a global optimization approach.” International journal of computational intelligence and applications 14.03 (2015): 1550017.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, GRSA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = GRSA.OriginalGRSA(epoch=100, pop_size=50, n_geometry=5, w_max=0.9, w_min=0.4, g_max=0.5, g_min=0.1)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='hard', kind='original', name='General Relativity Search Algorithm', year=2015, family=None, scientific_status='normal', concerns=(), evidence_urls=())
before_main_loop()[source]
calculate_x_direction(b_sign, x_p, geodesic_x_p, x_p_prev, x_p_gbest)[source]
evolve(epoch: int) → None[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch – The current iteration

mealpy.physics_based.HGSO module

class mealpy.physics_based.HGSO.OriginalHGSO(epoch: int = 10000, pop_size: int = 100, n_clusters: int = 2, **kwargs: object)[source]

Bases: Optimizer

The original version of: Henry Gas Solubility Optimization (HGSO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [10, 10000]. Default is 100.

  • n_clusters (int) – Number of clusters, in range [2, int(pop_size/5)]. Default is 2.

References

  1. Hashim, F.A., Houssein, E.H., Mabrouk, M.S., Al-Atabany, W. and Mirjalili, S., 2019. Henry gas solubility optimization: A novel physics-based algorithm. Future Generation Computer Systems, 101, pp.646-667. https://doi.org/10.1016/j.future.2019.07.015

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, HGSO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = HGSO.OriginalHGSO(epoch=1000, pop_size=50, n_clusters = 3)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='hard', kind='original', name='Henry Gas Solubility Optimization', year=2019, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

flatten_group__(group)[source]
get_best_solution_in_team__(group=None)[source]
initialization()[source]
initialize_variables()[source]

mealpy.physics_based.KLA module

class mealpy.physics_based.KLA.OriginalKLA(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Kirchhoff’s Law Algorithm (KLA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [10, 10000]. Default is 100.

Links

  1. https://www.mathworks.com/matlabcentral/fileexchange/181589-kirchhoff-s-law-algorithm-kla

  2. https://doi.org/10.1007/s10462-025-11289-5

References

  1. Ghasemi, Mojtaba, Nima Khodadadi, Pavel Trojovský, Li Li, Zulkefli Mansor, Laith Abualigah, Amal H. Alharbi, and El-Sayed M. El-Kenawy. “Kirchhoff’s law algorithm (KLA): A novel physics-inspired non-parametric metaheuristic algorithm for optimization problems.” Artificial Intelligence Review 58, no. 10 (2025): 325.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, KLA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = KLA.OriginalKLA(epoch=100, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name="Kirchhoff's Law Algorithm", year=2025, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch: int) → None[source]
Parameters

epoch – The current iteration

mealpy.physics_based.KOA module

class mealpy.physics_based.KOA.OriginalKOA(epoch: int = 10000, pop_size: int = 25, tc: int = 3, lamda: float = 15, mu0: float = 0.1, **kwargs: object)[source]

Bases: Optimizer

The original version of: Kepler Optimization Algorithm (KOA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 25.

  • tc (int) – Cycle parameter (tc in the paper), in range [1, 1000]. Default is 3.

  • lamda (float) – Decay factor (lambda in the paper), in range (0.0, 1000.0). Default is 15.

  • mu0 (float) – Initial mass parameter (M0 in the paper), in range (0.0, 10.0). Default is 0.1.

References

  1. Abdel-Basset, Mohamed, et al. “Kepler optimization algorithm: A new metaheuristic algorithm inspired by Kepler’s laws of planetary motion.” Knowledge-based systems 268 (2023): 110454. https://doi.org/10.1016/j.knosys.2023.110454

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, KOA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = KOA.OriginalKOA(epoch=100, pop_size=50, tc=3, lamda=15.0, mu0=0.1)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='hard', kind='original', name='Kepler Optimization Algorithm', year=2023, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialize_variables()[source]

mealpy.physics_based.LSO module

class mealpy.physics_based.LSO.DevLSO(epoch: int = 10000, pop_size: int = 100, Ps: float = 0.05, Pe: float = 0.6, B: float = 0.05, **kwargs: object)[source]

Bases: Optimizer

Our developed version of: Light Spectrum Optimizer (LSO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • Ps (float) – Probability of first and second scattering stages, in range (0.0, 1.0). Default is 0.05.

  • Pe (float) – Controlling parameter to exchange between scattering stages, in range (0.0, 1.0). Default is 0.6.

  • B (float) – Exploitation probability in the first scattering stage, in range (0.0, 1.0). Default is 0.05.

Note

This version includes some improvements:

  • Uses adaptive parameters that change based on epoch

  • Simplified boundary handling

  • More efficient implementation

References

  1. Abdel-Basset, M., Mohamed, R., 2022. Light Spectrum Optimizer: A Novel Physics-Inspired Metaheuristic Optimization Algorithm. Mathematics, 10(19), 3466. https://doi.org/10.3390/math10193466

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, LSO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = LSO.DevLSO(epoch=1000, pop_size=50, Ps=0.05, Pe=0.7, B=0.06)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='nightmare', kind='developed', name='Light Spectrum Optimizer (Dev)', year=None, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.LSO.OriginalLSO(epoch: int = 10000, pop_size: int = 100, Ps: float = 0.05, Pe: float = 0.6, Ph: float = 0.4, B: float = 0.05, **kwargs: object)[source]

Bases: Optimizer

The original version of: Light Spectrum Optimizer (LSO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • Ps (float) – Probability of first and second scattering stages, in range (0.0, 1.0). Default is 0.05.

  • Pe (float) – Controlling parameter to exchange between scattering stages, in range (0.0, 1.0). Default is 0.6.

  • Ph (float) – Probability of hybridization between boundary handling methods, in range (0.0, 1.0). Default is 0.4.

  • B (float) – Exploitation probability in the first scattering stage, in range (0.0, 1.0). Default is 0.05.

Links

  1. https://doi.org/10.3390/math10193466

  2. https://www.mathworks.com/matlabcentral/fileexchange/126215-light-spectrum-optimizer-lso

References

  1. Abdel-Basset, M., Mohamed, R., 2022. Light Spectrum Optimizer: A Novel Physics-Inspired Metaheuristic Optimization Algorithm. Mathematics, 10(19), 3466.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, LSO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = LSO.OriginalLSO(epoch=1000, pop_size=50, Ps=0.2, Pe=0.3, Ph=0.4, B=0.05)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='nightmare', kind='original', name='Light Spectrum Optimizer', year=2022, family=None, scientific_status='normal', concerns=(), evidence_urls=())
amend_solution(pos_new: ndarray) → ndarray[source]

Apply boundary handling based on Ph probability using self.generator.

evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.MSO module

class mealpy.physics_based.MSO.OriginalMSO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Mirage Search Optimization (MSO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

Links

  1. https://doi.org/10.1016/j.advengsoft.2025.103883

  2. https://www.mathworks.com/matlabcentral/fileexchange/180042-mirage-search-optimization

References

  1. He, J., Zhao, S., Ding, J., & Wang, Y. (2025). Mirage search optimization: Application to path planning and engineering design problems. Advances in Engineering Software, 203, 103883.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, MSO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = MSO.OriginalMSO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Mirage Search Optimization', year=2025, family=None, scientific_status='normal', concerns=(), evidence_urls=())
asind(x)[source]
atand(x)[source]
atanh(x)[source]
cosd(x)[source]
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

sind(x)[source]
tand(x)[source]

mealpy.physics_based.MVO module

class mealpy.physics_based.MVO.DevMVO(epoch: int = 10000, pop_size: int = 100, wep_min: float = 0.2, wep_max: float = 1.0, **kwargs: object)[source]

Bases: Optimizer

Our developed version: Multi-Verse Optimizer (MVO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • wep_min (float) – Wormhole Existence Probability (min in Eq.(3.3) paper), in range (0.0, 0.5). Default is 0.2.

  • wep_max (float) – Wormhole Existence Probability (max in Eq.(3.3) paper), in range [0.5, 3.0]. Default is 1.0.

Note

  • New routtele wheel selection can handle negative values

  • Removed condition when self.generator.normalize fitness. So the chance to choose while whole higher –> better

References

  1. Mirjalili, S., Mirjalili, S.M. and Hatamlou, A., 2016. Multi-verse optimizer: a nature-inspired algorithm for global optimization. Neural Computing and Applications, 27(2), pp.495-513. https://dx.doi.org/10.1007/s00521-015-1870-7

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, MVO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = MVO.DevMVO(epoch=1000, pop_size=50, wep_min = 0.2, wep_max = 1.0)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='developed', name='Multi-Verse Optimizer (Dev)', year=2016, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.MVO.OriginalMVO(epoch: int = 10000, pop_size: int = 100, wep_min: float = 0.2, wep_max: float = 1.0, **kwargs: object)[source]

Bases: DevMVO

The original version of: Multi-Verse Optimizer (MVO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • wep_min (float) – Wormhole Existence Probability (min in Eq.(3.3) paper), in range (0.0, 0.5). Default is 0.2.

  • wep_max (float) – Wormhole Existence Probability (max in Eq.(3.3) paper), in range [0.5, 3.0]. Default is 1.0.

Links

  1. https://dx.doi.org/10.1007/s00521-015-1870-7

  2. https://www.mathworks.com/matlabcentral/fileexchange/50112-multi-verse-optimizer-mvo

References

  1. Mirjalili, S., Mirjalili, S.M. and Hatamlou, A., 2016. Multi-verse optimizer: a nature-inspired algorithm for global optimization. Neural Computing and Applications, 27(2), pp.495-513.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, MVO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = MVO.OriginalMVO(epoch=1000, pop_size=50, wep_min = 0.2, wep_max = 1.0)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Multi-Verse Optimizer', year=2016, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

normalize__(d, to_sum=True)[source]
roulette_wheel_selection__(weights=None)[source]

mealpy.physics_based.NRO module

class mealpy.physics_based.NRO.OriginalNRO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Nuclear Reaction Optimization (NRO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

References

1. Wei, Z., Huang, C., Wang, X., Han, T. and Li, Y., 2019. Nuclear reaction optimization: A novel and powerful physics-based algorithm for global optimization. IEEE Access, 7, pp.66084-66109. https://doi.org/10.1109/ACCESS.2019.2918406.

2. Wei, Z.L., Zhang, Z.R., Huang, C.Q., Han, B., Tang, S.Q. and Wang, L., 2019, June. An Approach Inspired from Nuclear Reaction Processes for Numerical Optimization. In Journal of Physics: Conference Series (Vol. 1213, No. 3, p. 032009). IOP Publishing.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, NRO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = NRO.OriginalNRO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='nightmare', kind='original', name='Nuclear Reaction Optimization', year=2019, family=None, scientific_status='normal', concerns=(), evidence_urls=())
amend_solution(solution: ndarray) → ndarray[source]

This function is based on optimizer’s strategy. In each optimizer, this function can be overridden

Parameters

solution – The position

Returns

The valid solution based on optimizer’s strategy

evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.RIME module

class mealpy.physics_based.RIME.OriginalRIME(epoch: int = 10000, pop_size: int = 100, sr: float = 5.0, **kwargs: object)[source]

Bases: Optimizer

The original version of: physical phenomenon of RIME-ice (RIME)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • sr (float) – Soft-rime parameters, in range (0.0, 100.0). Default is 5.0.

Links

  1. https://doi.org/10.1016/j.neucom.2023.02.010

  2. https://www.mathworks.com/matlabcentral/fileexchange/124610-rime-a-physics-based-optimization

References

  1. Su, H., Zhao, D., Heidari, A. A., Liu, L., Zhang, X., Mafarja, M., & Chen, H. (2023). RIME: A physics-based optimization. Neurocomputing.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, RIME
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = RIME.OriginalRIME(epoch=1000, pop_size=50, sr = 5.0)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='easy', kind='original', name='physical phenomenon of RIME-ice', year=2023, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

mealpy.physics_based.SA module

class mealpy.physics_based.SA.GaussianSA(epoch: int = 10000, pop_size: int = 2, temp_init: float = 100, cooling_rate: float = 0.99, scale: float = 0.1, **kwargs: object)[source]

Bases: Optimizer

Our Gaussian-based version of: Gaussian Simulated Annealing (GaussianSA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [2, 10000]. Default is 2.

  • temp_init (float) – Initial temperature, in range [1, 10000]. Default is 100.

  • cooling_rate (float) – Cooling rate, in range (0.0, 1.0). Default is 0.99.

  • scale (float) – The scale in gaussian random, in range (0.0, 100.0). Default is 0.1.

Note

  • SA is single-based solution, so the pop_size parameter is not matter in this algorithm

  • The temp_init is very important factor. Should set it equal to the distance between LB and UB

References

  1. Kirkpatrick, S., Gelatt Jr, C. D., & Vecchi, M. P. (1983). Optimization by simulated annealing. science, 220(4598), 671-680.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, SA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = SA.GaussianSA(epoch=1000, pop_size=2, temp_init = 100, cooling_rate = 0.99, scale = 0.1)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='easy', kind='developed', name='Simulated Annealing (Dev)', year=None, family=None, scientific_status='normal', concerns=(), evidence_urls=())
before_main_loop()[source]
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.SA.OriginalSA(epoch: int = 10000, pop_size: int = 2, temp_init: float = 100, step_size: float = 0.1, **kwargs: object)[source]

Bases: Optimizer

The original version of: Simulated Annealing (SA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [2, 10000]. Default is 2.

  • temp_init (float) – Initial temperature, in range [1, 10000]. Default is 100.

  • step_size (float) – The step size of random movement, in range (-100.0, 100.0). Default is 0.1.

Note

SA is single-based solution, so the pop_size parameter is not matter in this algorithm

References

  1. Kirkpatrick, S., Gelatt Jr, C. D., & Vecchi, M. P. (1983). Optimization by simulated annealing. science, 220(4598), 671-680.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, SA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = SA.OriginalSA(epoch=1000, pop_size=50, temp_init = 100, step_size = 0.1)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='easy', kind='original', name='Simulated Annealing', year=1983, family=None, scientific_status='normal', concerns=(), evidence_urls=())
before_main_loop()[source]
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.SA.SwarmSA(epoch: int = 10000, pop_size: int = 100, max_sub_iter: int = 5, t0: int = 1000, t1: int = 1, move_count: int = 5, mutation_rate: float = 0.1, mutation_step_size: float = 0.1, mutation_step_size_damp: float = 0.99, **kwargs: object)[source]

Bases: Optimizer

Our swarm version of: Simulated Annealing (SwarmSA)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

  • max_sub_iter (int) – Maximum Number of Sub-Iteration (within fixed temperature), in range [1, 100000]. Default is 5.

  • t0 (int) – Initial Temperature, in range [500, 2000]. Default is 1000.

  • t1 (int) – Final Temperature, in range [1, 100]. Default is 1.

  • move_count (int) – Move Count per Individual Solution, in range [2, int(pop_size / 2)]. Default is 5.

  • mutation_rate (float) – Mutation Rate, in range (0.0, 1.0). Default is 0.1.

  • mutation_step_size (float) – Mutation Step Size, in range (0.0, 1.0). Default is 0.1.

  • mutation_step_size_damp (float) – Mutation Step Size Damp, in range (0.0, 1.0). Default is 0.99.

References

  1. Van Laarhoven, P.J. and Aarts, E.H., 1987. Simulated annealing. In Simulated annealing: Theory and applications (pp. 7-15). Springer, Dordrecht. https://doi.org/10.1007/978-94-015-7744-1_2

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, SA
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = SA.SwarmSA(epoch=1000, pop_size=50, max_sub_iter = 5, t0 = 1000, t1 = 1,
>>>         move_count = 5, mutation_rate = 0.1, mutation_step_size = 0.1, mutation_step_size_damp = 0.99)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='easy', kind='developed', name='Simulated Annealing (Dev)', year=None, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialization()[source]
mutate__(position, sigma)[source]

mealpy.physics_based.SOO module

class mealpy.physics_based.SOO.OriginalSOO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Stellar Oscillation Optimizer (SOO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

Danger

  1. The MATLAB code in the link below by the author is completely different from the pseudocode in the original paper. I don’t understand how the first author could write such an incorrect implementation and still obtain good results. There are only two possibilities: either the author fabricated the results in the paper, or the paper itself is fundamentally flawed.

  2. For example, you can see equation number 8 — it involves taking the average of two new positions. However, in the code, it is incorrectly implemented as position 1 plus half of position 2. Even more concerning is that the pseudocode in the paper is completely different from the actual code. The MATLAB coding quality is really poor. In the pseudocode, it states that the fitness should be calculated and the global best as well as the top 3 best should be updated, yet this is entirely missing in the code.

  3. Therefore, I do not recommend users to use this algorithm, as it lacks integrity between the results in the paper and the actual experimental implementation.

Links

  1. https://mathworks.com/matlabcentral/fileexchange/161921-stellar-oscillation-optimizer-meta-heuristic-optimimization

  2. https://doi.org/10.1007/s10586-024-04976-5

References

  1. Rodan, A., Al-Tamimi, A. K., Al-Alnemer, L., & Mirjalili, S. (2025). Stellar oscillation optimizer: a nature-inspired metaheuristic optimization algorithm. Cluster Computing, 28(6), 362.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, SOO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = SOO.OriginalSOO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Stellar Oscillation Optimizer', year=2025, family=None, scientific_status='questionable', concerns=(<ScientificConcern.INCORRECT_EQUATIONS: 'incorrect_equations'>, <ScientificConcern.CODE_PSEUDOCODE_MISMATCH: 'code_pseudocode_mismatch'>, <ScientificConcern.AMBIGUOUS_METHODOLOGY: 'ambiguous_methodology'>, <ScientificConcern.POOR_REPRODUCIBILITY: 'poor_reproducibility'>), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialize_variables()[source]

mealpy.physics_based.TWO module

class mealpy.physics_based.TWO.EnhancedTWO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: OppoTWO, LevyTWO

The original version of: Enhanced Tug of War Optimization (ETWO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

References

  1. Nguyen, T., Hoang, B., Nguyen, G. and Nguyen, B.M., 2020. A new workload prediction model using extreme learning machine and enhanced tug of war optimization. Procedia Computer Science, 170, pp.362-369. https://doi.org/10.1016/j.procs.2020.03.063

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, TWO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = TWO.EnhancedTWO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='variant', name='Enhanced Tug of War Optimization', year=2020, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialization()[source]
class mealpy.physics_based.TWO.LevyTWO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: OriginalTWO

The Levy-flight version of: Tug of War Optimization (LevyTWO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, TWO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = TWO.LevyTWO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='developed', name='Tug of War Optimization (Dev)', year=None, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

class mealpy.physics_based.TWO.OppoTWO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: OriginalTWO

The opossition-based learning version: Tug of War Optimization (OTWO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, TWO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = TWO.OppoTWO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='developed', name='Tug of War Optimization (Dev)', year=None, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialization()[source]
class mealpy.physics_based.TWO.OriginalTWO(epoch: int = 10000, pop_size: int = 100, **kwargs: object)[source]

Bases: Optimizer

The original version of: Tug of War Optimization (TWO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [5, 10000]. Default is 100.

References

  1. Kaveh, A., 2017. Tug of war optimization. In Advances in metaheuristic algorithms for optimal design of structures (pp. 451-487). Springer, Cham. https://doi.org/10.1007/978-3-030-59392-6_15

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, TWO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = TWO.OriginalTWO(epoch=1000, pop_size=50)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Tug of War Optimization', year=2017, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

generate_empty_agent(solution: Optional[ndarray] = None) → Agent[source]

Generate new agent with solution

Parameters

solution (np.ndarray) – The solution

initialization()[source]
update_weight__(teams)[source]

mealpy.physics_based.WDO module

class mealpy.physics_based.WDO.OriginalWDO(epoch: int = 10000, pop_size: int = 100, RT: int = 3, g_c: float = 0.2, alp: float = 0.4, c_e: float = 0.4, max_v: float = 0.3, **kwargs: object)[source]

Bases: Optimizer

The original version of: Wind Driven Optimization (WDO)

Parameters

  • epoch (int) – Maximum number of iterations, in range [1, 100000]. Default is 10000.

  • pop_size (int) – Number of population size, in range [10, 10000]. Default is 100.

  • RT (int) – RT coefficient, in range [1, 4]. Default is 3.

  • g_c (float) – Gravitational constant, in range (0.0, 1.0). Default is 0.2.

  • alp (float) – Constants in the update equation, in range (0.0, 1.0). Default is 0.4.

  • c_e (float) – Coriolis effect, in range (0.0, 1.0). Default is 0.4.

  • max_v (float) – Maximum allowed speed, in range (0.0, 1.0). Default is 0.3.

Note

  • pop is the set of “air parcel” - “position”

  • air parcel: is the set of gas atoms. Each atom represents a dimension in position and has its own velocity

  • pressure represented by fitness value

References

  1. Bayraktar, Z., Komurcu, M., Bossard, J.A. and Werner, D.H., 2013. The wind driven optimization technique and its application in electromagnetics. IEEE transactions on antennas and propagation, 61(5), pp.2745-2757. https://doi.org/10.1109/TAP.2013.2238654

Examples

>>> import numpy as np
>>> from mealpy import FloatVar, WDO
>>>
>>> def objective_function(solution):
>>>     return np.sum(solution**2)
>>>
>>> problem_dict = {
>>>     "bounds": FloatVar(lb=(-10.,) * 30, ub=(10.,) * 30, name="delta"),
>>>     "minmax": "min",
>>>     "obj_func": objective_function
>>> }
>>>
>>> model = WDO.OriginalWDO(epoch=1000, pop_size=50, RT = 3, g_c = 0.2, alp = 0.4, c_e = 0.4, max_v = 0.3)
>>> g_best = model.solve(problem_dict)
>>> print(f"Solution: {g_best.solution}, Fitness: {g_best.target.fitness}")
>>> print(f"Solution: {model.g_best.solution}, Fitness: {model.g_best.target.fitness}")
OPT_INFO: ClassVar[OptInfo | None] = OptInfo(difficulty='medium', kind='original', name='Wind Driven Optimization', year=2013, family=None, scientific_status='normal', concerns=(), evidence_urls=())
evolve(epoch)[source]

The main operations (equations) of algorithm. Inherit from Optimizer class

Parameters

epoch (int) – The current iteration

initialize_variables()[source]