pymetaheuristic

A Python library for metaheuristic optimization and collaborative search, bringing together 374 optimization algorithms across swarm, evolutionary, trajectory, physics-inspired, nature-inspired, human-inspired, and mathematical families. pymetaheuristic makes metaheuristics observable, comparable, cooperative, and benchmarkable through single optimizers, island systems, adaptive orchestration, diagnostics, and scientific benchmark studies.

A. Version Note

This README targets pymetaheuristic-v5+. It can be installed with:

pip install pymetaheuristic

For legacy, the old library can still be installed with:

pip install pymetaheuristic==1.9.5

B. pymetaheuristic Lab

New to Python or prefer a graphical interface? The pymetaheuristic Lab provides a convenient Web App to run optimizations without writing extensive code.

import pymetaheuristic

# Start the web service using:
pymetaheuristic.web_app()

# Terminate the web service using:
pymetaheuristic.web_stop()

• Preview -- pyMetaheuristic Lab -- in Google Colab

This Google Colab Demo is intended for quick demos only. For the best experience, run the Web UI locally or open it directly in a full browser.

C. Summary

1. Introduction
2. Installation and Package Overview
   • 2.1 Installation
   • 2.2 Package Overview
   • 2.3 Optimization, Telemetry, Export, and Plotting Example --- [Colab Demo] ---
   • 2.4 Termination Criteria --- [Colab Demo] ---
   • 2.5 Constraint Handling Example --- [Colab Demo] ---
   • 2.6 Cooperative Multi-island Example --- [Colab Demo] ---
   • 2.7 Orchestrated Cooperation Example --- [Colab Demo] ---
   • 2.8 Island System Unified Interface --- [Colab Demo] ---
   • 2.9 Adaptive Orchestration Policies
   • 2.10 Chaotic Maps, Initialisation Presets, and Transfer Functions --- [Colab Demo] ---
   • 2.11 Hyperparameter Tuner --- [Colab Demo] ---
   • 2.12 Save, Load, and Checkpoint --- [Colab Demo] ---
   • 2.13 Benchmark Runner --- [Colab Demo] ---
   • 2.14 Benchmark Study --- [Colab Demo] ---
   • 2.15 EvoMapX Explainability --- [Colab Demo] ---
3. Algorithm Details
4. Test Functions --- [Colab Demo] ---
5. Other Libraries

---

1. Introduction

Back to Summary

pymetaheuristic is a Python optimization library built around metaheuristics, benchmark functions, stepwise execution, telemetry, cooperation, rule-based orchestration, constraint-aware evaluation, composable termination criteria, typed variable spaces, chaotic initialization, transfer functions, hyperparameter tuning, and benchmark sweeps. The package provides:

• a broad collection of metaheuristic algorithms
• benchmark functions for testing and visualization
• a stepwise engine API for controlled execution
• telemetry, export helpers, evaluation-indexed convergence data, and save/load for experiments
• EvoMapX explainability with Levels 1--4, explicit internal probe labels, OAM/PEG/CDS diagnostics, population snapshots, lineage metadata, and non-intrusive operator
• cooperative multi-island optimization through cooperative_optimize
• clean object-based island systems through IslandSystem, Island, TopologyConfig, and MigrationConfig
• adaptive orchestration through fixed, rule-based, bandit, and portfolio-adaptive controllers
• island diagnostics, including migration matrices, contribution tables, island roles, action effectiveness, and topology summaries
• built-in constrained optimization support plus named repair strategies (clip, wang, reflect, rand, limit_inverse)
• composable Termination object with four independent stopping conditions
• automatic per-step diversity and exploration/exploitation tracking in history
• plotly-based diversity, convergence, runtime, and explore/exploit charts, including evaluation-indexed convergence plots
• typed variable space (FloatVar, IntegerVar, CategoricalVar, PermutationVar, BinaryVar)
• ten chaotic maps plus lhs, obl, and sobol population initialization presets
• eight transfer functions and BinaryAdapter for binary/discrete optimization
• HyperparameterTuner for grid/random hyperparameter search
• BenchmarkRunner for lightweight multi-algorithm × multi-problem sweeps
• BenchmarkStudy for scientific benchmarking of algorithms, island systems, and orchestration controllers, with rank tables, statistical tests, convergence plots, ECDFs, performance profiles, and result persistence
• save_result, load_result, save_checkpoint, load_checkpoint for persistence
• callback system with lifecycle hooks and callback-driven early stopping
• object-based Problem API with parametrized bounds, latex_code(), and curated test-problem wrappers
• reusable levy_flight() utility and human-readable algorithm.info() metadata

---

2. Installation and Package Overview

---

2.1 Installation

Standard installation:

pip install pymetaheuristic

---

2.2 Package Overview

Back to Summary

Area	Main objects / functions	What it covers
Core Optimization	optimize, list_algorithms, get_algorithm_info, create_optimizer	Single-algorithm optimization, algorithm discovery, and inspection of default parameters
Termination	Termination, EarlyStopping, callbacks	Composable stopping criteria: max_steps, max_evaluations, max_time, max_early_stop, target_fitness, and callback-driven stops
Constraints and Feasibility	optimize(..., constraints=..., constraint_handler=...)	Constrained optimization with inequality/equality constraints, feasibility-aware evaluation
Benchmarks and Plots (Plotly)	FUNCTIONS, get_test_function, plot_function, plot_convergence, compare_convergence, plot_benchmark_summary, plot_island_dynamics, plot_collaboration_network, plot_population_snapshot	Built-in benchmark functions and plotly-based landscape, convergence, and cooperation visualizations
History Charts (Plotly)	plot_global_best_chart, plot_diversity_chart, plot_explore_exploit_chart, plot_runtime_chart, plot_run_dashboard, plot_diversity_comparison	Per-step diversity, exploration/exploitation, runtime, and convergence charts using plotly
Telemetry and Export	summarize_result, export_history_csv, export_population_snapshots_json, convergence_data	Experiment summarization, evaluation-indexed convergence extraction, and export of history and snapshots
EvoMapX Explainability	get_evomapx_profile, get_evomapx_operators, result.evomapx_analysis, result.explain_evomapx, result.plot_evomapx_attribution, result.plot_evomapx_cds, result.plot_evomapx_peg, result.export_evomapx_json, result.export_evomapx_csv	Passive explainability layer with explicit internal probe labels, OAM/IAM attribution matrices, CDS rankings, PEG lineage graphs, population snapshots, and Levels 1--4 diagnostics
IO (Persistence)	save_result, load_result, save_checkpoint, load_checkpoint, result_to_json, result_from_json	Save and restore results; checkpoint-and-resume for long runs
Typed Variable Space	FloatVar, IntegerVar, BinaryVar, CategoricalVar, PermutationVar, build_problem_spec, decode_position, encode_position	Define mixed-type search spaces; automatic encode/decode to/from continuous representation
Problem Objects	Problem, FunctionalProblem, SphereProblem, RastriginProblem, AckleyProblem, RosenbrockProblem, ZakharovProblem, get_test_problem	N-dimensional object-based problem definitions with parametrized bounds and latex_code()
Chaotic Maps	ChaoticMap, chaotic_sequence, chaotic_population, AVAILABLE_CHAOTIC_MAPS	Ten chaotic maps for diversity-preserving population initialisation and perturbation
Initialisation Presets	uniform_population, lhs_population, obl_population, sobol_population, get_init_function, AVAILABLE_INIT_STRATEGIES	Composable initialisation strategies for any algorithm through init_function= or init_name=
Transfer Functions	apply_transfer, binarize, BinaryAdapter, vstf_01–vstf_04, sstf_01–sstf_04, AVAILABLE_TRANSFER_FUNCTIONS	Eight transfer functions mapping continuous positions to binary probabilities for binary optimization
Repair and Random Utilities	limit, limit_inverse, wang, rand, reflect, get_repair_function, levy_flight	Named bound-repair policies and a reusable Lévy-flight sampler
Hyperparameter Tuner	HyperparameterTuner	Grid or random search over algorithm hyperparameters across multiple trials
Benchmark Runner	BenchmarkRunner	Lightweight multi-algorithm × multi-problem sweeps with summary aggregation and plotly-based benchmark charts
Benchmark Study	BenchmarkStudy, BenchmarkResult, BenchmarkProblem, ProblemSuite, ExperimentRecord, load_benchmark	Scientific benchmarking of algorithms, island systems, and orchestration controllers with long-format records, ranks, statistical tests, convergence plots, ECDFs, performance profiles, rank heatmaps, and JSON persistence
Cooperation	cooperative_optimize, replay_cooperative_result, IslandSystem, Island, TopologyConfig, MigrationConfig, ExecutionConfig	Direct and object-based multi-island cooperative optimization with configurable topology, migration interval, migration size, and migration policy
Orchestration	orchestrated_optimize, OrchestrationSpec, CollaborativeConfig, RulesConfig, BanditConfig, PortfolioConfig, OrchestrationConfig	Checkpoint-driven cooperation with fixed, rule-based, bandit, and portfolio-adaptive orchestration
Island Diagnostics	migration_matrix, topology_summary, island_contribution, island_roles, action_effectiveness, diagnostics_summary	Post-run interpretation of island systems, including communication patterns, donor/receiver behavior, island roles, and controller action effectiveness
Reference	print_root_exports, print_reference, search_reference	Programmatic argument reference for all callables

To quickly inspect parameters:

import pymetaheuristic

# List
pymetaheuristic.print_root_exports()

# Detail
pymetaheuristic.print_reference("optimize")

---

2.3 Optimization, Telemetry, Export, and Plotting Example

Back to Summary

optimize is the main high-level entry point for running a single metaheuristic on a user-defined objective function. The user specifies the algorithm, search bounds, and computational budget, while optional keyword arguments configure the selected optimizer and control diagnostics, such as history storage and population snapshots. The function returns a structured result object containing the best solution found, its objective value, and optional run traces that can later be summarized, exported, or plotted. In the example below, optimize applies Particle Swarm Optimization (PSO) to the Easom function over a bounded two-dimensional domain, stores the optimization trajectory, and then summarizes the run with summarize_result.

When store_history and store_population_snapshots are enabled, the returned result object contains enough information to support post-run analysis, reproducibility, and visualization. The history can be exported as a tabular CSV file, population states can be saved as JSON snapshots for later inspection, and convergence can be visualized directly with the built-in plotting utilities. In the example below, PSO is applied to the Sphere function, the optimization trace is exported to disk, and the convergence behavior is plotted for immediate inspection.

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

# To use a built-in test function instead, uncomment the next line:
# easom = pymetaheuristic.get_test_function("easom")

# Or define your own objective function.
# The input must be a list (or array-like) of variable values,
# and its length corresponds to the problem dimension.

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

result = pymetaheuristic.optimize(
					algorithm                  = "pso",
					target_function            = easom,
					min_values                 = (-5, -5),
					max_values                 = ( 5,  5),
					max_steps                  = 30,
					seed                       = 42,
					store_history              = True,
					store_population_snapshots = True,
				)

print(result.best_fitness)
print(len(result.history))
print(pymetaheuristic.summarize_result(result))

pymetaheuristic.export_history_csv(result, "population_history.csv")
pymetaheuristic.export_population_snapshots_json(result, "population_snapshots.json")
fig = pymetaheuristic.plot_convergence(result)

---

2.4 Termination Criteria

Back to Summary

Termination is a composable stopping-criteria object that replaces (or extends) the individual max_steps, max_evaluations, target_fitness, and timeout_seconds keyword arguments. The first condition that triggers ends the run.

Four independent condition types are supported:

• MG (max_steps): maximum number of macro-steps / iterations.
• FE (max_evaluations): maximum number of objective-function evaluations.
• TB (max_time): wall-clock time bound in seconds.
• ES (max_early_stop): early stopping — halt if the global best has not improved by more than epsilon for this many consecutive steps.

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

# Build a composable termination with multiple conditions
# The run stops as soon as ANY condition is triggered.
term = pymetaheuristic.Termination(
		max_steps       = 1000,
		max_evaluations = 50000,
		max_time        = 30.0,       # 30-second wall-clock limit
		max_early_stop  = 25,         # stop if no improvement for 25 steps
		epsilon         = 1e-8,
	   )

result = pymetaheuristic.optimize(
		algorithm       = "pso",
		target_function = easom,
		min_values      = (-5, -5),
		max_values      = ( 5,  5),
		termination     = term,
		seed            = 42,
	 )

print(f"Best fitness:        {result.best_fitness:.6f}")
print(f"Steps run:           {result.steps}")
print(f"Evaluations:         {result.evaluations}")
print(f"Termination reason:  {result.termination_reason}")

---

2.5 Constraint Handling Example

Back to Summary

This example illustrates how optimize can be applied to constrained optimization problems. The user provides one or more constraint functions alongside the objective, and the solver evaluates candidate solutions by combining objective quality with constraint satisfaction according to the selected handling strategy. In this case, the "deb" constraint handler applies feasibility-based comparison rules, so feasible solutions are preferred over infeasible ones, and among infeasible candidates, those with smaller violations are favored. The returned result, therefore, includes not only the best position and penalized search outcome but also metadata describing the raw objective value, the magnitude of constraint violation, and whether the final solution is feasible.

• Click Here for the Full Google Colab Example

import pymetaheuristic 

# ─────────────────────────────────────────────────────────────────────────────
# Variables: 1) wire diameter d, 2) mean coil diameter D, 3) number of coils N
# Solution:  f* ≈ 0.012665
# ─────────────────────────────────────────────────────────────────────────────

def tension_spring(x = [0, 0, 0]):
    d, D, N = x[0], x[1], x[2]
    return (N + 2) * D * d**2

constraints = [
			  lambda x: 1 - (x[1]**3 * x[2]) / (71785 * x[0]**4),
			  lambda x: (4*x[1]**2 - x[0]*x[1]) / (12566*(x[1]*x[0]**3 - x[0]**4)) + 1/(5108*x[0]**2) - 1,
			  lambda x: 1 - 140.45*x[0] / (x[1]**2 * x[2]),
			  lambda x: (x[0] + x[1]) / 1.5 - 1,
              ]

result = pymetaheuristic.optimize(
			algorithm          = "pso",
			target_function    = tension_spring,
			min_values         = (0.05, 0.25,  2.0),
			max_values         = (2.00, 1.30, 15.0),
			constraints        = constraints,
			constraint_handler = "deb",
			max_steps          = 2500,
			seed               = 42,
				 )

print(result.best_position)
print(result.best_fitness)
print(result.metadata["best_raw_fitness"])
print(result.metadata["best_violation"])
print(result.metadata["best_is_feasible"])

Other constraints examples:

constraint  = [lambda x: x[0] + x[1] - 1.0]                    # x0 + x1 <= 1
constraints = [
				lambda x:  x[0]**2 + x[1]**2 - 4.0,            # x0^2 + x1^2 <= 4
				lambda x: -x[0],                               # x0 >= 0
				lambda x: -x[1],                               # x1 >= 0
				lambda x:  x[2] - 5.0,                         # x2 <= 5
				lambda x:  2.0 - x[2],                         # x2 >= 2
				lambda x:  abs(x[0] - x[1]) - 0.5,             # |x0 - x1| <= 0.5
				lambda x:  max(x[0], x[1]) - 3.0,              # max(x0, x1) <= 3
				lambda x:  x[0]*x[1] - 2.0,                    # x0*x1 <= 2
				lambda x:  np.sin(x[0]) + x[1] - 1.5,          # sin(x0) + x1 <= 1.5
				lambda x: {"type": "eq", "value": x[0] - x[1]} # x0 = x1
              ]

def c1(x):
    return x[0] + x[1] - 1.0                     # x0 + x1 <= 1

def c2(x):
    return -x[0]                                 # x0 >= 0

def c3(x):
    return {"type": "eq", "value": x[0] - x[1]}  # x0 = x1

constraints = [c1, c2, c3]

---

2.6 Cooperative Multi-island Example

Back to Summary

cooperative_optimize extends the framework from single-optimizer execution to a collaborative multi-island setting, where several heterogeneous metaheuristics explore the same search space in parallel and periodically exchange information. This interface is useful when the user wants to combine complementary search behaviors—for example, swarm-based, evolutionary, and trajectory-based methods—within a single optimization run. The migration mechanism controls when candidate solutions are shared, how many are transferred, and how communication is structured through a topology such as a ring. In the example below, PSO, GA, SA, and ABCO are executed as cooperating islands on the Easom function, with periodic migration events that allow promising solutions discovered by one method to influence the others.

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

result = pymetaheuristic.cooperative_optimize(
	islands            = [
							{"algorithm": "pso",  "config": {"swarm_size": 25}},
							{"algorithm": "ga",   "config": {}},
							{"algorithm": "sa",   "config": {"temperature_iterations": 20}},
							{"algorithm": "abco", "config": {}},
						  ],
	target_function    = easom,
	min_values         = (-5, -5),
	max_values         = ( 5,  5),
	max_steps          = 20,
	migration_interval = 5,
	migration_size     = 2,
	topology           = "ring",
	seed               = 42,
			   )

print(result.best_fitness)
print(len(result.events))

---

2.7 Orchestrated Cooperation Example

Back to Summary

orchestrated_optimize adds an adaptive decision layer atop cooperative multi-island optimization. Instead of relying only on fixed migration schedules, the run is periodically inspected at predefined checkpoints, and an orchestration policy decides whether corrective actions such as rebalancing, perturbation, restarting, or waiting should be applied. This interface is useful when the user wants cooperation to become state-aware and responsive to signals such as stagnation, loss of diversity, or uneven progress across islands. In the example below, PSO, GA, and SA cooperate on the Easom function under a rule-based orchestration policy, and the resulting object records not only the best solution found but also the sequence of checkpoints and the decisions taken during the run.

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic  

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

config = pymetaheuristic.CollaborativeConfig(
	orchestration = pymetaheuristic.OrchestrationSpec(
														mode                       = "rules",
														checkpoint_interval        = 5,
														max_actions_per_checkpoint = 2,
														warmup_checkpoints         = 1,
													 ),
	rules         = pymetaheuristic.RulesConfig(
													stagnation_threshold     = 4,
													low_diversity_threshold  = 0.05,
													high_diversity_threshold = 0.25,
													perturbation_sigma       = 0.05,
											   ),
	)

result    = pymetaheuristic.orchestrated_optimize(
	islands         = [
						{"label": "pso", "algorithm": "pso", "config": {"swarm_size": 20}},
						{"label": "ga",  "algorithm": "ga",  "config": {"population_size": 20}},
						{"label": "sa",  "algorithm": "sa",  "config": {"temperature": 10.0}},
					  ],
	target_function = easom,
	min_values      = (-5, -5),
	max_values      = ( 5,  5),
	max_steps       = 20,
	seed            = 42,
	config          = config,
	)

print(result.best_fitness)
print(len(result.checkpoints))
print(len(result.decisions))

---

2.8 Island System Unified Interface

Back to Summary

IslandSystem is the object-based interface for defining collaborative optimization systems. It wraps the direct APIs cooperative_optimize and orchestrated_optimize into a cleaner architecture where islands, topology, migration, orchestration, and execution settings are declared as reusable configuration objects. This interface is recommended when the same island portfolio must be reused across cooperative, rule-based, bandit, portfolio-adaptive, or benchmarked runs.

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

system      = pymetaheuristic.IslandSystem(
    islands = [
        pymetaheuristic.Island(
            label     = "pso_explorer",
            algorithm = "pso",
            role      = "explorer",
            config    = {"swarm_size": 25},
        ),
        pymetaheuristic.Island(
            label     = "ga_diversity",
            algorithm = "ga",
            role      = "diversity_keeper",
            config    = {"population_size": 30},
        ),
        pymetaheuristic.Island(
            label     = "sa_refiner",
            algorithm = "sa",
            role      = "local_refiner",
            config    = {"temperature": 10.0},
        ),
        pymetaheuristic.Island(
            label     = "abco_explorer",
            algorithm = "abco",
            role      = "swarm_explorer",
            config    = {},
        ),
    ],
    topology     = pymetaheuristic.TopologyConfig(name = "ring",),
    migration    = pymetaheuristic.MigrationConfig(
        interval = 5,
        size     = 2,
        mode     = "elite",
        policy   = "push",
    ),
    orchestration = pymetaheuristic.OrchestrationConfig(
        checkpoint_interval        = 5,
        warmup_checkpoints         = 1,
        max_actions_per_checkpoint = 2,
    ),
    rules = pymetaheuristic.RulesConfig(
        stagnation_threshold     = 4,
        low_diversity_threshold  = 0.05,
        high_diversity_threshold = 0.25,
        perturbation_sigma       = 0.05,
    ),
    objective = "min",
    max_steps = 250,
    seed      = 42,
)

result = system.optimize(
    target_function = easom,
    min_values      = (-5, -5),
    max_values      = ( 5,  5),
    mode            = "cooperative",
)

print(result.best_fitness)
print(result.best_position)
print(len(result.events))

Island diagnostics transform cooperative and orchestrated runs into interpretable collaborative-search reports. After a run, the result object can summarize migration flows, topology structure, island contributions, island roles, and the effectiveness of orchestration actions. These diagnostics are useful for understanding whether cooperation helped, which island acted as the best refiner, which island donated useful candidates, and whether adaptive interventions were beneficial.

import pandas as pd

# Migration matrix: how many candidates moved between islands.
migration_df = pd.DataFrame(result.migration_matrix(value = "migrants")).fillna(0)
print(migration_df)

# Contribution table: final fitness, improvement, donor/receiver behavior.
contribution_df = pd.DataFrame(result.island_contribution()).T
print(contribution_df)

# Interpretable island roles.
roles_df = pd.DataFrame(result.island_roles()).T
print(roles_df)

# Topology and communication summary.
topology = result.topology_summary()
print(topology)

# Action effectiveness for cooperative migration or orchestrated decisions.
actions = result.action_effectiveness()
print(actions)

Diagnostic plots are also available:

result.plot_migration_network(value = "migrants", show = True, renderer = "colab")
result.plot_island_fitness(show = True, renderer = "colab")

---

2.9 Adaptive Orchestration Policies

Back to Summary

The orchestration layer supports multiple coordination policies. The "cooperative" mode uses fixed migration, "rules" applies checkpoint-based rules, "bandit" uses a multi-armed bandit controller to select actions based on previous rewards, and "portfolio_adaptive" changes behavior according to the optimization phase and island-state indicators.

import numpy as np
import pymetaheuristic

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)


system = pymetaheuristic.IslandSystem(
    islands=[
        {"label": "pso", "algorithm": "pso", "config": {"swarm_size": 25}},
        {"label": "ga",  "algorithm": "ga",  "config": {"population_size": 30}},
        {"label": "sa",  "algorithm": "sa",  "config": {"temperature": 10.0}},
    ],
    max_steps = 250,
    seed      = 42,
)

modes   = ["cooperative", "rules", "bandit", "portfolio_adaptive"]
results = {}

for mode in modes:
    results[mode] = system.optimize(
        target_function = easom,
        min_values      = (-5, -5),
        max_values      = ( 5,  5),
        mode            = mode,
    )

for mode, res in results.items():
    print(mode,
         "best_fitness = ", res.best_fitness,
         "events       = ", len(getattr(res, "events", []) or []),
         "checkpoints  = ", len(getattr(res, "checkpoints", []) or []),
         "decisions    = ", len(getattr(res, "decisions", []) or []),
    )

Bandit orchestration can be configured explicitly:

config = pymetaheuristic.CollaborativeConfig(
    orchestration = pymetaheuristic.OrchestrationSpec(
        mode                       = "bandit",
        checkpoint_interval        = 5,
        max_actions_per_checkpoint = 2,
        warmup_checkpoints         = 1,
    ),
    rules = pymetaheuristic.RulesConfig(
        stagnation_threshold       = 3,
        low_diversity_threshold    = 0.10,
        perturbation_sigma         = 0.05,
    ),
    bandit = pymetaheuristic.BanditConfig(
        policy                     = "ucb",
        exploration                = 0.5,
        action_cost_penalty        = 0.05,
    ),
)

result = pymetaheuristic.orchestrated_optimize(
    islands = [
        {"label": "pso", "algorithm": "pso", "config": {"swarm_size": 25}},
        {"label": "ga",  "algorithm": "ga",  "config": {"population_size": 30}},
        {"label": "sa",  "algorithm": "sa",  "config": {"temperature": 10.0}},
    ],
    target_function = easom,
    min_values      = (-5, -5),
    max_values      = ( 5,  5),
    max_steps       = 25,
    seed            = 42,
    config          = config,
)

print(result.best_fitness)
print(result.action_effectiveness())

---

2.10 Chaotic Maps, Initialisation Presets, and Transfer Functions

Back to Summary

Chaotic maps are initializations based on deterministic chaotic sequences that improve early population diversity and help avoid premature convergence. Ten maps are available: logistic, tent, bernoulli, chebyshev, circle, cubic, icmic, piecewise, sine, gauss. The default for population initialization is random. Transfer functions map continuous positions to bit-flip probabilities, enabling any continuous metaheuristic to solve binary or Boolean problems. Four V-shaped (v1–v4) and four S-shaped (s1–s4) functions are available. BinaryAdapter wraps any algorithm and automatically applies the transfer function.

• Click Here for the Full Google Colab Example

import itertools
import numpy as np
import pymetaheuristic

# Knapsack Instance
weights  = np.array([23, 31, 29, 44, 53, 38, 63, 85, 89, 82], dtype = int)
values   = np.array([92, 57, 49, 68, 60, 43, 67, 84, 87, 72], dtype = int)
capacity = 165
n_items  = len(weights)

# Known Optimum
# x      = [1, 1, 1, 1, 0, 1, 0, 0, 0, 0]
# profit = 309
# weight = 165

# Target Function:
def knapsack(bits):
    bits    = np.asarray(bits, dtype = int)
    total_w = np.sum(weights * bits)
    total_v = np.sum(values  * bits)
    if total_w > capacity:
        return 1000.0 + (total_w - capacity)  
    return -float(total_v)  

# Optimize
engine = pymetaheuristic.create_optimizer(
                                          algorithm       = "ga",
                                          target_function = knapsack,
                                          min_values      = [0.0] * n_items,
                                          max_values      = [1.0] * n_items,
                                          population_size = 15,    
                                          max_steps       = 300,
                                          seed            = 42,
                                          init_name       = "chaotic:tent",
                                         )

# Results
adapter      = pymetaheuristic.BinaryAdapter(engine, transfer_fn = "v2")
result       = adapter.run()
found_profit = -result.best_fitness
print("\nMetaheuristic result")
print("Best profit:", found_profit)
print("Binary solution reported:", result.metadata.get("binary_best_position"))

In addition to ordinary uniform random initialization, pymetaheuristic supports composable population initialization presets. These presets can be selected by name through init_name= or passed directly as a callable through init_function=. Available initialization strategies include:

Strategy	Name / alias	Description
Uniform random	"uniform"	Standard independent uniform sampling inside the search bounds.
Latin Hypercube Sampling	"lhs", "latin_hypercube", "lhs_population"	Stratified sampling that spreads the initial population more evenly across each dimension.
Opposition-Based Learning	"obl"	Generates opposition-aware candidates to increase initial search coverage.
Sobol sequence	"sobol"	Low-discrepancy quasi-random sampling for space-filling initialization.
Chaotic initialization	"chaotic:<map>"	Uses one of the available chaotic maps, e.g. "chaotic:tent" or "chaotic:logistic".

The simplest way to use Latin Hypercube initialization is:

import pymetaheuristic
print(pymetaheuristic.AVAILABLE_INIT_STRATEGIES)

def sphere(x):
    return sum(v * v for v in x)

result = pymetaheuristic.optimize(
    algorithm       = "pso",
    target_function = sphere,
    min_values      = [-5.0] * 10,
    max_values      = [ 5.0] * 10,
    max_steps       = 100,
    seed            = 42,
    init_name       = "lhs",
)

print(result.best_fitness)
print(result.best_position)

---

2.11 Hyperparameter Tuner

Back to Summary

HyperparameterTuner performs grid or random search over an algorithm's hyperparameters. It runs each configuration for n_trials independent trials, aggregates results, and returns a DataFrame (if pandas is available) or a list of dicts. The best_params and best_fitness attributes summarise the optimal configuration found.

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

tuner = pymetaheuristic.HyperparameterTuner(
		algorithm       = "pso",
		param_grid      = {
							  "swarm_size": [20, 50, 100],
							  "w":          [0.4, 0.7, 0.9],
							  "c1":         [1.5, 2.0],
							  "c2":         [1.5, 2.0],
							  "init_name":  ["uniform", "chaotic:tent"],
						  },
		target_function = easom,
		min_values      = [-5, -5],
		max_values      = [ 5,  5],
		termination     = pymetaheuristic.Termination(max_steps = 200),
		n_trials        = 5,
		objective       = "min",
		seed            = 42,
		search          = "grid",
		)

df      = tuner.run()
summary = tuner.summary()

print(f"Best params:  {tuner.best_params}")
print(f"Best fitness: {tuner.best_fitness:.6f}")
print(summary.head())

---

2.12 Save, Load, and Checkpoint

Back to Summary

The IO module provides a set of functions for persisting results and resuming interrupted runs.

• Click Here for the Full Google Colab Example

• save_result / load_result: pickle a completed OptimizationResult to disk.
• result_to_json / result_from_json: export a human-readable JSON summary.
• save_checkpoint / load_checkpoint: pickle a running (engine, state) pair; resume by calling engine.step(state) in a loop.

import numpy as np
import pymetaheuristic

# Easom: 
def easom(x = [0, 0]):
    x1, x2 = x
    return -np.cos(x1) * np.cos(x2) * np.exp(-(x1 - np.pi) ** 2 - (x2 - np.pi) ** 2)

# Optimize - Run
result = pymetaheuristic.optimize(
                                  algorithm                  = 'pso',
                                  target_function            = easom,
                                  min_values                 = (-5, -5),
                                  max_values                 = ( 5,  5),
                                  max_steps                  = 25, # iterations
                                  seed                       = 42,
                                  store_history              = True,
                                  store_population_snapshots = True,
                                )

# Save & Load a Completed Result
pymetaheuristic.save_result(result, "easom_ga.pkl")
r2 = pymetaheuristic.load_result("easom_ga.pkl")
print(f"Reloaded best fitness:  {r2.best_fitness:.6f}")
print(f"Reloaded best position: {r2.best_position}")

# Export and Read a JSON Summary
pymetaheuristic.result_to_json(result, "easom_ga.json")
summary = pymetaheuristic.result_from_json("easom_ga.json")
print(f"JSON best_fitness:  {summary['best_fitness']}")
print(f"JSON best_position: {summary['best_position']}")

# Checkpoint and Resume
engine = pymetaheuristic.create_optimizer(
                                            algorithm                  = algorithm_id,
                                            target_function            = easom,
                                            min_values                 = (-5, -5),
                                            max_values                 = ( 5,  5),
                                            max_steps                  = 25, # iterations
                                            seed                       = 42,
                                            store_history              = True,
                                            store_population_snapshots = True,
                                          )

state = engine.initialize()

# Run
for _ in range(0, 100):
    state = engine.step(state)

pymetaheuristic.save_checkpoint(engine, state, "easom_checkpoint.pkl")
print(f"Checkpoint saved at step {state.step}, best = {state.best_fitness:.6f}")

# Resume from Checkpoint
engine2, state2 = pymetaheuristic.load_checkpoint("easom_checkpoint.pkl")

while not engine2.should_stop(state2):
    state2 = engine2.step(state2)

result_resumed = engine2.finalize(state2)
print(f"Resumed best fitness:  {result_resumed.best_fitness:.6f}")
print(f"Resumed best position: {result_resumed.best_position}")

---

2.13 Benchmark Runner

Back to Summary

BenchmarkRunner is the lightweight benchmark interface for multi-algorithm × multi-problem comparative sweeps. It executes every algorithm on every problem for a configurable number of independent trials, records the best fitness and wall-clock time for each run, and captures failed trials without interrupting the sweep. The raw results are returned as a tidy DataFrame that can be aggregated into summary statistics, rank tables, and publication-quality compact tables. For a more complete scientific benchmarking workflow involving algorithms, island systems, orchestration controllers, statistical tests, convergence plots, ECDFs, performance profiles, and persistence, use BenchmarkStudy.

• Click Here for the Full Google Colab Example

import pandas as pd
import pymetaheuristic

# Algorithms
algorithms = ["acgwo", "gwo", "i_gwo", "fox", "tlbo"]

# Problems
rastrigin  = pymetaheuristic.get_test_function("rastrigin")
rosenbrock = pymetaheuristic.get_test_function("rosenbrocks_valley")

problems = [
               {
                   "name":            "Rastrigin-5D",
                   "target_function": rastrigin,
                   "min_values":      [-5.12] * 5,
                   "max_values":      [ 5.12] * 5,
                   "objective":       "min",
               },
               {
                   "name":            "Rosenbrock-5D",
                   "target_function": rosenbrock,
                   "min_values":      [-30.0] * 5,
                   "max_values":      [ 30.0] * 5,
                   "objective":       "min",
               },
           ]

# Runner
termination = pymetaheuristic.Termination(max_steps = 250)
runner      = pymetaheuristic.BenchmarkRunner(
                                               algorithms  = algorithms,
                                               problems    = problems,
                                               termination = termination,
                                               n_trials    = 5,
                                               seed        = 42,
                                               n_jobs      = 1,
                                             ) 
raw_df = runner.run(show_progress = True)

# Raw Results
failed_df  = raw_df[raw_df["error"].notna()].copy()
valid_df   = raw_df[raw_df["error"].isna()].copy()
summary_df = runner.summary().copy()

# Rank Table
rank_table                 = summary_df.pivot(index = "algorithm", columns = "problem", values = "rank")
rank_table["average_rank"] = rank_table.mean(axis = 1)
rank_table                 = rank_table.sort_values("average_rank")

---

2.14 Benchmark Study

Back to Summary

BenchmarkStudy is the scientific benchmarking interface. Unlike BenchmarkRunner, which focuses on lightweight algorithm sweeps, BenchmarkStudy can compare ordinary algorithms, island systems, and orchestration controllers under the same experimental protocol. It stores long-format experiment records, supports repeated trials, computes rank tables and statistical tests, and provides benchmark plots such as convergence curves, ECDFs, performance profiles, and rank heatmaps.

• Click Here for the Full Google Colab Example

import pymetaheuristic

# Benchmark problems.
problems = pymetaheuristic.ProblemSuite.from_names(["sphere", "rastrigin", "ackley", "rosenbrock"], dimensions = 2)

system      = pymetaheuristic.IslandSystem(
    islands = [
        pymetaheuristic.Island(
            label     = "pso_explorer",
            algorithm = "pso",
            role      = "explorer",
            config    = {"swarm_size": 25},
        ),
        pymetaheuristic.Island(
            label     = "ga_diversity",
            algorithm = "ga",
            role      = "diversity_keeper",
            config    = {"population_size": 30},
        ),
        pymetaheuristic.Island(
            label     = "sa_refiner",
            algorithm = "sa",
            role      = "local_refiner",
            config    = {"temperature": 10.0},
        ),
        pymetaheuristic.Island(
            label     = "abco_explorer",
            algorithm = "abco",
            role      = "swarm_explorer",
            config    = {},
        ),
    ],
    topology     = pymetaheuristic.TopologyConfig(name = "ring",),
    migration    = pymetaheuristic.MigrationConfig(
        interval = 5,
        size     = 2,
        mode     = "elite",
        policy   = "push",
    ),
    orchestration = pymetaheuristic.OrchestrationConfig(
        checkpoint_interval        = 5,
        warmup_checkpoints         = 1,
        max_actions_per_checkpoint = 2,
    ),
    rules = pymetaheuristic.RulesConfig(
        stagnation_threshold     = 4,
        low_diversity_threshold  = 0.05,
        high_diversity_threshold = 0.25,
        perturbation_sigma       = 0.05,
    ),
    objective = "min",
    max_steps = 250,
    seed      = 42,
)

benchmark_system_rules     = {"type": "island_system", "name": "islands_rules",              "system": system, "mode": "rules",}
benchmark_system_bandit    = {"type": "island_system", "name": "islands_bandit",             "system": system, "mode": "bandit",}
benchmark_system_portfolio = {"type": "island_system", "name": "islands_portfolio_adaptive", "system": system, "mode": "portfolio_adaptive",}

study = pymetaheuristic.BenchmarkStudy(
    candidates = [
        {
            "name":      "pso",
            "type":      "algorithm",
            "algorithm": "pso",
            "config":    {"swarm_size": 30},
        },
        {
            "name":      "ga",
            "type":      "algorithm",
            "algorithm": "ga",
            "config":    {"population_size": 40},
        },
        {
            "name":      "de",
            "type":      "algorithm",
            "algorithm": "de",
            "config":    {"population_size": 40},
        },
		  benchmark_system_rules,
		  benchmark_system_bandit,
		  benchmark_system_portfolio,
    ],
    problems        = problems,
    n_trials        = 5,
    max_evaluations = 5000,
    seed            = 42,
)

benchmark_result = study.run()

# Long-format experiment table.
df = benchmark_result.to_dataframe()
print(df.head())

# Summary and ranking.
print(benchmark_result.summary())
print(benchmark_result.rank_table())
print(benchmark_result.scientific_summary())

# Statistical tests.
print(benchmark_result.friedman_test())
print(benchmark_result.wilcoxon_pairwise())

# Save and reload.
benchmark_result.save("benchmark_demo.json")
loaded = pymetaheuristic.load_benchmark("benchmark_demo.json")
print(loaded.summary())

Benchmark plots:

benchmark_result.plot_convergence(show = True, renderer = "colab")
benchmark_result.plot_ecdf(show = True, renderer = "colab")
benchmark_result.plot_performance_profile(show = True, renderer = "colab")
benchmark_result.plot_rank_heatmap(show = True, renderer = "colab")

Use BenchmarkRunner when you want a quick multi-algorithm × multi-problem sweep and a compact DataFrame summary. Use BenchmarkStudy when you need a scientific experimental protocol with repeated trials, fixed budgets, algorithm and island-system candidates, rank tables, statistical tests, convergence plots, ECDFs, performance profiles, rank heatmaps, and save/load support.

---

2.15 EvoMapX Explainability

Back to Summary

pymetaheuristic includes a package-wide EvoMapX Explainability layer for ordinary optimizers, cooperative island systems, and orchestrated island systems. It helps answer a question that convergence curves alone cannot answer: which algorithm, island, migration event, or operator mechanism drove the improvement? The current implementation uses a probe architecture. The probes observe optimizer execution but do not replace the original engine logic. They do not call the objective function independently, consume random numbers, reorder candidates, alter stopping criteria, change the evaluation budget, or modify the optimization trajectory. EvoMapX currently provides three complementary diagnostics:

• Operator / Island Attribution Matrix (OAM/IAM): A time-indexed contribution matrix. Rows are attribution units and columns are optimization steps. The attribution unit can be an explicit internal operator label, an algorithm, an island, a migration event, or an agent.
• Convergence Driver Score (CDS): An aggregate score derived from the attribution matrix. It ranks the units that contributed most to convergence.
• Population Evolution Graph (PEG): A graph representation of population continuity, parent-child relationships when available, inferred lineage, and migration links.

Per-operator attribution is computed from population lineage: the signed parent->child fitness change of each candidate is grouped by the operator that produced it, which requires no extra evaluations. The fidelity building blocks are:

Support level	Meaning
Lineage Δf telemetry	Signed, operator-level Δf computed passively from parent->child fitness changes.
Operator counts	Per-step counts showing how many times each operator was applied.
Population lineage	Parent -> child metadata used to build PEG ancestry edges instead of nearest-neighbour fallback edges.
Profile metadata	Declared operator taxonomy used for documentation, web-app summaries, and support tables.

The explainability layer supports four levels:

EvoMapX level	Main purpose	What is recorded
1	Population snapshots	Copied population states over time, avoiding reference aliasing to the final population
2	Operator attribution	Explicit probe labels, signed fitness deltas, operator counts, and OAM/CDS-ready contribution records
3	Lineage tracing	Level 2 plus candidate IDs, parent IDs, and PEG-ready ancestry metadata
4	Full activity diagnostics	Level 3 plus diversity change, displacement, changed-count, inferred acceptance rate, dominant operator, and candidate-evaluation summaries

EvoMapX uses signed objective-consistent fitness changes. For minimization, a positive contribution means improvement; a negative contribution means deterioration. This preserves the true contribution pattern of each operator instead of clipping losses to zero.

• Click Here for the Full Google Colab Example

Inspecting EvoMapX:

import pymetaheuristic

profile = pymetaheuristic.get_evomapx_profile("wca")
labels  = pymetaheuristic.get_evomapx_operators("wca")
print(profile.to_dict())
print(labels)

Single Algorithm EvoMapX:

import pymetaheuristic

def sphere(x):
    return sum(v * v for v in x)

result = pymetaheuristic.optimize(
    "woa",
    target_function = sphere,
    min_values      = [-5.0] * 10,
    max_values      = [ 5.0] * 10,
    objective       = "min",
    max_steps       = 40,
    seed            = 42,
    store_history   = True,
    evomapx         = True,
    evomapx_level   = 4,
)

print("Best fitness:",  result.best_fitness)
print("Best position:", result.best_position)
report = result.evomapx_analysis(level = "operator")
print(result.explain_evomapx(level = "operator"))

# Interactive Plot
result.plot_evomapx_attribution(level = "operator", filepath = "woa_oam.html")
result.plot_evomapx_cds(level = "operator", filepath = "woa_cds.html")
result.plot_evomapx_peg(filepath = "woa_peg.html")

# Exports
result.export_evomapx_json("woa_evomapx.json", level = "operator")
result.export_evomapx_csv("woa_oam.csv",       level = "operator")

Island EvoMapX:

import pymetaheuristic

def sphere(x):
    return sum(v * v for v in x)

result = pymetaheuristic.cooperative_optimize(
    islands = [
        {"algorithm": "de",  "label": "DE explorer", "config": {"size": 25}},
        {"algorithm": "pso", "label": "PSO swarm",   "config": {"size": 25}},
        {"algorithm": "cem", "label": "CEM modeler", "config": {"size": 30, "k_samples": 6}},
    ],
    target_function            = sphere,
    min_values                 = [-5.0] * 10,
    max_values                 = [ 5.0] * 10,
    objective                  = "min",
    max_steps                  = 50,
    migration_interval         = 5,
    migration_size             = 3,
    topology                   = "ring",
    seed                       = 42,
    store_history              = True,
    store_population_snapshots = True,
    evomapx                    = True,
    evomapx_level              = 4,
)

# Which Island drove convergence?
print(result.explain_evomapx(level = "island"))

# Which explicit internal operators drove convergence?
print(result.explain_evomapx(level = "operator"))
result.plot_evomapx_attribution(level = "island", filepath = "island_oam.html")
result.plot_evomapx_cds(level = "island", filepath = "island_cds.html")
result.plot_evomapx_peg(filepath = "population_evolution_graph.html")

---

3. Algorithm Details

Back to Summary

You can inspect the default parameters of any metaheuristic in the library using get_algorithm_info().

import pymetaheuristic
from pprint import pprint

# Get Info
algorithm_id = "pso"   # change this to any ID from the table, e.g. "de", "ga", "gwo", "woa"
algo_info    = pymetaheuristic.get_algorithm_info(algorithm_id)

# Results
print("Algorithm ID:",   algo_info["algorithm_id"])
print("Algorithm Name:", algo_info["algorithm_name"])
print("")
print("Default Parameters:")
pprint(algo_info["defaults"])

Output:

Algorithm ID:   pso
Algorithm Name: Particle Swarm Optimization

Default Parameters:
{'c1': 2.0, 'c2': 2.0, 'decay': 0, 'swarm_size': 30, 'w': 0.9}

The table below summarizes the optimization engines currently available in the library. The Algorithm column reports the conventional algorithm name, ID gives the identifier used in the codebase, Family provides a coarse methodological grouping, Population indicates whether the algorithm maintains an explicit candidate population, Candidate Injection indicates whether the algorithm is currently marked as able to absorb external candidates during cooperative or orchestrated workflows, Restart shows whether native restart support is declared, and Snapshot Fit provides a practical recommendation for using store_population_snapshots in the current implementation. Click the algorithm name to open its primary reference or original source. The EvoMapX column lists the semantic operator labels used by the passive EvoMapX resolver. Each label names an interpretable operator region of the algorithm (for example, gwo.alpha_guidance, woa.spiral_bubble_net, or wca.evaporation_raining), and the per-operator Convergence Driver Score is computed from the signed parent->child fitness change of the candidates that operator actually produced. Engines fall into two honest categories. Most engines (246) evaluate each operator output separately and therefore expose a genuine multi-operator decomposition whose attribution responds to the seed and the objective. The remaining engines evaluate one combined candidate per step (for example, Differential Evolution builds a single trial vector from mutation and crossover and evaluates it once); their operators have no separately observable fitness effect, so they expose a single honest combined label (such as de.differential_mutation_crossover_selection) with a Convergence Driver Score of 1.0 rather than a fabricated split. Every label in this column is verified passive (the probe never adds an evaluation, consumes a random draw, reorders candidates, or changes the trajectory) and, for multi-operator engines, responds to the run rather than being a fixed apportionment. All algorithms support checkpointing through the library framework, and all constraint handling is available through the framework-level constraint machinery.

---

Algorithm	ID	Family	Population	Candidate Injection	Restart	Snapshot Fit	EvoMapX
Adam (Adaptive Moment Estimation)	adam	math	No	No	No	No	adam.candidate_generation adam.selection adam.search_direction adam.step_acceptance adam.initialization
Adaptive Aquila Optimizer	aao	swarm	Yes	No	No	No	aao.adaptive_aquila_guidance aao.position_update aao.elite_local_refinement aao.selection

🔍 View complete Metaheuristic reference table

Algorithm	ID	Family	Population	Candidate Injection	Restart	Snapshot Fit	EvoMapX
Adam (Adaptive Moment Estimation)	adam	math	No	No	No	No	adam.candidate_generation adam.selection adam.search_direction adam.step_acceptance adam.initialization
Adaptive Aquila Optimizer	aao	swarm	Yes	No	No	No	aao.adaptive_aquila_guidance aao.position_update aao.elite_local_refinement aao.selection
Adaptive Chaotic Grey Wolf Optimizer	acgwo	swarm	Yes	Yes	No	Yes	acgwo.selection acgwo.adaptive_weighted_pack_update acgwo.alpha_guidance_trial acgwo.beta_guidance_trial acgwo.delta_guidance_trial
Adaptive Equilibrium Optimization	adaptive_eo	physics	Yes	No	No	No	adaptive_eo.selection adaptive_eo.adaptive_local_refinement adaptive_eo.equilibrium_pool_guided_update
Adaptive Exploration State-Space Particle Swarm Optimization	aesspso	swarm	Yes	Yes	No	Yes	aesspso.adaptive_velocity_position_update
Adaptive Inertia Weight Particle Swarm Optimization	aiw_pso	swarm	Yes	No	No	No	aiw_pso.position_update aiw_pso.selection aiw_pso.velocity_update aiw_pso.elite_local_refinement
Adaptive Random Search	ars	trajectory	Yes	Yes	No	Yes	ars.small_step ars.large_step
African Vultures Optimization Algorithm	avoa	swarm	Yes	Yes	No	Yes	avoa.exploration_vulture_soaring avoa.random_roost_exploration avoa.convergent_competition_exploitation avoa.levy_food_exploitation avoa.aggressive_siege_exploitation avoa.spiral_siege_exploitation
Ali Baba and the Forty Thieves	aft	human	Yes	Yes	No	Yes	aft.best_guided_tracking aft.random_treasure_search aft.opposition_tracking
Anarchic Society Optimization	aso	swarm	Yes	Yes	No	Yes	aso.anarchic_social_position_update
Animated Oat Optimization Algorithm	aoo	swarm	Yes	No	No	No	aoo.mean_wind_animation_update aoo.best_wind_animation_update aoo.self_wind_animation_update aoo.rolling_levy_animation_update aoo.projectile_jump_animation_update
Ant Colony Optimization (Continuous)	acor	swarm	Yes	Yes	No	Yes	acor.archive_kernel_sampling_update
Ant Colony Optimization	aco	swarm	Yes	No	No	Yes	aco.pheromone_weighted_perturbation_in_each_dimension
Ant Lion Optimizer	alo	swarm	Yes	Yes	No	Yes	alo.random_walk alo.state_update alo.candidate_generation alo.selection alo.combine
Aquila Optimizer	ao	swarm	Yes	Yes	No	Yes	ao.high_soar_vertical_stoop ao.contour_flight_exploration ao.low_flight_attack ao.walk_and_grab_prey
Archerfish Hunting Optimizer	aho	swarm	Yes	Yes	No	Yes	aho.single_shot_prey_projection aho.double_shot_prey_projection aho.levy_stagnation_rescue
Archimedes Optimization Algorithm	arch_oa	physics	Yes	Yes	No	Yes	arch_oa.archimedes_density_volume_acceleration_update
Arithmetic Optimization Algorithm	aoa	swarm	Yes	Yes	No	Yes	aoa.arithmetic_operator_position_update
Artemisinin Optimization	artemisinin_o	nature	Yes	Yes	No	Yes	artemisinin_o.self_growth_update artemisinin_o.best_growth_update artemisinin_o.differential_mutation_update artemisinin_o.self_reset_mutation artemisinin_o.best_reset_mutation artemisinin_o.boundary_best_repair
Artificial Algae Algorithm	aaa	swarm	Yes	No	Yes	Yes	aaa.recombination aaa.selection aaa.adaptation_most_starving_colony_moves_toward aaa.is_replaced_by_corresponding_cell_biggest
Artificial Bee Colony Optimization	abco	swarm	Yes	Yes	No	Yes	abco.employed abco.onlooker abco.scout
Artificial Ecosystem Optimization	aeo	human	Yes	Yes	No	Yes	aeo.selection aeo.consumer_decomposer_update aeo.production_worst_agent
Artificial Electric Field Algorithm	aefa	physics	Yes	Yes	No	Yes	aefa.electric_field_force_update
Artificial Fish Swarm Algorithm	afsa	swarm	Yes	Yes	No	Yes	afsa.leap
Artificial Gorilla Troops Optimizer	agto	swarm	Yes	Yes	No	Yes	agto.migration agto.exploration agto.state_update agto.exploitation
Artificial Hummingbird Algorithm	aha	swarm	Yes	Yes	No	Yes	aha.guided_foraging aha.territorial_foraging aha.migration
Artificial Lemming Algorithm	ala	swarm	Yes	Yes	No	Yes	ala.high_energy_digging_walk ala.high_energy_lemming_migration ala.low_energy_spiral_foraging ala.low_energy_levy_escape
Artificial Protozoa Optimizer	apo	swarm	Yes	Yes	No	Yes	apo.dormancy_random_restart apo.dormancy_local_perturbation apo.foraging_reproduction_update apo.autotrophic_foraging_update
Artificial Rabbits Optimization	aro	swarm	Yes	Yes	No	Yes	aro.detour_foraging aro.random_hiding
Atom Search Optimization	aso_atom	physics	Yes	Yes	No	Yes	aso_atom.do_not_move_current_elites_unless
Automated Design of Variation Operators	autov	evolutionary	Yes	Yes	No	Yes	autov.learned_variation_operator_update
BFGS Quasi-Newton Method	bfgs	math	No	No	No	No	bfgs.update
BIPOP-CMA-ES	bipop_cmaes	evolutionary	Yes	No	Yes	Yes	bipop_cmaes.update
Bacterial Chemotaxis Optimizer	bco	nature	Yes	Yes	No	Yes	bco.swim_refinement_update
Bacterial Colony Optimization	bacterial_colony_o	nature	Yes	No	No	Yes	bacterial_colony_o.migration bacterial_colony_o.position_update bacterial_colony_o.recombination bacterial_colony_o.selection bacterial_colony_o.current_colony_best_accept_only_it bacterial_colony_o.implementation_but_only_as_bounded_macro
Bacterial Foraging Optimization	bfo	swarm	Yes	Yes	No	Yes	bfo.chemotaxis_tumble_update bfo.selection
Bald Eagle Search	bes	swarm	Yes	Yes	No	Yes	bes.candidate_generation bes.selection bes.candidate_search
Barnacles Mating Optimizer	bmo	swarm	Yes	Yes	No	Yes	bmo.barnacle_recombination bmo.random_barnacle_drift
Basin Hopping	basin_hopping	trajectory	No	No	Yes	No	basin_hopping.update
Basketball Team Optimization Algorithm	btoa	human	Yes	No	No	Yes	btoa.position_update btoa.selection btoa.defensive_play_refinement btoa.dynamic_position_candidate btoa.offensive_play_update
Bat Algorithm	bat_a	swarm	Yes	Yes	No	Yes	bat_a.candidate_generation bat_a.selection bat_a.force_or_velocity_update bat_a.position_update bat_a.acceptance bat_a.state_update bat_a.initialization
Battle Royale Optimization	bro	human	Yes	Yes	No	Yes	bro.find_nearest_neighbour bro.battle_damage_relocation_update bro.selection
Bees Algorithm	bea	swarm	Yes	Yes	No	Yes	bea.elite_site_neighbourhood_search bea.selected_site_neighbourhood_search bea.scout_site_global_search
Binary Space Partition Tree Genetic Algorithm	bspga	evolutionary	Yes	Yes	No	Yes	bspga.binary_partition_tree_variation_update
Biogeography-Based Optimization	bbo	evolutionary	Yes	Yes	No	Yes	bbo.migration_mutation_selection_update
Bird Swarm Algorithm	bsa	swarm	Yes	Yes	No	Yes	bsa.foraging_flight_update bsa.vigilance_flight_update bsa.producer_guided_flight_update bsa.scrounger_random_flight_update
Birds-of-Paradise Search	bps	swarm	Yes	No	No	Yes	bps.long_distance_flight bps.local_tree_movement bps.best_tree_attraction
Black Widow Optimization	bwo	evolutionary	Yes	Yes	No	Yes	bwo.crossover bwo.mutation bwo.procreation bwo.candidate_generation bwo.selection
Black-winged Kite Algorithm	bka	swarm	Yes	Yes	No	Yes	bka.sine_soaring_update bka.random_soaring_update bka.peer_repulsion_cauchy_update bka.leader_attraction_cauchy_update
Bonobo Optimizer	bono	swarm	Yes	Yes	No	Yes	bono.social_guidance_phase bono.exploratory_directional_move
Boxelder Bug Search Optimization	bbso	swarm	Yes	No	No	Yes	bbso.coordinated_following_trial bbso.self_following_trial
Brain Storm Optimization	bso	human	Yes	Yes	No	Yes	bso.single_cluster_center_idea bso.single_cluster_member_idea bso.empty_cluster_center_idea bso.two_cluster_center_blend bso.two_cluster_member_blend
Brown-Bear Optimization Algorithm	bboa	swarm	Yes	Yes	No	Yes	bboa.selection bboa.2_sniffing bboa.pedal_marking_update
Butterfly Optimization Algorithm	boa	swarm	Yes	Yes	No	Yes	boa.global_fragrance_attraction boa.local_fragrance_random_walk
Camel Algorithm	camel	swarm	Yes	Yes	No	Yes	camel.endurance_temperature_update camel.selection
Capuchin Search Algorithm	capsa	swarm	Yes	Yes	No	Yes	capsa.jumping_global_motion capsa.long_jump_global_motion capsa.velocity_swing_update capsa.best_swing_update capsa.velocity_memory_update capsa.random_tree_leap capsa.group_following_update
Cat Swarm Optimization	cat_so	swarm	Yes	Yes	No	Yes	cat_so.seeking_mode_expansive_copy_update cat_so.seeking_mode_contracting_copy_update cat_so.tracing_mode_velocity_update
Catch Fish Optimization Algorithm	cfoa	swarm	Yes	No	No	No	cfoa.individual_foraging_update cfoa.group_foraging_update cfoa.late_gaussian_capture_update
Cauchy-Gaussian mutation and improved search strategy GWO	cg_gwo	swarm	Yes	No	No	No	cg_gwo.selection cg_gwo.elite_local_refinement cg_gwo.leader_guided_population_update
Chameleon Swarm Algorithm	chameleon_sa	swarm	Yes	Yes	No	Yes	chameleon_sa.social_pbest_gbest_update chameleon_sa.random_global_exploration
Chaos Game Optimization	cgo	math	Yes	Yes	No	Yes	cgo.current_seed_attractor cgo.best_seed_attractor cgo.mean_group_seed_attractor cgo.dimension_mutation_seed
Chaotic-based Grey Wolf Optimizer	chaotic_gwo	swarm	Yes	No	No	No	chaotic_gwo.selection chaotic_gwo.elite_local_refinement chaotic_gwo.leader_guided_population_update
Cheetah Based Optimization	cddo	swarm	Yes	Yes	No	Yes	cddo.cheetah_chase_position_update
Cheetah Optimizer	cdo	swarm	Yes	Yes	No	Yes	cdo.alpha_cheetah_attack_component cdo.beta_cheetah_attack_component cdo.gamma_cheetah_attack_component
Chernobyl Disaster Optimizer	cdo_chernobyl	physics	Yes	Yes	No	Yes	cdo_chernobyl.alpha_beta_gamma_radiation_update cdo_chernobyl.cdo_chernobyl_position_update cdo_chernobyl.selection
Chicken Swarm Optimization	chicken_so	swarm	Yes	No	No	Yes	chicken_so.selection chicken_so.chicken_so_semantic_update
Child Drawing Development Optimization Algorithm	cddo_child	human	Yes	Yes	No	Yes	cddo_child.child_drawing_development_update
Chimp Optimization Algorithm	choa	swarm	Yes	Yes	No	Yes	choa.chimp_hunting_position_update
Chinese Pangolin Optimizer	cpo	swarm	Yes	No	No	Yes	cpo.aroma_luring_trial cpo.predation_feeding_trial
Circle-Based Search Algorithm	circle_sa	math	Yes	Yes	No	Yes	circle_sa.circle_position_update
Circulatory System Based Optimization	csbo	swarm	Yes	Yes	No	Yes	csbo.systolic csbo.diastolic
Clonal Selection Algorithm	clonalg	evolutionary	Yes	Yes	No	Yes	clonalg.candidate_generation clonalg.selection clonalg.cloning clonalg.hypermutation
Coati Optimization Algorithm	coati_oa	swarm	Yes	Yes	No	Yes	coati_oa.candidate_generation coati_oa.selection coati_oa.behavioral_move
Cockroach Swarm Optimization	cockroach_so	swarm	Yes	Yes	No	Yes	cockroach_so.dispersal cockroach_so.replacement cockroach_so.state_update
Compact Genetic Algorithm	compact_ga	distribution	No	No	No	No	compact_ga.model_update compact_ga.sampling compact_ga.selection compact_ga.state_update compact_ga.compact_genetic_algorithm_semantic_update
Competitive Swarm Optimizer	cso	swarm	Yes	Yes	No	Yes	cso.mean_all_positions
Coot Bird Optimization	coot	swarm	Yes	Yes	No	Yes	coot.chain_movement_update
Coral Reefs Optimization	cro	evolutionary	Yes	Yes	No	Yes	cro.broadcast_spawning_recombination cro.brooding_clone_mutation cro.depredation_random_reseeding
Coronavirus Herd Immunity Optimization	chio	human	Yes	Yes	No	Yes	chio.infected_contact_update chio.susceptible_contact_update chio.immune_contact_update
Cosmic Evolution Optimization	ceo_cosmic	physics	Yes	Yes	No	Yes	ceo_cosmic.exploration_attraction_alignment ceo_cosmic.global_collision_update ceo_cosmic.resonance_refinement_update
Covariance Matrix Adaptation Evolution Strategy	cmaes	evolutionary	Yes	Yes	No	Yes	cmaes.covariance_sampling_recombination_update
Coyote Optimization Algorithm	coa	swarm	Yes	Yes	No	Yes	coa.alpha_social_condition_update coa.tendency_social_condition_update coa.pup_birth_replacement coa.migration_exchange
Crayfish Optimization Algorithm	crayfish_oa	swarm	Yes	Yes	No	Yes	crayfish_oa.high_temperature_shelter_update crayfish_oa.high_temperature_competition_update crayfish_oa.food_competition_update crayfish_oa.food_intake_update
Cross Entropy Method	cem	distribution	Yes	Yes	No	Yes	cem.model_sampling_elite_distribution_update
Crow Search Algorithm	csa	swarm	Yes	Yes	No	Yes	csa.memory_following_update csa.awareness_random_relocation csa.mixed_memory_random_update
Cuckoo Catfish Optimizer	cco	swarm	Yes	Yes	No	Yes	cco.candidate_search cco.selection cco.candidate_generation
Cuckoo Search	cuckoo_s	swarm	Yes	Yes	No	Yes	cuckoo_s.levy_flight cuckoo_s.replacement cuckoo_s.candidate_generation cuckoo_s.selection
Cultural Algorithm	ca	evolutionary	Yes	Yes	No	Yes	ca.cultural_belief_guided_update
Dandelion Optimizer	do_dandelion	physics	Yes	Yes	No	Yes	do_dandelion.rising_seed_phase do_dandelion.descent_diffusion_phase do_dandelion.elite_landing_phase do_dandelion.candidate_generation do_dandelion.selection
Deep Sleep Optimiser	dso	human	Yes	Yes	No	Yes	dso.deep_sleep_decay_update dso.slow_wave_recovery_update
Deer Hunting Optimization Algorithm	doa	human	Yes	Yes	No	Yes	doa.hunting doa.search doa.state_update doa.exploitation_move doa.replacement
Dhole Optimization Algorithm	dhole_oa	swarm	Yes	No	No	Yes	dhole_oa.searching_stage dhole_oa.encircling_stage dhole_oa.large_prey_attack dhole_oa.small_prey_kill
Differential Evolution JADE	jade	evolutionary	Yes	No	No	No	jade.candidate_generation jade.selection jade.mutation jade.crossover jade.initialization
Differential Evolution MTS	hde	evolutionary	Yes	Yes	No	Yes	hde.candidate_search hde.selection hde.differential_evolution_update
Differential Evolution with Self-Adaptive Populations	sap_de	evolutionary	Yes	No	No	No	sap_de.selection sap_de.elite_local_refinement sap_de.self_adaptive_parameter_de_update
Differential Evolution	de	evolutionary	Yes	Yes	No	Yes	de.differential_mutation_crossover_selection
Dispersive Fly Optimization	dfo	swarm	Yes	Yes	No	Yes	dfo.dispersive_fly_neighbour_update dfo.elite_disturbance_update dfo.selection
Diversity enhanced Strategy based Grey Wolf Optimizer	ds_gwo	swarm	Yes	No	No	No	ds_gwo.selection ds_gwo.elite_local_refinement ds_gwo.leader_guided_population_update
Divine Religions Algorithm	dra	human	Yes	No	No	No	dra.selection dra.dialectic_interaction_update
Dolphin Echolocation Optimization	deo_dolphin	swarm	Yes	Yes	No	Yes	deo_dolphin.elite_reference_echo_guidance deo_dolphin.elite_jitter_echo_guidance deo_dolphin.peer_reference_echo_guidance deo_dolphin.peer_jitter_echo_guidance
Dragonfly Algorithm	da	swarm	Yes	Yes	No	Yes	da.neighbour_alignment_update da.levy_flight_exploration da.food_enemy_swarm_update
Dream Optimization Algorithm	dream_oa	human	Yes	No	No	Yes	dream_oa.dream_generation_refinement_update
Dung Beetle Optimizer	dbo	swarm	Yes	Yes	No	Yes	dbo.foraging dbo.selection dbo.state_update dbo.ball_rolling_dance_update
Dwarf Mongoose Optimization Algorithm	dmoa	swarm	Yes	Yes	No	Yes	dmoa.selection dmoa.3_baby_sitter_eviction dmoa.scalar_broadcast dmoa.scout_phase
Dynamic Differential Annealed Optimization	ddao	physics	Yes	Yes	No	Yes	ddao.exploration ddao.selection ddao.state_update ddao.dynamic_annealed_refinement_update
Dynamic Virtual Bats Algorithm	dvba	swarm	Yes	Yes	No	Yes	dvba.force_or_velocity_update dvba.position_update dvba.random_walk dvba.state_update dvba.candidate_generation dvba.selection
Earthworm Optimization Algorithm	eoa	swarm	Yes	Yes	No	Yes	eoa.crossover eoa.state_update eoa.mutation eoa.candidate_generation eoa.selection eoa.reproduction
Ecological Cycle Optimizer	ecological_cycle_o	swarm	Yes	Yes	No	Yes	ecological_cycle_o.selection ecological_cycle_o.ecological_cycle_transition_update ecological_cycle_o.eval_accept_group
Educational Competition Optimizer	eco	human	Yes	Yes	No	Yes	eco.primary_competition_update eco.sine_cosine_learning_update eco.best_weighted_learning_update eco.levy_exam_update
Eel and Grouper Optimizer	eel_grouper_o	swarm	Yes	No	No	No	eel_grouper_o.eel_weighted_hunting_update eel_grouper_o.grouper_weighted_hunting_update
Efficient Global Optimization	ego	distribution	Yes	Yes	No	Yes	ego.expected_improvement_candidate_generation
Efficient and Robust Grey Wolf Optimizer	er_gwo	swarm	Yes	No	No	No	er_gwo.selection er_gwo.elite_local_refinement er_gwo.leader_guided_population_update
Egret Swarm Optimization Algorithm	esoa	swarm	Yes	Yes	No	Yes	esoa.behavioral_move esoa.selection esoa.egret_sit_and_wait_update
Electric Charged Particles Optimization	ecpo	physics	Yes	Yes	No	Yes	ecpo.electric_charge_random_perturbation
Electric Eel Foraging Optimization	eefo	swarm	Yes	No	No	No	eefo.interaction_migration eefo.resting_area_update eefo.levy_hunting_update eefo.prey_capture_update
Electrical Storm Optimization	eso	physics	Yes	Yes	No	Yes	eso.electric_storm_field_update
Electromagnetic Field Optimization	efo	physics	Yes	Yes	No	Yes	efo.electromagnetic_field_update efo.random_field_reinitialization efo.dimension_reset_mutation
Elephant Herding Optimization	eho	swarm	Yes	Yes	No	Yes	eho.long_range_clan_best_guided_update eho.short_range_clan_best_guided_update eho.matriarch_center_update eho.separating_random_relocation
Elk Herd Optimizer	elk_ho	swarm	Yes	Yes	No	Yes	elk_ho.selection elk_ho.family_mating_position_update
Emperor Penguin Colony	epc	swarm	Yes	Yes	No	Yes	epc.spiral_attraction_update epc.thermal_mutation_update
Energy Valley Optimizer	evo	physics	Yes	Yes	No	Yes	evo.exploration evo.state_update evo.exploitation
Enhanced Artificial Ecosystem-Based Optimization	enhanced_aeo	human	Yes	No	No	No	enhanced_aeo.selection enhanced_aeo.ecosystem_producer_consumer_update enhanced_aeo.enhanced_decomposition_refinement
Enhanced Tug of War Optimization	enhanced_two	physics	Yes	No	No	No	enhanced_two.candidate_generation enhanced_two.selection enhanced_two.force_update enhanced_two.state_update enhanced_two.initialization
Enzyme Activity Optimizer	eao	nature	Yes	Yes	No	Yes	eao.sinusoidal_best_substrate_update eao.vector_scaled_differential_substrate_update eao.scalar_scaled_differential_substrate_update
Equilibrium Optimizer	eo	physics	Yes	Yes	No	Yes	eo.equilibrium_position_update
Escape Algorithm	esc	human	Yes	Yes	No	Yes	esc.escape_from_worst_update esc.move_toward_best_update esc.random_exploration_update
Evolution Strategy (Mu + Lambda)	es	evolutionary	Yes	Yes	No	Yes	es.parent_survivor es.large_step_mutation_offspring es.small_step_mutation_offspring
Evolutionary Programming	ep	evolutionary	Yes	Yes	No	Yes	ep.parent_survivor ep.large_strategy_mutation_offspring ep.small_strategy_mutation_offspring
Expanded Grey Wolf Optimizer	ex_gwo	swarm	Yes	No	No	No	ex_gwo.selection ex_gwo.elite_local_refinement ex_gwo.leader_guided_population_update
Exponential Distribution Optimizer	edo	math	Yes	Yes	No	Yes	edo.distribution_update edo.candidate_generation edo.state_update
Exponential-Trigonometric Optimization	eto	math	Yes	Yes	No	Yes	eto.exponential_orbit_update eto.trigonometric_orbit_update
Extra-Trees Bayesian Optimization	et_bo	surrogate	No	No	No	No	et_bo.update
Fast Evolutionary Programming	fep	evolutionary	Yes	Yes	No	Yes	fep.fast_mutation_tournament_selection_update
Fata Geophysics Optimizer	fata	physics	Yes	Yes	No	Yes	fata.random_refraction_update fata.best_refraction_update fata.peer_refraction_update
Feasibility Rule with Objective Function Information	frofi	evolutionary	Yes	Yes	No	Yes	frofi.current_to_rand_de frofi.rand_to_best_crossover_de frofi.no_crossover_de frofi.targeted_mutation
Fennec Fox Optimizer	ffo	swarm	Yes	Yes	No	Yes	ffo.exploration ffo.state_update ffo.exploitation
Fick's Law Algorithm	fla	physics	Yes	Yes	No	Yes	fla.forward_diffusion_transfer fla.source_fluid_diffusion fla.receiver_fluid_diffusion fla.reverse_diffusion_transfer fla.equilibrium_exploitation_update
Firefly Algorithm	firefly_a	swarm	Yes	Yes	No	Yes	firefly_a.attraction_dominant_move firefly_a.randomization_dominant_move
Fireworks Algorithm	fwa	swarm	Yes	Yes	No	Yes	fwa.selection fwa.state_update
Fish School Search	fss	swarm	Yes	Yes	No	Yes	fss.collective_volitive_movement fss.selection
Fitness Dependent Optimizer	fdo	swarm	Yes	Yes	No	Yes	fdo.fitness_weighted_pace_update fdo.best_guided_position_update fdo.selection
Fletcher-Reeves Conjugate Gradient	frcg	math	No	No	No	No	frcg.update
Flood Algorithm	flood_a	physics	Yes	Yes	No	Yes	flood_a.flood_flow_direction_update flood_a.flood_recession_refinement_update flood_a.selection
Flow Direction Algorithm	fda	swarm	Yes	Yes	No	Yes	fda.downhill_flow_direction_update fda.neighbour_flow_direction_update fda.elite_flow_direction_update
Flower Pollination Algorithm	fpa	swarm	Yes	Yes	No	Yes	fpa.global_levy_pollination fpa.local_pollination
Forensic-Based Investigation Optimization	fbio	human	Yes	Yes	No	Yes	fbio.candidate_generation fbio.selection fbio.exploration
Forest Optimization Algorithm	foa	swarm	Yes	Yes	No	Yes	foa.local_seeding_growth_update foa.selection
Fossa Optimization Algorithm	foa_fossa	swarm	Yes	Yes	No	Yes	foa_fossa.prey_pursuit_update foa_fossa.defensive_escape_update
Fox Optimizer	fox	swarm	Yes	Yes	No	Yes	fox.prey_jump_exploitation fox.current_to_random_walk_update fox.best_radius_random_walk
Frilled Lizard Optimization	flo	swarm	Yes	Yes	No	Yes	flo.update
Fruit-Fly Algorithm	ffa	swarm	Yes	Yes	No	Yes	ffa.fruitfly_smell_search_update
Fuzzy Hierarchical Operator - Grey Wolf Optimizer	fuzzy_gwo	swarm	Yes	No	No	No	fuzzy_gwo.selection fuzzy_gwo.elite_local_refinement fuzzy_gwo.leader_guided_population_update
Gaining-Sharing Knowledge Algorithm	gska	human	Yes	Yes	No	Yes	gska.gaining_sharing_knowledge_update
Gaussian Process Bayesian Optimization	gp_bo	surrogate	No	No	No	No	gp_bo.update
Gazelle Optimization Algorithm	gazelle_oa	swarm	Yes	Yes	No	Yes	gazelle_oa.brownian_foraging_update gazelle_oa.levy_elite_transition_update gazelle_oa.levy_foraging_update gazelle_oa.random_patch_avoidance_update gazelle_oa.peer_difference_escape_update
Gekko Japonicus Algorithm	gja	swarm	Yes	Yes	No	Yes	gja.levy_wall_search gja.gaussian_wall_search
Generalized Normal Distribution Optimizer	gndo	math	Yes	Yes	No	Yes	gndo.generalized_normal_local_update gndo.difference_vector_global_update
Genetic Algorithm	ga	evolutionary	Yes	Yes	No	Yes	ga.candidate_generation ga.selection ga.breed ga.mutate
Genghis Khan Shark Optimizer	gkso	swarm	Yes	Yes	No	Yes	gkso.genghis_khan_crossover_exploration gkso.shark_hunting_pso_update
Geometric Mean Optimizer	gmo	swarm	Yes	Yes	No	Yes	gmo.marketing_guidance_update
Germinal Center Optimization	gco	human	Yes	Yes	No	Yes	gco.dark_zone_mutation_update
Geyser Inspired Algorithm	gea	physics	Yes	Yes	No	Yes	gea.neighbour_geyser_eruption_update gea.pressure_random_eruption_update
Giant Pacific Octopus Optimizer	gpoo	swarm	Yes	No	No	Yes	gpoo.octopus_tentacle_prey_position_update
Giant Trevally Optimizer	gto	swarm	Yes	Yes	No	Yes	gto.candidate_search gto.selection gto.candidate_generation gto.behavioral_move
Glider Snake Optimization	gso_glider_snake	swarm	Yes	No	No	No	gso_glider_snake.glider_snake_position_update
Glowworm Swarm Optimization	gso	swarm	Yes	Yes	No	Yes	gso.glowworm_luciferin_movement_update
Golden Jackal Optimizer	gjo	swarm	Yes	Yes	No	Yes	gjo.male_female_exploitation gjo.male_female_exploration
Gradient-Based Optimizer	gbo	math	Yes	Yes	No	Yes	gbo.gradient_search_rule_update gbo.local_escaping_operator_update
Gradient-Based Particle Swarm Optimization	gpso	swarm	Yes	Yes	No	Yes	gpso.velocity_position_update
Gradient-Boosted Regression Trees Bayesian Optimization	gbrt_bo	surrogate	No	No	No	No	gbrt_bo.update
Grasshopper Optimization Algorithm	goa	swarm	Yes	Yes	No	Yes	goa.grasshopper_social_force_update
Gravitational Search Algorithm	gsa	physics	Yes	Yes	No	Yes	gsa.gravitational_force_acceleration_update
Greedy Randomized Adaptive Search Procedure	grasp	trajectory	No	No	Yes	No	grasp.update
Grey Wolf Optimizer	gwo	swarm	Yes	Yes	No	Yes	gwo.alpha_guidance gwo.beta_guidance gwo.delta_guidance gwo.position_update
Greylag Goose Optimization	ggo	swarm	Yes	Yes	No	Yes	ggo.greylag_goose_flock_update
Growth Optimizer	go_growth	swarm	Yes	Yes	No	Yes	go_growth.growth_phase_update go_growth.maturity_phase_update go_growth.selection
Harmony Search Algorithm	hsa	trajectory	Yes	No	No	Yes	hsa.harmony_memory_improvisation_update
Harris Hawks Optimization	hho	swarm	Yes	Yes	No	Yes	hho.exploration hho.soft_besiege hho.hard_besiege hho.soft_besiege_rapid_dive hho.hard_besiege_rapid_dive hho.levy_rapid_dive_refinement
Heap-Based Optimizer	hbo	human	Yes	Yes	No	Yes	hbo.heap_rank_pressure_update
Henry Gas Solubility Optimization	hgso	physics	Yes	Yes	No	Yes	hgso.cluster_best_solubility_update hgso.global_best_solubility_update hgso.worst_agent_random_reset
Hiking Optimization Algorithm	hiking_oa	human	Yes	Yes	No	Yes	hiking_oa.hiking_slope_velocity_update
Hill Climb Algorithm	hc	trajectory	No	No	No	No	hc.update
Hippopotamus Optimization Algorithm	ho_hippo	swarm	Yes	Yes	No	Yes	ho_hippo.exploitation ho_hippo.selection ho_hippo.state_update ho_hippo.group_defense_position_update ho_hippo.predator_defense_update ho_hippo.river_pond_position_update
Honey Badger Algorithm	hba_honey	swarm	Yes	Yes	No	Yes	hba_honey.digging_phase_update hba_honey.honey_phase_update
Horse Herd Optimization Algorithm	horse_oa	swarm	Yes	Yes	No	Yes	horse_oa.dominant_stallion_update horse_oa.experienced_horse_social_update horse_oa.middle_rank_grazing_update horse_oa.foal_exploration_update
Human Conception Optimizer	hco	human	Yes	Yes	No	Yes	hco.conception_growth_update
Human Evolutionary Optimization Algorithm	heoa	human	Yes	Yes	No	Yes	heoa.elite_local_refinement heoa.learner_levy_best_attraction heoa.explorer_centroid_escape heoa.follower_best_contraction heoa.risk_taker_best_sampling
Hunger Games Search	hgs	swarm	Yes	Yes	No	Yes	hgs.random_hunger_exploration hgs.hunger_weighted_approach hgs.hunger_weighted_retreat
Hunting Search Algorithm	hus	swarm	Yes	Yes	No	Yes	hus.update
Hybrid Bat Algorithm	hba	swarm	Yes	Yes	No	Yes	hba.bat_frequency_movement hba.de_local_search
Hybrid Grey Wolf - Whale Optimization Algorithm	gwo_woa	swarm	Yes	No	No	No	gwo_woa.selection gwo_woa.elite_local_refinement gwo_woa.leader_guided_population_update
Hybrid Improved Whale Optimization Algorithm	hi_woa	swarm	Yes	No	No	No	hi_woa.selection hi_woa.elite_local_refinement hi_woa.whale_position_update
Hybrid Self-Adaptive Bat Algorithm	hsaba	swarm	Yes	Yes	No	Yes	hsaba.local_bat_random_walk hsaba.velocity_bat_update hsaba.differential_evolution_refinement
IPOP-CMA-ES	ipop_cmaes	evolutionary	Yes	No	Yes	Yes	ipop_cmaes.update
Imperialist Competitive Algorithm	ica	human	Yes	Yes	No	Yes	ica.assimilation ica.imperialist_revolution ica.colony_revolution ica.intra_empire_competition
Improved Adaptive Grey Wolf Optimization	iagwo	swarm	Yes	No	No	No	iagwo.adaptive_alpha_beta_delta_update
Improved Artificial Ecosystem-based Optimization	improved_aeo	human	Yes	No	No	No	improved_aeo.selection improved_aeo.ecosystem_producer_consumer_update improved_aeo.improved_decomposition_refinement
Improved Artificial Rabbits Optimization	iaro	swarm	Yes	No	No	No	iaro.improved_rabbit_global_update iaro.elite_local_refinement iaro.selection
Improved Grey Wolf Optimizer	i_gwo	swarm	Yes	Yes	No	Yes	i_gwo.selection i_gwo.alpha_guidance_trial i_gwo.beta_guidance_trial i_gwo.delta_guidance_trial i_gwo.mean_leader_position_update
Improved Kepler Optimization Algorithm	ikoa	physics	Yes	Yes	No	Yes	ikoa.selection ikoa.assignment_matching_position_update ikoa.improved_matching_refinement_update
Improved L-SHADE	ilshade	evolutionary	Yes	Yes	No	Yes	ilshade.linear_population_reduction_mutation_selection
Improved Multi-Operator Differential Evolution	imode	evolutionary	Yes	Yes	No	Yes	imode.candidate_generation imode.selection imode.state_update imode.initialization imode.mutation imode.crossover
Improved Opposite-based Learning Grey Wolf Optimizer	iobl_gwo	swarm	Yes	No	No	No	iobl_gwo.selection iobl_gwo.elite_local_refinement iobl_gwo.leader_guided_population_update
Improved Queuing Search Algorithm	improved_qsa	human	Yes	No	No	No	improved_qsa.selection improved_qsa.queue_business_one_update improved_qsa.queue_business_two_refinement
Improved Teaching-Learning-based Optimization	improved_tlo	swarm	Yes	No	No	No	improved_tlo.selection improved_tlo.elite_local_refinement improved_tlo.teacher_learner_population_update
Improved Whale Optimization Algorithm	i_woa	swarm	Yes	Yes	No	Yes	i_woa.polynomial_breeding_refinement
Incremental model-based Grey Wolf Optimizer	incremental_gwo	swarm	Yes	No	No	No	incremental_gwo.selection incremental_gwo.elite_local_refinement incremental_gwo.leader_guided_population_update
Invasive Weed Optimization	iwo	nature	Yes	Yes	No	Yes	iwo.seed_dispersal_colonization_update
Iterated Local Search	ils	trajectory	No	No	Yes	No	ils.update
Ivy Algorithm	ivya	nature	Yes	Yes	No	Yes	ivya.neighbor_growth_update ivya.best_growth_update
Jaya Algorithm	jy	swarm	Yes	Yes	No	Yes	jy.best_away_from_worst_update
Jellyfish Search Optimizer	jso	swarm	Yes	Yes	No	Yes	jso.ocean_current_swarm_motion_update
Komodo Mlipir Algorithm	kma	swarm	Yes	Yes	No	Yes	kma.update
Krill Herd Algorithm	kha	swarm	Yes	No	No	Yes	kha.crossover kha.diffusion kha.mutation kha.selection kha.state_update kha.induced_movement_update
LSHADE-cnEpSin	lshade_cnepsin	evolutionary	Yes	Yes	No	Yes	lshade_cnepsin.cn_epsin_mutation_crossover_selection
Leaf in Wind Optimization	liwo	physics	Yes	Yes	No	Yes	liwo.breeze_spiral_translation liwo.strong_wind_displacement
Life Choice-Based Optimizer	lco	human	Yes	Yes	No	Yes	lco.life_choice_boundary_reflection_update
Light Spectrum Optimizer	lso_spectrum	physics	Yes	Yes	No	Yes	lso_spectrum.light_spectrum_position_update
Linear Subspace Surrogate Modeling Evolutionary Algorithm	l2smea	evolutionary	Yes	Yes	No	Yes	l2smea.update
Lion Optimization Algorithm	loa	swarm	Yes	Yes	No	Yes	loa.nomad_roaming_update loa.pride_mating_recombination loa.pride_leader_roaming_update loa.nomad_roaming_update.mutation loa.pride_mating_recombination.mutation loa.pride_leader_roaming_update.mutation loa.territorial_takeover_exchange
Liver Cancer Algorithm	lca	nature	Yes	Yes	No	Yes	lca.best_cell_replication lca.peer_lateral_invasion lca.angiogenesis_mutation
Lungs Performance-Based Optimization	lpo	nature	Yes	Yes	No	Yes	lpo.lichen_growth_propagation_update
Lyrebird Optimization Algorithm	loa_lyrebird	swarm	Yes	Yes	No	Yes	loa_lyrebird.better_bird_imitation_update loa_lyrebird.escape_step_update
Lévy Flight Distribution	lfd	swarm	Yes	Yes	No	Yes	lfd.levy_flight_search
Lévy Flight Jaya Algorithm	levy_ja	swarm	Yes	No	No	No	levy_ja.candidate_search levy_ja.selection levy_ja.candidate_generation levy_ja.initialization
Lévy Flight and Selective Opposition Artificial Rabbit Algorithm	laro	swarm	Yes	No	No	No	laro.candidate_search laro.selection laro.candidate_generation laro.initialization
Magnificent Frigatebird Optimization	mfo	swarm	Yes	No	No	Yes	mfo.exploration_move mfo.exploitation_move mfo.replacement
Manta Ray Foraging Optimization	mrfo	swarm	Yes	Yes	No	Yes	mrfo.chain_foraging mrfo.cyclone_random_foraging mrfo.cyclone_best_foraging mrfo.somersault_foraging
Mantis Shrimp Optimization Algorithm	mshoa	swarm	Yes	Yes	No	Yes	mshoa.smasher_attack_update mshoa.spearer_circular_attack_update mshoa.defense_position_update
Marine Predators Algorithm	mpa	swarm	Yes	Yes	No	Yes	mpa.brownian_exploration mpa.brownian_transition mpa.levy_transition mpa.levy_exploitation mpa.fads
Market Game Optimization Algorithm	mgoa_market	human	Yes	Yes	No	Yes	mgoa_market.market_gradient_position_update
Memetic Algorithm	memetic_a	evolutionary	Yes	Yes	No	Yes	memetic_a.candidate_generation memetic_a.selection memetic_a.recombination memetic_a.mutation memetic_a.mutate memetic_a.xhc
Mirage-Search Optimizer	mso	physics	Yes	Yes	No	Yes	mso.superior_mirage_search_update mso.inferior_mirage_search_update
Modified Artificial Ecosystem-Based Optimization	modified_aeo	human	Yes	No	No	No	modified_aeo.selection modified_aeo.ecosystem_producer_consumer_update modified_aeo.modified_decomposition_refinement
Modified Equilibrium Optimizer	modified_eo	physics	Yes	No	No	No	modified_eo.selection modified_eo.modified_equilibrium_pool_update modified_eo.modified_local_refinement
Monarch Butterfly Optimization	mbo	swarm	Yes	Yes	No	Yes	mbo.monarch_migration_adjusting_update
Monkey King Evolution V1	mke	evolutionary	Yes	Yes	No	Yes	mke.king_learning_fluctuation_update mke.peer_knowledge_difference_update
Moss Growth Optimization	moss_go	nature	Yes	Yes	No	Yes	moss_go.water_dispersal_growth_update
Most Valuable Player Algorithm	mvpa	human	Yes	Yes	No	Yes	mvpa.mvp_guided_player_update
Moth Flame Algorithm	mfa	swarm	Yes	Yes	No	Yes	mfa.moth_flame_spiral_update
Moth Search Algorithm	msa_e	swarm	Yes	Yes	No	Yes	msa_e.golden_ratio_exploitation_update
Mountain Gazelle Optimizer	mgo	swarm	Yes	Yes	No	Yes	mgo.territory_mountain_herding_update
Mountaineering Team-Based Optimization	mtbo	human	Yes	No	No	Yes	mtbo.team_leader_coordinated_movement mtbo.avalanche_worst_avoidance mtbo.team_mean_movement mtbo.random_relocation_phase mtbo.candidate_generation mtbo.selection
Multi-Start Local Search	msls	trajectory	No	No	Yes	No	msls.update
Multi-Surrogate-Assisted Ant Colony Optimization	misaco	swarm	Yes	Yes	No	Yes	misaco.update
Multi-Verse Optimizer	mvo	swarm	Yes	Yes	No	Yes	mvo.candidate_generation mvo.selection mvo.exploitation_move mvo.replacement
Multifactorial Evolutionary Algorithm II	mfea2	evolutionary	Yes	Yes	No	Yes	mfea2.update
Multifactorial Evolutionary Algorithm	mfea	evolutionary	Yes	Yes	No	Yes	mfea.assortative_mating_mutation_transfer_update
Multiple Trajectory Search	mts	trajectory	Yes	Yes	No	Yes	mts.multiple_trajectory_local_search_update
Multiswarm-Assisted Expensive Optimization	samso	swarm	Yes	Yes	No	Yes	samso.self_adaptive_migratory_swarm_update
NLAPSMjSO-EDA	nlapsmjso_eda	evolutionary	Yes	No	No	Yes	nlapsmjso_eda.sampling nlapsmjso_eda.selection nlapsmjso_eda.state_update nlapsmjso_eda.non_linear_population_analysis_update
Naked Mole-Rat Algorithm	nmra	swarm	Yes	Yes	No	Yes	nmra.breeder_exploitation_update nmra.worker_exploration_update
Narwhal Optimizer	nwoa	swarm	Yes	Yes	No	Yes	nwoa.exploration_move nwoa.exploitation_move nwoa.replacement
Nelder-Mead Method	nmm	trajectory	Yes	Yes	No	Yes	nmm.reflection_update nmm.expansion_update nmm.contraction_update nmm.shrink_update
Neural Network-Based Dimensionality Reduction Evolutionary Algorithm	nndrea_so	evolutionary	Yes	Yes	No	Yes	nndrea_so.nn_weight_de_stage nndrea_so.solution_de_stage
Nizar Optimization Algorithm	noa	math	Yes	Yes	No	Yes	noa.newton_position_update
Northern Goshawk Optimization	ngo	swarm	Yes	Yes	No	Yes	ngo.phase_one_update ngo.pursuit_exploitation_update ngo.selection
Nuclear Reaction Optimization	nro	physics	Yes	Yes	No	Yes	nro.nuclear_fission_update nro.nuclear_fusion_update nro.selection
Numeric Crunch Algorithm	nca	math	Yes	Yes	No	Yes	nca.acceleration_hyperbolic_contraction_random_subset_components
Opposition-based Coral Reefs Optimization	ocro	evolutionary	Yes	No	No	No	ocro.candidate_generation ocro.selection ocro.position_update ocro.state_update ocro.initialization
Opposition-based learning Grey Wolf Optimizer	ogwo	swarm	Yes	No	No	No	ogwo.selection ogwo.elite_local_refinement ogwo.leader_guided_population_update
Optimal Foraging Algorithm	ofa	swarm	Yes	Yes	No	Yes	ofa.owl_neighbour_flight_update
Osprey Optimization Algorithm	ooa	swarm	Yes	Yes	No	Yes	ooa.hunting ooa.search ooa.selection ooa.state_update ooa.fish_carrying_local_update
Parameter-Free Bat Algorithm	plba	swarm	Yes	Yes	No	Yes	plba.path_looping_bat_update
Parent-Centric Crossover (G3-PCX style)	pcx	evolutionary	Yes	Yes	No	Yes	pcx.parent_centric_crossover_update
Pareto Sequential Sampling	pss	math	Yes	Yes	No	Yes	pss.prominent_domain_sampling_update pss.full_domain_sampling_update pss.mixed_domain_sampling_update
Parrot Optimizer	parrot_o	swarm	Yes	Yes	No	Yes	parrot_o.flight_area_search_update
Particle Swarm Optimization	pso	swarm	Yes	Yes	No	Yes	pso.inertia_velocity_update pso.cognitive_memory_update pso.social_global_update
Pathfinder Algorithm	pfa	swarm	Yes	Yes	No	Yes	pfa.pathfinder_position_update
Pelican Optimization Algorithm	poa	swarm	Yes	Yes	No	Yes	poa.prey_pursuit_update poa.water_surface_winging_update
Physical Education Teacher Inspired Optimization	petio	human	Yes	No	No	Yes	petio.performance_evaluation_teaching_update
Pied Kingfisher Optimizer	pko	swarm	Yes	Yes	No	Yes	pko.diving_beating_rate_update pko.crest_angle_foraging_update pko.hovering_attack_update pko.population_escape_update
Polar Fox Optimization	pfa_polar_fox	swarm	Yes	No	No	No	pfa_polar_fox.exploitation pfa_polar_fox.selection pfa_polar_fox.state_update pfa_polar_fox.experience_phase pfa_polar_fox.leader_guided_refinement_update pfa_polar_fox.leader_phase
Polar Lights Optimizer	plo	physics	Yes	Yes	No	Yes	plo.aurora_global_local_update plo.polar_light_collision_update
Political Optimizer	political_o	human	Yes	Yes	No	Yes	political_o.candidate_generation political_o.selection political_o.parliamentary
Poor and Rich Optimization Algorithm	pro	human	Yes	Yes	No	Yes	pro.learning pro.state_update pro.candidate_generation pro.selection
Population-Based Incremental Learning	pbil	distribution	No	No	No	No	pbil.update
Prairie Dog Optimization Algorithm	pdo	swarm	Yes	Yes	No	Yes	pdo.prairie_dog_burrow_alarm_update
Puma Optimizer	puma_o	swarm	Yes	Yes	No	Yes	puma_o.update
QLE Sine Cosine Algorithm	qle_sca	swarm	Yes	No	No	No	qle_sca.candidate_generation qle_sca.selection qle_sca.learning qle_sca.state_update qle_sca.initialization
Quadratic Interpolation Optimization	qio	math	Yes	Yes	No	Yes	qio.three_point_quadratic_interpolation qio.two_point_reflection_interpolation
Queuing Search Algorithm	qsa	human	Yes	Yes	No	Yes	qsa.business1 qsa.business2 qsa.business3
RIME-ice Algorithm	rime	physics	Yes	Yes	No	Yes	rime.hard_rime_puncture_update
RMSProp	rmsprop	math	No	No	No	No	rmsprop.candidate_generation rmsprop.selection rmsprop.search_direction rmsprop.step_acceptance rmsprop.initialization
RUNge Kutta Optimizer	run	math	Yes	Yes	No	Yes	run.selection run.enhanced_solution_quality_update run.runge_kutta_position_update
Rain-Cloud Condensation Optimizer	rcco	physics	Yes	No	No	Yes	rcco.rain_cloud_convection_update rcco.cloud_collision_local_update rcco.selection
Random Forest Bayesian Optimization	rf_bo	surrogate	No	No	No	No	rf_bo.update
Random Search	random_s	trajectory	Yes	Yes	No	Yes	random_s.random_sampling_update
Rat Swarm Optimizer	rso	swarm	Yes	Yes	No	Yes	rso.long_chasing_update rso.short_chasing_update
Red-billed Blue Magpie Optimizer	rbmo	swarm	Yes	Yes	No	Yes	rbmo.update
Remora Optimization Algorithm	roa	swarm	Yes	Yes	No	Yes	roa.remora_attempt_update
Reptile Search Algorithm	rsa	swarm	Yes	Yes	No	Yes	rsa.reptile_hunting_encircling_update
Rock Hyraxes Swarm Optimization	rhso	swarm	Yes	No	No	Yes	rhso.rhinoceros_herd_position_update
Rüppell's Fox Optimizer	rfo	swarm	Yes	Yes	No	Yes	rfo.red_fox_smell_search_update
Sailfish Optimizer	sfo	swarm	Yes	Yes	No	Yes	sfo.behavioral_move sfo.selection
Salp Swarm Algorithm	ssa	swarm	Yes	Yes	No	Yes	ssa.leader_plus_food_guidance ssa.leader_minus_food_guidance ssa.follower_front_chain_update ssa.follower_rear_chain_update
Sammon Mapping Assisted Differential Evolution	sade_sammon	evolutionary	Yes	Yes	No	Yes	sade_sammon.sammon_surrogate_de_selection_update
Sand Cat Swarm Optimization	scso	swarm	Yes	Yes	No	Yes	scso.exploration_move scso.replacement scso.selection scso.exploitation_move scso.candidate_generation
Satin Bowerbird Optimizer	sbo	swarm	Yes	Yes	No	Yes	sbo.bowerbird_mutation_update
Sea Lion Optimization	slo	swarm	Yes	Yes	No	Yes	slo.best_encircling_update slo.random_peer_encircling_update slo.spiral_attack_update
Seagull Optimization Algorithm	soa	swarm	Yes	Yes	No	Yes	soa.seagull_spiral_attack_update
Seahorse Optimizer	seaho	swarm	Yes	Yes	No	Yes	seaho.candidate_generation seaho.selection seaho.recombination
Search And Rescue Optimization	saro	human	Yes	Yes	No	Yes	saro.candidate_generation saro.selection saro.individual saro.candidate_search saro.social
Search Space Independent Operator Based Deep Reinforcement Learning	ssio_rl	evolutionary	Yes	Yes	No	Yes	ssio_rl.update
Secretary Bird Optimization Algorithm	sboa	swarm	Yes	Yes	No	Yes	sboa.update
Self-Adaptive Bat Algorithm	saba	swarm	Yes	Yes	No	Yes	saba.self_adaptive_bat_update
Self-Adaptive Differential Evolution	sade	evolutionary	Yes	No	No	No	sade.selection sade.adaptive_strategy_de_update sade.elite_local_refinement
Self-Adaptive Differential Evolution	jde	evolutionary	Yes	Yes	No	Yes	jde.de_trial jde.f_self_adaptation_trial jde.cr_self_adaptation_trial jde.f_cr_self_adaptation_trial
Sequential Quadratic Programming	sqp	math	No	No	No	No	sqp.update
Serval Optimization Algorithm	serval_oa	swarm	Yes	Yes	No	Yes	serval_oa.hunting serval_oa.selection serval_oa.state_update
Shuffle-based Runner-Root Algorithm	srsr	swarm	Yes	Yes	No	Yes	srsr.exploration srsr.selection srsr.1_accumulation_new_positions_via_gaussian
Siberian Tiger Optimization	sto	swarm	Yes	Yes	No	Yes	sto.prey_hunting_update sto.range_reduction_update
Simple Optimization Algorithm	sopt	distribution	Yes	Yes	No	Yes	sopt.statistical_population_selection_update
Simulated Annealing	sa	trajectory	No	Yes	Yes	No	sa.update
Sine Cosine Algorithm	sine_cosine_a	swarm	Yes	Yes	No	Yes	sine_cosine_a.sine_position_update sine_cosine_a.cosine_position_update
Singer Optimization Algorithm	singer_oa	human	Yes	Yes	No	Yes	singer_oa.imitation_mimicry_phase singer_oa.creation_perturbation_phase
Sinh Cosh Optimizer	scho	math	Yes	Yes	No	Yes	scho.scholar_chess_position_update
Slime Mould Algorithm	sma	nature	Yes	Yes	No	Yes	sma.random_dispersion_update sma.best_weighted_oscillation_update sma.contracting_vibration_update
Snake Optimizer	so_snake	swarm	Yes	Yes	No	Yes	so_snake.male_snake_update so_snake.female_snake_update so_snake.selection
Snow Ablation Optimizer	snow_oa	physics	Yes	Yes	No	Yes	snow_oa.exploration_group_update snow_oa.development_group_update
Social Ski-Driver Optimization	ssdo	human	Yes	Yes	No	Yes	ssdo.sine_velocity_update ssdo.cosine_velocity_update
Social Spider Algorithm	sspider_a	swarm	Yes	Yes	No	Yes	sspider_a.social_spider_vibration_update
Social Spider Swarm Optimizer	sso	swarm	Yes	Yes	No	Yes	sso.female_spider_position_update sso.male_spider_position_update
Sparrow Search Algorithm	sparrow_sa	swarm	Yes	Yes	No	Yes	sparrow_sa.producer_safe_foraging sparrow_sa.producer_alarm_random_walk sparrow_sa.scrounger_worst_avoidance sparrow_sa.scrounger_best_following sparrow_sa.awareness_best_escape sparrow_sa.awareness_worst_escape
Spider Monkey Optimization	smo	swarm	Yes	Yes	No	Yes	smo.local_leader_phase smo.global_leader_phase smo.local_leader_decision
Spotted Hyena Inspired Optimizer	shio	swarm	Yes	Yes	No	Yes	shio.first_iguana_guidance shio.second_iguana_guidance shio.third_iguana_guidance
Spotted Hyena Optimizer	sho	swarm	Yes	Yes	No	Yes	sho.spotted_hyena_hunting_update
Squirrel Search Algorithm	squirrel_sa	swarm	Yes	Yes	No	Yes	squirrel_sa.acorn_to_hickory_glide squirrel_sa.normal_to_acorn_glide squirrel_sa.normal_to_hickory_glide squirrel_sa.predator_random_relocation
Starfish Optimization Algorithm	sfoa	swarm	Yes	Yes	No	Yes	sfoa.foraging sfoa.state_update sfoa.exploitation_move sfoa.replacement sfoa.exploration
Steepest Descent	sd	math	No	No	No	No	sd.candidate_generation sd.selection sd.search_direction sd.step_acceptance sd.initialization
Stellar Oscillator Optimization	soo	physics	Yes	Yes	No	Yes	soo.selection soo.1_oscillatory_position soo.2_top_3_average_oscillatory
Student Psychology Based Optimization	spbo	swarm	Yes	Yes	No	Yes	spbo.groups spbo.selection spbo.average_student_phase_update spbo.best_student spbo.excellent_student_phase_update
Success-History Adaptive Differential Evolution	shade	evolutionary	Yes	Yes	No	Yes	shade.success_history_mutation_crossover_selection
Success-History Intelligent Optimizer	shio_success	swarm	Yes	Yes	No	Yes	shio_success.best_history_guidance shio_success.second_history_guidance shio_success.third_history_guidance
Superb Fairy-wren Optimization Algorithm	superb_foa	swarm	Yes	Yes	No	Yes	superb_foa.global_smell_random_update superb_foa.levy_food_attraction superb_foa.best_food_convergence
Supply-Demand-Based Optimization	supply_do	human	Yes	Yes	No	Yes	supply_do.quantity_equilibrium_update supply_do.price_equilibrium_update
Surrogate-Assisted Cooperative Co-Evolutionary Algorithm of Minamo II	sacc_eam2	evolutionary	Yes	Yes	No	Yes	sacc_eam2.even_subcomponent_de_update sacc_eam2.odd_subcomponent_de_update
Surrogate-Assisted Cooperative Swarm Optimization	sacoso	swarm	Yes	Yes	No	Yes	sacoso.cognitive_swarm_update sacoso.social_swarm_update
Surrogate-Assisted DE with Adaptive Multi-Subspace Search	sade_amss	evolutionary	Yes	Yes	No	Yes	sade_amss.adaptive_multistrategy_subspace_de_update
Surrogate-Assisted DE with Adaptive Training Data Selection Criterion	sade_atdsc	evolutionary	Yes	Yes	No	Yes	sade_atdsc.adaptive_trial_distribution_selection_update
Surrogate-Assisted Partial Optimization	sapo	evolutionary	Yes	Yes	No	Yes	sapo.update
Swarm Robotics Search And Rescue	srsr_robotics	swarm	Yes	No	No	Yes	srsr_robotics.candidate_generation srsr_robotics.selection srsr_robotics.guidance srsr_robotics.state_update srsr_robotics.exploration
Symbiotic Organisms Search	sos	swarm	Yes	Yes	No	Yes	sos.candidate_generation sos.selection sos.mutualism sos.comensalism sos.parasitism
Tabu Search	ts	trajectory	No	No	No	No	ts.update
Tasmanian Devil Optimization	tdo	swarm	Yes	Yes	No	Yes	tdo.exploration tdo.state_update tdo.hunting tdo.exploitation
Teaching Learning Based Optimization	tlbo	swarm	Yes	Yes	No	Yes	tlbo.teacher_phase tlbo.learner_phase
Teamwork Optimization Algorithm	toa	human	Yes	Yes	No	Yes	toa.stage_1_supervisor_guidance toa.learning toa.state_update toa.candidate_generation toa.selection
Termite Life Cycle Optimizer	tlco	swarm	Yes	Yes	No	Yes	tlco.teacher_phase_update tlco.learner_phase_update tlco.selection
Tianji Horse Racing Optimizer	thro	human	Yes	Yes	No	Yes	thro.throwing_race_update
Tornado Optimizer with Coriolis Force	toc	physics	Yes	Yes	No	Yes	toc.combination_velocity_update
Tree Physiology Optimization	tpo	nature	Yes	Yes	No	Yes	tpo.carbon_nutrient_leaf_update
Tree-Seed Algorithm	tree_seed_a	nature	Yes	No	No	Yes	tree_seed_a.toward_best_seed tree_seed_a.away_random_seed
Triangulation Topology Aggregation Optimizer	ttao	math	Yes	Yes	No	Yes	ttao.crossover ttao.selection ttao.state_update ttao.extra_candidate_diversification_update ttao.random_population_refresh_update
Tug of War Optimization	two	physics	Yes	Yes	No	Yes	two.tug_of_war_weight_force_update
Tuna Swarm Optimization	tso	swarm	Yes	Yes	No	Yes	tso.leader_spiral_update tso.random_migration_update tso.spiral_following_update tso.parabolic_foraging_update
Tunicate Swarm Algorithm	tsa	swarm	Yes	Yes	No	Yes	tsa.toward_best_tunicate_update tsa.away_best_tunicate_update tsa.swarm_chain_averaging_update
Turbulent Flow of Water-based Optimization	tfwo	physics	Yes	No	No	Yes	tfwo.effect_of_objects tfwo.random_object_relocation tfwo.effect_of_whirlpools tfwo.best_whirlpool_preservation tfwo.object_whirlpool_exchange tfwo.state_structure_update
Variable Neighborhood Search	vns	trajectory	No	No	Yes	No	vns.update
Virus Colony Search	vcs	swarm	Yes	Yes	No	Yes	vcs.virus_diffusion vcs.host_cell_infection vcs.immune_response
Walrus Optimization Algorithm	waoa	swarm	Yes	Yes	No	Yes	waoa.feeding_exploration_update waoa.range_narrowing_exploitation
War Strategy Optimization	warso	human	Yes	Yes	No	Yes	warso.attack_strategy_update warso.defense_strategy_update
Water Cycle Algorithm	wca	nature	Yes	Yes	No	Yes	wca.stream_toward_river wca.stream_river_exchange wca.river_toward_sea wca.evaporation_raining
Water Uptake and Transport in Plants	wutp	nature	Yes	Yes	No	Yes	wutp.horizontal_water_transport_update
Wave Optimization Algorithm	wo_wave	physics	Yes	Yes	No	Yes	wo_wave.wave_propagation_position_update
Wavelet Mutation and Quadratic Interpolation MRFO	wmqimrfo	swarm	Yes	No	No	No	wmqimrfo.selection wmqimrfo.elite_local_refinement wmqimrfo.weighted_multi_quadratic_mrfo_update
Weighting and Inertia Random Walk Optimizer	info	math	Yes	Yes	No	Yes	info.best_weighted_mean_rule info.random_weighted_mean_rule
Whale Fruit-fly Optimization Algorithm	whale_foa	swarm	Yes	No	No	No	whale_foa.selection whale_foa.elite_local_refinement whale_foa.whale_position_update
Whale Optimization Algorithm	woa	swarm	Yes	Yes	No	Yes	woa.search_for_prey woa.encircling_prey woa.spiral_bubble_net
White Shark Optimizer	wso	swarm	Yes	Yes	No	Yes	wso.white_shark_swarm_position_update
Wildebeest Herd Optimization	who	swarm	Yes	Yes	No	Yes	who.selection who.1_local_movement_milling who.2_herd_instinct who.social_memory
Wind Driven Optimization	wdo	physics	Yes	Yes	No	Yes	wdo.wind_velocity_position_update
Wolverine Optimization Algorithm	wooa	swarm	Yes	Yes	No	Yes	wooa.scavenging_predator_following wooa.prey_attack_update wooa.fight_chase_local_update
Young's Double-Slit Experiment Optimizer	ydse	physics	Yes	Yes	No	Yes	ydse.central_bright_fringe_update ydse.bright_fringe_interference_update ydse.dark_fringe_interference_update
Zebra Optimization Algorithm	zoa	swarm	Yes	Yes	No	Yes	zoa.behavioral_move zoa.selection zoa.candidate_generation

---

4. Test Functions

Back to Summary

The graph module can be used with the built-in benchmark functions or with any user-defined scalar objective function that follows the same interface f(x) -> float. The unified plotting function automatically adapts the visualization to the number of variables:

**1D**: Line Plot                                  (1  Variable, `plot_function_1d`)
**2D**: Contour Map and Heatmap                    (2  Variables,`plot_function_2d`)
**3D**: Interactive Surface Plot                   (2  Variables,`plot_function_3d`)
**ND**: Parallel-coordinates Plot & PCA Projection (3+ Variables,`plot_function_nd`)

• Click Here for the Full Google Colab Example

import pymetaheuristic

rastrigin = pymetaheuristic.get_test_function("rastrigin")

# Plot
pymetaheuristic.plot_function_3d(
								  rastrigin,
                                  min_values = (-5.12, -5.12),
                                  max_values = ( 5.12,  5.12),
                                  solutions  = ([   0,    0]),
								  title      = "Rastrigin",
								  filepath   = "out.html",  # also supports .png / .svg / .pdf  
							    )

The table below summarizes the benchmark functions currently available in the library. The Function column reports the conventional function name, ID gives the callable identifier used in the codebase (when importing from pymetaheuristic.src.test_functions), Domain and Global Minimum describes, when applicable, the corresponding decision vector, and the known global optimum in terms of objective value.

Benchmark Function Optima

All functions below use the minimization convention. Notation

Symbol	Meaning
D	Number of decision variables.
x*	Global minimizer.
f*	Global minimum value.
0D	D-dimensional vector of zeros.
1D	D-dimensional vector of ones.

2-Dimensional Functions

Function	ID	Domain	Global Minimum
Ackley	ackley	[-32.768, 32.768]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
Beale	beale	[-4.5, 4.5]2	f(x1, x2) = 0; (x1, x2) = (3, 0.5)
Bohachevsky F1	bohachevsky_1	[-100, 100]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
Bohachevsky F2	bohachevsky_2	[-100, 100]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
Bohachevsky F3	bohachevsky_3	[-100, 100]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
Booth	booth	[-10, 10]2	f(x1, x2) = 0; (x1, x2) = (1, 3)
Branin RCOS	branin_rcos	x1 ∈ [-5, 10], x2 ∈ [0, 15]	f* = 0.3978873577 at (-π, 12.275); (π, 2.275); (3π, 2.475)
Bukin F6	bukin_6	x1 ∈ [-15, -5], x2 ∈ [-3, 3]	f(x1, x2) = 0; (x1, x2) = (-10, 1)
Cross-in-Tray	cross_in_tray	[-10, 10]2	f* ≈ -2.0626118708 at (x1, x2) = (±1.349406609, ±1.349406609)
Drop-Wave	drop_wave	[-5.12, 5.12]2	f(x1, x2) = -1; (x1, x2) = (0, 0)
Easom	easom	[-100, 100]2	f(x1, x2) = -1; (x1, x2) = (π, π)
Eggholder	eggholder	[-512, 512]2	f* ≈ -959.6407; (x1, x2) ≈ (512, 404.2319)
Goldstein-Price	goldstein_price	[-2, 2]2	f(x1, x2) = 3; (x1, x2) = (0, -1)
Himmelblau	himmelblau	[-5, 5]2	f* = 0 at (3, 2); (-2.805118, 3.131312); (-3.779310, -3.283186); (3.584428, -1.848126)
Hölder Table	holder_table	[-10, 10]2	f* ≈ -19.208502568 at (x1, x2) = (±8.055023472, ±9.664590029)
Levi F13	levi_13	[-10, 10]2	f(x1, x2) = 0; (x1, x2) = (1, 1)
Matyas	matyas	[-10, 10]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
McCormick	mccormick	x1 ∈ [-1.5, 4], x2 ∈ [-3, 4]	f* ≈ -1.913222955; (x1, x2) ≈ (-0.54719756, -1.54719756)
Schaffer F2	schaffer_2	[-100, 100]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
Schaffer F4	schaffer_4	[-100, 100]2	f* ≈ 0.292578632 at (0, ±1.25313), (±1.25313, 0)
Schaffer F6	schaffer_6	[-100, 100]2	f(x1, x2) = 0; (x1, x2) = (0, 0)
Six-Hump Camel Back	six_hump_camel_back	x1 ∈ [-3, 3], x2 ∈ [-2, 2]	f* ≈ -1.031628453 at (0.089842, -0.712656); (-0.089842, 0.712656)
Three-Hump Camel Back	three_hump_camel_back	[-5, 5]2	f(x1, x2) = 0; (x1, x2) = (0, 0)

D-Dimensional Functions

Function	ID	Domain	Global Minimum
Alpine 1	alpine_1	[-10, 10]D	f(x) = 0; xi = 0, i = 1, ..., D
Alpine 2	alpine_2	[0, 10]D	f* ≈ -(2.808131180)D; xi ≈ 7.917052698 [N1]
Axis Parallel Hyper-Ellipsoid	axis_parallel_hyper_ellipsoid	[-5.12, 5.12]D	f(x) = 0; xi = 0, i = 1, ..., D
Bent Cigar	bent_cigar	[-100, 100]D	f(x) = 0; x = 0D
Chung-Reynolds	chung_reynolds	[-100, 100]D	f(x) = 0; x = 0D
Cosine Mixture	cosine_mixture	[-1, 1]D	f(x) = -0.1D; x = 0D [N1]
Csendes	csendes	[-1, 1]D	f(x) = 0; x = 0D
De Jong F1 / Sphere	de_jong_1	[-5.12, 5.12]D	f(x) = 0; x = 0D
Discus	discus	[-100, 100]D	f(x) = 0; x = 0D
Dixon-Price	dixon_price	[-10, 10]D	f(x) = 0; xi = 2-((2i - 2) / 2i), i = 1, ..., D
Elliptic	elliptic	[-100, 100]D	f(x) = 0; x = 0D
Expanded Griewank plus Rosenbrock	expanded_griewank_plus_rosenbrock	[-5, 5]D	f(x) = 0; x = 1D
Griewank	griewangk_8	[-600, 600]D	f(x) = 0; x = 0D
Happy Cat	happy_cat	[-100, 100]D	f(x) = 0; x = -1D
HGBat	hgbat	[-100, 100]D	f(x) = 0; x = -1D
Katsuura	katsuura	[-100, 100]D	f(x) = 0; x = 0D [N2]
Levy	levy	[-10, 10]D	f(x) = 0; x = 1D
Michalewicz	michalewicz	[0, π]D	Dimension- and m-dependent [N3]
Modified Schwefel	modified_schwefel	[-100, 100]D	f(x) = 0; x = 0D [N4]
Perm 0,d,beta	perm	[-D, D]D	f(x) = 0; xi = 1 / i, i = 1, ..., D
Pinter	pinter	[-10, 10]D	f(x) = 0; x = 0D
Powell	powell	[-4, 5]D	f(x) = 0; x = 0D [N5]
Qing	qing	[-500, 500]D	f(x) = 0; xi = ±√i, i = 1, ..., D
Quintic	quintic	[-10, 10]D	f(x) = 0; each xi ∈ {-1, 2}
Rastrigin	rastrigin	[-5.12, 5.12]D	f(x) = 0; x = 0D
Ridge	ridge	[-100, 100]D	f(x) = 0; x = 0D [N6]
Rosenbrock Valley	rosenbrocks_valley	[-5, 10]D	f(x) = 0; x = 1D
Salomon	salomon	[-100, 100]D	f(x) = 0; x = 0D
Schumer-Steiglitz	schumer_steiglitz	[-100, 100]D	f(x) = 0; x = 0D
Schwefel	schwefel	[-500, 500]D	f(x) = 0; xi ≈ 420.968746228, i = 1, ..., D
Schwefel 2.21	schwefel_221	[-100, 100]D	f(x) = 0; x = 0D
Schwefel 2.22	schwefel_222	[-100, 100]D	f(x) = 0; x = 0D
Sphere 2 / Sum of Different Powers	sphere_2	[-1, 1]D	f(x) = 0; x = 0D
Sphere 3 / Rotated Hyper-Ellipsoid	sphere_3	[-65.536, 65.536]D	f(x) = 0; x = 0D
Step	step	[-100, 100]D	f(x) = 0; abs(xi) < 1 [N7]
Step 2	step_2	[-100, 100]D	f(x) = 0; -0.5 ≤ xi < 0.5 [N7]
Step 3	step_3	[-100, 100]D	f(x) = 0; abs(xi) < 1 [N7]
Stepint	stepint	[-5.12, 5.12]D	f = 25 - 6D*; xi ∈ [-5.12, -5) [N8]
Styblinski-Tang	styblinski_tang	[-5, 5]D	f ≈ -39.166165704D*; xi ≈ -2.903534028
Trid	trid	[-D2, D2]D	f* = -D(D + 4)(D - 1) / 6; xi = i(D + 1 - i)
Weierstrass	weierstrass	[-0.5, 0.5]D	f(x) = 0; x = 0D
Whitley	whitley	[-10.24, 10.24]D	f(x) = 0; x = 1D
Zakharov	zakharov	[-5, 10]D	f(x) = 0; x = 0D

CEC 2022 Functions

Function	ID	Domain	Global Minimum
CEC 2022 F1	cec_2022_f01	2, 10, 20	f* = 300
CEC 2022 F2	cec_2022_f02	2, 10, 20	f* = 400
CEC 2022 F3	cec_2022_f03	2, 10, 20	f* = 600
CEC 2022 F4	cec_2022_f04	2, 10, 20	f* = 800
CEC 2022 F5	cec_2022_f05	2, 10, 20	f* = 900
CEC 2022 F6	cec_2022_f06	10, 20	f* = 1800
CEC 2022 F7	cec_2022_f07	10, 20	f* = 2000
CEC 2022 F8	cec_2022_f08	10, 20	f* = 2200
CEC 2022 F9	cec_2022_f09	2, 10, 20	f* = 2300
CEC 2022 F10	cec_2022_f10	2, 10, 20	f* = 2400
CEC 2022 F11	cec_2022_f11	2, 10, 20	f* = 2600
CEC 2022 F12	cec_2022_f12	2, 10, 20	f* = 2700

Engineering Design Benchmarks

Engineering benchmarks expose an objective function, along with bounds and constraints. Use get_engineering_benchmark("<id>") to retrieve objective, constraints, min_values, max_values, and best-known metadata. Constraint functions follow the package convention g(x) ≤ 0.

Function	ID	Domain	Global Minimum	Constraints
Tension/compression spring design	tension_spring	d ∈ [0.05, 2], D ∈ [0.25, 1.30], N ∈ [2, 15]	f* ≈ 0.012665; (d, D, N) ≈ (0.05169, 0.35675, 11.2871) [N9]	4 inequalities
Welded beam design	welded_beam	h ∈ [0.1, 2], l ∈ [0.1, 10], t ∈ [0.1, 10], b ∈ [0.1, 2]	f* ≈ 1.724852; (h, l, t, b) ≈ (0.20573, 3.47049, 9.03662, 0.20573)	7 inequalities
Pressure vessel design, continuous relaxation	pressure_vessel	Ts, Th ∈ [0, 99], R ∈ [10, 200], L ∈ [10, 240]	f* ≈ 5804.376217; (Ts, Th, R, L) ≈ (0.727591, 0.359649, 37.699012, 240) [N10]	4 inequalities
Pressure vessel design, discrete thickness	pressure_vessel_discrete	Ts, Th rounded upward to multiples of 1/16; R ∈ [10, 200], L ∈ [10, 240]	f* ≈ 6059.714335; (Ts, Th, R, L) ≈ (0.8125, 0.4375, 42.098446, 176.636596) [N10]	4 inequalities
Speed reducer design	speed_reducer	7 bounded design variables	f* ≈ 2994.471066; x ≈ (3.5, 0.7, 17, 7.3, 7.71532, 3.35021, 5.28665)	11 inequalities
Three-bar truss design	three_bar_truss	A1, A2 ∈ [0, 1]	f* ≈ 263.895843; (A1, A2) ≈ (0.788675, 0.408248)	3 inequalities
Cantilever beam design	cantilever_beam	xi ∈ [0.01, 100], i = 1, ..., 5	f* ≈ 1.339956; x ≈ (6.016016, 5.309173, 4.494330, 3.501475, 2.152665)	1 inequality
Gear train design	gear_train	integer xi ∈ [12, 60], i = 1, ..., 4	f* ≈ 2.700857 × 10-12; x = (16, 19, 43, 49) [N11]	box + integrality

Notes

Note	Meaning
N1	Alpine 2 and Cosine Mixture have sign-convention traps in the literature. This package uses minimization-compatible signs.
N2	Katsuura is implemented as the product expression minus 1, so the exposed minimum is 0 at the origin.
N3	Michalewicz has no single dimension-free closed-form optimum. For m = 10, common reference values are approximately: D = 2, f = -1.8013; D = 5, f = -4.6877; D = 10, f* = -9.6602.
N4	Modified Schwefel is exposed in shifted CEC-style coordinates, so the visible optimizer is 0D.
N5	Powell requires D to be a multiple of 4.
N6	This is the cumulative ridge implementation, not the BBOB sharp-ridge function.
N7	Step functions have optimizer intervals, not isolated optimizer points.
N8	Stepint is bound-dependent. With bounds [-5.12, 5.12]D, f = 25 - 6D*; without bounds, it is unbounded below.
N9	Engineering-design rows are constrained benchmarks. The Python module exposes get_engineering_benchmark(id) so users can pass the returned objective, bounds, and constraints directly to pymetaheuristic.optimize.
N10	Pressure vessel has two common variants. pressure_vessel is the continuous relaxation; pressure_vessel_discrete rounds shell/head thickness upward to multiples of 1/16 before objective and constraint evaluation.
N11	Gear train is a discrete integer benchmark. The implementation rounds variables to the nearest integer tooth counts by default.

---

5. Other Libraries

Back to Summary

• For Multiobjective Optimization or Many Objectives Optimization, try pyMultiobjective
• For Traveling Salesman Problems (TSP), try pyCombinatorial

Acknowledgement

This section is dedicated to everyone who helped improve or correct the code. Thank you very much!

• Raiser (01.MARCH.2022) - https://github.com/mpraiser - University of Chinese Academy of Sciences (China)