pymetaheuristic 7.0.0

pymetaheuristic: A Python Library for Metaheuristic Optimization and Collaborative Search

pymetaheuristic

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

A. Version Note

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

pip install pymetaheuristic

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

pip install pymetaheuristic==1.9.5

B. pymetaheuristic Lab

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

import pymetaheuristic

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

# Terminate the web service using:
pymetaheuristic.web.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 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] ---
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
• cooperative multi-island optimization through cooperative_optimize
• clean object-based island systems through IslandSystem, Island, TopologyConfig, and MigrationConfig
• adaptive orchestration through fixed, rule-based, bandit, and portfolio-adaptive controllers
• island diagnostics, including migration matrices, contribution tables, island roles, action effectiveness, and topology summaries
• built-in constrained optimization support plus named repair strategies (clip, wang, reflect, rand, limit_inverse)
• composable Termination object with four independent stopping conditions
• automatic per-step diversity and exploration/exploitation tracking in history
• plotly-based diversity, convergence, runtime, and explore/exploit charts, including evaluation-indexed convergence plots
• typed variable space (FloatVar, IntegerVar, CategoricalVar, PermutationVar, BinaryVar)
• ten chaotic maps plus lhs, obl, and sobol population initialization presets
• eight transfer functions and BinaryAdapter for binary/discrete optimization
• HyperparameterTuner for grid/random hyperparameter search
• BenchmarkRunner for lightweight multi-algorithm × multi-problem sweeps
• BenchmarkStudy for scientific benchmarking of algorithms, island systems, and orchestration controllers, with rank tables, statistical tests, convergence plots, ECDFs, performance profiles, and result persistence
• save_result, load_result, save_checkpoint, load_checkpoint for persistence
• callback system with lifecycle hooks and callback-driven early stopping
• object-based Problem API with parametrized bounds, latex_code(), and curated test-problem wrappers
• reusable levy_flight() utility and human-readable algorithm.info() metadata

---

2. Installation and Package Overview

---

2.1 Installation

Standard installation:

pip install pymetaheuristic

---

2.2 Package Overview

Back to Summary

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

To quickly inspect parameters:

import pymetaheuristic

# List
pymetaheuristic.print_root_exports()

# Detail
pymetaheuristic.print_reference("optimize")

---

2.3 Optimization, Telemetry, Export, and Plotting Example

Back to Summary

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

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

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

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

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

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

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

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

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

---

2.4 Termination Criteria

Back to Summary

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

Four independent condition types are supported:

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

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

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

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

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

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

---

2.5 Constraint Handling Example

Back to Summary

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

• Click Here for the Full Google Colab Example

import pymetaheuristic 

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

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

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

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

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

Other constraints examples:

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

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

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

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

constraints = [c1, c2, c3]

---

2.6 Cooperative Multi-island Example

Back to Summary

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

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

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

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

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

---

2.7 Orchestrated Cooperation Example

Back to Summary

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

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic  

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

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

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

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

---

2.8 Island System Unified Interface

Back to Summary

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

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

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

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

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

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

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

import pandas as pd

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

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

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

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

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

Diagnostic plots are also available:

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

---

2.9 Adaptive Orchestration Policies

Back to Summary

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

import numpy as np
import pymetaheuristic

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


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 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"))

---

2.11 Hyperparameter Tuner

Back to Summary

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

• Click Here for the Full Google Colab Example

import numpy as np
import pymetaheuristic

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

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

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

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

---

2.12 Save, Load, and Checkpoint

Back to Summary

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

• Click Here for the Full Google Colab Example

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

import numpy as np
import pymetaheuristic

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

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

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

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

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

state = engine.initialize()

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

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

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

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

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

---

2.13 Benchmark Runner

Back to Summary

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

• Click Here for the Full Google Colab Example

import pandas as pd
import pymetaheuristic

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

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

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

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

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

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

---

2.14 Benchmark Study

Back to Summary

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

• Click Here for the Full Google Colab Example

import pymetaheuristic

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

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

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

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

benchmark_result = study.run()

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

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

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

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

Benchmark plots:

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

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

---

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_iinfo   = 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"])

Algorithm ID:   pso
Algorithm Name: Particle Swarm Optimization

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

The table below summarizes the optimization engines currently available in the library. The Algorithm column reports the conventional algorithm name, ID gives the identifier used in the codebase, Family provides a coarse methodological grouping, Population indicates whether the algorithm maintains an explicit candidate population, Candidate Injection indicates whether the algorithm is currently marked as able to absorb external candidates during cooperative or orchestrated workflows, Restart shows whether native restart support is declared, and Snapshot Fit provides a practical recommendation for using store_population_snapshots in the current implementation. Click the algorithm name to open its primary reference or original source. All algorithms support checkpointing through the library framework, and all constraint handling is available through the framework-level constraint machinery.

---

Algorithm	ID	Family	Population	Candidate Injection	Restart	Snapshot Fit
Adam (Adaptive Moment Estimation)	adam	math	No	No	No	No
Adaptive Chaotic Grey Wolf Optimizer	acgwo	swarm	Yes	Yes	No	Yes

🔍 View complete Metaheuristic reference table

Algorithm	ID	Family	Population	Candidate Injection	Restart	Snapshot Fit
Adam (Adaptive Moment Estimation)	adam	math	No	No	No	No
Adaptive Aquila Optimizer	aao	swarm	Yes	No	No	No
Adaptive Chaotic Grey Wolf Optimizer	acgwo	swarm	Yes	Yes	No	Yes
Adaptive Equilibrium Optimization	adaptive_eo	physics	Yes	No	No	No
Adaptive Exploration State-Space Particle Swarm Optimization	aesspso	swarm	Yes	Yes	No	Yes
Adaptive Inertia Weight Particle Swarm Optimization	aiw_pso	swarm	Yes	No	No	No
Adaptive Random Search	ars	trajectory	Yes	Yes	No	Yes
African Vultures Optimization Algorithm	avoa	swarm	Yes	Yes	No	Yes
Ali Baba and the Forty Thieves	aft	human	Yes	Yes	No	Yes
Anarchic Society Optimization	aso	swarm	Yes	Yes	No	Yes
Animated Oat Optimization Algorithm	aoo	swarm	Yes	No	No	No
Ant Colony Optimization (Continuous)	acor	swarm	Yes	Yes	No	Yes
Ant Colony Optimization	aco	swarm	Yes	No	No	Yes
Ant Lion Optimizer	alo	swarm	Yes	Yes	No	Yes
Aquila Optimizer	ao	swarm	Yes	Yes	No	Yes
Archerfish Hunting Optimizer	aho	swarm	Yes	Yes	No	Yes
Archimedes Optimization Algorithm	arch_oa	physics	Yes	Yes	No	Yes
Arithmetic Optimization Algorithm	aoa	swarm	Yes	Yes	No	Yes
Artemisinin Optimization	artemisinin_o	nature	Yes	Yes	No	Yes
Artificial Algae Algorithm	aaa	swarm	Yes	No	Yes	Yes
Artificial Bee Colony Optimization	abco	swarm	Yes	Yes	No	Yes
Artificial Ecosystem Optimization	aeo	human	Yes	Yes	No	Yes
Artificial Electric Field Algorithm	aefa	physics	Yes	Yes	No	Yes
Artificial Fish Swarm Algorithm	afsa	swarm	Yes	Yes	No	Yes
Artificial Gorilla Troops Optimizer	agto	swarm	Yes	Yes	No	Yes
Artificial Hummingbird Algorithm	aha	swarm	Yes	Yes	No	Yes
Artificial Lemming Algorithm	ala	swarm	Yes	Yes	No	Yes
Artificial Protozoa Optimizer	apo	swarm	Yes	Yes	No	Yes
Artificial Rabbits Optimization	aro	swarm	Yes	Yes	No	Yes
Atom Search Optimization	aso_atom	physics	Yes	Yes	No	Yes
Automated Design of Variation Operators	autov	evolutionary	Yes	Yes	No	Yes
BFGS Quasi-Newton Method	bfgs	math	No	No	No	No
BIPOP-CMA-ES	bipop_cmaes	evolutionary	Yes	No	Yes	Yes
Bacterial Chemotaxis Optimizer	bco	nature	Yes	Yes	No	Yes
Bacterial Colony Optimization	bacterial_colony_o	nature	Yes	No	No	Yes
Bacterial Foraging Optimization	bfo	swarm	Yes	Yes	No	Yes
Bald Eagle Search	bes	swarm	Yes	Yes	No	Yes
Barnacles Mating Optimizer	bmo	swarm	Yes	Yes	No	Yes
Basin Hopping	basin_hopping	trajectory	No	No	Yes	No
Basketball Team Optimization Algorithm	btoa	human	Yes	No	No	Yes
Bat Algorithm	bat_a	swarm	Yes	Yes	No	Yes
Battle Royale Optimization	bro	human	Yes	Yes	No	Yes
Bees Algorithm	bea	swarm	Yes	Yes	No	Yes
Binary Space Partition Tree Genetic Algorithm	bspga	evolutionary	Yes	Yes	No	Yes
Biogeography-Based Optimization	bbo	evolutionary	Yes	Yes	No	Yes
Bird Swarm Algorithm	bsa	swarm	Yes	Yes	No	Yes
Birds-of-Paradise Search	bps	swarm	Yes	No	No	Yes
Black Widow Optimization	bwo	evolutionary	Yes	Yes	No	Yes
Black-winged Kite Algorithm	bka	swarm	Yes	Yes	No	Yes
Bonobo Optimizer	bono	swarm	Yes	Yes	No	Yes
Boxelder Bug Search Optimization	bbso	swarm	Yes	No	No	Yes
Brain Storm Optimization	bso	human	Yes	Yes	No	Yes
Brown-Bear Optimization Algorithm	bboa	swarm	Yes	Yes	No	Yes
Butterfly Optimization Algorithm	boa	swarm	Yes	Yes	No	Yes
Camel Algorithm	camel	swarm	Yes	Yes	No	Yes
Capuchin Search Algorithm	capsa	swarm	Yes	Yes	No	Yes
Cat Swarm Optimization	cat_so	swarm	Yes	Yes	No	Yes
Catch Fish Optimization Algorithm	cfoa	swarm	Yes	No	No	No
Cauchy-Gaussian mutation and improved search strategy GWO	cg_gwo	swarm	Yes	No	No	No
Chameleon Swarm Algorithm	chameleon_sa	swarm	Yes	Yes	No	Yes
Chaos Game Optimization	cgo	math	Yes	Yes	No	Yes
Chaotic-based Grey Wolf Optimizer	chaotic_gwo	swarm	Yes	No	No	No
Cheetah Based Optimization	cddo	swarm	Yes	Yes	No	Yes
Cheetah Optimizer	cdo	swarm	Yes	Yes	No	Yes
Chernobyl Disaster Optimizer	cdo_chernobyl	physics	Yes	Yes	No	Yes
Chicken Swarm Optimization	chicken_so	swarm	Yes	No	No	Yes
Child Drawing Development Optimization Algorithm	cddo_child	human	Yes	Yes	No	Yes
Chimp Optimization Algorithm	choa	swarm	Yes	Yes	No	Yes
Chinese Pangolin Optimizer	cpo	swarm	Yes	No	No	Yes
Circle-Based Search Algorithm	circle_sa	math	Yes	Yes	No	Yes
Circulatory System Based Optimization	csbo	swarm	Yes	Yes	No	Yes
Clonal Selection Algorithm	clonalg	evolutionary	Yes	Yes	No	Yes
Coati Optimization Algorithm	coati_oa	swarm	Yes	Yes	No	Yes
Cockroach Swarm Optimization	cockroach_so	swarm	Yes	Yes	No	Yes
Compact Genetic Algorithm	compact_ga	distribution	No	No	No	No
Competitive Swarm Optimizer	cso	swarm	Yes	Yes	No	Yes
Coot Bird Optimization	coot	swarm	Yes	Yes	No	Yes
Coral Reefs Optimization	cro	evolutionary	Yes	Yes	No	Yes
Coronavirus Herd Immunity Optimization	chio	human	Yes	Yes	No	Yes
Cosmic Evolution Optimization	ceo_cosmic	physics	Yes	Yes	No	Yes
Covariance Matrix Adaptation Evolution Strategy	cmaes	evolutionary	Yes	Yes	No	Yes
Coyote Optimization Algorithm	coa	swarm	Yes	Yes	No	Yes
Crayfish Optimization Algorithm	crayfish_oa	swarm	Yes	Yes	No	Yes
Cross Entropy Method	cem	distribution	Yes	Yes	No	Yes
Crow Search Algorithm	csa	swarm	Yes	Yes	No	Yes
Cuckoo Catfish Optimizer	cco	swarm	Yes	Yes	No	Yes
Cuckoo Search	cuckoo_s	swarm	Yes	Yes	No	Yes
Cultural Algorithm	ca	evolutionary	Yes	Yes	No	Yes
Dandelion Optimizer	do_dandelion	physics	Yes	Yes	No	Yes
Deep Sleep Optimiser	dso	human	Yes	Yes	No	Yes
Deer Hunting Optimization Algorithm	doa	human	Yes	Yes	No	Yes
Dhole Optimization Algorithm	dhole_oa	swarm	Yes	No	No	Yes
Differential Evolution JADE	jade	evolutionary	Yes	No	No	No
Differential Evolution MTS	hde	evolutionary	Yes	Yes	No	Yes
Differential Evolution with Self-Adaptive Populations	sap_de	evolutionary	Yes	No	No	No
Differential Evolution	de	evolutionary	Yes	Yes	No	Yes
Dispersive Fly Optimization	dfo	swarm	Yes	Yes	No	Yes
Diversity enhanced Strategy based Grey Wolf Optimizer	ds_gwo	swarm	Yes	No	No	No
Divine Religions Algorithm	dra	human	Yes	No	No	No
Dolphin Echolocation Optimization	deo_dolphin	swarm	Yes	Yes	No	Yes
Dragonfly Algorithm	da	swarm	Yes	Yes	No	Yes
Dream Optimization Algorithm	dream_oa	human	Yes	No	No	Yes
Dung Beetle Optimizer	dbo	swarm	Yes	Yes	No	Yes
Dwarf Mongoose Optimization Algorithm	dmoa	swarm	Yes	Yes	No	Yes
Dynamic Differential Annealed Optimization	ddao	physics	Yes	Yes	No	Yes
Dynamic Virtual Bats Algorithm	dvba	swarm	Yes	Yes	No	Yes
Earthworm Optimization Algorithm	eoa	swarm	Yes	Yes	No	Yes
Ecological Cycle Optimizer	ecological_cycle_o	swarm	Yes	Yes	No	Yes
Educational Competition Optimizer	eco	human	Yes	Yes	No	Yes
Eel and Grouper Optimizer	eel_grouper_o	swarm	Yes	No	No	No
Efficient Global Optimization	ego	distribution	Yes	Yes	No	Yes
Efficient and Robust Grey Wolf Optimizer	er_gwo	swarm	Yes	No	No	No
Egret Swarm Optimization Algorithm	esoa	swarm	Yes	Yes	No	Yes
Electric Charged Particles Optimization	ecpo	physics	Yes	Yes	No	Yes
Electric Eel Foraging Optimization	eefo	swarm	Yes	No	No	No
Electrical Storm Optimization	eso	physics	Yes	Yes	No	Yes
Electromagnetic Field Optimization	efo	physics	Yes	Yes	No	Yes
Elephant Herding Optimization	eho	swarm	Yes	Yes	No	Yes
Elk Herd Optimizer	elk_ho	swarm	Yes	Yes	No	Yes
Emperor Penguin Colony	epc	swarm	Yes	Yes	No	Yes
Energy Valley Optimizer	evo	physics	Yes	Yes	No	Yes
Enhanced Artificial Ecosystem-Based Optimization	enhanced_aeo	human	Yes	No	No	No
Enhanced Tug of War Optimization	enhanced_two	physics	Yes	No	No	No
Enzyme Activity Optimizer	eao	nature	Yes	Yes	No	Yes
Equilibrium Optimizer	eo	physics	Yes	Yes	No	Yes
Escape Algorithm	esc	human	Yes	Yes	No	Yes
Evolution Strategy (Mu + Lambda)	es	evolutionary	Yes	Yes	No	Yes
Evolutionary Programming	ep	evolutionary	Yes	Yes	No	Yes
Expanded Grey Wolf Optimizer	ex_gwo	swarm	Yes	No	No	No
Exponential Distribution Optimizer	edo	math	Yes	Yes	No	Yes
Exponential-Trigonometric Optimization	eto	math	Yes	Yes	No	Yes
Extra-Trees Bayesian Optimization	et_bo	surrogate	No	No	No	No
Fast Evolutionary Programming	fep	evolutionary	Yes	Yes	No	Yes
Fata Geophysics Optimizer	fata	physics	Yes	Yes	No	Yes
Feasibility Rule with Objective Function Information	frofi	evolutionary	Yes	Yes	No	Yes
Fennec Fox Optimizer	ffo	swarm	Yes	Yes	No	Yes
Fick's Law Algorithm	fla	physics	Yes	Yes	No	Yes
Firefly Algorithm	firefly_a	swarm	Yes	Yes	No	Yes
Fireworks Algorithm	fwa	swarm	Yes	Yes	No	Yes
Fish School Search	fss	swarm	Yes	Yes	No	Yes
Fitness Dependent Optimizer	fdo	swarm	Yes	Yes	No	Yes
Fletcher-Reeves Conjugate Gradient	frcg	math	No	No	No	No
Flood Algorithm	flood_a	physics	Yes	Yes	No	Yes
Flow Direction Algorithm	fda	swarm	Yes	Yes	No	Yes
Flower Pollination Algorithm	fpa	swarm	Yes	Yes	No	Yes
Forensic-Based Investigation Optimization	fbio	human	Yes	Yes	No	Yes
Forest Optimization Algorithm	foa	swarm	Yes	Yes	No	Yes
Fossa Optimization Algorithm	foa_fossa	swarm	Yes	Yes	No	Yes
Fox Optimizer	fox	swarm	Yes	Yes	No	Yes
Frilled Lizard Optimization	flo	swarm	Yes	Yes	No	Yes
Fruit-Fly Algorithm	ffa	swarm	Yes	Yes	No	Yes
Fuzzy Hierarchical Operator - Grey Wolf Optimizer	fuzzy_gwo	swarm	Yes	No	No	No
Gaining-Sharing Knowledge Algorithm	gska	human	Yes	Yes	No	Yes
Gaussian Process Bayesian Optimization	gp_bo	surrogate	No	No	No	No
Gazelle Optimization Algorithm	gazelle_oa	swarm	Yes	Yes	No	Yes
Gekko Japonicus Algorithm	gja	swarm	Yes	Yes	No	Yes
Generalized Normal Distribution Optimizer	gndo	math	Yes	Yes	No	Yes
Genetic Algorithm	ga	evolutionary	Yes	Yes	No	Yes
Genghis Khan Shark Optimizer	gkso	swarm	Yes	Yes	No	Yes
Geometric Mean Optimizer	gmo	swarm	Yes	Yes	No	Yes
Germinal Center Optimization	gco	human	Yes	Yes	No	Yes
Geyser Inspired Algorithm	gea	physics	Yes	Yes	No	Yes
Giant Pacific Octopus Optimizer	gpoo	swarm	Yes	No	No	Yes
Giant Trevally Optimizer	gto	swarm	Yes	Yes	No	Yes
Glider Snake Optimization	gso_glider_snake	swarm	Yes	No	No	No
Glowworm Swarm Optimization	gso	swarm	Yes	Yes	No	Yes
Golden Jackal Optimizer	gjo	swarm	Yes	Yes	No	Yes
Gradient-Based Optimizer	gbo	math	Yes	Yes	No	Yes
Gradient-Based Particle Swarm Optimization	gpso	swarm	Yes	Yes	No	Yes
Gradient-Boosted Regression Trees Bayesian Optimization	gbrt_bo	surrogate	No	No	No	No
Grasshopper Optimization Algorithm	goa	swarm	Yes	Yes	No	Yes
Gravitational Search Algorithm	gsa	physics	Yes	Yes	No	Yes
Greedy Randomized Adaptive Search Procedure	grasp	trajectory	No	No	Yes	No
Grey Wolf Optimizer	gwo	swarm	Yes	Yes	No	Yes
Greylag Goose Optimization	ggo	swarm	Yes	Yes	No	Yes
Growth Optimizer	go_growth	swarm	Yes	Yes	No	Yes
Harmony Search Algorithm	hsa	trajectory	Yes	No	No	Yes
Harris Hawks Optimization	hho	swarm	Yes	Yes	No	Yes
Heap-Based Optimizer	hbo	human	Yes	Yes	No	Yes
Henry Gas Solubility Optimization	hgso	physics	Yes	Yes	No	Yes
Hiking Optimization Algorithm	hiking_oa	human	Yes	Yes	No	Yes
Hill Climb Algorithm	hc	trajectory	No	No	No	No
Hippopotamus Optimization Algorithm	ho_hippo	swarm	Yes	Yes	No	Yes
Honey Badger Algorithm	hba_honey	swarm	Yes	Yes	No	Yes
Horse Herd Optimization Algorithm	horse_oa	swarm	Yes	Yes	No	Yes
Human Conception Optimizer	hco	human	Yes	Yes	No	Yes
Human Evolutionary Optimization Algorithm	heoa	human	Yes	Yes	No	Yes
Hunger Games Search	hgs	swarm	Yes	Yes	No	Yes
Hunting Search Algorithm	hus	swarm	Yes	Yes	No	Yes
Hybrid Bat Algorithm	hba	swarm	Yes	Yes	No	Yes
Hybrid Grey Wolf - Whale Optimization Algorithm	gwo_woa	swarm	Yes	No	No	No
Hybrid Improved Whale Optimization Algorithm	hi_woa	swarm	Yes	No	No	No
Hybrid Self-Adaptive Bat Algorithm	hsaba	swarm	Yes	Yes	No	Yes
IPOP-CMA-ES	ipop_cmaes	evolutionary	Yes	No	Yes	Yes
Imperialist Competitive Algorithm	ica	human	Yes	Yes	No	Yes
Improved Adaptive Grey Wolf Optimization	iagwo	swarm	Yes	No	No	No
Improved Artificial Ecosystem-based Optimization	improved_aeo	human	Yes	No	No	No
Improved Artificial Rabbits Optimization	iaro	swarm	Yes	No	No	No
Improved Grey Wolf Optimizer	i_gwo	swarm	Yes	Yes	No	Yes
Improved Kepler Optimization Algorithm	ikoa	physics	Yes	Yes	No	Yes
Improved L-SHADE	ilshade	evolutionary	Yes	Yes	No	Yes
Improved Multi-Operator Differential Evolution	imode	evolutionary	Yes	Yes	No	Yes
Improved Opposite-based Learning Grey Wolf Optimizer	iobl_gwo	swarm	Yes	No	No	No
Improved Queuing Search Algorithm	improved_qsa	human	Yes	No	No	No
Improved Teaching-Learning-based Optimization	improved_tlo	swarm	Yes	No	No	No
Improved Whale Optimization Algorithm	i_woa	swarm	Yes	Yes	No	Yes
Incremental model-based Grey Wolf Optimizer	incremental_gwo	swarm	Yes	No	No	No
Invasive Weed Optimization	iwo	nature	Yes	Yes	No	Yes
Iterated Local Search	ils	trajectory	No	No	Yes	No
Ivy Algorithm	ivya	nature	Yes	Yes	No	Yes
Jaya Algorithm	jy	swarm	Yes	Yes	No	Yes
Jellyfish Search Optimizer	jso	swarm	Yes	Yes	No	Yes
Komodo Mlipir Algorithm	kma	swarm	Yes	Yes	No	Yes
Krill Herd Algorithm	kha	swarm	Yes	No	No	Yes
LSHADE-cnEpSin	lshade_cnepsin	evolutionary	Yes	Yes	No	Yes
Leaf in Wind Optimization	liwo	physics	Yes	Yes	No	Yes
Life Choice-Based Optimizer	lco	human	Yes	Yes	No	Yes
Light Spectrum Optimizer	lso_spectrum	physics	Yes	Yes	No	Yes
Linear Subspace Surrogate Modeling Evolutionary Algorithm	l2smea	evolutionary	Yes	Yes	No	Yes
Lion Optimization Algorithm	loa	swarm	Yes	Yes	No	Yes
Liver Cancer Algorithm	lca	nature	Yes	Yes	No	Yes
Lungs Performance-Based Optimization	lpo	nature	Yes	Yes	No	Yes
Lyrebird Optimization Algorithm	loa_lyrebird	swarm	Yes	Yes	No	Yes
Lévy Flight Distribution	lfd	swarm	Yes	Yes	No	Yes
Lévy Flight Jaya Algorithm	levy_ja	swarm	Yes	No	No	No
Lévy Flight and Selective Opposition Artificial Rabbit Algorithm	laro	swarm	Yes	No	No	No
Magnificent Frigatebird Optimization	mfo	swarm	Yes	No	No	Yes
Manta Ray Foraging Optimization	mrfo	swarm	Yes	Yes	No	Yes
Mantis Shrimp Optimization Algorithm	mshoa	swarm	Yes	Yes	No	Yes
Marine Predators Algorithm	mpa	swarm	Yes	Yes	No	Yes
Market Game Optimization Algorithm	mgoa_market	human	Yes	Yes	No	Yes
Memetic Algorithm	memetic_a	evolutionary	Yes	Yes	No	Yes
Mirage-Search Optimizer	mso	physics	Yes	Yes	No	Yes
Modified Artificial Ecosystem-Based Optimization	modified_aeo	human	Yes	No	No	No
Modified Equilibrium Optimizer	modified_eo	physics	Yes	No	No	No
Monarch Butterfly Optimization	mbo	swarm	Yes	Yes	No	Yes
Monkey King Evolution V1	mke	evolutionary	Yes	Yes	No	Yes
Moss Growth Optimization	moss_go	nature	Yes	Yes	No	Yes
Most Valuable Player Algorithm	mvpa	human	Yes	Yes	No	Yes
Moth Flame Algorithm	mfa	swarm	Yes	Yes	No	Yes
Moth Search Algorithm	msa_e	swarm	Yes	Yes	No	Yes
Mountain Gazelle Optimizer	mgo	swarm	Yes	Yes	No	Yes
Mountaineering Team-Based Optimization	mtbo	human	Yes	No	No	Yes
Multi-Start Local Search	msls	trajectory	No	No	Yes	No
Multi-Surrogate-Assisted Ant Colony Optimization	misaco	swarm	Yes	Yes	No	Yes
Multi-Verse Optimizer	mvo	swarm	Yes	Yes	No	Yes
Multifactorial Evolutionary Algorithm II	mfea2	evolutionary	Yes	Yes	No	Yes
Multifactorial Evolutionary Algorithm	mfea	evolutionary	Yes	Yes	No	Yes
Multiple Trajectory Search	mts	trajectory	Yes	Yes	No	Yes
Multiswarm-Assisted Expensive Optimization	samso	swarm	Yes	Yes	No	Yes
NLAPSMjSO-EDA	nlapsmjso_eda	evolutionary	Yes	No	No	Yes
Naked Mole-Rat Algorithm	nmra	swarm	Yes	Yes	No	Yes
Narwhal Optimizer	nwoa	swarm	Yes	Yes	No	Yes
Nelder-Mead Method	nmm	trajectory	Yes	Yes	No	Yes
Neural Network-Based Dimensionality Reduction Evolutionary Algorithm	nndrea_so	evolutionary	Yes	Yes	No	Yes
Nizar Optimization Algorithm	noa	math	Yes	Yes	No	Yes
Northern Goshawk Optimization	ngo	swarm	Yes	Yes	No	Yes
Nuclear Reaction Optimization	nro	physics	Yes	Yes	No	Yes
Numeric Crunch Algorithm	nca	math	Yes	Yes	No	Yes
Opposition-based Coral Reefs Optimization	ocro	evolutionary	Yes	No	No	No
Opposition-based learning Grey Wolf Optimizer	ogwo	swarm	Yes	No	No	No
Optimal Foraging Algorithm	ofa	swarm	Yes	Yes	No	Yes
Osprey Optimization Algorithm	ooa	swarm	Yes	Yes	No	Yes
Parameter-Free Bat Algorithm	plba	swarm	Yes	Yes	No	Yes
Parent-Centric Crossover (G3-PCX style)	pcx	evolutionary	Yes	Yes	No	Yes
Pareto Sequential Sampling	pss	math	Yes	Yes	No	Yes
Parrot Optimizer	parrot_o	swarm	Yes	Yes	No	Yes
Particle Swarm Optimization	pso	swarm	Yes	Yes	No	Yes
Pathfinder Algorithm	pfa	swarm	Yes	Yes	No	Yes
Pelican Optimization Algorithm	poa	swarm	Yes	Yes	No	Yes
Physical Education Teacher Inspired Optimization	petio	human	Yes	No	No	Yes
Pied Kingfisher Optimizer	pko	swarm	Yes	Yes	No	Yes
Polar Fox Optimization	pfa_polar_fox	swarm	Yes	No	No	No
Polar Lights Optimizer	plo	physics	Yes	Yes	No	Yes
Political Optimizer	political_o	human	Yes	Yes	No	Yes
Poor and Rich Optimization Algorithm	pro	human	Yes	Yes	No	Yes
Population-Based Incremental Learning	pbil	distribution	No	No	No	No
Prairie Dog Optimization Algorithm	pdo	swarm	Yes	Yes	No	Yes
Puma Optimizer	puma_o	swarm	Yes	Yes	No	Yes
QLE Sine Cosine Algorithm	qle_sca	swarm	Yes	No	No	No
Quadratic Interpolation Optimization	qio	math	Yes	Yes	No	Yes
Queuing Search Algorithm	qsa	human	Yes	Yes	No	Yes
RIME-ice Algorithm	rime	physics	Yes	Yes	No	Yes
RMSProp	rmsprop	math	No	No	No	No
RUNge Kutta Optimizer	run	math	Yes	Yes	No	Yes
Rain-Cloud Condensation Optimizer	rcco	physics	Yes	No	No	Yes
Random Forest Bayesian Optimization	rf_bo	surrogate	No	No	No	No
Random Search	random_s	trajectory	Yes	Yes	No	Yes
Rat Swarm Optimizer	rso	swarm	Yes	Yes	No	Yes
Red-billed Blue Magpie Optimizer	rbmo	swarm	Yes	Yes	No	Yes
Remora Optimization Algorithm	roa	swarm	Yes	Yes	No	Yes
Reptile Search Algorithm	rsa	swarm	Yes	Yes	No	Yes
Rock Hyraxes Swarm Optimization	rhso	swarm	Yes	No	No	Yes
Rüppell's Fox Optimizer	rfo	swarm	Yes	Yes	No	Yes
Sailfish Optimizer	sfo	swarm	Yes	Yes	No	Yes
Salp Swarm Algorithm	ssa	swarm	Yes	Yes	No	Yes
Sammon Mapping Assisted Differential Evolution	sade_sammon	evolutionary	Yes	Yes	No	Yes
Sand Cat Swarm Optimization	scso	swarm	Yes	Yes	No	Yes
Satin Bowerbird Optimizer	sbo	swarm	Yes	Yes	No	Yes
Sea Lion Optimization	slo	swarm	Yes	Yes	No	Yes
Seagull Optimization Algorithm	soa	swarm	Yes	Yes	No	Yes
Seahorse Optimizer	seaho	swarm	Yes	Yes	No	Yes
Search And Rescue Optimization	saro	human	Yes	Yes	No	Yes
Search Space Independent Operator Based Deep Reinforcement Learning	ssio_rl	evolutionary	Yes	Yes	No	Yes
Secretary Bird Optimization Algorithm	sboa	swarm	Yes	Yes	No	Yes
Self-Adaptive Bat Algorithm	saba	swarm	Yes	Yes	No	Yes
Self-Adaptive Differential Evolution	sade	evolutionary	Yes	No	No	No
Self-Adaptive Differential Evolution	jde	evolutionary	Yes	Yes	No	Yes
Sequential Quadratic Programming	sqp	math	No	No	No	No
Serval Optimization Algorithm	serval_oa	swarm	Yes	Yes	No	Yes
Shuffle-based Runner-Root Algorithm	srsr	swarm	Yes	Yes	No	Yes
Siberian Tiger Optimization	sto	swarm	Yes	Yes	No	Yes
Simple Optimization Algorithm	sopt	distribution	Yes	Yes	No	Yes
Simulated Annealing	sa	trajectory	No	Yes	Yes	No
Sine Cosine Algorithm	sine_cosine_a	swarm	Yes	Yes	No	Yes
Singer Optimization Algorithm	singer_oa	human	Yes	Yes	No	Yes
Sinh Cosh Optimizer	scho	math	Yes	Yes	No	Yes
Slime Mould Algorithm	sma	nature	Yes	Yes	No	Yes
Snake Optimizer	so_snake	swarm	Yes	Yes	No	Yes
Snow Ablation Optimizer	snow_oa	physics	Yes	Yes	No	Yes
Social Ski-Driver Optimization	ssdo	human	Yes	Yes	No	Yes
Social Spider Algorithm	sspider_a	swarm	Yes	Yes	No	Yes
Social Spider Swarm Optimizer	sso	swarm	Yes	Yes	No	Yes
Sparrow Search Algorithm	sparrow_sa	swarm	Yes	Yes	No	Yes
Spider Monkey Optimization	smo	swarm	Yes	Yes	No	Yes
Spotted Hyena Inspired Optimizer	shio	swarm	Yes	Yes	No	Yes
Spotted Hyena Optimizer	sho	swarm	Yes	Yes	No	Yes
Squirrel Search Algorithm	squirrel_sa	swarm	Yes	Yes	No	Yes
Starfish Optimization Algorithm	sfoa	swarm	Yes	Yes	No	Yes
Steepest Descent	sd	math	No	No	No	No
Stellar Oscillator Optimization	soo	physics	Yes	Yes	No	Yes
Student Psychology Based Optimization	spbo	swarm	Yes	Yes	No	Yes
Success-History Adaptive Differential Evolution	shade	evolutionary	Yes	Yes	No	Yes
Success-History Intelligent Optimizer	shio_success	swarm	Yes	Yes	No	Yes
Superb Fairy-wren Optimization Algorithm	superb_foa	swarm	Yes	Yes	No	Yes
Supply-Demand-Based Optimization	supply_do	human	Yes	Yes	No	Yes
Surrogate-Assisted Cooperative Co-Evolutionary Algorithm of Minamo II	sacc_eam2	evolutionary	Yes	Yes	No	Yes
Surrogate-Assisted Cooperative Swarm Optimization	sacoso	swarm	Yes	Yes	No	Yes
Surrogate-Assisted DE with Adaptive Multi-Subspace Search	sade_amss	evolutionary	Yes	Yes	No	Yes
Surrogate-Assisted DE with Adaptive Training Data Selection Criterion	sade_atdsc	evolutionary	Yes	Yes	No	Yes
Surrogate-Assisted Partial Optimization	sapo	evolutionary	Yes	Yes	No	Yes
Swarm Robotics Search And Rescue	srsr_robotics	swarm	Yes	No	No	Yes
Symbiotic Organisms Search	sos	swarm	Yes	Yes	No	Yes
Tabu Search	ts	trajectory	No	No	No	No
Tasmanian Devil Optimization	tdo	swarm	Yes	Yes	No	Yes
Teaching Learning Based Optimization	tlbo	swarm	Yes	Yes	No	Yes
Teamwork Optimization Algorithm	toa	human	Yes	Yes	No	Yes
Termite Life Cycle Optimizer	tlco	swarm	Yes	Yes	No	Yes
Tianji Horse Racing Optimizer	thro	human	Yes	Yes	No	Yes
Tornado Optimizer with Coriolis Force	toc	physics	Yes	Yes	No	Yes
Tree Physiology Optimization	tpo	nature	Yes	Yes	No	Yes
Tree-Seed Algorithm	tree_seed_a	nature	Yes	No	No	Yes
Triangulation Topology Aggregation Optimizer	ttao	math	Yes	Yes	No	Yes
Tug of War Optimization	two	physics	Yes	Yes	No	Yes
Tuna Swarm Optimization	tso	swarm	Yes	Yes	No	Yes
Tunicate Swarm Algorithm	tsa	swarm	Yes	Yes	No	Yes
Turbulent Flow of Water-based Optimization	tfwo	physics	Yes	No	No	Yes
Variable Neighborhood Search	vns	trajectory	No	No	Yes	No
Virus Colony Search	vcs	swarm	Yes	Yes	No	Yes
Walrus Optimization Algorithm	waoa	swarm	Yes	Yes	No	Yes
War Strategy Optimization	warso	human	Yes	Yes	No	Yes
Water Cycle Algorithm	wca	nature	Yes	Yes	No	Yes
Water Uptake and Transport in Plants	wutp	nature	Yes	Yes	No	Yes
Wave Optimization Algorithm	wo_wave	physics	Yes	Yes	No	Yes
Wavelet Mutation and Quadratic Interpolation MRFO	wmqimrfo	swarm	Yes	No	No	No
Weighting and Inertia Random Walk Optimizer	info	math	Yes	Yes	No	Yes
Whale Fruit-fly Optimization Algorithm	whale_foa	swarm	Yes	No	No	No
Whale Optimization Algorithm	woa	swarm	Yes	Yes	No	Yes
White Shark Optimizer	wso	swarm	Yes	Yes	No	Yes
Wildebeest Herd Optimization	who	swarm	Yes	Yes	No	Yes
Wind Driven Optimization	wdo	physics	Yes	Yes	No	Yes
Wolverine Optimization Algorithm	wooa	swarm	Yes	Yes	No	Yes
Young's Double-Slit Experiment Optimizer	ydse	physics	Yes	Yes	No	Yes
Zebra Optimization Algorithm	zoa	swarm	Yes	Yes	No	Yes

---

4. Test Functions

Back to Summary

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

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

• Click Here for the Full Google Colab Example

import pymetaheuristic

rastrigin = pymetaheuristic.get_test_function("rastrigin")

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

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

Benchmark Function Optima

All functions below use the minimization convention. Notation

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

2-Dimensional Functions

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

D-Dimensional Functions

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

CEC 2022 Functions

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

Engineering Design Benchmarks

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

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

Notes

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

---

5. Other Libraries

Back to Summary

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

Acknowledgement

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

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