{"id":21186502,"url":"https://github.com/thieu1995/mealpy","last_synced_at":"2025-05-15T00:07:28.974Z","repository":{"id":40413946,"uuid":"247671009","full_name":"thieu1995/mealpy","owner":"thieu1995","description":"A Collection Of The State-of-the-art Metaheuristic Algorithms In Python (Metaheuristic/Optimizer/Nature-inspired/Biology)","archived":false,"fork":false,"pushed_at":"2024-09-03T21:46:52.000Z","size":15757,"stargazers_count":987,"open_issues_count":20,"forks_count":201,"subscribers_count":15,"default_branch":"master","last_synced_at":"2025-04-12T00:52:36.953Z","etag":null,"topics":["arithmetic-optimization-algorithm","bio-inspired-optimization","differential-evolution","equilibrium-optimizer","genetic-algorithm","grey-wolf-optimizer","harris-hawks-optimization","harris-hawks-optimizationg","henry-gas-solubility-optimization","hunger-games-search","location-optimization","metaheuristics","nature-inspired-algorithms","particle-swarm-optimization","production-planning","schedule-optimization","slime-mould-algorithm","supply-chain-optimization","swarm-intelligence","whale-optimization"],"latest_commit_sha":null,"homepage":"https://mealpy.readthedocs.io","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"gpl-3.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/thieu1995.png","metadata":{"files":{"readme":"README.md","changelog":"ChangeLog.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":"CITATION.cff","codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2020-03-16T10:16:54.000Z","updated_at":"2025-04-11T11:12:23.000Z","dependencies_parsed_at":"2024-05-21T11:49:05.365Z","dependency_job_id":"1117e8f4-4ac2-4f05-a7b7-2c7d50b60fba","html_url":"https://github.com/thieu1995/mealpy","commit_stats":{"total_commits":1350,"total_committers":10,"mean_commits":135.0,"dds":"0.011851851851851891","last_synced_commit":"09b176960e3b29211283cbe0f56f05bdf2fb128e"},"previous_names":[],"tags_count":58,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/thieu1995%2Fmealpy","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/thieu1995%2Fmealpy/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/thieu1995%2Fmealpy/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/thieu1995%2Fmealpy/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/thieu1995","download_url":"https://codeload.github.com/thieu1995/mealpy/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254249197,"owners_count":22039029,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["arithmetic-optimization-algorithm","bio-inspired-optimization","differential-evolution","equilibrium-optimizer","genetic-algorithm","grey-wolf-optimizer","harris-hawks-optimization","harris-hawks-optimizationg","henry-gas-solubility-optimization","hunger-games-search","location-optimization","metaheuristics","nature-inspired-algorithms","particle-swarm-optimization","production-planning","schedule-optimization","slime-mould-algorithm","supply-chain-optimization","swarm-intelligence","whale-optimization"],"created_at":"2024-11-20T18:24:04.005Z","updated_at":"2025-05-15T00:07:23.942Z","avatar_url":"https://github.com/thieu1995.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cp align=\"center\"\u003e\n\u003cimg style=\"height:400px;\" \nsrc=\"https://thieu1995.github.io/post/2022-04/19-mealpy-tutorials/mealpy5-nobg.png\" \nalt=\"MEALPY\"/\u003e\n\u003c/p\u003e\n\n---\n\n\n[![GitHub release](https://img.shields.io/badge/release-3.0.1-yellow.svg)](https://github.com/thieu1995/mealpy/releases)\n[![Wheel](https://img.shields.io/pypi/wheel/gensim.svg)](https://pypi.python.org/pypi/mealpy) \n[![PyPI version](https://badge.fury.io/py/mealpy.svg)](https://badge.fury.io/py/mealpy)\n![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mealpy.svg)\n![PyPI - Status](https://img.shields.io/pypi/status/mealpy.svg)\n![PyPI - Downloads](https://img.shields.io/pypi/dm/mealpy.svg)\n[![Downloads](https://static.pepy.tech/badge/mealpy)](https://pepy.tech/project/mealpy)\n[![Tests \u0026 Publishes to PyPI](https://github.com/thieu1995/mealpy/actions/workflows/publish-package.yaml/badge.svg)](https://github.com/thieu1995/mealpy/actions/workflows/publish-package.yaml)\n![GitHub Release Date](https://img.shields.io/github/release-date/thieu1995/mealpy.svg)\n[![Documentation Status](https://readthedocs.org/projects/mealpy/badge/?version=latest)](https://mealpy.readthedocs.io/en/latest/?badge=latest)\n[![Chat](https://img.shields.io/badge/Chat-on%20Telegram-blue)](https://t.me/+fRVCJGuGJg1mNDg1)\n[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/thieu1995/mealpy.svg)](http://isitmaintained.com/project/thieu1995/mealpy \"Average time to resolve an issue\")\n[![Percentage of issues still open](http://isitmaintained.com/badge/open/thieu1995/mealpy.svg)](http://isitmaintained.com/project/thieu1995/mealpy \"Percentage of issues still open\")\n![GitHub contributors](https://img.shields.io/github/contributors/thieu1995/mealpy.svg)\n[![GitTutorial](https://img.shields.io/badge/PR-Welcome-%23FF8300.svg?)](https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project)\n[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3711948.svg)](https://doi.org/10.1016/j.sysarc.2023.102871)\n[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)\n\n\n# Introduction \n\nMEALPY is the largest python library in the world for most of the cutting-edge meta-heuristic algorithms \n(nature-inspired algorithms, black-box optimization, global search optimizers, iterative learning algorithms, \ncontinuous optimization, derivative free optimization, gradient free optimization, zeroth order optimization, \nstochastic search optimization, random search optimization). These algorithms belong to population-based algorithms \n(PMA), which are the most popular algorithms in the field of approximate optimization.\n\n* **Free software:** GNU General Public License (GPL) V3 license\n* **Total algorithms**: 215 (190 official (original, hybrid, variants), 25 developed)\n* **Documentation:** https://mealpy.readthedocs.io/en/latest/\n* **Python versions:** \u003e=3.7x\n* **Dependencies:** numpy, scipy, pandas, matplotlib\n\n\n![MEALPY3-0-0](.github/img/mealpy-classification.png)\n\n\n\n### Citation Request\n\nPlease include these citations if you plan to use this library:\n\n```code \n@article{van2023mealpy,\n  title={MEALPY: An open-source library for latest meta-heuristic algorithms in Python},\n  author={Van Thieu, Nguyen and Mirjalili, Seyedali},\n  journal={Journal of Systems Architecture},\n  year={2023},\n  publisher={Elsevier},\n  doi={10.1016/j.sysarc.2023.102871}\n}\n\n@article{van2023groundwater,\n  title={Groundwater level modeling using Augmented Artificial Ecosystem Optimization},\n  author={Van Thieu, Nguyen and Barma, Surajit Deb and Van Lam, To and Kisi, Ozgur and Mahesha, Amai},\n  journal={Journal of Hydrology},\n  volume={617},\n  pages={129034},\n  year={2023},\n  publisher={Elsevier},\n  doi={https://doi.org/10.1016/j.jhydrol.2022.129034}\n}\n\n@article{ahmed2021comprehensive,\n  title={A comprehensive comparison of recent developed meta-heuristic algorithms for streamflow time series forecasting problem},\n  author={Ahmed, Ali Najah and Van Lam, To and Hung, Nguyen Duy and Van Thieu, Nguyen and Kisi, Ozgur and El-Shafie, Ahmed},\n  journal={Applied Soft Computing},\n  volume={105},\n  pages={107282},\n  year={2021},\n  publisher={Elsevier},\n  doi={10.1016/j.asoc.2021.107282}\n}\n\n```\n\n\n# Usage \n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch2\u003eGoals\u003c/h2\u003e\u003c/summary\u003e\n\nOur goals are to implement all classical as well as the state-of-the-art nature-inspired algorithms, create a simple interface that helps researchers access optimization algorithms as quickly as possible, and share knowledge of the optimization field with everyone without a fee. What you can do with mealpy:\n\n- Analyse parameters of meta-heuristic algorithms.\n- Perform Qualitative and Quantitative Analysis of algorithms.\n- Analyse rate of convergence of algorithms.\n- Test and Analyse the scalability and the robustness of algorithms.\n- Save results in various formats (csv, json, pickle, png, pdf, jpeg)\n- Export and import models can also be done with Mealpy.\n- **Solve any optimization problem**\n\n\u003c/details\u003e\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch2\u003eInstallation\u003c/h2\u003e\u003c/summary\u003e\n\n* Install the stable (latest) version from [PyPI release](https://pypi.python.org/pypi/mealpy):\n```sh\n$ pip install mealpy==3.0.1\n```\n\n* Install the alpha/beta version from PyPi\n```sh\n$ pip install mealpy==2.5.4a6\n```\n\n* Install the pre-release version directly from the source code:\n```sh\n$ git clone https://github.com/thieu1995/mealpy.git\n$ cd mealpy\n$ python setup.py install\n```\n\n* In case, you want to install the development version from Github:\n```sh\n$ pip install git+https://github.com/thieu1995/permetrics \n```\n\nAfter installation, you can import Mealpy as any other Python module:\n\n```sh\n$ python\n\u003e\u003e\u003e import mealpy\n\u003e\u003e\u003e mealpy.__version__\n\n\u003e\u003e\u003e print(mealpy.get_all_optimizers())\n\u003e\u003e\u003e model = mealpy.get_optimizer_by_name(\"OriginalWOA\")(epoch=100, pop_size=50)\n```\n\n\u003c/details\u003e\n\n\n\n## Examples\n\nBefore dive into some examples, let me ask you a question. What type of problem are you trying to solve? \nAdditionally, what would be the solution for your specific problem? \nBased on the table below, you can select an appropriate type of decision variables to use.\n\n\n\u003cdiv align=\"center\"\u003e\n\n| Class           | Syntax                                                                                                       | Problem Types               |\n|-----------------|--------------------------------------------------------------------------------------------------------------|-----------------------------|\n| FloatVar        | `FloatVar(lb=(-10., )*7, ub=(10., )*7, name=\"delta\")`                                                        | Continuous Problem          |\n| IntegerVar      | `IntegerVar(lb=(-10., )*7, ub=(10., )*7, name=\"delta\")`                                                      | LP, IP, NLP, QP, MIP        |\n| StringVar       | `StringVar(valid_sets=((\"auto\", \"backward\", \"forward\"), (\"leaf\", \"branch\", \"root\")), name=\"delta\")`          | ML, AI-optimize             |\n| BinaryVar       | `BinaryVar(n_vars=11, name=\"delta\")`                                                                         | Networks                    |\n| BoolVar         | `BoolVar(n_vars=11, name=\"delta\")`                                                                           | ML, AI-optimize             |\n| PermutationVar  | `PermutationVar(valid_set=(-10, -4, 10, 6, -2), name=\"delta\")`                                               | Combinatorial Optimization  |\n| MixedSetVar     | `MixedSetVar(valid_sets=((\"auto\", 2, 3, \"backward\", True), (0, \"tournament\", \"round-robin\")), name=\"delta\")` | MIP,  MILP                  |\n| TransferBoolVar | `TransferBoolVar(n_vars=11, name=\"delta\", tf_func=\"sstf_02\")`                                                | ML, AI-optimize, Feature    |\n|TransferBinaryVar| `TransferBinaryVar(n_vars=11, name=\"delta\", tf_func=\"vstf_04\")`                                              | Networks, Feature Selection |\n\n\u003c/div\u003e\n\nLet's go through a basic and advanced example.\n\n\n### Simple Benchmark Function\n\n**Using Problem dict**\n\n```python\nfrom mealpy import FloatVar, SMA\nimport numpy as np\n\ndef objective_function(solution):\n    return np.sum(solution**2)\n\nproblem = {\n    \"obj_func\": objective_function,\n    \"bounds\": FloatVar(lb=(-100., )*30, ub=(100., )*30),\n    \"minmax\": \"min\",\n    \"log_to\": None,\n}\n\n## Run the algorithm\nmodel = SMA.OriginalSMA(epoch=100, pop_size=50, pr=0.03)\ng_best = model.solve(problem)\nprint(f\"Best solution: {g_best.solution}, Best fitness: {g_best.target.fitness}\")\n```\n\n**Define a custom Problem class**\n\n\n**Please note that, there is no more `generate_position`, `amend_solution`, and `fitness_function` in Problem class.**\nWe take care everything under the DataType Class above. Just choose which one fit for your problem.\n**We recommend you define a custom class that inherit `Problem` class if your decision variable is not FloatVar**\n\n\n```python\nfrom mealpy import Problem, FloatVar, BBO \nimport numpy as np\n\n# Our custom problem class\nclass Squared(Problem):\n    def __init__(self, bounds=None, minmax=\"min\", data=None, **kwargs):\n        self.data = data \n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, solution):\n        x = self.decode_solution(solution)[\"my_var\"]\n        return np.sum(x ** 2)\n\n## Now, we define an algorithm, and pass an instance of our *Squared* class as the problem argument. \nbound = FloatVar(lb=(-10., )*20, ub=(10., )*20, name=\"my_var\")\nproblem = Squared(bounds=bound, minmax=\"min\", name=\"Squared\", data=\"Amazing\")\nmodel = BBO.OriginalBBO(epoch=100, pop_size=20)\ng_best = model.solve(problem)\n```\n\n\n### Set Seed for Optimizer (So many people asking for this feature)\n\nYou can set random seed number for each run of single optimizer.\n\n```python\nmodel = SMA.OriginalSMA(epoch=100, pop_size=50, pr=0.03)\ng_best = model.solve(problem=problem, seed=10)  # Default seed=None\n```\n\n\n### Large-Scale Optimization\n\n```python\nfrom mealpy import FloatVar, SHADE\nimport numpy as np\n\ndef objective_function(solution):\n    return np.sum(solution**2)\n\nproblem = {\n    \"obj_func\": objective_function,\n    \"bounds\": FloatVar(lb=(-1000., )*10000, ub=(1000.,)*10000),     # 10000 dimensions\n    \"minmax\": \"min\",\n    \"log_to\": \"console\",\n}\n\n## Run the algorithm\noptimizer = SHADE.OriginalSHADE(epoch=10000, pop_size=100)\ng_best = optimizer.solve(problem)\nprint(f\"Best solution: {g_best.solution}, Best fitness: {g_best.target.fitness}\")\n```\n\n\n\n### Distributed Optimization / Parallelization Optimization\n\nPlease read the article titled [MEALPY: An open-source library for latest meta-heuristic algorithms in Python](https://doi.org/10.1016/j.sysarc.2023.102871) to \ngain a clear understanding of the concept of parallelization (distributed \noptimization) in metaheuristics. Not all metaheuristics can be run in parallel.\n\n\n```python\nfrom mealpy import FloatVar, SMA\nimport numpy as np\n\n\ndef objective_function(solution):\n    return np.sum(solution**2)\n\nproblem = {\n    \"obj_func\": objective_function,\n    \"bounds\": FloatVar(lb=(-100., )*100, ub=(100., )*100),\n    \"minmax\": \"min\",\n    \"log_to\": \"console\",\n}\n\n## Run distributed SMA algorithm using 10 threads\noptimizer = SMA.OriginalSMA(epoch=10000, pop_size=100, pr=0.03)\noptimizer.solve(problem, mode=\"thread\", n_workers=10)        # Distributed to 10 threads\nprint(f\"Best solution: {optimizer.g_best.solution}, Best fitness: {optimizer.g_best.target.fitness}\")\n\n## Run distributed SMA algorithm using 8 CPUs (cores)\noptimizer.solve(problem, mode=\"process\", n_workers=8)        # Distributed to 8 cores\nprint(f\"Best solution: {optimizer.g_best.solution}, Best fitness: {optimizer.g_best.target.fitness}\")\n```\n\n\n\n## The Benefit Of Using Custom Problem Class (BEST PRACTICE)\n\n### Optimize Machine Learning model\n\nIn this example, we use SMA optimize to optimize the hyper-parameters of SVC model.\n\n```python\nfrom sklearn.svm import SVC\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn import datasets, metrics\n\nfrom mealpy import FloatVar, StringVar, IntegerVar, BoolVar, MixedSetVar, SMA, Problem\n\n\n# Load the data set; In this example, the breast cancer dataset is loaded.\nX, y = datasets.load_breast_cancer(return_X_y=True)\n\n# Create training and test split\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)\n\nsc = StandardScaler()\nX_train_std = sc.fit_transform(X_train)\nX_test_std = sc.transform(X_test)\n\ndata = {\n    \"X_train\": X_train_std,\n    \"X_test\": X_test_std,\n    \"y_train\": y_train,\n    \"y_test\": y_test\n}\n\n\nclass SvmOptimizedProblem(Problem):\n    def __init__(self, bounds=None, minmax=\"max\", data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        C_paras, kernel_paras = x_decoded[\"C_paras\"], x_decoded[\"kernel_paras\"]\n        degree, gamma, probability = x_decoded[\"degree_paras\"], x_decoded[\"gamma_paras\"], x_decoded[\"probability_paras\"]\n\n        svc = SVC(C=C_paras, kernel=kernel_paras, degree=degree, \n                  gamma=gamma, probability=probability, random_state=1)\n        # Fit the model\n        svc.fit(self.data[\"X_train\"], self.data[\"y_train\"])\n        # Make the predictions\n        y_predict = svc.predict(self.data[\"X_test\"])\n        # Measure the performance\n        return metrics.accuracy_score(self.data[\"y_test\"], y_predict)\n\nmy_bounds = [\n    FloatVar(lb=0.01, ub=1000., name=\"C_paras\"),\n    StringVar(valid_sets=('linear', 'poly', 'rbf', 'sigmoid'), name=\"kernel_paras\"),\n    IntegerVar(lb=1, ub=5, name=\"degree_paras\"),\n    MixedSetVar(valid_sets=('scale', 'auto', 0.01, 0.05, 0.1, 0.5, 1.0), name=\"gamma_paras\"),\n    BoolVar(n_vars=1, name=\"probability_paras\"),\n]\nproblem = SvmOptimizedProblem(bounds=my_bounds, minmax=\"max\", data=data)\nmodel = SMA.OriginalSMA(epoch=100, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")\nprint(f\"Best solution: {model.g_best.solution}\")\nprint(f\"Best accuracy: {model.g_best.target.fitness}\")\nprint(f\"Best parameters: {model.problem.decode_solution(model.g_best.solution)}\")\n```\n\n\n\n### Solving Combinatorial Problems\n\n\n**Traveling Salesman Problem (TSP)**\n\nIn the context of the Mealpy for the Traveling Salesman Problem (TSP), a solution is a possible route that \nrepresents a tour of visiting all the cities exactly once and returning to the starting city. The solution is \ntypically represented as a permutation of the cities, where each city appears exactly once in the permutation.\n\n\nFor example, let's consider a TSP instance with 5 cities labeled as A, B, C, D, and E. A possible solution could be \nrepresented as the permutation `[A, B, D, E, C]`, which indicates the order in which the cities are visited. This \nsolution suggests that the tour starts at city A, then moves to city B, then D, E, and finally C before returning to city A.\n\n\n```python\nimport numpy as np\nfrom mealpy import PermutationVar, WOA, Problem\n\n# Define the positions of the cities\ncity_positions = np.array([[60, 200], [180, 200], [80, 180], [140, 180], [20, 160],\n                           [100, 160], [200, 160], [140, 140], [40, 120], [100, 120],\n                           [180, 100], [60, 80], [120, 80], [180, 60], [20, 40],\n                           [100, 40], [200, 40], [20, 20], [60, 20], [160, 20]])\nnum_cities = len(city_positions)\ndata = {\n    \"city_positions\": city_positions,\n    \"num_cities\": num_cities,\n}\n\nclass TspProblem(Problem):\n    def __init__(self, bounds=None, minmax=\"min\", data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    @staticmethod\n    def calculate_distance(city_a, city_b):\n        # Calculate Euclidean distance between two cities\n        return np.linalg.norm(city_a - city_b)\n\n    @staticmethod\n    def calculate_total_distance(route, city_positions):\n        # Calculate total distance of a route\n        total_distance = 0\n        num_cities = len(route)\n        for idx in range(num_cities):\n            current_city = route[idx]\n            next_city = route[(idx + 1) % num_cities]  # Wrap around to the first city\n            total_distance += TspProblem.calculate_distance(city_positions[current_city], city_positions[next_city])\n        return total_distance\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        route = x_decoded[\"per_var\"]\n        fitness = self.calculate_total_distance(route, self.data[\"city_positions\"])\n        return fitness\n\n\nbounds = PermutationVar(valid_set=list(range(0, num_cities)), name=\"per_var\")\nproblem = TspProblem(bounds=bounds, minmax=\"min\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=100, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}\")      # Decoded (Real) solution\n```\n\n\n\n**Job Shop Scheduling Problem Using Woa Optimizer**\n\nNote that this implementation assumes that the job times and machine times are provided as 2D lists, where \n`job_times[i][j]` represents the processing time of job `i` on machine `j`.\n\nKeep in mind that this is a simplified implementation, and you may need to modify it according to the specific \n requirements and constraints of your Job Shop Scheduling problem.\n\n\n```python\nimport numpy as np\nfrom mealpy import PermutationVar, WOA, Problem\n\n\njob_times = [[2, 1, 3], [4, 2, 1], [3, 3, 2]]\nmachine_times = [[3, 2, 1], [1, 4, 2], [2, 3, 2]]\n\nn_jobs = len(job_times)\nn_machines = len(machine_times)\n\ndata = {\n    \"job_times\": job_times,\n    \"machine_times\": machine_times,\n    \"n_jobs\": n_jobs,\n    \"n_machines\": n_machines\n}\n\nclass JobShopProblem(Problem):\n    def __init__(self, bounds=None, minmax=\"min\", data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"per_var\"]\n        makespan = np.zeros((self.data[\"n_jobs\"], self.data[\"n_machines\"]))\n        for gene in x:\n            job_idx = gene // self.data[\"n_machines\"]\n            machine_idx = gene % self.data[\"n_machines\"]\n            if job_idx == 0 and machine_idx == 0:\n                makespan[job_idx][machine_idx] = job_times[job_idx][machine_idx]\n            elif job_idx == 0:\n                makespan[job_idx][machine_idx] = makespan[job_idx][machine_idx - 1] + job_times[job_idx][machine_idx]\n            elif machine_idx == 0:\n                makespan[job_idx][machine_idx] = makespan[job_idx - 1][machine_idx] + job_times[job_idx][machine_idx]\n            else:\n                makespan[job_idx][machine_idx] = max(makespan[job_idx][machine_idx - 1], makespan[job_idx - 1][machine_idx]) + job_times[job_idx][machine_idx]\n        return np.max(makespan)\n\n\nbounds = PermutationVar(valid_set=list(range(0, n_jobs*n_machines)), name=\"per_var\")\nproblem = JobShopProblem(bounds=bounds, minmax=\"min\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=100, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}\")      # Decoded (Real) solution\n```\n\n\n\n**Shortest Path Problem**\n\nIn this example, the graph is represented as a NumPy array where each element represents the cost or distance between two nodes.\n\nNote that this implementation assumes that the graph is represented by a symmetric matrix, where `graph[i,j]` \nrepresents the distance between nodes `i` and `j`. If your graph representation is different, you may need to modify \nthe code accordingly.\n\nPlease keep in mind that this implementation is a basic example and may not be optimized for large-scale problems. \nFurther modifications and optimizations may be required depending on your specific use case.\n\n\n```python\nimport numpy as np\nfrom mealpy import PermutationVar, WOA, Problem\n\n# Define the graph representation\ngraph = np.array([\n    [0, 2, 4, 0, 7, 9],\n    [2, 0, 1, 4, 2, 8],\n    [4, 1, 0, 1, 3, 0],\n    [6, 4, 5, 0, 3, 2],\n    [0, 2, 3, 3, 0, 2],\n    [9, 0, 4, 2, 2, 0]\n])\n\n\nclass ShortestPathProblem(Problem):\n    def __init__(self, bounds=None, minmax=\"min\", data=None, **kwargs):\n        self.data = data\n        self.eps = 1e10         # Penalty function for vertex with 0 connection\n        super().__init__(bounds, minmax, **kwargs)\n\n    # Calculate the fitness of an individual\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        individual = x_decoded[\"path\"]\n\n        total_distance = 0\n        for idx in range(len(individual) - 1):\n            start_node = individual[idx]\n            end_node = individual[idx + 1]\n            weight = self.data[start_node, end_node]\n            if weight == 0:\n                return self.eps\n            total_distance += weight\n        return total_distance\n\n\nnum_nodes = len(graph)\nbounds = PermutationVar(valid_set=list(range(0, num_nodes)), name=\"path\")\nproblem = ShortestPathProblem(bounds=bounds, minmax=\"min\", data=graph)\n\nmodel = WOA.OriginalWOA(epoch=100, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}\")      # Decoded (Real) solution\n```\n\n\n\n\n**Location Optimization**\n\n\nLet's consider an example of location optimization in the context of a retail company that wants to open a certain \nnumber of new stores in a region to maximize market coverage while minimizing operational costs.\n\nA company wants to open five new stores in a region with several potential locations. The objective is to \ndetermine the optimal locations for these stores while considering factors such as population density and \ntransportation costs. The goal is to maximize market coverage by locating stores in areas with high demand while \nminimizing the overall transportation costs required to serve customers.\n\nBy applying location optimization techniques, the retail company can make informed decisions about where to open new \nstores, considering factors such as population density and transportation costs. This approach allows the company to \nmaximize market coverage, make efficient use of resources, and ultimately improve customer service and profitability.\n\nNote that this example is a simplified illustration, and in real-world scenarios, location optimization problems can \ninvolve more complex constraints, additional factors, and larger datasets. However, the general process remains \nsimilar, involving data analysis, mathematical modeling, and optimization techniques to determine the optimal \nlocations for facilities.\n\n\n```python\nimport numpy as np\nfrom mealpy import BinaryVar, WOA, Problem\n\n# Define the coordinates of potential store locations\nlocations = np.array([\n    [2, 4],\n    [5, 6],\n    [9, 3],\n    [7, 8],\n    [1, 10],\n    [3, 2],\n    [5, 5],\n    [8, 2],\n    [7, 6],\n    [1, 9]\n])\n# Define the transportation costs matrix based on the Euclidean distance between locations\ndistance_matrix = np.linalg.norm(locations[:, np.newaxis] - locations, axis=2)\n\n# Define the number of stores to open\nnum_stores = 5\n\n# Define the maximum distance a customer should travel to reach a store\nmax_distance = 10\n\ndata = {\n    \"num_stores\": num_stores,\n    \"max_distance\": max_distance,\n    \"penalty\": 1e10\n}\n\n\nclass LocationOptProblem(Problem):\n    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):\n        self.data = data\n        self.eps = 1e10\n        super().__init__(bounds, minmax, **kwargs)\n\n    # Define the fitness evaluation function\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"placement_var\"]\n        total_coverage = np.sum(x)\n        total_dist = np.sum(x[:, np.newaxis] * distance_matrix)\n        if total_dist == 0:                 # Penalize solutions with fewer stores\n            return self.eps\n        if total_coverage \u003c self.data[\"num_stores\"]:    # Penalize solutions with fewer stores\n            return self.eps\n        return total_dist\n\n\nbounds = BinaryVar(n_vars=len(locations), name=\"placement_var\")\nproblem = LocationOptProblem(bounds=bounds, minmax=\"min\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=50, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}\")      # Decoded (Real) solution\n\n```\n\n\n**Supply Chain Optimization**\n\nLet's assume we have a supply chain network with 5 distribution centers (DC1, DC2, DC3, DC4, DC5) and 10 products \n(P1, P2, P3, ..., P10). Our goal is to determine the optimal allocation of products to the distribution centers in \na way that minimizes the total transportation cost.\n\nEach solution represents an allocation of products to distribution centers. We can use a binary matrix with \ndimensions `(10, 5)` where each element `(i, j)` represents whether product `i` is allocated to distribution center `j`. \nFor example, a chromosome `[1, 0, 1, 0, 1]` would mean that product `1` is allocated to `DC1`, `DC3`, `DC5`.\n\nWe can add the maximum capacity of each distribution center, therefor we need penalty term to the fitness \nevaluation function to penalize solutions that violate this constraint. The penalty can be based on the degree of \nviolation or a fixed penalty value.\n\n\n```python\nimport numpy as np\nfrom mealpy import BinaryVar, WOA, Problem\n\n# Define the problem parameters\nnum_products = 10\nnum_distribution_centers = 5\n\n# Define the transportation cost matrix (randomly generated for the example)\ntransportation_cost = np.random.randint(1, 10, size=(num_products, num_distribution_centers))\n\ndata = {\n    \"num_products\": num_products,\n    \"num_distribution_centers\": num_distribution_centers,\n    \"transportation_cost\": transportation_cost,\n    \"max_capacity\": 4,      # Maximum capacity of each distribution center\n    \"penalty\": 1e10         # Define a penalty value for maximum capacity of each distribution center\n}\n\n\nclass SupplyChainProblem(Problem):\n    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"placement_var\"].reshape((self.data[\"num_products\"], self.data[\"num_distribution_centers\"]))\n\n        if np.any(np.all(x==0, axis=1)):    \n        # If any row has all 0 value, it indicates that this product is not allocated to any distribution center.\n            return 0\n\n        total_cost = np.sum(self.data[\"transportation_cost\"] * x)\n        # Penalty for violating maximum capacity constraint\n        excess_capacity = np.maximum(np.sum(x, axis=0) - self.data[\"max_capacity\"], 0)\n        penalty = np.sum(excess_capacity)\n        # Calculate fitness value as the inverse of the total cost plus the penalty\n        fitness = 1 / (total_cost + penalty)\n        return fitness\n\n\nbounds = BinaryVar(n_vars=num_products * num_distribution_centers, name=\"placement_var\")\nproblem = SupplyChainProblem(bounds=bounds, minmax=\"max\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=50, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)['placement_var'].reshape((num_products, num_distribution_centers))}\")\n```\n\n\n**Healthcare Workflow Optimization Problem**\n\nDefine a chromosome representation that encodes the allocation of resources and patient flow in the emergency \ndepartment. This could be a binary matrix where each row represents a patient and each column represents a resource \n(room). If the element is 1, it means the patient is assigned to that particular room, and if the element is 0, it \nmeans the patient is not assigned to that room\n\nPlease note that this implementation is a basic template and may require further customization based on the specific \nobjectives, constraints, and evaluation criteria of your healthcare workflow optimization problem. You'll need to \ndefine the specific fitness function and optimization objectives based on the factors you want to optimize, such as \npatient waiting times, resource utilization, and other relevant metrics in the healthcare workflow context.\n\n\n```python\nimport numpy as np\nfrom mealpy import BinaryVar, WOA, Problem\n\n# Define the problem parameters\nnum_patients = 50  # Number of patients\nnum_resources = 10  # Number of resources (room)\n\n# Define the patient waiting time matrix (randomly generated for the example)\n# Why? May be, doctors need time to prepare tools,...\nwaiting_matrix = np.random.randint(1, 10, size=(num_patients, num_resources))\n\ndata = {\n    \"num_patients\": num_patients,\n    \"num_resources\": num_resources,\n    \"waiting_matrix\": waiting_matrix,\n    \"max_resource_capacity\": 10,        # Maximum capacity of each room\n    \"max_waiting_time\": 60,             # Maximum waiting time\n    \"penalty_value\": 1e2,         # Define a penalty value\n    \"penalty_patient\": 1e10\n}\n\n\nclass SupplyChainProblem(Problem):\n    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"placement_var\"].reshape(self.data[\"num_patients\"], self.data[\"num_resources\"])\n\n        # If any row has all 0 value, it indicates that this patient is not allocated to any room.\n        # If a patient a assigned to more than 3 room, not allow\n        if np.any(np.all(x==0, axis=1)) or np.any(np.sum(x\u003e3, axis=1)):\n            return self.data[\"penalty_patient\"]\n\n        # Calculate fitness based on optimization objectives\n        room_used = np.sum(x, axis=0)\n        wait_time = np.sum(x * self.data[\"waiting_matrix\"], axis=1)\n        violated_constraints = np.sum(room_used \u003e self.data[\"max_resource_capacity\"]) + np.sum(wait_time \u003e self.data[\"max_waiting_time\"])\n\n        # Calculate the fitness value based on the objectives\n        resource_utilization_fitness = 1 - np.mean(room_used) / self.data[\"max_resource_capacity\"]\n        waiting_time_fitness = 1 - np.mean(wait_time) / self.data[\"max_waiting_time\"]\n\n        fitness = resource_utilization_fitness + waiting_time_fitness + self.data['penalty_value'] * violated_constraints\n        return fitness\n\n\nbounds = BinaryVar(n_vars=num_patients * num_resources, name=\"placement_var\")\nproblem = SupplyChainProblem(bounds=bounds, minmax=\"min\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=50, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)['placement_var'].reshape((num_patients, num_resources))}\")\n```\n\n\n**Production Optimization Problem**\n\nLet's consider a simplified example of production optimization in the context of a manufacturing company that \nproduces electronic devices, such as smartphones. The objective is to maximize production output while minimizing \nproduction costs.\n\nThis example uses binary representations for production configurations, assuming each task can be assigned to a \nresource (1) or not (0). You may need to adapt the representation and operators to suit your specific production \noptimization problem.\n\n\n```python\nimport numpy as np\nfrom mealpy import BinaryVar, WOA, Problem\n\n# Define the problem parameters\nnum_tasks = 10\nnum_resources = 5\n\n# Example task processing times\ntask_processing_times = np.array([2, 3, 4, 2, 3, 2, 3, 4, 2, 3])\n\n# Example resource capacity\nresource_capacity = np.array([10, 8, 6, 12, 15])\n\n# Example production costs and outputs\nproduction_costs = np.array([5, 6, 4, 7, 8, 9, 5, 6, 7, 8])\nproduction_outputs = np.array([20, 18, 16, 22, 25, 24, 20, 18, 19, 21])\n\n# Example maximum total production time\nmax_total_time = 50\n\n# Example maximum defect rate\nmax_defect_rate = 0.2\n\n# Penalty for invalid solution\npenalty = -1000\n\ndata = {\n    \"num_tasks\": num_tasks,\n    \"num_resources\": num_resources,\n    \"task_processing_times\": task_processing_times,\n    \"resource_capacity\": resource_capacity,\n    \"production_costs\": production_costs,\n    \"production_outputs\": production_outputs,\n    \"max_defect_rate\": max_defect_rate,\n    \"penalty\": penalty\n}\n\n\nclass SupplyChainProblem(Problem):\n    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"placement_var\"].reshape((self.data[\"num_tasks\"], self.data[\"num_resources\"]))\n\n        # If any row has all 0 value, it indicates that this task is not allocated to any resource\n        if np.any(np.all(x==0, axis=1)) or np.any(np.all(x==0, axis=0)):\n            return self.data[\"penalty\"]\n\n        # Check violated constraints\n        violated_constraints = 0\n\n        # Calculate resource utilization\n        resource_utilization = np.sum(x, axis=0)\n        # Resource capacity constraint\n        if np.any(resource_utilization \u003e self.data[\"resource_capacity\"]):\n            violated_constraints += 1\n\n        # Time constraint\n        total_time = np.sum(np.dot(self.data[\"task_processing_times\"].reshape(1, -1), x))\n        if total_time \u003e max_total_time:\n            violated_constraints += 1\n\n        # Quality constraint\n        defect_rate = np.dot(self.data[\"production_costs\"].reshape(1, -1), x) / np.dot(self.data[\"production_outputs\"], x)\n        if np.any(defect_rate \u003e max_defect_rate):\n            violated_constraints += 1\n\n        # Calculate the fitness value based on the objectives and constraints\n        profit = np.sum(np.dot(self.data[\"production_outputs\"].reshape(1, -1), x)) - np.sum(np.dot(self.data[\"production_costs\"].reshape(1, -1), x))\n        if violated_constraints \u003e 0:\n            return profit + self.data[\"penalty\"] * violated_constraints       # Penalize solutions with violated constraints\n        return profit\n\n\nbounds = BinaryVar(n_vars=num_tasks * num_resources, name=\"placement_var\")\nproblem = SupplyChainProblem(bounds=bounds, minmax=\"max\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=50, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)['placement_var'].reshape((num_tasks, num_resources))}\")\n```\n\n\n\n\n**Employee Rostering Problem Using Woa Optimizer**\n\nThe goal is to create an optimal schedule that assigns employees to shifts while satisfying various \nconstraints and objectives. Note that this implementation assumes that shift_requirements array \nhas dimensions (num_employees, num_shifts), and shift_costs is a 1D array of length num_shifts.\n\nPlease keep in mind that this is a simplified implementation, and you may need to modify it according to the \nspecific requirements and constraints of your employee rostering problem. Additionally, you might want to \nintroduce additional mechanisms or constraints such as fairness, employee preferences, or shift \ndependencies to enhance the model's effectiveness in real-world scenarios.\n\nFor example, if you have 5 employees and 3 shifts, a chromosome could be represented as [2, 1, 0, 2, 0], \nwhere employee 0 is assigned to shift 2, employee 1 is assigned to shift 1, \nemployee 2 is assigned to shift 0, and so on.\n\n```python\nimport numpy as np\nfrom mealpy import IntegerVar, WOA, Problem\n\n\nshift_requirements = np.array([[2, 1, 3], [4, 2, 1], [3, 3, 2]])\nshift_costs = np.array([10, 8, 12])\n\nnum_employees = shift_requirements.shape[0]\nnum_shifts = shift_requirements.shape[1]\n\ndata = {\n    \"shift_requirements\": shift_requirements,\n    \"shift_costs\": shift_costs,\n    \"num_employees\": num_employees,\n    \"num_shifts\": num_shifts\n}\n\nclass EmployeeRosteringProblem(Problem):\n    def __init__(self, bounds=None, minmax=\"min\", data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"shift_var\"]\n\n        shifts_covered = np.zeros(self.data[\"num_shifts\"])\n        total_cost = 0\n        for idx in range(self.data[\"num_employees\"]):\n            shift_idx = x[idx]\n            shifts_covered[shift_idx] += 1\n            total_cost += self.data[\"shift_costs\"][shift_idx]\n        coverage_diff = self.data[\"shift_requirements\"] - shifts_covered\n        coverage_penalty = np.sum(np.abs(coverage_diff))\n        return total_cost + coverage_penalty\n\n\nbounds = IntegerVar(lb=[0, ]*num_employees, ub=[num_shifts-1, ]*num_employees, name=\"shift_var\")\nproblem = EmployeeRosteringProblem(bounds=bounds, minmax=\"min\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=50, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}\")      # Decoded (Real) solution\n```\n\n**Maintenance Scheduling**\n\nIn maintenance scheduling, the goal is to optimize the schedule for performing maintenance tasks on\nvarious assets or equipment. The objective is to minimize downtime and maximize the utilization of\nassets while considering various constraints such as resource availability, task dependencies, and time constraints.\n\nEach element in the solution represents whether a task is assigned to an asset (1) or not (0). The schedule \nspecifies when each task should start and which asset it is assigned to, aiming to minimize the total downtime.\n\nBy using the Mealpy, you can find an efficient maintenance schedule that minimizes downtime,\nmaximizes asset utilization, and satisfies various constraints, ultimately optimizing \nthe maintenance operations for improved reliability and productivity.\n\n```python\n\nimport numpy as np\nfrom mealpy import BinaryVar, WOA, Problem\n\n\nnum_tasks = 10\nnum_assets = 5\ntask_durations = np.random.randint(1, 10, size=(num_tasks, num_assets))\n\ndata = {\n    \"num_tasks\": num_tasks,\n    \"num_assets\": num_assets,\n    \"task_durations\": task_durations,\n    \"unassigned_penalty\": -100         # Define a penalty value for no task is assigned to asset\n}\n\n\nclass MaintenanceSchedulingProblem(Problem):\n    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):\n        self.data = data\n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, x):\n        x_decoded = self.decode_solution(x)\n        x = x_decoded[\"task_var\"]\n        downtime = -np.sum(x.reshape((self.data[\"num_tasks\"], self.data[\"num_assets\"])) * self.data[\"task_durations\"])\n        if np.sum(x) == 0:\n            downtime += self.data[\"unassigned_penalty\"]\n        return downtime\n\n\nbounds = BinaryVar(n_vars=num_tasks * num_assets, name=\"task_var\")\nproblem = MaintenanceSchedulingProblem(bounds=bounds, minmax=\"max\", data=data)\n\nmodel = WOA.OriginalWOA(epoch=50, pop_size=20)\nmodel.solve(problem)\n\nprint(f\"Best agent: {model.g_best}\")                    # Encoded solution\nprint(f\"Best solution: {model.g_best.solution}\")        # Encoded solution\nprint(f\"Best fitness: {model.g_best.target.fitness}\")\nprint(f\"Best real scheduling: {model.problem.decode_solution(model.g_best.solution).reshape((num_tasks, num_assets))}\")      # Decoded (Real) solution\n```\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eConstrained Benchmark Function\u003c/h3\u003e\u003c/summary\u003e\n\n```python\nfrom mealpy import FloatVar, SMA\nimport numpy as np\n\n## Link: https://onlinelibrary.wiley.com/doi/pdf/10.1002/9781119136507.app2\ndef objective_function(solution):\n    def g1(x):\n        return 2*x[0] + 2*x[1] + x[9] + x[10] - 10\n    def g2(x):\n        return 2 * x[0] + 2 * x[2] + x[9] + x[10] - 10\n    def g3(x):\n        return 2 * x[1] + 2 * x[2] + x[10] + x[11] - 10\n    def g4(x):\n        return -8*x[0] + x[9]\n    def g5(x):\n        return -8*x[1] + x[10]\n    def g6(x):\n        return -8*x[2] + x[11]\n    def g7(x):\n        return -2*x[3] - x[4] + x[9]\n    def g8(x):\n        return -2*x[5] - x[6] + x[10]\n    def g9(x):\n        return -2*x[7] - x[8] + x[11]\n\n    def violate(value):\n        return 0 if value \u003c= 0 else value\n\n    fx = 5 * np.sum(solution[:4]) - 5*np.sum(solution[:4]**2) - np.sum(solution[4:13])\n\n    ## Increase the punishment for g1 and g4 to boost the algorithm (You can choice any constraint instead of g1 and g4)\n    fx += violate(g1(solution))**2 + violate(g2(solution)) + violate(g3(solution)) + \\\n            2*violate(g4(solution)) + violate(g5(solution)) + violate(g6(solution))+ \\\n            violate(g7(solution)) + violate(g8(solution)) + violate(g9(solution))\n    return fx\n\nproblem = {\n    \"obj_func\": objective_function,\n    \"bounds\": FloatVar(lb=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ub=[1, 1, 1, 1, 1, 1, 1, 1, 1, 100, 100, 100, 1]),\n    \"minmax\": \"min\",\n}\n\n## Run the algorithm\noptimizer = SMA.OriginalSMA(epoch=100, pop_size=50, pr=0.03)\noptimizer.solve(problem)\nprint(f\"Best solution: {optimizer.g_best.solution}, Best fitness: {optimizer.g_best.target.fitness}\")\n```\n\n\u003c/details\u003e\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eMulti-objective Benchmark Function\u003c/h3\u003e\u003c/summary\u003e\n\n```python\nfrom mealpy import FloatVar, SMA \nimport numpy as np\n\n\n## Link: https://en.wikipedia.org/wiki/Test_functions_for_optimization\ndef objective_function(solution):\n\n    def booth(x, y):\n        return (x + 2*y - 7)**2 + (2*x + y - 5)**2\n\n    def bukin(x, y):\n        return 100 * np.sqrt(np.abs(y - 0.01 * x**2)) + 0.01 * np.abs(x + 10)\n\n    def matyas(x, y):\n        return 0.26 * (x**2 + y**2) - 0.48 * x * y\n\n    return [booth(solution[0], solution[1]), bukin(solution[0], solution[1]), matyas(solution[0], solution[1])]\n\n\nproblem = {\n    \"obj_func\": objective_function,\n    \"bounds\": FloatVar(lb=(-10, -10), ub=(10, 10)),\n    \"minmax\": \"min\",\n    \"obj_weights\": [0.4, 0.1, 0.5]               # Define it or default value will be [1, 1, 1]\n}\n\n## Run the algorithm\noptimizer = SMA.OriginalSMA(epoch=100, pop_size=50, pr=0.03)\noptimizer.solve(problem)\nprint(f\"Best solution: {optimizer.g_best.solution}, Best fitness: {optimizer.g_best.target.fitness}\")\n\n## You can access all of available figures via object \"history\" like this:\noptimizer.history.save_global_objectives_chart(filename=\"hello/goc\")\noptimizer.history.save_local_objectives_chart(filename=\"hello/loc\")\noptimizer.history.save_global_best_fitness_chart(filename=\"hello/gbfc\")\noptimizer.history.save_local_best_fitness_chart(filename=\"hello/lbfc\")\noptimizer.history.save_runtime_chart(filename=\"hello/rtc\")\noptimizer.history.save_exploration_exploitation_chart(filename=\"hello/eec\")\noptimizer.history.save_diversity_chart(filename=\"hello/dc\")\noptimizer.history.save_trajectory_chart(list_agent_idx=[3, 5], selected_dimensions=[2], filename=\"hello/tc\")\n```\n\n\u003c/details\u003e\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eCustom Problem \u003c/h3\u003e\u003c/summary\u003e\n\n\nFor our custom problem, we can create a class and inherit from the `Problem` class, named the child class the  \n'Squared' class. In the initialization method of the 'Squared' class, we have to set the `bounds`, and `minmax`  \nof the problem (bounds: a problem's type, and minmax: a string specifying whether the problem is a 'min' or 'max' problem). \n\nAfterwards, we have to override the abstract method `obj_func()`, which takes a parameter 'solution' (the solution \nto be evaluated) and returns the function value. The resulting code should look something like the code snippet \nbelow. 'Name' is an additional parameter we want to include in this class, and you can include any other additional \nparameters you need. But remember to set up all additional parameters before super() called.\n\n\n```python\nfrom mealpy import Problem, FloatVar, BBO \nimport numpy as np\n\n# Our custom problem class\nclass Squared(Problem):\n    def __init__(self, bounds=None, minmax=\"min\", data=None, **kwargs):\n        self.data = data \n        super().__init__(bounds, minmax, **kwargs)\n\n    def obj_func(self, solution):\n        return np.sum(solution ** 2)\n\n    \n## Now, we define an algorithm, and pass an instance of our *Squared* class as the problem argument. \nproblem = Squared(bounds=FloatVar(lb=(-10., )*20, ub=(10., )*20), minmax=\"min\", name=\"Squared\", data=\"Amazing\")\nmodel = BBO.OriginalBBO(epoch=10, pop_size=50)\ng_best = model.solve(problem)\n\n## Show some attributes\nprint(g_best.solution)\nprint(g_best.target.fitness)\nprint(g_best.target.objectives)\nprint(g_best)\nprint(model.get_parameters())\nprint(model.get_name())\nprint(model.get_attributes()[\"g_best\"])\nprint(model.problem.get_name())\nprint(model.problem.n_dims)\nprint(model.problem.bounds)\nprint(model.problem.lb)\nprint(model.problem.ub)\n```\n\n\u003c/details\u003e\n\n\n\n\n\n\n\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eTuner class (GridSearchCV/ParameterSearch, Hyper-parameter tuning)\u003c/h3\u003e\u003c/summary\u003e\n\n\nWe build a dedicated class, Tuner, that can help you tune your algorithm's parameters.\n\n```python\nfrom opfunu.cec_based.cec2017 import F52017\nfrom mealpy import FloatVar, BBO, Tuner\n\n## You can define your own problem, here I took the F5 benchmark function in CEC-2017 as an example.\nf1 = F52017(30, f_bias=0)\n\np1 = {\n    \"bounds\": FloatVar(lb=f1.lb, ub=f1.ub),\n    \"obj_func\": f1.evaluate,\n    \"minmax\": \"min\",\n    \"name\": \"F5\",\n    \"log_to\": \"console\",\n}\n\nparas_bbo_grid = {\n    \"epoch\": [10, 20, 30, 40],\n    \"pop_size\": [50, 100, 150],\n    \"n_elites\": [2, 3, 4, 5],\n    \"p_m\": [0.01, 0.02, 0.05]\n}\n\nterm = {\n    \"max_epoch\": 200,\n    \"max_time\": 20,\n    \"max_fe\": 10000\n}\n\nif __name__ == \"__main__\":\n    model = BBO.OriginalBBO()\n    tuner = Tuner(model, paras_bbo_grid)\n    tuner.execute(problem=p1, termination=term, n_trials=5, n_jobs=4, mode=\"thread\", n_workers=4, verbose=True)\n    ## Solve this problem 5 times (n_trials) using 5 processes (n_jobs), each process will handle 1 trial. \n    ## The mode to run the solver is thread (mode), distributed to 4 threads \n\n    print(tuner.best_row)\n    print(tuner.best_score)\n    print(tuner.best_params)\n    print(type(tuner.best_params))\n    print(tuner.best_algorithm)\n    \n    ## Save results to csv file \n    tuner.export_results(save_path=\"history\", file_name=\"tuning_best_fit.csv\")\n    tuner.export_figures()\n    \n    ## Re-solve the best model on your problem \n    g_best = tuner.resolve(mode=\"thread\", n_workers=4, termination=term)\n    print(g_best.solution, g_best.target.fitness)\n    print(tuner.algorithm.problem.get_name())\n    print(tuner.best_algorithm.get_name())\n```\n\n\u003c/details\u003e\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eMultitask class (Multitask solver)\u003c/h3\u003e\u003c/summary\u003e\n\n\nWe also build a dedicated class, Multitask, that can help you run several scenarios. For example:\n\n1. Run 1 algorithm with 1 problem, and multiple trials\n2. Run 1 algorithm with multiple problems, and multiple trials\n3. Run multiple algorithms with 1 problem, and multiple trials\n4. Run multiple algorithms with multiple problems, and multiple trials\n\n\n```python\n#### Using multiple algorithm to solve multiple problems with multiple trials\n\n## Import libraries\nfrom opfunu.cec_based.cec2017 import F52017, F102017, F292017\nfrom mealpy import FloatVar\nfrom mealpy import BBO, DE\nfrom mealpy import Multitask\n\n## Define your own problems\nf1 = F52017(30, f_bias=0)\nf2 = F102017(30, f_bias=0)\nf3 = F292017(30, f_bias=0)\n\np1 = {\n    \"bounds\": FloatVar(lb=f1.lb, ub=f1.ub),\n    \"obj_func\": f1.evaluate,\n    \"minmax\": \"min\",\n    \"name\": \"F5\",\n    \"log_to\": \"console\",\n}\n\np2 = {\n    \"bounds\": FloatVar(lb=f2.lb, ub=f2.ub),\n    \"obj_func\": f2.evaluate,\n    \"minmax\": \"min\",\n    \"name\": \"F10\",\n    \"log_to\": \"console\",\n}\n\np3 = {\n    \"bounds\": FloatVar(lb=f3.lb, ub=f3.ub),\n    \"obj_func\": f3.evaluate,\n    \"minmax\": \"min\",\n    \"name\": \"F29\",\n    \"log_to\": \"console\",\n}\n\n## Define models\nmodel1 = BBO.DevBBO(epoch=10000, pop_size=50)\nmodel2 = BBO.OriginalBBO(epoch=10000, pop_size=50)\nmodel3 = DE.OriginalDE(epoch=10000, pop_size=50)\nmodel4 = DE.SAP_DE(epoch=10000, pop_size=50)\n\n## Define termination if needed\nterm = {\n    \"max_fe\": 3000\n}\n\n## Define and run Multitask\nif __name__ == \"__main__\":\n    multitask = Multitask(algorithms=(model1, model2, model3, model4), problems=(p1, p2, p3), terminations=(term, ), modes=(\"thread\", ), n_workers=4)\n    # default modes = \"single\", default termination = epoch (as defined in problem dictionary)\n    multitask.execute(n_trials=5, n_jobs=None, save_path=\"history\", save_as=\"csv\", save_convergence=True, verbose=False)\n    # multitask.execute(n_trials=5, save_path=\"history\", save_as=\"csv\", save_convergence=True, verbose=False)\n    \n    ## Check the directory: history/, you will see list of .csv result files\n```\n\nFor more usage examples please look at [examples](/examples) folder.\n\nMore advanced examples can also be found in the [Mealpy-examples repository](https://github.com/thieu1995/mealpy_examples).\n\n\n\u003c/details\u003e\n\n\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eGet Visualize Figures\u003c/h3\u003e\u003c/summary\u003e\n\n* [Tutorials](/examples/utils/visualize/all_charts.py)\n\n\u003cp align=\"center\"\u003e\u003cimg src=\"https://thieu1995.github.io/post/2022-04/19-mealpy-tutorials/mealpy2.png\" alt=\"MEALPY\"/\u003e\n\u003c/p\u003e\n\n\u003c/details\u003e\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eAll Optimizers\u003c/h3\u003e\u003c/summary\u003e\n\n```python\n\n\nimport numpy as np\nfrom opfunu.cec_based.cec2017 import F292017\n\nfrom mealpy import BBO, PSO, GA, ALO, AO, ARO, AVOA, BA, BBOA, BMO, EOA, IWO\nfrom mealpy import FloatVar\nfrom mealpy import GJO, FOX, FOA, FFO, FFA, FA, ESOA, EHO, DO, DMOA, CSO, CSA, CoatiOA, COA, BSA\nfrom mealpy import HCO, ICA, LCO, WarSO, TOA, TLO, SSDO, SPBO, SARO, QSA, ArchOA, ASO, CDO, EFO, EO, EVO, FLA\nfrom mealpy import HGSO, MVO, NRO, RIME, SA, WDO, TWO, ABC, ACOR, AGTO, BeesA, BES, BFO, ZOA, WOA, WaOA, TSO\nfrom mealpy import PFA, OOA, NGO, NMRA, MSA, MRFO, MPA, MGO, MFO, JA, HHO, HGS, HBA, GWO, GTO, GOA\nfrom mealpy import Problem\nfrom mealpy import SBO, SMA, SOA, SOS, TPO, TSA, VCS, WHO, AOA, CEM, CGO, CircleSA, GBO, HC, INFO, PSS, RUN, SCA\nfrom mealpy import SHIO, TS, HS, AEO, GCO, WCA, CRO, DE, EP, ES, FPA, MA, SHADE, BRO, BSO, CA, CHIO, FBIO, GSKA, HBO\nfrom mealpy import TDO, STO, SSpiderO, SSpiderA, SSO, SSA, SRSR, SLO, SHO, SFO, ServalOA, SeaHO, SCSO, POA\nfrom mealpy import (StringVar, FloatVar, BoolVar, PermutationVar, MixedSetVar, IntegerVar, BinaryVar,\n                    TransferBinaryVar, TransferBoolVar)\nfrom mealpy import Tuner, Multitask, Problem, Optimizer, Termination, ParameterGrid\nfrom mealpy import get_all_optimizers, get_optimizer_by_name\n\n\n\nif __name__ == \"__main__\":\n    model = BBO.OriginalBBO(epoch=10, pop_size=30, p_m=0.01, n_elites=2)\n    model = PSO.OriginalPSO(epoch=100, pop_size=50, c1=2.05, c2=20.5, w=0.4)\n    model = PSO.LDW_PSO(epoch=100, pop_size=50, c1=2.05, c2=20.5, w_min=0.4, w_max=0.9)\n    model = PSO.AIW_PSO(epoch=100, pop_size=50, c1=2.05, c2=20.5, alpha=0.4)\n    model = PSO.P_PSO(epoch=100, pop_size=50)\n    model = PSO.HPSO_TVAC(epoch=100, pop_size=50, ci=0.5, cf=0.1)\n    model = PSO.C_PSO(epoch=100, pop_size=50, c1=2.05, c2=2.05, w_min=0.4, w_max=0.9)\n    model = PSO.CL_PSO(epoch=100, pop_size=50, c_local=1.2, w_min=0.4, w_max=0.9, max_flag=7)\n    model = GA.BaseGA(epoch=100, pop_size=50, pc=0.9, pm=0.05, selection=\"tournament\", k_way=0.4, crossover=\"multi_points\", mutation=\"swap\")\n    model = GA.SingleGA(epoch=100, pop_size=50, pc=0.9, pm=0.8, selection=\"tournament\", k_way=0.4, crossover=\"multi_points\", mutation=\"swap\")\n    model = GA.MultiGA(epoch=100, pop_size=50, pc=0.9, pm=0.8, selection=\"tournament\", k_way=0.4, crossover=\"multi_points\", mutation=\"swap\")\n    model = GA.EliteSingleGA(epoch=100, pop_size=50, pc=0.95, pm=0.8, selection=\"roulette\", crossover=\"uniform\", mutation=\"swap\", k_way=0.2, elite_best=0.1,\n                             elite_worst=0.3, strategy=0)\n    model = GA.EliteMultiGA(epoch=100, pop_size=50, pc=0.95, pm=0.8, selection=\"roulette\", crossover=\"uniform\", mutation=\"swap\", k_way=0.2, elite_best=0.1,\n                            elite_worst=0.3, strategy=0)\n    model = ABC.OriginalABC(epoch=1000, pop_size=50, n_limits=50)\n    model = ACOR.OriginalACOR(epoch=1000, pop_size=50, sample_count=25, intent_factor=0.5, zeta=1.0)\n    model = AGTO.OriginalAGTO(epoch=1000, pop_size=50, p1=0.03, p2=0.8, beta=3.0)\n    model = AGTO.MGTO(epoch=1000, pop_size=50, pp=0.03)\n    model = ALO.OriginalALO(epoch=100, pop_size=50)\n    model = ALO.DevALO(epoch=100, pop_size=50)\n    model = AO.OriginalAO(epoch=100, pop_size=50)\n    model = ARO.OriginalARO(epoch=100, pop_size=50)\n    model = ARO.LARO(epoch=100, pop_size=50)\n    model = ARO.IARO(epoch=100, pop_size=50)\n    model = AVOA.OriginalAVOA(epoch=100, pop_size=50, p1=0.6, p2=0.4, p3=0.6, alpha=0.8, gama=2.5)\n    model = BA.OriginalBA(epoch=100, pop_size=50, loudness=0.8, pulse_rate=0.95, pf_min=0.1, pf_max=10.0)\n    model = BA.AdaptiveBA(epoch=100, pop_size=50, loudness_min=1.0, loudness_max=2.0, pr_min=-2.5, pr_max=0.85, pf_min=0.1, pf_max=10.)\n    model = BA.DevBA(epoch=100, pop_size=50, pulse_rate=0.95, pf_min=0., pf_max=10.)\n    model = BBOA.OriginalBBOA(epoch=100, pop_size=50)\n    model = BMO.OriginalBMO(epoch=100, pop_size=50, pl=4)\n    model = EOA.OriginalEOA(epoch=100, pop_size=50, p_c=0.9, p_m=0.01, n_best=2, alpha=0.98, beta=0.9, gama=0.9)\n    model = IWO.OriginalIWO(epoch=100, pop_size=50, seed_min=3, seed_max=9, exponent=3, sigma_start=0.6, sigma_end=0.01)\n    model = SBO.DevSBO(epoch=100, pop_size=50, alpha=0.9, p_m=0.05, psw=0.02)\n    model = SBO.OriginalSBO(epoch=100, pop_size=50, alpha=0.9, p_m=0.05, psw=0.02)\n    model = SMA.OriginalSMA(epoch=100, pop_size=50, p_t=0.03)\n    model = SMA.DevSMA(epoch=100, pop_size=50, p_t=0.03)\n    model = SOA.OriginalSOA(epoch=100, pop_size=50, fc=2)\n    model = SOA.DevSOA(epoch=100, pop_size=50, fc=2)\n    model = SOS.OriginalSOS(epoch=100, pop_size=50)\n    model = TPO.DevTPO(epoch=100, pop_size=50, alpha=0.3, beta=50., theta=0.9)\n    model = TSA.OriginalTSA(epoch=100, pop_size=50)\n    model = VCS.OriginalVCS(epoch=100, pop_size=50, lamda=0.5, sigma=0.3)\n    model = VCS.DevVCS(epoch=100, pop_size=50, lamda=0.5, sigma=0.3)\n    model = WHO.OriginalWHO(epoch=100, pop_size=50, n_explore_step=3, n_exploit_step=3, eta=0.15, p_hi=0.9, local_alpha=0.9, local_beta=0.3, global_alpha=0.2,\n                            global_beta=0.8, delta_w=2.0, delta_c=2.0)\n    model = AOA.OriginalAOA(epoch=100, pop_size=50, alpha=5, miu=0.5, moa_min=0.2, moa_max=0.9)\n    model = CEM.OriginalCEM(epoch=100, pop_size=50, n_best=20, alpha=0.7)\n    model = CGO.OriginalCGO(epoch=100, pop_size=50)\n    model = CircleSA.OriginalCircleSA(epoch=100, pop_size=50, c_factor=0.8)\n    model = GBO.OriginalGBO(epoch=100, pop_size=50, pr=0.5, beta_min=0.2, beta_max=1.2)\n    model = HC.OriginalHC(epoch=100, pop_size=50, neighbour_size=50)\n    model = HC.SwarmHC(epoch=100, pop_size=50, neighbour_size=10)\n    model = INFO.OriginalINFO(epoch=100, pop_size=50)\n    model = PSS.OriginalPSS(epoch=100, pop_size=50, acceptance_rate=0.8, sampling_method=\"LHS\")\n    model = RUN.OriginalRUN(epoch=100, pop_size=50)\n    model = SCA.OriginalSCA(epoch=100, pop_size=50)\n    model = SCA.DevSCA(epoch=100, pop_size=50)\n    model = SCA.QleSCA(epoch=100, pop_size=50, alpha=0.1, gama=0.9)\n    model = SHIO.OriginalSHIO(epoch=100, pop_size=50)\n    model = TS.OriginalTS(epoch=100, pop_size=50, tabu_size=5, neighbour_size=20, perturbation_scale=0.05)\n    model = HS.OriginalHS(epoch=100, pop_size=50, c_r=0.95, pa_r=0.05)\n    model = HS.DevHS(epoch=100, pop_size=50, c_r=0.95, pa_r=0.05)\n    model = AEO.OriginalAEO(epoch=100, pop_size=50)\n    model = AEO.EnhancedAEO(epoch=100, pop_size=50)\n    model = AEO.ModifiedAEO(epoch=100, pop_size=50)\n    model = AEO.ImprovedAEO(epoch=100, pop_size=50)\n    model = AEO.AugmentedAEO(epoch=100, pop_size=50)\n    model = GCO.OriginalGCO(epoch=100, pop_size=50, cr=0.7, wf=1.25)\n    model = GCO.DevGCO(epoch=100, pop_size=50, cr=0.7, wf=1.25)\n    model = WCA.OriginalWCA(epoch=100, pop_size=50, nsr=4, wc=2.0, dmax=1e-6)\n    model = CRO.OriginalCRO(epoch=100, pop_size=50, po=0.4, Fb=0.9, Fa=0.1, Fd=0.1, Pd=0.5, GCR=0.1, gamma_min=0.02, gamma_max=0.2, n_trials=5)\n    model = CRO.OCRO(epoch=100, pop_size=50, po=0.4, Fb=0.9, Fa=0.1, Fd=0.1, Pd=0.5, GCR=0.1, gamma_min=0.02, gamma_max=0.2, n_trials=5, restart_count=50)\n    model = DE.OriginalDE(epoch=100, pop_size=50, wf=0.7, cr=0.9, strategy=0)\n    model = DE.JADE(epoch=100, pop_size=50, miu_f=0.5, miu_cr=0.5, pt=0.1, ap=0.1)\n    model = DE.SADE(epoch=100, pop_size=50)\n    model = DE.SAP_DE(epoch=100, pop_size=50, branch=\"ABS\")\n    model = EP.OriginalEP(epoch=100, pop_size=50, bout_size=0.05)\n    model = EP.LevyEP(epoch=100, pop_size=50, bout_size=0.05)\n    model = ES.OriginalES(epoch=100, pop_size=50, lamda=0.75)\n    model = ES.LevyES(epoch=100, pop_size=50, lamda=0.75)\n    model = ES.CMA_ES(epoch=100, pop_size=50)\n    model = ES.Simple_CMA_ES(epoch=100, pop_size=50)\n    model = FPA.OriginalFPA(epoch=100, pop_size=50, p_s=0.8, levy_multiplier=0.2)\n    model = MA.OriginalMA(epoch=100, pop_size=50, pc=0.85, pm=0.15, p_local=0.5, max_local_gens=10, bits_per_param=4)\n    model = SHADE.OriginalSHADE(epoch=100, pop_size=50, miu_f=0.5, miu_cr=0.5)\n    model = SHADE.L_SHADE(epoch=100, pop_size=50, miu_f=0.5, miu_cr=0.5)\n    model = BRO.OriginalBRO(epoch=100, pop_size=50, threshold=3)\n    model = BRO.DevBRO(epoch=100, pop_size=50, threshold=3)\n    model = BSO.OriginalBSO(epoch=100, pop_size=50, m_clusters=5, p1=0.2, p2=0.8, p3=0.4, p4=0.5, slope=20)\n    model = BSO.ImprovedBSO(epoch=100, pop_size=50, m_clusters=5, p1=0.25, p2=0.5, p3=0.75, p4=0.6)\n    model = CA.OriginalCA(epoch=100, pop_size=50, accepted_rate=0.15)\n    model = CHIO.OriginalCHIO(epoch=100, pop_size=50, brr=0.15, max_age=10)\n    model = CHIO.DevCHIO(epoch=100, pop_size=50, brr=0.15, max_age=10)\n    model = FBIO.OriginalFBIO(epoch=100, pop_size=50)\n    model = FBIO.DevFBIO(epoch=100, pop_size=50)\n    model = GSKA.OriginalGSKA(epoch=100, pop_size=50, pb=0.1, kf=0.5, kr=0.9, kg=5)\n    model = GSKA.DevGSKA(epoch=100, pop_size=50, pb=0.1, kr=0.9)\n    model = HBO.OriginalHBO(epoch=100, pop_size=50, degree=3)\n    model = HCO.OriginalHCO(epoch=100, pop_size=50, wfp=0.65, wfv=0.05, c1=1.4, c2=1.4)\n    model = ICA.OriginalICA(epoch=100, pop_size=50, empire_count=5, assimilation_coeff=1.5, revolution_prob=0.05, revolution_rate=0.1, revolution_step_size=0.1,\n                            zeta=0.1)\n    model = LCO.OriginalLCO(epoch=100, pop_size=50, r1=2.35)\n    model = LCO.ImprovedLCO(epoch=100, pop_size=50)\n    model = LCO.DevLCO(epoch=100, pop_size=50, r1=2.35)\n    model = WarSO.OriginalWarSO(epoch=100, pop_size=50, rr=0.1)\n    model = TOA.OriginalTOA(epoch=100, pop_size=50)\n    model = TLO.OriginalTLO(epoch=100, pop_size=50)\n    model = TLO.ImprovedTLO(epoch=100, pop_size=50, n_teachers=5)\n    model = TLO.DevTLO(epoch=100, pop_size=50)\n    model = SSDO.OriginalSSDO(epoch=100, pop_size=50)\n    model = SPBO.OriginalSPBO(epoch=100, pop_size=50)\n    model = SPBO.DevSPBO(epoch=100, pop_size=50)\n    model = SARO.OriginalSARO(epoch=100, pop_size=50, se=0.5, mu=50)\n    model = SARO.DevSARO(epoch=100, pop_size=50, se=0.5, mu=50)\n    model = QSA.OriginalQSA(epoch=100, pop_size=50)\n    model = QSA.DevQSA(epoch=100, pop_size=50)\n    model = QSA.OppoQSA(epoch=100, pop_size=50)\n    model = QSA.LevyQSA(epoch=100, pop_size=50)\n    model = QSA.ImprovedQSA(epoch=100, pop_size=50)\n    model = ArchOA.OriginalArchOA(epoch=100, pop_size=50, c1=2, c2=5, c3=2, c4=0.5, acc_max=0.9, acc_min=0.1)\n    model = ASO.OriginalASO(epoch=100, pop_size=50, alpha=50, beta=0.2)\n    model = CDO.OriginalCDO(epoch=100, pop_size=50)\n    model = EFO.OriginalEFO(epoch=100, pop_size=50, r_rate=0.3, ps_rate=0.85, p_field=0.1, n_field=0.45)\n    model = EFO.DevEFO(epoch=100, pop_size=50, r_rate=0.3, ps_rate=0.85, p_field=0.1, n_field=0.45)\n    model = EO.OriginalEO(epoch=100, pop_size=50)\n    model = EO.AdaptiveEO(epoch=100, pop_size=50)\n    model = EO.ModifiedEO(epoch=100, pop_size=50)\n    model = EVO.OriginalEVO(epoch=100, pop_size=50)\n    model = FLA.OriginalFLA(epoch=100, pop_size=50, C1=0.5, C2=2.0, C3=0.1, C4=0.2, C5=2.0, DD=0.01)\n    model = HGSO.OriginalHGSO(epoch=100, pop_size=50, n_clusters=3)\n    model = MVO.OriginalMVO(epoch=100, pop_size=50, wep_min=0.2, wep_max=1.0)\n    model = MVO.DevMVO(epoch=100, pop_size=50, wep_min=0.2, wep_max=1.0)\n    model = NRO.OriginalNRO(epoch=100, pop_size=50)\n    model = RIME.OriginalRIME(epoch=100, pop_size=50, sr=5.0)\n    model = SA.OriginalSA(epoch=100, pop_size=50, temp_init=100, step_size=0.1)\n    model = SA.GaussianSA(epoch=100, pop_size=50, temp_init=100, cooling_rate=0.99, scale=0.1)\n    model = SA.SwarmSA(epoch=100, pop_size=50, max_sub_iter=5, t0=1000, t1=1, move_count=5, mutation_rate=0.1, mutation_step_size=0.1,\n                       mutation_step_size_damp=0.99)\n    model = WDO.OriginalWDO(epoch=100, pop_size=50, RT=3, g_c=0.2, alp=0.4, c_e=0.4, max_v=0.3)\n    model = TWO.OriginalTWO(epoch=100, pop_size=50)\n    model = TWO.EnhancedTWO(epoch=100, pop_size=50)\n    model = TWO.OppoTWO(epoch=100, pop_size=50)\n    model = TWO.LevyTWO(epoch=100, pop_size=50)\n    model = ABC.OriginalABC(epoch=100, pop_size=50, n_limits=50)\n    model = ACOR.OriginalACOR(epoch=100, pop_size=50, sample_count=25, intent_factor=0.5, zeta=1.0)\n    model = AGTO.OriginalAGTO(epoch=100, pop_size=50, p1=0.03, p2=0.8, beta=3.0)\n    model = AGTO.MGTO(epoch=100, pop_size=50, pp=0.03)\n    model = BeesA.OriginalBeesA(epoch=100, pop_size=50, selected_site_ratio=0.5, elite_site_ratio=0.4, selected_site_bee_ratio=0.1, elite_site_bee_ratio=2.0,\n                                dance_radius=0.1, dance_reduction=0.99)\n    model = BeesA.CleverBookBeesA(epoch=100, pop_size=50, n_elites=16, n_others=4, patch_size=5.0, patch_reduction=0.985, n_sites=3, n_elite_sites=1)\n    model = BeesA.ProbBeesA(epoch=100, pop_size=50, recruited_bee_ratio=0.1, dance_radius=0.1, dance_reduction=0.99)\n    model = BES.OriginalBES(epoch=100, pop_size=50, a_factor=10, R_factor=1.5, alpha=2.0, c1=2.0, c2=2.0)\n    model = BFO.OriginalBFO(epoch=100, pop_size=50, Ci=0.01, Ped=0.25, Nc=5, Ns=4, d_attract=0.1, w_attract=0.2, h_repels=0.1, w_repels=10)\n    model = BFO.ABFO(epoch=100, pop_size=50, C_s=0.1, C_e=0.001, Ped=0.01, Ns=4, N_adapt=2, N_split=40)\n    model = ZOA.OriginalZOA(epoch=100, pop_size=50)\n    model = WOA.OriginalWOA(epoch=100, pop_size=50)\n    model = WOA.HI_WOA(epoch=100, pop_size=50, feedback_max=10)\n    model = WaOA.OriginalWaOA(epoch=100, pop_size=50)\n    model = TSO.OriginalTSO(epoch=100, pop_size=50)\n    model = TDO.OriginalTDO(epoch=100, pop_size=50)\n    model = STO.OriginalSTO(epoch=100, pop_size=50)\n    model = SSpiderO.OriginalSSpiderO(epoch=100, pop_size=50, fp_min=0.65, fp_max=0.9)\n    model = SSpiderA.OriginalSSpiderA(epoch=100, pop_size=50, r_a=1.0, p_c=0.7, p_m=0.1)\n    model = SSO.OriginalSSO(epoch=100, pop_size=50)\n    model = SSA.OriginalSSA(epoch=100, pop_size=50, ST=0.8, PD=0.2, SD=0.1)\n    model = SSA.DevSSA(epoch=100, pop_size=50, ST=0.8, PD=0.2, SD=0.1)\n    model = SRSR.OriginalSRSR(epoch=100, pop_size=50)\n    model = SLO.OriginalSLO(epoch=100, pop_size=50)\n    model = SLO.ModifiedSLO(epoch=100, pop_size=50)\n    model = SLO.ImprovedSLO(epoch=100, pop_size=50, c1=1.2, c2=1.5)\n    model = SHO.OriginalSHO(epoch=100, pop_size=50, h_factor=5.0, n_trials=10)\n    model = SFO.OriginalSFO(epoch=100, pop_size=50, pp=0.1, AP=4.0, epsilon=0.0001)\n    model = SFO.ImprovedSFO(epoch=100, pop_size=50, pp=0.1)\n    model = ServalOA.OriginalServalOA(epoch=100, pop_size=50)\n    model = SeaHO.OriginalSeaHO(epoch=100, pop_size=50)\n    model = SCSO.OriginalSCSO(epoch=100, pop_size=50)\n    model = POA.OriginalPOA(epoch=100, pop_size=50)\n    model = PFA.OriginalPFA(epoch=100, pop_size=50)\n    model = OOA.OriginalOOA(epoch=100, pop_size=50)\n    model = NGO.OriginalNGO(epoch=100, pop_size=50)\n    model = NMRA.OriginalNMRA(epoch=100, pop_size=50, pb=0.75)\n    model = NMRA.ImprovedNMRA(epoch=100, pop_size=50, pb=0.75, pm=0.01)\n    model = MSA.OriginalMSA(epoch=100, pop_size=50, n_best=5, partition=0.5, max_step_size=1.0)\n    model = MRFO.OriginalMRFO(epoch=100, pop_size=50, somersault_range=2.0)\n    model = MRFO.WMQIMRFO(epoch=100, pop_size=50, somersault_range=2.0, pm=0.5)\n    model = MPA.OriginalMPA(epoch=100, pop_size=50)\n    model = MGO.OriginalMGO(epoch=100, pop_size=50)\n    model = MFO.OriginalMFO(epoch=100, pop_size=50)\n    model = JA.OriginalJA(epoch=100, pop_size=50)\n    model = JA.LevyJA(epoch=100, pop_size=50)\n    model = JA.DevJA(epoch=100, pop_size=50)\n    model = HHO.OriginalHHO(epoch=100, pop_size=50)\n    model = HGS.OriginalHGS(epoch=100, pop_size=50, PUP=0.08, LH=10000)\n    model = HBA.OriginalHBA(epoch=100, pop_size=50)\n    model = GWO.OriginalGWO(epoch=100, pop_size=50)\n    model = GWO.GWO_WOA(epoch=100, pop_size=50)\n    model = GWO.RW_GWO(epoch=100, pop_size=50)\n    model = GTO.OriginalGTO(epoch=100, pop_size=50, A=0.4, H=2.0)\n    model = GTO.Matlab101GTO(epoch=100, pop_size=50)\n    model = GTO.Matlab102GTO(epoch=100, pop_size=50)\n    model = GOA.OriginalGOA(epoch=100, pop_size=50, c_min=0.00004, c_max=1.0)\n    model = GJO.OriginalGJO(epoch=100, pop_size=50)\n    model = FOX.OriginalFOX(epoch=100, pop_size=50, c1=0.18, c2=0.82)\n    model = FOA.OriginalFOA(epoch=100, pop_size=50)\n    model = FOA.WhaleFOA(epoch=100, pop_size=50)\n    model = FOA.DevFOA(epoch=100, pop_size=50)\n    model = FFO.OriginalFFO(epoch=100, pop_size=50)\n    model = FFA.OriginalFFA(epoch=100, pop_size=50, gamma=0.001, beta_base=2, alpha=0.2, alpha_damp=0.99, delta=0.05, exponent=2)\n    model = FA.OriginalFA(epoch=100, pop_size=50, max_sparks=50, p_a=0.04, p_b=0.8, max_ea=40, m_sparks=50)\n    model = ESOA.OriginalESOA(epoch=100, pop_size=50)\n    model = EHO.OriginalEHO(epoch=100, pop_size=50, alpha=0.5, beta=0.5, n_clans=5)\n    model = DO.OriginalDO(epoch=100, pop_size=50)\n    model = DMOA.OriginalDMOA(epoch=100, pop_size=50, n_baby_sitter=3, peep=2)\n    model = DMOA.DevDMOA(epoch=100, pop_size=50, peep=2)\n    model = CSO.OriginalCSO(epoch=100, pop_size=50, mixture_ratio=0.15, smp=5, spc=False, cdc=0.8, srd=0.15, c1=0.4, w_min=0.4, w_max=0.9)\n    model = CSA.OriginalCSA(epoch=100, pop_size=50, p_a=0.3)\n    model = CoatiOA.OriginalCoatiOA(epoch=100, pop_size=50)\n    model = COA.OriginalCOA(epoch=100, pop_size=50, n_coyotes=5)\n    model = BSA.OriginalBSA(epoch=100, pop_size=50, ff=10, pff=0.8, c1=1.5, c2=1.5, a1=1.0, a2=1.0, fc=0.5)\n\n```\n\n\u003c/details\u003e\n\n\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch2\u003eMealpy Application\u003c/h2\u003e\u003c/summary\u003e\n\n\n### Mealpy + Neural Network (Replace the Gradient Descent Optimizer)\n\n* Time-series Problem:\n  * Traditional MLP\n    code: [Link](https://github.com/thieu1995/mealpy/tree/master/examples/applications/keras/traditional-mlp-time-series.py)\n  * Hybrid code (Mealpy +\n    MLP): [Link](https://github.com/thieu1995/mealpy/tree/master/examples/applications/keras/mha-hybrid-mlp-time-series.py)\n* Classification Problem:\n  * Traditional MLP\n    code: [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/keras/traditional-mlp-classification.py)\n  * Hybrid code (Mealpy +\n    MLP): [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/keras/mha-hybrid-mlp-classification.py)\n\n### Mealpy + Neural Network (Optimize Neural Network Hyper-parameter)\n\nCode: [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/keras/mha-hyper-parameter-mlp-time-series.py)\n\n### Other Applications\n\n* Solving Knapsack Problem (Discrete\n  problems): [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/discrete-problems/knapsack_problem.ipynb)\n\n* Solving Product Planning Problem (Discrete\n  problems): [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/discrete-problems/product_planning.ipynb)\n\n* Optimize SVM (SVC)\n  model: [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/sklearn/svm_classification.py)\n\n* Optimize Linear Regression\n  Model: [Link](https://github.com/thieu1995/mealpy/blob/master/examples/applications/pytorch/linear_regression.py)\n\n* Travelling Salesman Problem: https://github.com/thieu1995/MHA-TSP \n\n* Feature selection problem: https://github.com/thieu1995/MHA-FS\n\n\u003c/details\u003e\n\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eGet Visualize Figures\u003c/h3\u003e\u003c/summary\u003e\n\n* [Tutorials](/examples/utils/visualize/all_charts.py)\n\n\u003cp align=\"center\"\u003e\u003cimg src=\"https://thieu1995.github.io/post/2022-04/19-mealpy-tutorials/mealpy2.png\" alt=\"MEALPY\"/\u003e\n\u003c/p\u003e\n\n\u003c/details\u003e\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch3\u003eTutorial Videos\u003c/h3\u003e\u003c/summary\u003e\n\nAll tutorial videos: [Link](https://mealpy.readthedocs.io/en/latest/pages/general/video_tutorials.html)\n\nAll code examples: [Link](https://github.com/thieu1995/mealpy/tree/master/examples)\n\nAll visualization examples: [Link](https://mealpy.readthedocs.io/en/latest/pages/visualization.html)\n\n\u003c/details\u003e\n\n\n# Documents\n\n\n## Official Channels (questions, problems)\n\n* Official source code repo: https://github.com/thieu1995/mealpy\n* Official document: https://mealpy.readthedocs.io/\n* Download releases: https://pypi.org/project/mealpy/\n* Issue tracker: https://github.com/thieu1995/mealpy/issues\n* Notable changes log: https://github.com/thieu1995/mealpy/blob/master/ChangeLog.md\n* Examples with different meapy version: https://github.com/thieu1995/mealpy/blob/master/EXAMPLES.md\n* Official chat/support group: https://t.me/+fRVCJGuGJg1mNDg1\n\n* This project also related to our another projects which are optimization and machine learning. Check it here:\n    * https://github.com/thieu1995/opfunu\n    * https://github.com/thieu1995/metaheuristics\n    * https://github.com/mafese\n    * https://github.com/permetrics\n    * https://github.com/pfevaluator\n    * https://github.com/MetaCluster\n    * https://github.com/enoppy\n    * https://github.com/aiir-team\n\n\n## My Comments\n\n* Meta-heuristic Categories: (Based on this article: [link](https://doi.org/10.1016/j.procs.2020.09.075))\n    + Evolutionary-based: Idea from Darwin's law of natural selection, evolutionary computing \n    + Swarm-based: Idea from movement, interaction of birds, organization of social ...\n    + Physics-based: Idea from physics law such as Newton's law of universal gravitation, black hole, multiverse \n    + Human-based: Idea from human interaction such as queuing search, teaching learning, ... \n    + Biology-based: Idea from biology creature (or microorganism),...\n    + System-based: Idea from eco-system, immune-system, network-system, ...\n    + Math-based: Idea from mathematical form or mathematical law such as sin-cosin \n    + Music-based: Idea from music instrument\n\n* Difficulty - Difficulty Level (Personal Opinion): **Objective observation from author**. Depend on the number of \n  parameters, number of equations, the original ideas, time spend for coding, source lines of code (SLOC).\n    + Easy: A few paras, few equations, SLOC very short\n    + Medium: more equations than Easy level, SLOC longer than Easy level\n    + Hard: Lots of equations, SLOC longer than Medium level, the paper hard to read.\n    + Hard* - Very hard: Lots of equations, SLOC too long, the paper is very hard to read.\n    \n** For newbie, we recommend to read the paper of algorithms which difficulty is \"easy\" or \"medium\" difficulty level.\n\n\n\u003ctable\u003e\u003cthead\u003e\u003ctr\u003e\u003cth\u003eGroup\u003c/th\u003e\u003cth\u003eName\u003c/th\u003e\u003cth\u003eModule\u003c/th\u003e\u003cth\u003eClass\u003c/th\u003e\u003cth\u003eYear\u003c/th\u003e\u003cth\u003eParas\u003c/th\u003e\u003cth\u003eDifficulty\u003c/th\u003e\u003c/tr\u003e\u003c/thead\u003e\u003ctbody\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eEvolutionary Programming\u003c/td\u003e\u003ctd\u003eEP\u003c/td\u003e\u003ctd\u003eOriginalEP\u003c/td\u003e\u003ctd\u003e1964\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eLevyEP\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eEvolution Strategies\u003c/td\u003e\u003ctd\u003eES\u003c/td\u003e\u003ctd\u003eOriginalES\u003c/td\u003e\u003ctd\u003e1971\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eLevyES\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eCMA_ES\u003c/td\u003e\u003ctd\u003e2003\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eSimple_CMA_ES\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eMemetic Algorithm\u003c/td\u003e\u003ctd\u003eMA\u003c/td\u003e\u003ctd\u003eOriginalMA\u003c/td\u003e\u003ctd\u003e1989\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eGenetic Algorithm\u003c/td\u003e\u003ctd\u003eGA\u003c/td\u003e\u003ctd\u003eBaseGA\u003c/td\u003e\u003ctd\u003e1992\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eSingleGA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eMultiGA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eEliteSingleGA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e10\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eEliteMultiGA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e10\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eDifferential Evolution\u003c/td\u003e\u003ctd\u003eDE\u003c/td\u003e\u003ctd\u003eBaseDE\u003c/td\u003e\u003ctd\u003e1997\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eJADE\u003c/td\u003e\u003ctd\u003e2009\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eSADE\u003c/td\u003e\u003ctd\u003e2005\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eSAP_DE\u003c/td\u003e\u003ctd\u003e2006\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eSuccess-History Adaptation Differential Evolution\u003c/td\u003e\u003ctd\u003eSHADE\u003c/td\u003e\u003ctd\u003eOriginalSHADE\u003c/td\u003e\u003ctd\u003e2013\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eL_SHADE\u003c/td\u003e\u003ctd\u003e2014\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eFlower Pollination Algorithm\u003c/td\u003e\u003ctd\u003eFPA\u003c/td\u003e\u003ctd\u003eOriginalFPA\u003c/td\u003e\u003ctd\u003e2014\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003eCoral Reefs Optimization\u003c/td\u003e\u003ctd\u003eCRO\u003c/td\u003e\u003ctd\u003eOriginalCRO\u003c/td\u003e\u003ctd\u003e2014\u003c/td\u003e\u003ctd\u003e11\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eEvolutionary\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eOCRO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e12\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eParticle Swarm Optimization\u003c/td\u003e\u003ctd\u003ePSO\u003c/td\u003e\u003ctd\u003eOriginalPSO\u003c/td\u003e\u003ctd\u003e1995\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003ePPSO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eHPSO_TVAC\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eC_PSO\u003c/td\u003e\u003ctd\u003e2015\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eCL_PSO\u003c/td\u003e\u003ctd\u003e2006\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eBacterial Foraging Optimization\u003c/td\u003e\u003ctd\u003eBFO\u003c/td\u003e\u003ctd\u003eOriginalBFO\u003c/td\u003e\u003ctd\u003e2002\u003c/td\u003e\u003ctd\u003e10\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eABFO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eBees Algorithm\u003c/td\u003e\u003ctd\u003eBeesA\u003c/td\u003e\u003ctd\u003eOriginalBeesA\u003c/td\u003e\u003ctd\u003e2005\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eProbBeesA\u003c/td\u003e\u003ctd\u003e2015\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eCleverBookBeesA\u003c/td\u003e\u003ctd\u003e2006\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eCat Swarm Optimization\u003c/td\u003e\u003ctd\u003eCSO\u003c/td\u003e\u003ctd\u003eOriginalCSO\u003c/td\u003e\u003ctd\u003e2006\u003c/td\u003e\u003ctd\u003e11\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eArtificial Bee Colony\u003c/td\u003e\u003ctd\u003eABC\u003c/td\u003e\u003ctd\u003eOriginalABC\u003c/td\u003e\u003ctd\u003e2007\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eAnt Colony Optimization\u003c/td\u003e\u003ctd\u003eACOR\u003c/td\u003e\u003ctd\u003eOriginalACOR\u003c/td\u003e\u003ctd\u003e2008\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eCuckoo Search Algorithm\u003c/td\u003e\u003ctd\u003eCSA\u003c/td\u003e\u003ctd\u003eOriginalCSA\u003c/td\u003e\u003ctd\u003e2009\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eFirefly Algorithm \u003c/td\u003e\u003ctd\u003eFFA\u003c/td\u003e\u003ctd\u003eOriginalFFA\u003c/td\u003e\u003ctd\u003e2009\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eFireworks Algorithm\u003c/td\u003e\u003ctd\u003eFA\u003c/td\u003e\u003ctd\u003eOriginalFA\u003c/td\u003e\u003ctd\u003e2010\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eBat Algorithm\u003c/td\u003e\u003ctd\u003eBA\u003c/td\u003e\u003ctd\u003eOriginalBA\u003c/td\u003e\u003ctd\u003e2010\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eAdaptiveBA\u003c/td\u003e\u003ctd\u003e2010\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eModifiedBA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eFruit-fly Optimization Algorithm\u003c/td\u003e\u003ctd\u003eFOA\u003c/td\u003e\u003ctd\u003eOriginalFOA\u003c/td\u003e\u003ctd\u003e2012\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseFOA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eWhaleFOA\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSocial Spider Optimization\u003c/td\u003e\u003ctd\u003eSSpiderO\u003c/td\u003e\u003ctd\u003eOriginalSSpiderO\u003c/td\u003e\u003ctd\u003e2018\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003ehard*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eGrey Wolf Optimizer\u003c/td\u003e\u003ctd\u003eGWO\u003c/td\u003e\u003ctd\u003eOriginalGWO\u003c/td\u003e\u003ctd\u003e2014\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eRW_GWO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSocial Spider Algorithm\u003c/td\u003e\u003ctd\u003eSSpiderA\u003c/td\u003e\u003ctd\u003eOriginalSSpiderA\u003c/td\u003e\u003ctd\u003e2015\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eAnt Lion Optimizer\u003c/td\u003e\u003ctd\u003eALO\u003c/td\u003e\u003ctd\u003eOriginalALO\u003c/td\u003e\u003ctd\u003e2015\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseALO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eMoth Flame Optimization\u003c/td\u003e\u003ctd\u003eMFO\u003c/td\u003e\u003ctd\u003eOriginalMFO\u003c/td\u003e\u003ctd\u003e2015\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseMFO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eElephant Herding Optimization\u003c/td\u003e\u003ctd\u003eEHO\u003c/td\u003e\u003ctd\u003eOriginalEHO\u003c/td\u003e\u003ctd\u003e2015\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eJaya Algorithm\u003c/td\u003e\u003ctd\u003eJA\u003c/td\u003e\u003ctd\u003eOriginalJA\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseJA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eLevyJA\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eWhale Optimization Algorithm\u003c/td\u003e\u003ctd\u003eWOA\u003c/td\u003e\u003ctd\u003eOriginalWOA\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eHI_WOA\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eDragonfly Optimization\u003c/td\u003e\u003ctd\u003eDO\u003c/td\u003e\u003ctd\u003eOriginalDO\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eBird Swarm Algorithm\u003c/td\u003e\u003ctd\u003eBSA\u003c/td\u003e\u003ctd\u003eOriginalBSA\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e9\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSpotted Hyena Optimizer\u003c/td\u003e\u003ctd\u003eSHO\u003c/td\u003e\u003ctd\u003eOriginalSHO\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSalp Swarm Optimization\u003c/td\u003e\u003ctd\u003eSSO\u003c/td\u003e\u003ctd\u003eOriginalSSO\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSwarm Robotics Search And Rescue\u003c/td\u003e\u003ctd\u003eSRSR\u003c/td\u003e\u003ctd\u003eOriginalSRSR\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eGrasshopper Optimisation Algorithm\u003c/td\u003e\u003ctd\u003eGOA\u003c/td\u003e\u003ctd\u003eOriginalGOA\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eCoyote Optimization Algorithm\u003c/td\u003e\u003ctd\u003eCOA\u003c/td\u003e\u003ctd\u003eOriginalCOA\u003c/td\u003e\u003ctd\u003e2018\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eMoth Search Algorithm\u003c/td\u003e\u003ctd\u003eMSA\u003c/td\u003e\u003ctd\u003eOriginalMSA\u003c/td\u003e\u003ctd\u003e2018\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSea Lion Optimization\u003c/td\u003e\u003ctd\u003eSLO\u003c/td\u003e\u003ctd\u003eOriginalSLO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eModifiedSLO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedSLO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eNake Mole*Rat Algorithm\u003c/td\u003e\u003ctd\u003eNMRA\u003c/td\u003e\u003ctd\u003eOriginalNMRA\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedNMRA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003ePathfinder Algorithm\u003c/td\u003e\u003ctd\u003ePFA\u003c/td\u003e\u003ctd\u003eOriginalPFA\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSailfish Optimizer\u003c/td\u003e\u003ctd\u003eSFO\u003c/td\u003e\u003ctd\u003eOriginalSFO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedSFO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eHarris Hawks Optimization\u003c/td\u003e\u003ctd\u003eHHO\u003c/td\u003e\u003ctd\u003eOriginalHHO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eManta Ray Foraging Optimization\u003c/td\u003e\u003ctd\u003eMRFO\u003c/td\u003e\u003ctd\u003eOriginalMRFO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eBald Eagle Search\u003c/td\u003e\u003ctd\u003eBES\u003c/td\u003e\u003ctd\u003eOriginalBES\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSparrow Search Algorithm\u003c/td\u003e\u003ctd\u003eSSA\u003c/td\u003e\u003ctd\u003eOriginalSSA\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseSSA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eHunger Games Search\u003c/td\u003e\u003ctd\u003eHGS\u003c/td\u003e\u003ctd\u003eOriginalHGS\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eAquila Optimizer\u003c/td\u003e\u003ctd\u003eAO\u003c/td\u003e\u003ctd\u003eOriginalAO\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eHybrid Grey Wolf * Whale Optimization Algorithm\u003c/td\u003e\u003ctd\u003eGWO\u003c/td\u003e\u003ctd\u003eGWO_WOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eMarine Predators Algorithm\u003c/td\u003e\u003ctd\u003eMPA\u003c/td\u003e\u003ctd\u003eOriginalMPA\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eHoney Badger Algorithm\u003c/td\u003e\u003ctd\u003eHBA\u003c/td\u003e\u003ctd\u003eOriginalHBA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSand Cat Swarm Optimization\u003c/td\u003e\u003ctd\u003eSCSO\u003c/td\u003e\u003ctd\u003eOriginalSCSO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eTuna Swarm Optimization\u003c/td\u003e\u003ctd\u003eTSO\u003c/td\u003e\u003ctd\u003eOriginalTSO\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eAfrican Vultures Optimization Algorithm\u003c/td\u003e\u003ctd\u003eAVOA\u003c/td\u003e\u003ctd\u003eOriginalAVOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eArtificial Gorilla Troops Optimization\u003c/td\u003e\u003ctd\u003eAGTO\u003c/td\u003e\u003ctd\u003eOriginalAGTO\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eMGTO\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eArtificial Rabbits Optimization\u003c/td\u003e\u003ctd\u003eARO\u003c/td\u003e\u003ctd\u003eOriginalARO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eLARO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eIARO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eEgret Swarm Optimization Algorithm\u003c/td\u003e\u003ctd\u003eESOA\u003c/td\u003e\u003ctd\u003eOriginalESOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eFox Optimizer\u003c/td\u003e\u003ctd\u003eFOX\u003c/td\u003e\u003ctd\u003eOriginalFOX\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eGolden Jackal Optimization\u003c/td\u003e\u003ctd\u003eGJO\u003c/td\u003e\u003ctd\u003eOriginalGJO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eGiant Trevally Optimization\u003c/td\u003e\u003ctd\u003eGTO\u003c/td\u003e\u003ctd\u003eOriginalGTO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eMatlab101GTO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eMatlab102GTO\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eMountain Gazelle Optimizer\u003c/td\u003e\u003ctd\u003eMGO\u003c/td\u003e\u003ctd\u003eOriginalMGO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSea-Horse Optimization\u003c/td\u003e\u003ctd\u003eSeaHO\u003c/td\u003e\u003ctd\u003eOriginalSeaHO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eSimulated Annealling\u003c/td\u003e\u003ctd\u003eSA\u003c/td\u003e\u003ctd\u003eOriginalSA\u003c/td\u003e\u003ctd\u003e1983\u003c/td\u003e\u003ctd\u003e9\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eGaussianSA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eSwarmSA\u003c/td\u003e\u003ctd\u003e1987\u003c/td\u003e\u003ctd\u003e9\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eWind Driven Optimization\u003c/td\u003e\u003ctd\u003eWDO\u003c/td\u003e\u003ctd\u003eOriginalWDO\u003c/td\u003e\u003ctd\u003e2013\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eMulti*Verse Optimizer\u003c/td\u003e\u003ctd\u003eMVO\u003c/td\u003e\u003ctd\u003eOriginalMVO\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseMVO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eTug of War Optimization\u003c/td\u003e\u003ctd\u003eTWO\u003c/td\u003e\u003ctd\u003eOriginalTWO\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eOppoTWO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eLevyTWO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eEnhancedTWO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eElectromagnetic Field Optimization\u003c/td\u003e\u003ctd\u003eEFO\u003c/td\u003e\u003ctd\u003eOriginalEFO\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseEFO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eNuclear Reaction Optimization\u003c/td\u003e\u003ctd\u003eNRO\u003c/td\u003e\u003ctd\u003eOriginalNRO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eHenry Gas Solubility Optimization\u003c/td\u003e\u003ctd\u003eHGSO\u003c/td\u003e\u003ctd\u003eOriginalHGSO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eAtom Search Optimization\u003c/td\u003e\u003ctd\u003eASO\u003c/td\u003e\u003ctd\u003eOriginalASO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eEquilibrium Optimizer\u003c/td\u003e\u003ctd\u003eEO\u003c/td\u003e\u003ctd\u003eOriginalEO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eModifiedEO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eAdaptiveEO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eArchimedes Optimization Algorithm\u003c/td\u003e\u003ctd\u003eArchOA\u003c/td\u003e\u003ctd\u003eOriginalArchOA\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eChernobyl Disaster Optimization\u003c/td\u003e\u003ctd\u003eCDO\u003c/td\u003e\u003ctd\u003eOriginalCDO\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eEnergy Valley Optimization\u003c/td\u003e\u003ctd\u003eEVO\u003c/td\u003e\u003ctd\u003eOriginalEVO\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003eFick\u0026#39;s Law Algorithm\u003c/td\u003e\u003ctd\u003eFLA\u003c/td\u003e\u003ctd\u003eOriginalFLA\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003ePhysics\u003c/th\u003e\u003ctd\u003ePhysical Phenomenon of RIME-ice\u003c/td\u003e\u003ctd\u003eRIME\u003c/td\u003e\u003ctd\u003eOriginalRIME\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eCulture Algorithm\u003c/td\u003e\u003ctd\u003eCA\u003c/td\u003e\u003ctd\u003eOriginalCA\u003c/td\u003e\u003ctd\u003e1994\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eImperialist Competitive Algorithm\u003c/td\u003e\u003ctd\u003eICA\u003c/td\u003e\u003ctd\u003eOriginalICA\u003c/td\u003e\u003ctd\u003e2007\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003ehard*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eTeaching Learning*based Optimization\u003c/td\u003e\u003ctd\u003eTLO\u003c/td\u003e\u003ctd\u003eOriginalTLO\u003c/td\u003e\u003ctd\u003e2011\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseTLO\u003c/td\u003e\u003ctd\u003e2012\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eITLO\u003c/td\u003e\u003ctd\u003e2013\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eBrain Storm Optimization\u003c/td\u003e\u003ctd\u003eBSO\u003c/td\u003e\u003ctd\u003eOriginalBSO\u003c/td\u003e\u003ctd\u003e2011\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedBSO\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eQueuing Search Algorithm\u003c/td\u003e\u003ctd\u003eQSA\u003c/td\u003e\u003ctd\u003eOriginalQSA\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseQSA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eOppoQSA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eLevyQSA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedQSA\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eSearch And Rescue Optimization\u003c/td\u003e\u003ctd\u003eSARO\u003c/td\u003e\u003ctd\u003eOriginalSARO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseSARO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eLife Choice*Based Optimization \u003c/td\u003e\u003ctd\u003eLCO\u003c/td\u003e\u003ctd\u003eOriginalLCO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseLCO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedLCO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eSocial Ski*Driver Optimization\u003c/td\u003e\u003ctd\u003eSSDO\u003c/td\u003e\u003ctd\u003eOriginalSSDO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eGaining Sharing Knowledge*based Algorithm\u003c/td\u003e\u003ctd\u003eGSKA\u003c/td\u003e\u003ctd\u003eOriginalGSKA\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseGSKA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eCoronavirus Herd Immunity Optimization\u003c/td\u003e\u003ctd\u003eCHIO\u003c/td\u003e\u003ctd\u003eOriginalCHIO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseCHIO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eForensic*Based Investigation Optimization\u003c/td\u003e\u003ctd\u003eFBIO\u003c/td\u003e\u003ctd\u003eOriginalFBIO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseFBIO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eBattle Royale Optimization\u003c/td\u003e\u003ctd\u003eBRO\u003c/td\u003e\u003ctd\u003eOriginalBRO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseBRO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eStudent Psychology Based Optimization\u003c/td\u003e\u003ctd\u003eSPBO\u003c/td\u003e\u003ctd\u003eOriginalSPBO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eDevSPBO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eHeap-based Optimization\u003c/td\u003e\u003ctd\u003eHBO\u003c/td\u003e\u003ctd\u003eOriginalHBO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eHuman Conception Optimization\u003c/td\u003e\u003ctd\u003eHCO\u003c/td\u003e\u003ctd\u003eOriginalHCO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eDwarf Mongoose Optimization Algorithm\u003c/td\u003e\u003ctd\u003eDMOA\u003c/td\u003e\u003ctd\u003eOriginalDMOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eDevDMOA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eWar Strategy Optimization\u003c/td\u003e\u003ctd\u003eWarSO\u003c/td\u003e\u003ctd\u003eOriginalWarSO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eInvasive Weed Optimization\u003c/td\u003e\u003ctd\u003eIWO\u003c/td\u003e\u003ctd\u003eOriginalIWO\u003c/td\u003e\u003ctd\u003e2006\u003c/td\u003e\u003ctd\u003e7\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eBiogeography*Based Optimization\u003c/td\u003e\u003ctd\u003eBBO\u003c/td\u003e\u003ctd\u003eOriginalBBO\u003c/td\u003e\u003ctd\u003e2008\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseBBO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eVirus Colony Search\u003c/td\u003e\u003ctd\u003eVCS\u003c/td\u003e\u003ctd\u003eOriginalVCS\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003ehard*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseVCS\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003ehard*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eSatin Bowerbird Optimizer\u003c/td\u003e\u003ctd\u003eSBO\u003c/td\u003e\u003ctd\u003eOriginalSBO\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseSBO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eEarthworm Optimisation Algorithm\u003c/td\u003e\u003ctd\u003eEOA\u003c/td\u003e\u003ctd\u003eOriginalEOA\u003c/td\u003e\u003ctd\u003e2018\u003c/td\u003e\u003ctd\u003e8\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eWildebeest Herd Optimization\u003c/td\u003e\u003ctd\u003eWHO\u003c/td\u003e\u003ctd\u003eOriginalWHO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e12\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eSlime Mould Algorithm\u003c/td\u003e\u003ctd\u003eSMA\u003c/td\u003e\u003ctd\u003eOriginalSMA\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseSMA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eBarnacles Mating Optimizer\u003c/td\u003e\u003ctd\u003eBMO\u003c/td\u003e\u003ctd\u003eOriginalBMO\u003c/td\u003e\u003ctd\u003e2018\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eTunicate Swarm Algorithm\u003c/td\u003e\u003ctd\u003eTSA\u003c/td\u003e\u003ctd\u003eOriginalTSA\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eSymbiotic Organisms Search\u003c/td\u003e\u003ctd\u003eSOS\u003c/td\u003e\u003ctd\u003eOriginalSOS\u003c/td\u003e\u003ctd\u003e2014\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eSeagull Optimization Algorithm\u003c/td\u003e\u003ctd\u003eSOA\u003c/td\u003e\u003ctd\u003eOriginalSOA\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eDevSOA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eBrown-Bear Optimization Algorithm\u003c/td\u003e\u003ctd\u003eBBOA\u003c/td\u003e\u003ctd\u003eOriginalBBOA\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eBio\u003c/th\u003e\u003ctd\u003eTree Physiology Optimization\u003c/td\u003e\u003ctd\u003eTPO\u003c/td\u003e\u003ctd\u003eOriginalTPO\u003c/td\u003e\u003ctd\u003e2017\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003eGerminal Center Optimization\u003c/td\u003e\u003ctd\u003eGCO\u003c/td\u003e\u003ctd\u003eOriginalGCO\u003c/td\u003e\u003ctd\u003e2018\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseGCO\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003eWater Cycle Algorithm\u003c/td\u003e\u003ctd\u003eWCA\u003c/td\u003e\u003ctd\u003eOriginalWCA\u003c/td\u003e\u003ctd\u003e2012\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003eArtificial Ecosystem*based Optimization\u003c/td\u003e\u003ctd\u003eAEO\u003c/td\u003e\u003ctd\u003eOriginalAEO\u003c/td\u003e\u003ctd\u003e2019\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eEnhancedAEO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eModifiedAEO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eImprovedAEO\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSystem\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eAugmentedAEO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eHill Climbing\u003c/td\u003e\u003ctd\u003eHC\u003c/td\u003e\u003ctd\u003eOriginalHC\u003c/td\u003e\u003ctd\u003e1993\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eSwarmHC\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eCross-Entropy Method \u003c/td\u003e\u003ctd\u003eCEM\u003c/td\u003e\u003ctd\u003eOriginalCEM\u003c/td\u003e\u003ctd\u003e1997\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eTabu Search\u003c/td\u003e\u003ctd\u003eTS\u003c/td\u003e\u003ctd\u003eOriginalTS\u003c/td\u003e\u003ctd\u003e2004\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eSine Cosine Algorithm\u003c/td\u003e\u003ctd\u003eSCA\u003c/td\u003e\u003ctd\u003eOriginalSCA\u003c/td\u003e\u003ctd\u003e2016\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseSCA\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eQLE-SCA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eGradient-Based Optimizer\u003c/td\u003e\u003ctd\u003eGBO\u003c/td\u003e\u003ctd\u003eOriginalGBO\u003c/td\u003e\u003ctd\u003e2020\u003c/td\u003e\u003ctd\u003e5\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eArithmetic Optimization Algorithm\u003c/td\u003e\u003ctd\u003eAOA\u003c/td\u003e\u003ctd\u003eOrginalAOA\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e6\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eChaos Game Optimization\u003c/td\u003e\u003ctd\u003eCGO\u003c/td\u003e\u003ctd\u003eOriginalCGO\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003ePareto-like Sequential Sampling\u003c/td\u003e\u003ctd\u003ePSS\u003c/td\u003e\u003ctd\u003eOriginalPSS\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eweIghted meaN oF vectOrs\u003c/td\u003e\u003ctd\u003eINFO\u003c/td\u003e\u003ctd\u003eOriginalINFO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003emedium\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eRUNge Kutta optimizer\u003c/td\u003e\u003ctd\u003eRUN\u003c/td\u003e\u003ctd\u003eOriginalRUN\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003ehard\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eCircle Search Algorithm\u003c/td\u003e\u003ctd\u003eCircleSA\u003c/td\u003e\u003ctd\u003eOriginalCircleSA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e3\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMath\u003c/th\u003e\u003ctd\u003eSuccess History Intelligent Optimization\u003c/td\u003e\u003ctd\u003eSHIO\u003c/td\u003e\u003ctd\u003eOriginalSHIO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e***\u003c/th\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003ctd\u003e***\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMusic\u003c/th\u003e\u003ctd\u003eHarmony Search\u003c/td\u003e\u003ctd\u003eHS\u003c/td\u003e\u003ctd\u003eOriginalHS\u003c/td\u003e\u003ctd\u003e2001\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eMusic\u003c/th\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003eBaseHS\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e4\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003e+++\u003c/th\u003e\u003ctd\u003e+++\u003c/td\u003e\u003ctd\u003e+++\u003c/td\u003e\u003ctd\u003e+++\u003c/td\u003e\u003ctd\u003e+++\u003c/td\u003e\u003ctd\u003e+++\u003c/td\u003e\u003ctd\u003e+++\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eWARNING\u003c/th\u003e\u003ctd\u003ePLEASE CHECK PLAGIARISM BEFORE USING BELOW ALGORITHMS\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003ctd\u003e*\u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eCoati Optimization Algorithm\u003c/td\u003e\u003ctd\u003eCoatiOA\u003c/td\u003e\u003ctd\u003eOriginalCoatiOA\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eFennec For Optimization\u003c/td\u003e\u003ctd\u003eFFO\u003c/td\u003e\u003ctd\u003eOriginalFFO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eNorthern Goshawk Optimization\u003c/td\u003e\u003ctd\u003eNGO\u003c/td\u003e\u003ctd\u003eOriginalNGO\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eOsprey Optimization Algorithm\u003c/td\u003e\u003ctd\u003eOOA\u003c/td\u003e\u003ctd\u003eOriginalOOA\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003ePelican Optimization Algorithm \u003c/td\u003e\u003ctd\u003ePOA\u003c/td\u003e\u003ctd\u003eOriginalPOA\u003c/td\u003e\u003ctd\u003e2023\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eServal Optimization Algorithm\u003c/td\u003e\u003ctd\u003eServalOA\u003c/td\u003e\u003ctd\u003eOriginalServalOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eSiberian Tiger Optimization\u003c/td\u003e\u003ctd\u003eSTO\u003c/td\u003e\u003ctd\u003eOriginalSTO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eTasmanian Devil Optimization\u003c/td\u003e\u003ctd\u003eTDO\u003c/td\u003e\u003ctd\u003eOriginalTDO\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eWalrus Optimization Algorithm\u003c/td\u003e\u003ctd\u003eWaOA\u003c/td\u003e\u003ctd\u003eOriginalWaOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eSwarm\u003c/th\u003e\u003ctd\u003eZebra Optimization Algorithm \u003c/td\u003e\u003ctd\u003eZOA\u003c/td\u003e\u003ctd\u003eOriginalZOA\u003c/td\u003e\u003ctd\u003e2022\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy \u003c/td\u003e\u003c/tr\u003e\u003ctr\u003e\u003cth\u003eHuman\u003c/th\u003e\u003ctd\u003eTeamwork Optimization Algorithm\u003c/td\u003e\u003ctd\u003eTOA\u003c/td\u003e\u003ctd\u003eOriginalTOA\u003c/td\u003e\u003ctd\u003e2021\u003c/td\u003e\u003ctd\u003e2\u003c/td\u003e\u003ctd\u003eeasy\u003c/td\u003e\u003c/tr\u003e\u003c/tbody\u003e\u003c/table\u003e\n\n\n\n\n\u003cdetails\u003e\u003csummary\u003e\u003ch1\u003eReferences\u003c/h1\u003e\u003c/summary\u003e\n\n### A\n\n* **ABC - Artificial Bee Colony**\n  * **OriginalABC**: Karaboga, D. (2005). An idea based on honey bee swarm for numerical optimization (Vol. 200, pp. 1-10). Technical report-tr06, Erciyes university, engineering faculty, computer engineering department.\n\n* **ACOR - Ant Colony Optimization**. \n  * **OriginalACOR**: Socha, K., \u0026 Dorigo, M. (2008). Ant colony optimization for continuous domains. European journal of operational research, 185(3), 1155-1173.\n\n* **ALO - Ant Lion Optimizer** \n  * **OriginalALO**: Mirjalili S (2015). “The Ant Lion Optimizer.” Advances in Engineering Software, 83, 80-98. doi: [10.1016/j.advengsoft.2015.01.010](https://doi.org/10.1016/j.advengsoft.2015.01.010)\n  * **BaseALO**: The developed version\n\n* **AEO - Artificial Ecosystem-based Optimization** \n  * **OriginalAEO**: Zhao, W., Wang, L., \u0026 Zhang, Z. (2019). Artificial ecosystem-based optimization: a novel nature-inspired meta-heuristic algorithm. Neural Computing and Applications, 1-43.\n  * **AugmentedAEO**: Van Thieu, N., Barma, S. D., Van Lam, T., Kisi, O., \u0026 Mahesha, A. (2022). Groundwater level modeling using Augmented Artificial Ecosystem Optimization. Journal of Hydrology, 129034.\n  * **ImprovedAEO**: Rizk-Allah, R. M., \u0026 El-Fergany, A. A. (2020). Artificial ecosystem optimizer for parameters identification of proton exchange membrane fuel cells model. International Journal of Hydrogen Energy.\n  * **EnhancedAEO**: Eid, A., Kamel, S., Korashy, A., \u0026 Khurshaid, T. (2020). An Enhanced Artificial Ecosystem-Based Optimization for Optimal Allocation of Multiple Distributed Generations. IEEE Access, 8, 178493-178513.\n  * **ModifiedAEO**: Menesy, A. S., Sultan, H. M., Korashy, A., Banakhr, F. A., Ashmawy, M. G., \u0026 Kamel, S. (2020). Effective parameter extraction of different polymer electrolyte membrane fuel cell stack models using a modified artificial ecosystem optimization algorithm. IEEE Access, 8, 31892-31909.\n  \n* **ASO - Atom Search Optimization**   \n  * **OriginalASO**: Zhao, W., Wang, L., \u0026 Zhang, Z. (2019). Atom search optimization and its application to solve a hydrogeologic parameter estimation problem. Knowledge-Based Systems, 163, 283-304.\n\n* **ArchOA - Archimedes Optimization Algorithm**\n  * **OriginalArchOA**: Hashim, F. A., Hussain, K., Houssein, E. H., Mabrouk, M. S., \u0026 Al-Atabany, W. (2021). Archimedes optimization algorithm: a new metaheuristic algorithm for solving","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fthieu1995%2Fmealpy","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fthieu1995%2Fmealpy","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fthieu1995%2Fmealpy/lists"}