pymetaheuristic

A Python library for metaheuristic optimization and collaborative search, bringing together 400 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 attribution
• 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 five 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
• 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 Easom 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, max_time, max_early_stop, and target_fitness keyword arguments. The first condition that triggers, ends the run.

Five 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.
• TF (target_fitness): stop when the direction-aware target fitness is reache

• 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:

import numpy as np

# Example 1
constraints = [lambda x: x[0] + x[1] - 1.0]                    # x0 + x1 <= 1

# Example 2
constraints = [
				lambda x:  x[0]**2 + x[1]**2 - 4.0,            # x$0^{2}$ + x$1^{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
              ]

# Example 3
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".

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_pso.pkl")
r2 = pymetaheuristic.load_result("easom_pso.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_pso.json")
summary = pymetaheuristic.result_from_json("easom_pso.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                  = '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,
                                          )

state = engine.initialize()

# Run the first 25 iterations, then save a resumable checkpoint.
for _ in range(0, 25):
    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. Diagnostic or model-update operators may be recorded through counts and metadata while receiving zero direct fitness attribution. The fidelity building blocks are::

Support level	Meaning
Lineage Δf telemetry	Signed, operator-level Δf computed passively from parent-to-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. Click an algorithm name to open its primary reference or original source. All algorithms support checkpointing through the library framework, while constraint handling is provided by the framework-level constraint machinery.

• Algorithm 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 and can also show population snapshots,
• 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,
• EvoMapX 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). Direct operators are attributed from already-evaluated parent-to-child fitness changes, while diagnostic operators may report activity with zero direct fitness attribution. No additional objective evaluations are introduced.

---

Algorithm	ID	Family	Population	Candidate Injection	Restart	EvoMapX
Adam (Adaptive Moment Estimation)	adam	math	No	No	No	adam.candidate_generation adam.selection adam.search_direction adam.step_acceptance adam.initialization
Adam Gradient Descent Optimizer	agdo	math	Yes	No	No	agdo.progressive_gradient_momentum_dynamic_interaction agdo.system_optimization_operator

🔍 View complete Metaheuristic reference table

Algorithm	ID	Family	Population	Candidate Injection	Restart	EvoMapX
Adam (Adaptive Moment Estimation)	adam	math	No	No	No	adam.candidate_generation adam.selection adam.search_direction adam.step_acceptance adam.initialization
Adam Gradient Descent Optimizer	agdo	math	Yes	No	No	agdo.progressive_gradient_momentum_dynamic_interaction agdo.system_optimization_operator
Adaptive Aquila Optimizer	aao	swarm	Yes	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	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	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	aesspso.adaptive_velocity_position_update
Adaptive Inertia Weight Particle Swarm Optimization	aiw_pso	swarm	Yes	No	No	aiw_pso.position_update aiw_pso.selection aiw_pso.velocity_update aiw_pso.elite_local_refinement
Adaptive Gaining-Sharing Knowledge Based Algorithm	agsk	human	Yes	Yes	No	agsk.parameter_setting_sampling agsk.junior_gaining_sharing agsk.senior_gaining_sharing agsk.midpoint_bound_repair agsk.greedy_selection agsk.parameter_adaptation agsk.linear_population_size_reduction
Adaptive Random Search	ars	trajectory	Yes	Yes	No	ars.small_step ars.large_step
African Vultures Optimization Algorithm	avoa	swarm	Yes	Yes	No	avoa.exploration_vulture_soaring avoa.random_roost_exploration avoa.convergent_competition_exploitation avoa.levy_food_exploitation avoa.aggressive_siege_exploitation avoa.spiral_siege_exploitation
Aitken Optimizer	atk	math	Yes	No	No	atk.aitken_acceleration_search atk.random_weighted_exponential_search atk.aitken_refinement atk.greedy_selection atk.reflective_bound_repair atk.historical_best_update
Ali Baba and the Forty Thieves	aft	human	Yes	Yes	No	aft.best_guided_tracking aft.random_treasure_search aft.opposition_tracking
Anarchic Society Optimization	aso	swarm	Yes	Yes	No	aso.anarchic_social_position_update
Animated Oat Optimization Algorithm	aoo	swarm	Yes	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	acor.archive_kernel_sampling_update
Ant Colony Optimization	aco	swarm	Yes	No	No	aco.pheromone_weighted_perturbation_in_each_dimension
Ant Lion Optimizer	alo	swarm	Yes	Yes	No	alo.random_walk alo.state_update alo.candidate_generation alo.selection alo.combine
Aquila Optimizer	ao	swarm	Yes	Yes	No	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	aho.single_shot_prey_projection aho.double_shot_prey_projection aho.levy_stagnation_rescue
Archimedes Optimization Algorithm	arch_oa	physics	Yes	Yes	No	arch_oa.archimedes_density_volume_acceleration_update
Arithmetic Optimization Algorithm	aoa	swarm	Yes	Yes	No	aoa.arithmetic_operator_position_update
Artemisinin Optimization	artemisinin_o	nature	Yes	Yes	No	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	No	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	abco.employed abco.onlooker abco.scout
Artificial Ecosystem Optimization	aeo	nature	Yes	Yes	No	aeo.selection aeo.consumer_decomposer_update aeo.production_worst_agent
Artificial Electric Field Algorithm	aefa	physics	Yes	Yes	No	aefa.electric_field_force_update
Artificial Fish Swarm Algorithm	afsa	swarm	Yes	Yes	No	afsa.leap
Artificial Gorilla Troops Optimizer	agto	swarm	Yes	Yes	No	agto.migration agto.exploration agto.state_update agto.exploitation
Artificial Hummingbird Algorithm	aha	swarm	Yes	Yes	No	aha.guided_foraging aha.territorial_foraging aha.migration
Artificial Lemming Algorithm	ala	swarm	Yes	Yes	No	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	apo.dormancy_random_restart apo.dormancy_local_perturbation apo.foraging_reproduction_update apo.autotrophic_foraging_update
Artificial Rabbits Optimization	aro	swarm	Yes	Yes	No	aro.detour_foraging aro.random_hiding
Atom Search Optimization	aso_atom	physics	Yes	Yes	No	aso_atom.do_not_move_current_elites_unless
Automated Design of Variation Operators	autov	evolutionary	Yes	Yes	No	autov.learned_variation_operator_update
Bacterial Chemotaxis Optimizer	bco	nature	Yes	Yes	No	bco.swim_refinement_update
Bacterial Colony Optimization	bacterial_colony_o	nature	Yes	No	No	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	bfo.chemotaxis_tumble_update bfo.selection
Bald Eagle Search	bes	swarm	Yes	Yes	No	bes.candidate_generation bes.selection bes.candidate_search
Barnacles Mating Optimizer	bmo	swarm	Yes	Yes	No	bmo.barnacle_recombination bmo.random_barnacle_drift
Basin Hopping	basin_hopping	trajectory	No	Yes	Yes	basin_hopping.update
Basketball Team Optimization Algorithm	btoa	human	Yes	No	No	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	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	bro.find_nearest_neighbour bro.battle_damage_relocation_update bro.selection
Bees Algorithm	bea	swarm	Yes	Yes	No	bea.elite_site_neighbourhood_search bea.selected_site_neighbourhood_search bea.scout_site_global_search
BFGS Quasi-Newton Method	bfgs	math	No	No	No	bfgs.update
Binary Space Partition Tree Genetic Algorithm	bspga	evolutionary	Yes	Yes	No	bspga.binary_partition_tree_variation_update
Biogeography-Based Optimization	bbo	evolutionary	Yes	Yes	No	bbo.migration_mutation_selection_update
BIPOP-CMA-ES	bipop_cmaes	evolutionary	Yes	Yes	Yes	bipop_cmaes.cmaes_sampling bipop_cmaes.elite_recombination bipop_cmaes.distribution_update bipop_cmaes.step_size_adaptation bipop_cmaes.large_population_restart bipop_cmaes.small_population_restart bipop_cmaes.budget_regime_selection bipop_cmaes.termination_check bipop_cmaes.boundary_repair bipop_cmaes.candidate_injection
Bird Swarm Algorithm	bsa	swarm	Yes	Yes	No	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	bps.long_distance_flight bps.local_tree_movement bps.best_tree_attraction
Black Widow Optimization	bwo	evolutionary	Yes	Yes	No	bwo.crossover bwo.mutation bwo.procreation bwo.candidate_generation bwo.selection
Black-winged Kite Algorithm	bka	swarm	Yes	Yes	No	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	bono.social_guidance_phase bono.exploratory_directional_move
Boxelder Bug Search Optimization	bbso	swarm	Yes	No	No	bbso.coordinated_following_trial bbso.self_following_trial
Brain Storm Optimization	bso	human	Yes	Yes	No	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	bboa.selection bboa.2_sniffing bboa.pedal_marking_update
Butterfly Optimization Algorithm	boa	swarm	Yes	Yes	No	boa.global_fragrance_attraction boa.local_fragrance_random_walk
Camel Algorithm	camel	swarm	Yes	Yes	No	camel.endurance_temperature_update camel.selection
Capuchin Search Algorithm	capsa	swarm	Yes	Yes	No	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	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	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	cg_gwo.selection cg_gwo.elite_local_refinement cg_gwo.leader_guided_population_update
Chameleon Swarm Algorithm	chameleon_sa	swarm	Yes	Yes	No	chameleon_sa.social_pbest_gbest_update chameleon_sa.random_global_exploration
Chaos Game Optimization	cgo	math	Yes	Yes	No	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	chaotic_gwo.selection chaotic_gwo.elite_local_refinement chaotic_gwo.leader_guided_population_update
Cheetah Based Optimization	cddo	swarm	Yes	Yes	No	cddo.cheetah_chase_position_update
Cheetah Optimizer	cdo	swarm	Yes	Yes	No	cdo.alpha_cheetah_attack_component cdo.beta_cheetah_attack_component cdo.gamma_cheetah_attack_component
Chernobyl Disaster Optimizer	cdo_chernobyl	physics	Yes	Yes	No	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	chicken_so.selection chicken_so.chicken_so_semantic_update
Child Drawing Development Optimization Algorithm	cddo_child	human	Yes	Yes	No	cddo_child.child_drawing_development_update
Chimp Optimization Algorithm	choa	swarm	Yes	Yes	No	choa.chimp_hunting_position_update
Chinese Pangolin Optimizer	cpo	swarm	Yes	No	No	cpo.aroma_luring_trial cpo.predation_feeding_trial
Circle-Based Search Algorithm	circle_sa	math	Yes	Yes	No	circle_sa.circle_position_update
Circulatory System Based Optimization	csbo	nature	Yes	Yes	No	csbo.systolic csbo.diastolic
Clonal Selection Algorithm	clonalg	evolutionary	Yes	Yes	No	clonalg.candidate_generation clonalg.selection clonalg.cloning clonalg.hypermutation
Coati Optimization Algorithm	coati_oa	swarm	Yes	Yes	No	coati_oa.candidate_generation coati_oa.selection coati_oa.behavioral_move
Cockroach Swarm Optimization	cockroach_so	swarm	Yes	Yes	No	cockroach_so.dispersal cockroach_so.replacement cockroach_so.state_update
Compact Genetic Algorithm	compact_ga	distribution	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	cso.mean_all_positions
Coot Bird Optimization	coot	swarm	Yes	Yes	No	coot.chain_movement_update
Coral Reefs Optimization	cro	evolutionary	Yes	Yes	No	cro.broadcast_spawning_recombination cro.brooding_clone_mutation cro.depredation_random_reseeding
Coronavirus Herd Immunity Optimization	chio	human	Yes	Yes	No	chio.infected_contact_update chio.susceptible_contact_update chio.immune_contact_update
Cosmic Evolution Optimization	ceo_cosmic	physics	Yes	Yes	No	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	cmaes.offspring_sampling cmaes.parent_selection cmaes.evolution_path_update cmaes.covariance_update cmaes.step_size_update cmaes.boundary_repair cmaes.initialization cmaes.candidate_injection
Coyote Optimization Algorithm	coa	swarm	Yes	Yes	No	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	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	cem.model_sampling_elite_distribution_update
Crow Search Algorithm	csa	swarm	Yes	Yes	No	csa.memory_following_update csa.awareness_random_relocation csa.mixed_memory_random_update
Cuckoo Catfish Optimizer	cco	swarm	Yes	Yes	No	cco.candidate_search cco.selection cco.candidate_generation
Cuckoo Search	cuckoo_s	swarm	Yes	Yes	No	cuckoo_s.levy_flight cuckoo_s.replacement cuckoo_s.candidate_generation cuckoo_s.selection
Cultural Algorithm	ca	evolutionary	Yes	Yes	No	ca.cultural_belief_guided_update
Dandelion Optimizer	do_dandelion	swarm	Yes	Yes	No	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	dso.deep_sleep_decay_update dso.slow_wave_recovery_update
Deer Hunting Optimization Algorithm	doa	human	Yes	Yes	No	doa.hunting doa.search doa.state_update doa.exploitation_move doa.replacement
Delta Plus	dp	math	Yes	No	No	dp.delta_operation
Dhole Optimization Algorithm	dhole_oa	swarm	Yes	No	No	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	jade.candidate_generation jade.selection jade.mutation jade.crossover jade.initialization
Differential Evolution MTS	hde	evolutionary	Yes	Yes	No	hde.candidate_search hde.selection hde.differential_evolution_update
Differential Evolution with Self-Adaptive Populations	sap_de	evolutionary	Yes	No	No	sap_de.selection sap_de.elite_local_refinement sap_de.self_adaptive_parameter_de_update
Differential Evolution	de	evolutionary	Yes	Yes	No	de.mutation de.crossover de.selection de.bound_repair
Dispersive Fly Optimization	dfo	swarm	Yes	Yes	No	dfo.dispersive_fly_neighbour_update dfo.elite_disturbance_update dfo.selection
Diversity enhanced Strategy based Grey Wolf Optimizer	ds_gwo	swarm	Yes	No	No	ds_gwo.selection ds_gwo.elite_local_refinement ds_gwo.leader_guided_population_update
Divine Religions Algorithm	dra	human	Yes	No	No	dra.selection dra.dialectic_interaction_update
Dolphin Echolocation Optimization	deo_dolphin	swarm	Yes	Yes	No	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	da.neighbour_alignment_update da.levy_flight_exploration da.food_enemy_swarm_update
Dream Optimization Algorithm	dream_oa	human	Yes	No	No	dream_oa.dream_generation_refinement_update
Dung Beetle Optimizer	dbo	swarm	Yes	Yes	No	dbo.foraging dbo.selection dbo.state_update dbo.ball_rolling_dance_update
Dwarf Mongoose Optimization Algorithm	dmoa	swarm	Yes	Yes	No	dmoa.selection dmoa.3_baby_sitter_eviction dmoa.scalar_broadcast dmoa.scout_phase
Dynamic Differential Annealed Optimization	ddao	physics	Yes	Yes	No	ddao.exploration ddao.selection ddao.state_update ddao.dynamic_annealed_refinement_update
Dynamic Virtual Bats Algorithm	dvba	swarm	Yes	Yes	No	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	eoa.crossover eoa.state_update eoa.mutation eoa.candidate_generation eoa.selection eoa.reproduction
Ecological Cycle Optimizer	ecological_cycle_o	swarm	Yes	Yes	No	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	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	eel_grouper_o.eel_weighted_hunting_update eel_grouper_o.grouper_weighted_hunting_update
Efficient and Robust Grey Wolf Optimizer	er_gwo	swarm	Yes	No	No	er_gwo.selection er_gwo.elite_local_refinement er_gwo.leader_guided_population_update
Efficient Global Optimization	ego	distribution	Yes	Yes	No	ego.expected_improvement_candidate_generation
Egret Swarm Optimization Algorithm	esoa	swarm	Yes	Yes	No	esoa.behavioral_move esoa.selection esoa.egret_sit_and_wait_update
Electric Charged Particles Optimization	ecpo	physics	Yes	Yes	No	ecpo.electric_charge_random_perturbation
Electric Eel Foraging Optimization	eefo	swarm	Yes	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	eso.electric_storm_field_update
Electromagnetic Field Optimization	efo	physics	Yes	Yes	No	efo.electromagnetic_field_update efo.random_field_reinitialization efo.dimension_reset_mutation
Elephant Herding Optimization	eho	swarm	Yes	Yes	No	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	elk_ho.selection elk_ho.family_mating_position_update
Emperor Penguin Colony	epc	swarm	Yes	Yes	No	epc.spiral_attraction_update epc.thermal_mutation_update
Energy Valley Optimizer	evo	physics	Yes	Yes	No	evo.exploration evo.state_update evo.exploitation
Enhanced Artificial Ecosystem-Based Optimization	enhanced_aeo	nature	Yes	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	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	eao.sinusoidal_best_substrate_update eao.vector_scaled_differential_substrate_update eao.scalar_scaled_differential_substrate_update
Equilibrium Optimizer	eo	physics	Yes	Yes	No	eo.equilibrium_position_update
Escape Algorithm	esc	human	Yes	Yes	No	esc.escape_from_worst_update esc.move_toward_best_update esc.random_exploration_update
Evolution Strategy (Mu + Lambda)	es	evolutionary	Yes	Yes	No	es.parent_survivor es.large_step_mutation_offspring es.small_step_mutation_offspring
Evolutionary Programming	ep	evolutionary	Yes	Yes	No	ep.parent_survivor ep.large_strategy_mutation_offspring ep.small_strategy_mutation_offspring
Expanded Grey Wolf Optimizer	ex_gwo	swarm	Yes	No	No	ex_gwo.selection ex_gwo.elite_local_refinement ex_gwo.leader_guided_population_update
Exponential Distribution Optimizer	edo	math	Yes	Yes	No	edo.distribution_update edo.candidate_generation edo.state_update
Exponential-Trigonometric Optimization	eto	math	Yes	Yes	No	eto.exponential_orbit_update eto.trigonometric_orbit_update
Extra-Trees Bayesian Optimization	et_bo	math	No	No	No	et_bo.extra_trees_surrogate_fit et_bo.random_cutpoint_screening et_bo.acquisition_search et_bo.candidate_evaluation et_bo.incumbent_update
Fast Evolutionary Programming	fep	evolutionary	Yes	Yes	No	fep.fast_mutation_tournament_selection_update
Fata Geophysics Optimizer	fata	physics	Yes	Yes	No	fata.random_refraction_update fata.best_refraction_update fata.peer_refraction_update
Feasibility Rule with Objective Function Information	frofi	evolutionary	Yes	Yes	No	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	ffo.exploration ffo.state_update ffo.exploitation
Fick's Law Algorithm	fla	physics	Yes	Yes	No	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	firefly_a.attraction_dominant_move firefly_a.randomization_dominant_move
Fireworks Algorithm	fwa	swarm	Yes	Yes	No	fwa.selection fwa.state_update
Fish School Search	fss	swarm	Yes	Yes	No	fss.collective_volitive_movement fss.selection
Fitness Dependent Optimizer	fdo	swarm	Yes	Yes	No	fdo.fitness_weighted_pace_update fdo.best_guided_position_update fdo.selection
Fletcher-Reeves Conjugate Gradient	frcg	math	No	No	No	frcg.update
Flood Algorithm	flood_a	physics	Yes	Yes	No	flood_a.flood_flow_direction_update flood_a.flood_recession_refinement_update flood_a.selection
Flow Direction Algorithm	fda	swarm	Yes	Yes	No	fda.downhill_flow_direction_update fda.neighbour_flow_direction_update fda.elite_flow_direction_update
Flower Pollination Algorithm	fpa	swarm	Yes	Yes	No	fpa.global_levy_pollination fpa.local_pollination
Forensic-Based Investigation Optimization	fbio	human	Yes	Yes	No	fbio.candidate_generation fbio.selection fbio.exploration
Forest Optimization Algorithm	foa	swarm	Yes	Yes	No	foa.local_seeding_growth_update foa.selection
Fossa Optimization Algorithm	foa_fossa	swarm	Yes	Yes	No	foa_fossa.prey_pursuit_update foa_fossa.defensive_escape_update
Fox Optimizer	fox	swarm	Yes	Yes	No	fox.prey_jump_exploitation fox.current_to_random_walk_update fox.best_radius_random_walk
Frilled Lizard Optimization	flo	swarm	Yes	Yes	No	flo.update
Fruit-Fly Algorithm	ffa	swarm	Yes	Yes	No	ffa.fruitfly_smell_search_update
Fuzzy Hierarchical Operator - Grey Wolf Optimizer	fuzzy_gwo	swarm	Yes	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	gska.gaining_sharing_knowledge_update
Gaussian Process Bayesian Optimization	gp_bo	math	No	No	No	gp_bo.update
Gazelle Optimization Algorithm	gazelle_oa	swarm	Yes	Yes	No	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	gja.levy_wall_search gja.gaussian_wall_search
Generalized Normal Distribution Optimizer	gndo	math	Yes	Yes	No	gndo.generalized_normal_local_update gndo.difference_vector_global_update
Genetic Algorithm	ga	evolutionary	Yes	Yes	No	ga.candidate_generation ga.selection ga.breed ga.mutate
Genghis Khan Shark Optimizer	gkso	swarm	Yes	Yes	No	gkso.genghis_khan_crossover_exploration gkso.shark_hunting_pso_update
Geometric Mean Optimizer	gmo	math	Yes	Yes	No	gmo.marketing_guidance_update
Germinal Center Optimization	gco	human	Yes	Yes	No	gco.dark_zone_mutation_update
Geyser Inspired Algorithm	gea	physics	Yes	Yes	No	gea.neighbour_geyser_eruption_update gea.pressure_random_eruption_update
Giant Pacific Octopus Optimizer	gpoo	swarm	Yes	Yes	No	gpoo.octopus_tentacle_prey_position_update
Giant Trevally Optimizer	gto	swarm	Yes	Yes	No	gto.candidate_search gto.selection gto.candidate_generation gto.behavioral_move
Glider Snake Optimization	gso_glider_snake	swarm	Yes	No	No	gso_glider_snake.glider_snake_position_update
Glowworm Swarm Optimization	gso	swarm	Yes	Yes	No	gso.glowworm_luciferin_movement_update
Golden Jackal Optimizer	gjo	swarm	Yes	Yes	No	gjo.male_female_exploitation gjo.male_female_exploration
Gradient-Based Optimizer	gbo	math	Yes	Yes	No	gbo.gradient_search_rule_update gbo.local_escaping_operator_update
Gradient-Based Particle Swarm Optimization	gpso	swarm	Yes	Yes	No	gpso.velocity_position_update
Gradient-Boosted Regression Trees Bayesian Optimization	gbrt_bo	math	No	No	No	gbrt_bo.update
Grasshopper Optimization Algorithm	goa	swarm	Yes	Yes	No	goa.grasshopper_social_force_update
Gravitational Search Algorithm	gsa	physics	Yes	Yes	No	gsa.gravitational_force_acceleration_update
Greedy Randomized Adaptive Search Procedure	grasp	trajectory	No	Yes	Yes	grasp.update
Grey Wolf Optimizer	gwo	swarm	Yes	Yes	No	gwo.alpha_guidance gwo.beta_guidance gwo.delta_guidance gwo.position_update
Greylag Goose Optimization	ggo	swarm	Yes	Yes	No	ggo.initialization ggo.dynamic_group_update ggo.exploration_leader_move_eq1 ggo.exploration_paddling_mutation_eq2 ggo.exploration_spiral_move_eq4 ggo.flock_local_search_eq7 ggo.exploitation_sentry_guidance_eq5_6 ggo.elitist_selection ggo.boundary_repair ggo.role_shuffle ggo.stagnation_group_boost ggo.candidate_injection
Growth Optimizer	go_growth	swarm	Yes	Yes	No	go_growth.growth_phase_update go_growth.maturity_phase_update go_growth.selection
Harmony Search Algorithm	hsa	trajectory	Yes	No	No	hsa.harmony_memory_improvisation_update
Harris Hawks Optimization	hho	swarm	Yes	Yes	No	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	hbo.heap_rank_pressure_update
Henry Gas Solubility Optimization	hgso	physics	Yes	Yes	No	hgso.cluster_best_solubility_update hgso.global_best_solubility_update hgso.worst_agent_random_reset
Hiking Optimization Algorithm	hiking_oa	human	Yes	Yes	No	hiking_oa.hiking_slope_velocity_update
Hill Climb Algorithm	hc	trajectory	No	No	No	hc.update
Hippopotamus Optimization Algorithm	ho_hippo	swarm	Yes	Yes	No	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	hba_honey.digging_phase_update hba_honey.honey_phase_update
Horse Herd Optimization Algorithm	horse_oa	swarm	Yes	Yes	No	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	hco.conception_growth_update
Human Evolutionary Optimization Algorithm	heoa	human	Yes	Yes	No	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	nature	Yes	Yes	No	hgs.random_hunger_exploration hgs.hunger_weighted_approach hgs.hunger_weighted_retreat
Hunting Search Algorithm	hus	swarm	Yes	Yes	No	hus.update
Hybrid Bat Algorithm	hba	swarm	Yes	Yes	No	hba.bat_frequency_movement hba.de_local_search
Hybrid Grey Wolf - Whale Optimization Algorithm	gwo_woa	swarm	Yes	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	hi_woa.selection hi_woa.elite_local_refinement hi_woa.whale_position_update
Hybrid Self-Adaptive Bat Algorithm	hsaba	swarm	Yes	Yes	No	hsaba.local_bat_random_walk hsaba.velocity_bat_update hsaba.differential_evolution_refinement
iLSHADE-RSP	ilshade_rsp	evolutionary	Yes	Yes	No	ilshade_rsp.mutation ilshade_rsp.crossover ilshade_rsp.selection ilshade_rsp.archive_update ilshade_rsp.success_history_update ilshade_rsp.population_reduction ilshade_rsp.rank_selective_pressure ilshade_rsp.weighted_pbest_scaling ilshade_rsp.cauchy_target_perturbation
Imperialist Competitive Algorithm	ica	human	Yes	Yes	No	ica.assimilation ica.imperialist_revolution ica.colony_revolution ica.intra_empire_competition
Improved Adaptive Grey Wolf Optimization	iagwo	swarm	Yes	No	No	iagwo.adaptive_alpha_beta_delta_update
Improved Artificial Ecosystem-based Optimization	improved_aeo	nature	Yes	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	iaro.improved_rabbit_global_update iaro.elite_local_refinement iaro.selection
Improved Grey Wolf Optimizer	i_gwo	swarm	Yes	Yes	No	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	ikoa.selection ikoa.assignment_matching_position_update ikoa.improved_matching_refinement_update
Improved L-SHADE	ilshade	evolutionary	Yes	Yes	No	ilshade.current_to_pbest_mutation ilshade.binomial_crossover ilshade.greedy_selection ilshade.external_archive_update ilshade.success_history_update ilshade.linear_population_size_reduction ilshade.pbest_schedule ilshade.fixed_memory_cell ilshade.early_parameter_control ilshade.midpoint_bound_repair
Improved Multi-Operator Differential Evolution	imode	evolutionary	Yes	Yes	No	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	iobl_gwo.selection iobl_gwo.elite_local_refinement iobl_gwo.leader_guided_population_update
Improved Queuing Search Algorithm	improved_qsa	human	Yes	No	No	improved_qsa.selection improved_qsa.queue_business_one_update improved_qsa.queue_business_two_refinement
Improved Teaching-Learning-based Optimization	improved_tlo	human	Yes	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	i_woa.polynomial_breeding_refinement
Incremental model-based Grey Wolf Optimizer	incremental_gwo	swarm	Yes	No	No	incremental_gwo.selection incremental_gwo.elite_local_refinement incremental_gwo.leader_guided_population_update
Invasive Weed Optimization	iwo	nature	Yes	Yes	No	iwo.seed_dispersal_colonization_update
IPOP-CMA-ES	ipop_cmaes	evolutionary	Yes	Yes	Yes	ipop_cmaes.initialization ipop_cmaes.cmaes_sampling ipop_cmaes.elite_recombination ipop_cmaes.distribution_update ipop_cmaes.population_restart ipop_cmaes.boundary_penalty ipop_cmaes.candidate_injection
Iterated Local Search	ils	trajectory	No	Yes	Yes	ils.update
Ivy Algorithm	ivya	nature	Yes	Yes	No	ivya.neighbor_growth_update ivya.best_growth_update
j2020	j2020	evolutionary	Yes	Yes	Yes	j2020.parameter_self_adaptation j2020.big_population_mutation j2020.small_population_mutation j2020.binomial_crossover j2020.bound_repair j2020.crowding_replacement j2020.greedy_selection j2020.best_migration j2020.big_population_restart j2020.small_population_restart j2020.candidate_injection
Jaya Algorithm	jy	math	Yes	Yes	No	jy.best_away_from_worst_update
Jellyfish Search Optimizer	jso	swarm	Yes	Yes	No	jso.ocean_current_swarm_motion_update
jSO Differential Evolution	jso_de	evolutionary	Yes	Yes	No	jso_de.mutation jso_de.weighted_pbest_scaling jso_de.crossover jso_de.selection jso_de.archive_update jso_de.success_history_update jso_de.population_reduction jso_de.bound_resampling
Komodo Mlipir Algorithm	kma	swarm	Yes	Yes	No	kma.update
Krill Herd Algorithm	kha	swarm	Yes	No	No	kha.crossover kha.diffusion kha.mutation kha.selection kha.state_update kha.induced_movement_update
L-SHADE (SHADE with Linear Population Size Reduction)	lshade	evolutionary	Yes	Yes	No	lshade.parameter_sampling lshade.current_to_pbest_mutation lshade.midpoint_bound_repair lshade.binomial_crossover lshade.greedy_selection lshade.external_archive_update lshade.success_history_update lshade.linear_population_size_reduction
L-SRTDE	l_srtde	evolutionary	Yes	No	No	l_srtde.success_rate_f_adaptation l_srtde.success_rate_pbest_control l_srtde.rank_selective_pressure l_srtde.r_new_to_ptop_mutation l_srtde.binomial_crossover l_srtde.bound_resampling l_srtde.selection l_srtde.newest_population_update l_srtde.top_population_update l_srtde.crossover_memory_update l_srtde.linear_population_reduction
Leaf in Wind Optimization	liwo	physics	Yes	Yes	No	liwo.breeze_spiral_translation liwo.strong_wind_displacement
Life Choice-Based Optimizer	lco	human	Yes	Yes	No	lco.life_choice_boundary_reflection_update
Light Spectrum Optimizer	lso_spectrum	physics	Yes	Yes	No	lso_spectrum.light_spectrum_position_update
Linear Subspace Surrogate Modeling Evolutionary Algorithm	l2smea	evolutionary	Yes	Yes	No	l2smea.lhs_initialization l2smea.gaussian_subspace_construction l2smea.linear_subspace_surrogate_fit l2smea.multi_task_candidate_search l2smea.bi_criteria_infill_selection l2smea.expensive_evaluation_archive_update l2smea.gaussian_parameter_update
Lion Optimization Algorithm	loa	swarm	Yes	Yes	No	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	lca.best_cell_replication lca.peer_lateral_invasion lca.angiogenesis_mutation
Love Evolution Algorithm	lea	human	Yes	No	No	lea.reflection_operation lea.value_phase_reflection_operation lea.value_phase_role_phase
LSHADE-cnEpSin	lshade_cnepsin	evolutionary	Yes	Yes	No	lshade_cnepsin.cn_epsin_mutation_crossover_selection
LSHADE-EpSin	lshade_epsin	evolutionary	Yes	Yes	No	lshade_epsin.mutation lshade_epsin.crossover lshade_epsin.selection lshade_epsin.archive_update lshade_epsin.success_history_update lshade_epsin.population_reduction lshade_epsin.sinusoidal_decreasing_f lshade_epsin.sinusoidal_increasing_f lshade_epsin.adaptive_frequency_update lshade_epsin.lshade_second_phase_adaptation lshade_epsin.gaussian_walk_local_search lshade_epsin.bound_repair
LSHADE-RSP	lshade_rsp	evolutionary	Yes	Yes	No	lshade_rsp.mutation lshade_rsp.weighted_pbest_scaling lshade_rsp.crossover lshade_rsp.selection lshade_rsp.archive_update lshade_rsp.success_history_update lshade_rsp.population_reduction lshade_rsp.rank_selective_pressure lshade_rsp.bound_resampling
LSHADE-SPACMA	lshade_spacma	evolutionary	Yes	Yes	No	lshade_spacma.mutation lshade_spacma.crossover lshade_spacma.selection lshade_spacma.archive_update lshade_spacma.success_history_update lshade_spacma.population_reduction lshade_spacma.cma_es_sampling lshade_spacma.cma_es_update lshade_spacma.semi_parameter_adaptation lshade_spacma.fcp_assignment lshade_spacma.fcp_memory_update lshade_spacma.lshade_branch lshade_spacma.cma_branch lshade_spacma.bound_repair
Lungs Performance-Based Optimization	lpo	nature	Yes	Yes	No	lpo.lichen_growth_propagation_update
Lyrebird Optimization Algorithm	loa_lyrebird	swarm	Yes	Yes	No	loa_lyrebird.better_bird_imitation_update loa_lyrebird.escape_step_update
Lévy Flight and Selective Opposition Artificial Rabbit Algorithm	laro	swarm	Yes	No	No	laro.candidate_search laro.selection laro.candidate_generation laro.initialization
Lévy Flight Distribution	lfd	distribution	Yes	Yes	No	lfd.levy_flight_search
Lévy Flight Jaya Algorithm	levy_ja	distribution	Yes	No	No	levy_ja.candidate_search levy_ja.selection levy_ja.candidate_generation levy_ja.initialization
Magnificent Frigatebird Optimization	mfo	swarm	Yes	No	No	mfo.exploration_move mfo.exploitation_move mfo.replacement
Manta Ray Foraging Optimization	mrfo	swarm	Yes	Yes	No	mrfo.chain_foraging mrfo.cyclone_random_foraging mrfo.cyclone_best_foraging mrfo.somersault_foraging
Mantis Shrimp Optimization Algorithm	mshoa	swarm	Yes	Yes	No	mshoa.smasher_attack_update mshoa.spearer_circular_attack_update mshoa.defense_position_update
Marine Predators Algorithm	mpa	swarm	Yes	Yes	No	mpa.brownian_exploration mpa.brownian_transition mpa.levy_transition mpa.levy_exploitation mpa.fads
Market Game Optimization Algorithm	mgoa_market	human	Yes	Yes	No	mgoa_market.market_gradient_position_update
Memetic Algorithm	memetic_a	evolutionary	Yes	Yes	No	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	mso.superior_mirage_search_update mso.inferior_mirage_search_update
mLSHADE-RL (Multi-operator Ensemble LSHADE with Restart and Local Search)	mlshade_rl	evolutionary	Yes	Yes	Yes	mlshade_rl.ms1_current_to_pbest_weight_archive mlshade_rl.ms2_current_to_pbest_no_archive mlshade_rl.ms3_current_to_ordpbest_weight mlshade_rl.crossover mlshade_rl.selection mlshade_rl.strategy_probability_update mlshade_rl.parameter_adaptation mlshade_rl.archive_update mlshade_rl.population_reduction mlshade_rl.restart mlshade_rl.local_search
Modified Artificial Ecosystem-Based Optimization	modified_aeo	nature	Yes	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	modified_eo.selection modified_eo.modified_equilibrium_pool_update modified_eo.modified_local_refinement
Monarch Butterfly Optimization	mbo	swarm	Yes	Yes	No	mbo.monarch_migration_adjusting_update
Monkey King Evolution V1	mke	evolutionary	Yes	Yes	No	mke.king_learning_fluctuation_update mke.peer_knowledge_difference_update
Moss Growth Optimization	moss_go	nature	Yes	Yes	No	moss_go.water_dispersal_growth_update
Most Valuable Player Algorithm	mvpa	human	Yes	Yes	No	mvpa.mvp_guided_player_update
Moth Flame Algorithm	mfa	swarm	Yes	Yes	No	mfa.moth_flame_spiral_update
Moth Search Algorithm	msa_e	swarm	Yes	Yes	No	msa_e.golden_ratio_exploitation_update
Mountain Gazelle Optimizer	mgo	swarm	Yes	Yes	No	mgo.territory_mountain_herding_update
Mountaineering Team-Based Optimization	mtbo	human	Yes	No	No	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	Yes	Yes	msls.update
Multisurrogate-Assisted Ant Colony Optimization	misaco	swarm	Yes	Yes	No	misaco.lhs_initialization misaco.acomv_offspring_generation misaco.rbf_fit_selection misaco.lsbt_fit_selection misaco.random_selection misaco.sqp_rbf_local_search misaco.expensive_candidate_evaluation misaco.archive_update
Multi-Verse Optimizer	mvo	swarm	Yes	Yes	No	mvo.candidate_generation mvo.selection mvo.exploitation_move mvo.replacement
Multifactorial Evolutionary Algorithm I	mfea	evolutionary	Yes	Yes	No	mfea.unified_initialization mfea.factorial_evaluation mfea.factorial_rank_update mfea.skill_factor_assignment mfea.assortative_mating mfea.intratask_sbx_crossover mfea.intertask_sbx_transfer mfea.parent_centric_gaussian_mutation mfea.vertical_cultural_transmission mfea.scalar_fitness_selection mfea.elitist_replacement mfea.boundary_repair mfea.candidate_injection
Multifactorial Evolutionary Algorithm II	mfea2	evolutionary	Yes	Yes	No	mfea2.unified_initialization mfea2.skill_factor_assignment mfea2.scalar_fitness_selection mfea2.univariate_model_building mfea2.online_rmp_matrix_learning mfea2.intratask_sbx_crossover mfea2.intertask_sbx_transfer mfea2.parent_centric_polynomial_mutation mfea2.elitist_scalar_replacement mfea2.boundary_repair mfea2.candidate_injection
Multiple Adaptation Differential Evolution (MadDE)	madde	evolutionary	Yes	Yes	No	madde.parameter_sampling madde.current_to_pbest_archive_mutation madde.current_to_rand_archive_mutation madde.weighted_rand_to_qbest_mutation madde.midpoint_bound_repair madde.binomial_crossover madde.qbest_binomial_crossover madde.greedy_selection madde.external_archive_update madde.success_history_update madde.mutation_probability_adaptation madde.linear_population_size_reduction
Multiple Trajectory Search	mts	trajectory	Yes	Yes	No	mts.multiple_trajectory_local_search_update
Naked Mole-Rat Algorithm	nmra	swarm	Yes	Yes	No	nmra.breeder_exploitation_update nmra.worker_exploration_update
Narwhal Optimizer	nwoa	swarm	Yes	Yes	No	nwoa.exploration_move nwoa.exploitation_move nwoa.replacement
Nelder-Mead Method	nmm	trajectory	Yes	Yes	No	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	nndrea_so.nn_weight_de_stage nndrea_so.solution_de_stage
New Caledonian Crow Learning Algorithm	nccla	swarm	Yes	No	No	nccla.vertical_social_learning nccla.horizontal_social_learning nccla.individual_learning nccla.juvenile_reinforcement nccla.parent_reinforcement nccla.parent_selection
Nizar Optimization Algorithm	noa	math	Yes	Yes	No	noa.newton_position_update
NL-SHADE-LBC	nlshade_lbc	evolutionary	Yes	Yes	No	nlshade_lbc.mutation nlshade_lbc.crossover nlshade_lbc.selection nlshade_lbc.archive_update nlshade_lbc.success_history_update nlshade_lbc.population_reduction nlshade_lbc.rank_selective_pressure nlshade_lbc.linear_bias_change nlshade_lbc.bound_resampling nlshade_lbc.crossover_rate_sorting
NL-SHADE-RSP-Midpoint	nlshade_rsp_midpoint	evolutionary	Yes	Yes	Yes	nlshade_rsp_midpoint.mutation nlshade_rsp_midpoint.crossover_binomial nlshade_rsp_midpoint.crossover_exponential nlshade_rsp_midpoint.crossover_rate_sorting nlshade_rsp_midpoint.selection nlshade_rsp_midpoint.archive_update nlshade_rsp_midpoint.adaptive_archive_probability nlshade_rsp_midpoint.success_history_update nlshade_rsp_midpoint.nonlinear_population_reduction nlshade_rsp_midpoint.rank_selective_pressure nlshade_rsp_midpoint.bound_resampling nlshade_rsp_midpoint.bound_random_repair_fallback nlshade_rsp_midpoint.midpoint_evaluation nlshade_rsp_midpoint.midpoint_replacement nlshade_rsp_midpoint.kmeans_midpoint nlshade_rsp_midpoint.midpoint_restart nlshade_rsp_midpoint.bounds_restart nlshade_rsp_midpoint.restart
NL-SHADE-RSP	nlshade_rsp	evolutionary	Yes	Yes	No	nlshade_rsp.mutation nlshade_rsp.crossover_binomial nlshade_rsp.crossover_exponential nlshade_rsp.crossover_rate_sorting nlshade_rsp.selection nlshade_rsp.archive_update nlshade_rsp.adaptive_archive_probability nlshade_rsp.success_history_update nlshade_rsp.nonlinear_population_reduction nlshade_rsp.rank_selective_pressure nlshade_rsp.bound_random_repair
NLAPSMjSO-EDA	nlapsmjso_eda	evolutionary	Yes	No	No	nlapsmjso_eda.sampling nlapsmjso_eda.selection nlapsmjso_eda.state_update nlapsmjso_eda.non_linear_population_analysis_update
Northern Goshawk Optimization	ngo	swarm	Yes	Yes	No	ngo.phase_one_update ngo.pursuit_exploitation_update ngo.selection
Nuclear Reaction Optimization	nro	physics	Yes	Yes	No	nro.nuclear_fission_update nro.nuclear_fusion_update nro.selection
Numeric Crunch Algorithm	nca	math	Yes	Yes	No	nca.acceleration_hyperbolic_contraction_random_subset_components
Opposition-based Coral Reefs Optimization	ocro	evolutionary	Yes	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	ogwo.selection ogwo.elite_local_refinement ogwo.leader_guided_population_update
Optimal Foraging Algorithm	ofa	swarm	Yes	Yes	No	ofa.owl_neighbour_flight_update
Osprey Optimization Algorithm	ooa	swarm	Yes	Yes	No	ooa.hunting ooa.search ooa.selection ooa.state_update ooa.fish_carrying_local_update
Parameter-Free Bat Algorithm	plba	swarm	Yes	Yes	No	plba.path_looping_bat_update
Parent-Centric Crossover (G3-PCX style)	pcx	evolutionary	Yes	Yes	No	pcx.parent_centric_crossover_update
Pareto Sequential Sampling	pss	math	Yes	Yes	No	pss.prominent_domain_sampling_update pss.full_domain_sampling_update pss.mixed_domain_sampling_update
Parrot Optimizer	parrot_o	swarm	Yes	Yes	No	parrot_o.flight_area_search_update
Particle Swarm Optimization	pso	swarm	Yes	Yes	No	pso.inertia_velocity_update pso.cognitive_memory_update pso.social_global_update
Pathfinder Algorithm	pfa	swarm	Yes	Yes	No	pfa.pathfinder_position_update
Pelican Optimization Algorithm	poa	swarm	Yes	Yes	No	poa.prey_pursuit_update poa.water_surface_winging_update
Philoponella prominens Optimizer	ppo	swarm	Yes	No	No	ppo.escape_sexual_cannibalism_juvenile_generation ppo.escape_predation_local_search
Physical Education Teacher Inspired Optimization	petio	human	Yes	Yes	No	petio.performance_evaluation_teaching_update
Pied Kingfisher Optimizer	pko	swarm	Yes	Yes	No	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	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	plo.aurora_global_local_update plo.polar_light_collision_update
Political Optimizer	political_o	human	Yes	Yes	No	political_o.candidate_generation political_o.selection political_o.parliamentary
Poor and Rich Optimization Algorithm	pro	human	Yes	Yes	No	pro.learning pro.state_update pro.candidate_generation pro.selection
Population-Based Incremental Learning	pbil	distribution	No	No	No	pbil.update
Prairie Dog Optimization Algorithm	pdo	swarm	Yes	Yes	No	pdo.prairie_dog_burrow_alarm_update
Puma Optimizer	puma_o	swarm	Yes	Yes	No	puma_o.update
Python Snake Optimization Algorithm (PySOA)	pysoa	swarm	Yes	Yes	No	pysoa.searching_for_prey pysoa.attacking_prey pysoa.random_agent_redirection pysoa.sensory_scanning pysoa.temperature_cooling
QLE Sine Cosine Algorithm	qle_sca	math	Yes	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	qio.three_point_quadratic_interpolation qio.two_point_reflection_interpolation
Queuing Search Algorithm	qsa	human	Yes	Yes	No	qsa.business1 qsa.business2 qsa.business3
Rain-Cloud Condensation Optimizer	rcco	physics	Yes	No	No	rcco.rain_cloud_convection_update rcco.cloud_collision_local_update rcco.selection
Random Forest Bayesian Optimization	rf_bo	math	No	No	No	rf_bo.update
Random Search	random_s	trajectory	Yes	Yes	No	random_s.random_sampling_update
Rat Swarm Optimizer	rso	swarm	Yes	Yes	No	rso.long_chasing_update rso.short_chasing_update
RDEx-SOP	rdex_sop	evolutionary	Yes	Yes	No	rdex_sop.standard_branch_mutation rdex_sop.exploitation_biased_mutation rdex_sop.binomial_crossover rdex_sop.cauchy_local_perturbation rdex_sop.greedy_selection rdex_sop.dynamic_pbest_selection rdex_sop.hybrid_rate_update rdex_sop.success_history_update rdex_sop.linear_population_reduction rdex_sop.bound_resampling
Reconstructed Differential Evolution	rde	evolutionary	Yes	Yes	No	rde.mutation_current_to_pbest rde.mutation_current_to_order_pbest rde.strategy_resource_allocation rde.extended_rank_selective_pressure rde.crossover rde.cauchy_target_perturbation rde.selection rde.archive_update rde.success_history_update rde.linear_population_reduction rde.bound_repair
Red-billed Blue Magpie Optimizer	rbmo	swarm	Yes	Yes	No	rbmo.update
Remora Optimization Algorithm	roa	swarm	Yes	Yes	No	roa.remora_attempt_update
Reptile Search Algorithm	rsa	swarm	Yes	Yes	No	rsa.reptile_hunting_encircling_update
RIME-ice Algorithm	rime	physics	Yes	Yes	No	rime.hard_rime_puncture_update
RMSProp	rmsprop	math	No	No	No	rmsprop.candidate_generation rmsprop.selection rmsprop.search_direction rmsprop.step_acceptance rmsprop.initialization
Rock Hyraxes Swarm Optimization	rhso	swarm	Yes	Yes	No	rhso.rhinoceros_herd_position_update
RRT-based Optimizer	rrto	swarm	Yes	No	No	rrto.adaptive_step_size_wandering rrto.absolute_difference_step rrto.boundary_based_step
RUNge Kutta Optimizer	run	math	Yes	Yes	No	run.selection run.enhanced_solution_quality_update run.runge_kutta_position_update
Rüppell's Fox Optimizer	rfo	swarm	Yes	Yes	No	rfo.red_fox_smell_search_update
Sailfish Optimizer	sfo	swarm	Yes	Yes	No	sfo.behavioral_move sfo.selection
Salp Swarm Algorithm	ssa	swarm	Yes	Yes	No	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	sade_sammon.sammon_surrogate_de_selection_update
Sand Cat Swarm Optimization	scso	swarm	Yes	Yes	No	scso.exploration_move scso.replacement scso.selection scso.exploitation_move scso.candidate_generation
Satin Bowerbird Optimizer	sbo	swarm	Yes	Yes	No	sbo.bowerbird_mutation_update
Sea Lion Optimization	slo	swarm	Yes	Yes	No	slo.best_encircling_update slo.random_peer_encircling_update slo.spiral_attack_update
Seagull Optimization Algorithm	soa	swarm	Yes	Yes	No	soa.seagull_spiral_attack_update
Seahorse Optimizer	seaho	swarm	Yes	Yes	No	seaho.candidate_generation seaho.selection seaho.recombination
Search And Rescue Optimization	saro	human	Yes	Yes	No	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	ssio_rl.update
Secant Optimization Algorithm	secant_oa	math	Yes	Yes	No	secant_oa.secant_update secant_oa.stochastic_exploitation secant_oa.mutation_gate secant_oa.selection
Secretary Bird Optimization Algorithm	sboa	swarm	Yes	Yes	No	sboa.update
Self-Adaptive Bat Algorithm	saba	swarm	Yes	Yes	No	saba.self_adaptive_bat_update
Self-Adaptive Differential Evolution	sade	evolutionary	Yes	No	No	sade.selection sade.adaptive_strategy_de_update sade.elite_local_refinement
Self-Adaptive Differential Evolution	jde	evolutionary	Yes	Yes	No	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	sqp.update
Serval Optimization Algorithm	serval_oa	swarm	Yes	Yes	No	serval_oa.hunting serval_oa.selection serval_oa.state_update
Shuffle-based Runner-Root Algorithm	srsr	swarm	Yes	Yes	No	srsr.exploration srsr.selection srsr.1_accumulation_new_positions_via_gaussian
Siberian Tiger Optimization	sto	swarm	Yes	Yes	No	sto.prey_hunting_update sto.range_reduction_update
Simple Optimization Algorithm	sopt	distribution	Yes	Yes	No	sopt.statistical_population_selection_update
Simulated Annealing	sa	trajectory	No	Yes	Yes	sa.update
Sine Cosine Algorithm	sine_cosine_a	math	Yes	Yes	No	sine_cosine_a.sine_position_update sine_cosine_a.cosine_position_update
Singer Optimization Algorithm	singer_oa	human	Yes	Yes	No	singer_oa.imitation_mimicry_phase singer_oa.creation_perturbation_phase
Sinh Cosh Optimizer	scho	math	Yes	Yes	No	scho.scholar_chess_position_update
Slime Mould Algorithm	sma	nature	Yes	Yes	No	sma.random_dispersion_update sma.best_weighted_oscillation_update sma.contracting_vibration_update
Snake Optimizer	so_snake	swarm	Yes	Yes	No	so_snake.male_snake_update so_snake.female_snake_update so_snake.selection
Snow Ablation Optimizer	snow_oa	physics	Yes	Yes	No	snow_oa.exploration_group_update snow_oa.development_group_update
Social Ski-Driver Optimization	ssdo	human	Yes	Yes	No	ssdo.sine_velocity_update ssdo.cosine_velocity_update
Social Spider Algorithm	sspider_a	swarm	Yes	Yes	No	sspider_a.social_spider_vibration_update
Social Spider Swarm Optimizer	sso	swarm	Yes	Yes	No	sso.female_spider_position_update sso.male_spider_position_update
Sparrow Search Algorithm	sparrow_sa	swarm	Yes	Yes	No	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	smo.local_leader_phase smo.global_leader_phase smo.local_leader_decision
Spotted Hyena Inspired Optimizer	shio	swarm	Yes	Yes	No	shio.first_iguana_guidance shio.second_iguana_guidance shio.third_iguana_guidance
Spotted Hyena Optimizer	sho	swarm	Yes	Yes	No	sho.spotted_hyena_hunting_update
Squirrel Search Algorithm	squirrel_sa	swarm	Yes	Yes	No	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	sfoa.foraging sfoa.state_update sfoa.exploitation_move sfoa.replacement sfoa.exploration
Steepest Descent	sd	math	No	No	No	sd.candidate_generation sd.selection sd.search_direction sd.step_acceptance sd.initialization
Stellar Oscillator Optimization	soo	physics	Yes	Yes	No	soo.selection soo.1_oscillatory_position soo.2_top_3_average_oscillatory
Student Psychology Based Optimization	spbo	human	Yes	Yes	No	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	shade.success_history_mutation_crossover_selection
Success-History Intelligent Optimizer	shio_success	swarm	Yes	Yes	No	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	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	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	sacc_eam2.even_subcomponent_de_update sacc_eam2.odd_subcomponent_de_update
Surrogate-Assisted Cooperative Swarm Optimization	sacoso	swarm	Yes	Yes	No	sacoso.cognitive_swarm_update sacoso.social_swarm_update
Surrogate-Assisted DE with Adaptive Multi-Subspace Search	sade_amss	evolutionary	Yes	Yes	No	sade_amss.lhs_initialization sade_amss.adaptive_strategy_switch sade_amss.random_original_subspace_construction sade_amss.pca_mapping_subspace_construction sade_amss.cubic_rbf_fit_predict sade_amss.de_best_1_binomial sade_amss.bound_repair sade_amss.exact_evaluation_archive_update
Surrogate-Assisted DE with Adaptive Training Data Selection Criterion	sade_atdsc	evolutionary	Yes	Yes	No	sade_atdsc.adaptive_trial_distribution_selection_update
Surrogate-Assisted Multiswarm Optimization	samso	swarm	Yes	Yes	No	samso.lhs_initialization samso.rbf_model_fit samso.rbf_optimum_infill samso.s_swarm_pso_update samso.l_swarm_tlbo_learner_update samso.prescreen_exact_evaluation samso.archive_update
Surrogate-Assisted Partial Optimization	sapo	evolutionary	Yes	Yes	No	sapo.lhs_initialization sapo.partial_selection_f_g_to_g sapo.partial_selection_g_to_f sapo.de_rand_1_binomial sapo.de_best_1_binomial sapo.reflection_bound_repair sapo.cubic_rbf_fit_predict sapo.feasibility_rule_selection sapo.expensive_evaluation_archive_update
Swarm Robotics Search And Rescue	srsr_robotics	swarm	Yes	No	No	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	sos.candidate_generation sos.selection sos.mutualism sos.comensalism sos.parasitism
Tabu Search	ts	trajectory	No	No	No	ts.update
Tasmanian Devil Optimization	tdo	swarm	Yes	Yes	No	tdo.exploration tdo.state_update tdo.hunting tdo.exploitation
Teaching Learning Based Optimization	tlbo	human	Yes	Yes	No	tlbo.teacher_phase tlbo.learner_phase
Teamwork Optimization Algorithm	toa	human	Yes	Yes	No	toa.stage_1_supervisor_guidance toa.learning toa.state_update toa.candidate_generation toa.selection
Termite Life Cycle Optimizer	tlco	swarm	Yes	Yes	No	tlco.teacher_phase_update tlco.learner_phase_update tlco.selection
Tianji Horse Racing Optimizer	thro	human	Yes	Yes	No	thro.initialization thro.competition_scenario_1_slowest_vs_slowest thro.competition_scenario_2_slowest_vs_fastest thro.competition_scenario_3_fastest_vs_fastest thro.competition_scenario_4_slowest_vs_fastest thro.competition_scenario_5_tie_slowest_vs_fastest thro.training_random_peer_difference thro.training_fastest_guidance thro.greedy_selection thro.random_bound_repair thro.candidate_injection
Tornado Optimizer with Coriolis Force	toc	physics	Yes	Yes	No	toc.fitness_proportional_assignment toc.coriolis_velocity_update toc.windstorm_to_tornado_evolution toc.windstorm_to_thunderstorm_evolution toc.thunderstorm_to_tornado_evolution toc.random_windstorm_formation toc.role_exchange_replacement
Tree Physiology Optimization	tpo	nature	Yes	Yes	No	tpo.carbon_nutrient_leaf_update
Tree-Seed Algorithm	tree_seed_a	nature	Yes	No	No	tree_seed_a.toward_best_seed tree_seed_a.away_random_seed
Triangulation Topology Aggregation Optimizer	ttao	math	Yes	Yes	No	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	two.tug_of_war_weight_force_update
Tuna Swarm Optimization	tso	swarm	Yes	Yes	No	tso.leader_spiral_update tso.random_migration_update tso.spiral_following_update tso.parabolic_foraging_update
Tunicate Swarm Algorithm	tsa	swarm	Yes	Yes	No	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	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	Yes	Yes	vns.update
Virus Colony Search	vcs	swarm	Yes	Yes	No	vcs.virus_diffusion vcs.host_cell_infection vcs.immune_response
Walrus Optimization Algorithm	waoa	swarm	Yes	Yes	No	waoa.feeding_exploration_update waoa.range_narrowing_exploitation
War Strategy Optimization	warso	human	Yes	Yes	No	warso.attack_strategy_update warso.defense_strategy_update
Water Cycle Algorithm	wca	nature	Yes	Yes	No	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	wutp.horizontal_water_transport_update
Wave Optimization Algorithm	wo_wave	physics	Yes	Yes	No	wo_wave.wave_propagation_position_update
Wavelet Mutation and Quadratic Interpolation MRFO	wmqimrfo	swarm	Yes	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	info.best_weighted_mean_rule info.random_weighted_mean_rule
Whale Fruit-fly Optimization Algorithm	whale_foa	swarm	Yes	No	No	whale_foa.selection whale_foa.elite_local_refinement whale_foa.whale_position_update
Whale Optimization Algorithm	woa	swarm	Yes	Yes	No	woa.search_for_prey woa.encircling_prey woa.spiral_bubble_net
White Shark Optimizer	wso	swarm	Yes	Yes	No	wso.white_shark_swarm_position_update
Wildebeest Herd Optimization	who	swarm	Yes	Yes	No	who.selection who.1_local_movement_milling who.2_herd_instinct who.social_memory
Wind Driven Optimization	wdo	physics	Yes	Yes	No	wdo.wind_velocity_position_update
Wolverine Optimization Algorithm	wooa	swarm	Yes	Yes	No	wooa.scavenging_predator_following wooa.prey_attack_update wooa.fight_chase_local_update
Young's Double-Slit Experiment Optimizer	ydse	physics	Yes	Yes	No	ydse.central_bright_fringe_update ydse.bright_fringe_interference_update ydse.dark_fringe_interference_update
Yukthi Opus	yo	trajectory	Yes	No	No	yo.mcmc_burn_in yo.post_burnin_selection yo.mcmc_proposal yo.greedy_refinement yo.simulated_annealing_acceptance yo.blacklist_filter yo.adaptive_reheating yo.elite_update
Zebra Optimization Algorithm	zoa	swarm	Yes	Yes	No	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(x1, x2) = 0.3978873577; (x1, x2) = (-π, 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(x1, x2) ≈ -2.0626118708; (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(x1, x2) ≈ -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(x1, x2) = 0; (x1, x2) = (3, 2); (-2.805118, 3.131312); (-3.779310, -3.283186); (3.584428, -1.848126)
Hölder Table	holder_table	[-10, 10]2	f(x1, x2) ≈ -19.208502568; (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(x1, x2) ≈ -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(x1, x2) ≈ 0.292578632; (x1, x2) = (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(x1, x2) ≈ -1.031628453; (x1, x2) = (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(x) ≈ -(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(x) = 25 - 6D; xi ∈ [-5.12, -5) [N8]
Styblinski-Tang	styblinski_tang	[-5, 5]D	f(x) ≈ -39.166165704D; xi ≈ -2.903534028
Trid	trid	[-D2, D2]D	f(x) = -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	[-100, 100]D, D = 2, 10, 20	f(x) = 300
CEC 2022 F2	cec_2022_f02	[-100, 100]D, D = 2, 10, 20	f(x) = 400
CEC 2022 F3	cec_2022_f03	[-100, 100]D, D = 2, 10, 20	f(x) = 600
CEC 2022 F4	cec_2022_f04	[-100, 100]D, D = 2, 10, 20	f(x) = 800
CEC 2022 F5	cec_2022_f05	[-100, 100]D, D = 2, 10, 20	f(x) = 900
CEC 2022 F6	cec_2022_f06	[-100, 100]D, D = 10, 20	f(x) = 1800
CEC 2022 F7	cec_2022_f07	[-100, 100]D, D = 10, 20	f(x) = 2000
CEC 2022 F8	cec_2022_f08	[-100, 100]D, D = 10, 20	f(x) = 2200
CEC 2022 F9	cec_2022_f09	[-100, 100]D, D = 2, 10, 20	f(x) = 2300
CEC 2022 F10	cec_2022_f10	[-100, 100]D, D = 2, 10, 20	f(x) = 2400
CEC 2022 F11	cec_2022_f11	[-100, 100]D, D = 2, 10, 20	f(x) = 2600
CEC 2022 F12	cec_2022_f12	[-100, 100]D, D = 2, 10, 20	f(x) = 2700

BBOB Functions

The 24 noiseless BBOB functions are deterministic instance-based benchmarks. Use get_bbob_function(function_id, dimension, instance) to retrieve a callable function and get_bbob_optimum(function_id, dimension, instance) to retrieve the corresponding shifted optimizer and optimum value.

Function	ID	Domain	Global Minimum
BBOB F01: Sphere	bbob_f01	[-5, 5]D, D ≥ 2	get_bbob_optimum(1, dimension, instance)
BBOB F02: Ellipsoidal	bbob_f02	[-5, 5]D, D ≥ 2	get_bbob_optimum(2, dimension, instance)
BBOB F03: Rastrigin	bbob_f03	[-5, 5]D, D ≥ 2	get_bbob_optimum(3, dimension, instance)
BBOB F04: Bueche-Rastrigin	bbob_f04	[-5, 5]D, D ≥ 2	get_bbob_optimum(4, dimension, instance)
BBOB F05: Linear Slope	bbob_f05	[-5, 5]D, D ≥ 2	get_bbob_optimum(5, dimension, instance)
BBOB F06: Attractive Sector	bbob_f06	[-5, 5]D, D ≥ 2	get_bbob_optimum(6, dimension, instance)
BBOB F07: Step Ellipsoidal	bbob_f07	[-5, 5]D, D ≥ 2	get_bbob_optimum(7, dimension, instance)
BBOB F08: Rosenbrock	bbob_f08	[-5, 5]D, D ≥ 2	get_bbob_optimum(8, dimension, instance)
BBOB F09: Rosenbrock Rotated	bbob_f09	[-5, 5]D, D ≥ 2	get_bbob_optimum(9, dimension, instance)
BBOB F10: Ellipsoidal Rotated	bbob_f10	[-5, 5]D, D ≥ 2	get_bbob_optimum(10, dimension, instance)
BBOB F11: Discus	bbob_f11	[-5, 5]D, D ≥ 2	get_bbob_optimum(11, dimension, instance)
BBOB F12: Bent Cigar	bbob_f12	[-5, 5]D, D ≥ 2	get_bbob_optimum(12, dimension, instance)
BBOB F13: Sharp Ridge	bbob_f13	[-5, 5]D, D ≥ 2	get_bbob_optimum(13, dimension, instance)
BBOB F14: Different Powers	bbob_f14	[-5, 5]D, D ≥ 2	get_bbob_optimum(14, dimension, instance)
BBOB F15: Rastrigin Rotated	bbob_f15	[-5, 5]D, D ≥ 2	get_bbob_optimum(15, dimension, instance)
BBOB F16: Weierstrass	bbob_f16	[-5, 5]D, D ≥ 2	get_bbob_optimum(16, dimension, instance)
BBOB F17: Schaffers F7, condition 10	bbob_f17	[-5, 5]D, D ≥ 2	get_bbob_optimum(17, dimension, instance)
BBOB F18: Schaffers F7, condition 1000	bbob_f18	[-5, 5]D, D ≥ 2	get_bbob_optimum(18, dimension, instance)
BBOB F19: Griewank-Rosenbrock	bbob_f19	[-5, 5]D, D ≥ 2	get_bbob_optimum(19, dimension, instance)
BBOB F20: Schwefel	bbob_f20	[-5, 5]D, D ≥ 2	get_bbob_optimum(20, dimension, instance)
BBOB F21: Gallagher 101 Peaks	bbob_f21	[-5, 5]D, D ≥ 2	get_bbob_optimum(21, dimension, instance)
BBOB F22: Gallagher 21 Peaks	bbob_f22	[-5, 5]D, D ≥ 2	get_bbob_optimum(22, dimension, instance)
BBOB F23: Katsuura	bbob_f23	[-5, 5]D, D ≥ 2	get_bbob_optimum(23, dimension, instance)
BBOB F24: Lunacek bi-Rastrigin	bbob_f24	[-5, 5]D, D ≥ 2	get_bbob_optimum(24, dimension, instance)

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. [N9]

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

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	Gear train is a discrete integer benchmark. The implementation rounds variables to the nearest integer tooth counts by default.
N11	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.

---

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)