Optimizer Catalog¶

from iwopy.benchmarks import ParetoProblem

problem = ParetoProblem(constrained=True)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    variable_ranges = problem.max_values_float() - problem.min_values_float()
    solver = create_optimizer(
        family="iwopy",  # Optimizer family
        optimizer="GG",  # Algorithm to use
        problem=problem,
        step_max=0.1 * variable_ranges,  # Initial steps: 10% of variable ranges
        step_min=1e-6 * variable_ranges,  # Minimum steps in variable units
        f_tol=1e-8,  # Objective improvement stopping tolerance
        max_iterations=100,  # Demo iterations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="iwopy",  # Optimizer family
        optimizer="SLSQP",  # Algorithm to use
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        ftol=1e-8,  # Objective and optimality stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer=None,  # Algorithm to use
        problem=problem,
        tol=1e-6,  # Method-specific convergence tolerance
        max_iterations=100,  # Demo iterations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="Nelder-Mead",  # Derivative-free simplex search
        problem=problem,
        adaptive=True,  # Adapt simplex coefficients to dimension
        max_iterations=200,  # Demo iterations; production start: 10000
        xatol=1e-6,  # Absolute variable convergence tolerance
        fatol=1e-8,  # Absolute objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="Powell",  # Derivative-free direction-set search
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol=1e-6,  # Relative variable convergence tolerance
        ftol=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="CG",  # Nonlinear conjugate-gradient optimization
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="BFGS",  # Quasi-Newton optimization
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="Newton-CG",  # Newton optimization with CG inner solves
        problem=problem,
        hess="2-point",  # Estimate the Hessian from objective gradients
        max_iterations=100,  # Demo iterations; production start: 1000
        xtol=1e-6,  # Average relative step convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="L-BFGS-B",  # Bound-constrained limited-memory optimization
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        ftol=1e-9,  # Relative objective improvement tolerance
        gtol=1e-6,  # Projected-gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="TNC",  # Bound-constrained truncated Newton optimization
        problem=problem,
        max_evaluations=500,  # Demo evaluations; production start: 10000
        gtol=1e-6,  # Projected-gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="COBYLA",  # Derivative-free constrained optimization
        problem=problem,
        rhobeg=1.0,  # Initial trust-region radius in variable units
        max_evaluations=500,  # Demo evaluations; production start: 10000
        tol=1e-6,  # Final trust-region radius
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="COBYQA",  # Derivative-free quadratic-model optimization
        problem=problem,
        initial_tr_radius=1.0,  # Initial radius in variable units
        final_tr_radius=1e-6,  # Final trust-region radius
        max_iterations=100,  # Demo iterations; production start: 1000
        max_evaluations=500,  # Demo evaluations; production start: 10000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="SLSQP",  # Sequential quadratic programming
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        ftol=1e-8,  # Objective and optimality stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="trust-constr",  # Constrained trust-region optimization
        problem=problem,
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Lagrangian gradient and feasibility tolerance
        xtol=1e-8,  # Minimum trust-region radius
        barrier_tol=1e-8,  # Inequality barrier stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

import numpy as np

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="dogleg",  # Dogleg trust-region optimization
        problem=problem,
        hess=lambda point: 2.0 * np.eye(len(point)),  # Replace for real problems
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="trust-ncg",  # Trust-region Newton-CG optimization
        problem=problem,
        hess="2-point",  # Estimate the Hessian from objective gradients
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

import numpy as np

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="trust-exact",  # Nearly exact trust-region optimization
        problem=problem,
        hess=lambda point: 2.0 * np.eye(len(point)),  # Replace for real problems
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="trust-krylov",  # Krylov trust-region optimization
        problem=problem,
        hess="2-point",  # Estimate the Hessian from objective gradients
        max_iterations=100,  # Demo iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from scipy.optimize import minimize

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer


def custom_method(fun, initial, args=(), jac=None, **options):
    """Delegate a SciPy callable method to BFGS.

    Parameters
    ----------
    fun
        Objective callable supplied by SciPy.
    initial
        Initial variable vector.
    args
        Additional objective arguments.
    jac
        Objective gradient callable.
    options
        SciPy method arguments; bfgs_iterations and gtol configure the
        delegated BFGS solver. Callable methods own their stopping semantics.

    Returns
    -------
    result
        SciPy optimization result from the delegated solve.
    """
    return minimize(
        fun,
        initial,
        args=args,
        jac=jac,
        method="BFGS",
        options={
            "maxiter": options.get("bfgs_iterations", 100),  # Maximum BFGS iterations
            "gtol": options.get("gtol", 1e-6),  # Gradient convergence tolerance
        },
    )


if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer=custom_method,  # User-provided SciPy optimization method
        problem=problem,
        bfgs_iterations=100,  # Demo delegated iterations; production start: 1000
        gtol=1e-6,  # Gradient convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="scipy",  # Optimizer family
        optimizer="differential_evolution",  # Algorithm to use
        problem=problem,
        vectorize=True,  # Evaluate each generation as an iwopy population
        population_multiplier=5,  # Demo multiplier per free variable; production: 15
        seed=42,  # Reproducible initialization and variation
        max_iterations=30,  # Demo generations; production start: 1000
        tol=1e-6,  # Relative population-energy convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    variable_ranges = problem.max_values_float() - problem.min_values_float()
    solver = create_optimizer(
        family="cma",  # Optimizer family
        optimizer="CMAES",  # Algorithm to use
        problem=problem,
        sigma0=0.25 * min(variable_ranges),  # Initial search scale in variable units
        seed=42,  # Reproducible sampling
        max_iterations=50,  # Demo generations; production start: 1000
        tolx=1e-6,  # Variable convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="GA",  # Genetic algorithm
        problem=problem,
        vectorize=True,  # Evaluate each generation as an iwopy population
        pop_size=20,  # Demo population; production start: 100
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="DE",  # Differential evolution
        problem=problem,
        variant="DE/best/1/bin",  # Mutation and crossover strategy
        vectorize=True,  # Evaluate each generation as an iwopy population
        pop_size=20,  # Demo population; production start: 100
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="PSO",  # Particle-swarm optimization
        problem=problem,
        adaptive=True,  # Adapt inertia and attraction coefficients
        vectorize=True,  # Evaluate each generation as an iwopy population
        pop_size=20,  # Demo swarm; production start: 40
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="NSGA2",  # Non-dominated sorting genetic algorithm
        problem=problem,
        vectorize=True,  # Evaluate each generation as an iwopy population
        pop_size=20,  # Demo Pareto population; production start: 100+
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)
    selected_index = result.find_pareto_objmix([0.5, 0.5])
    print("Selected variables:", result.vars_float[selected_index])
    print("Selected objectives:", result.objs[selected_index])

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="NSGA3",  # Reference-direction non-dominated sorting
        problem=problem,
        n_partitions=12,  # Production: choose partitions for 100+ directions
        vectorize=True,  # Evaluate each generation as an iwopy population
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)
    selected_index = result.find_pareto_objmix([0.5, 0.5])
    print("Selected variables:", result.vars_float[selected_index])
    print("Selected objectives:", result.objs[selected_index])

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem(constrained=True)
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="NSGA2",  # Non-dominated sorting genetic algorithm
        problem=problem,
        vectorize=True,  # Evaluate each generation as an iwopy population
        pop_size=20,  # Demo Pareto population; production start: 100+
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)
    selected_index = result.find_pareto_objmix([0.5, 0.5])
    print("Selected variables:", result.vars_float[selected_index])
    print("Selected objectives:", result.objs[selected_index])
    print("Selected constraint:", result.cons[selected_index])

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem(constrained=True)
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="NSGA3",  # Reference-direction non-dominated sorting
        problem=problem,
        n_partitions=12,  # Production: choose partitions for 100+ directions
        vectorize=True,  # Evaluate each generation as an iwopy population
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)
    selected_index = result.find_pareto_objmix([0.5, 0.5])
    print("Selected variables:", result.vars_float[selected_index])
    print("Selected objectives:", result.objs[selected_index])
    print("Selected constraint:", result.cons[selected_index])

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="CMAES",  # Covariance-matrix adaptation
        problem=problem,
        x0=problem.initial_values_float(),  # Problem-defined starting point
        sigma=0.25,  # Initial scale in normalized variable coordinates
        verb_log=0,  # Disable native file logging
        vectorize=True,  # Evaluate each generation as an iwopy population
        seed=42,  # Reproducible sampling
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import MixedProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = MixedProblem()
    solver = create_optimizer(
        family="pymoo",  # Optimizer family
        optimizer="MixedVariableGA",  # Mixed integer/float genetic algorithm
        problem=problem,
        vectorize=True,  # Evaluate each generation as an iwopy population
        pop_size=20,  # Demo population; production start: 100
        seed=42,  # Reproducible sampling and variation
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Objective-space convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="cobyla",  # Derivative-free linear constraint models
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="ipopt",  # Select the IPOPT backend
        problem=problem,
        hessian_approximation="limited-memory",  # Approximate the Hessian
        pop_size=1,  # One starting point, not a population search
        max_iterations=100,  # Demo iterations; production start: 1000
        tol=1e-8,  # Scaled convergence tolerance
        constr_viol_tol=1e-6,  # Maximum absolute constraint violation
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="sga",  # Simple genetic algorithm
        problem=problem,
        cr=0.9,  # Crossover probability
        m=0.02,  # Per-gene mutation probability
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo population; production start: 100
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="pso",  # Particle-swarm optimization
        problem=problem,
        omega=0.7298,  # Inertia or constriction coefficient
        eta1=2.05,  # Attraction toward personal best positions
        eta2=2.05,  # Attraction toward neighbourhood best positions
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo swarm; production start: 40
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="bee_colony",  # Artificial bee colony
        problem=problem,
        limit=20,  # Failed improvement attempts before abandoning a source
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo colony; production start: 100
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="nsga2",  # Non-dominated sorting genetic algorithm
        problem=problem,
        cr=0.95,  # Crossover probability
        m=1.0 / problem.n_vars_float,  # Per-gene mutation probability
        seed=42,  # Reproducible evolution
        pop_size=20,  # Production: 100+ individuals, in multiples of four
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    solver.algo.set_verbosity(0)
    result = solver.algo.evolve(solver.pop)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="de",  # Differential evolution
        problem=problem,
        F=0.8,  # Differential mutation scale
        CR=0.9,  # Crossover probability
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo population; production start: 100
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Population objective-spread stopping tolerance
        xtol=1e-6,  # Population variable-spread stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="de1220",  # Adapt differential-evolution strategies
        problem=problem,
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo population; production start: 100
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Population objective-spread stopping tolerance
        xtol=1e-6,  # Population variable-spread stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="sade",  # Self-adaptive differential evolution
        problem=problem,
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo population; production start: 100
        max_iterations=10,  # Demo generations; production start: 1000
        ftol=1e-6,  # Population objective-spread stopping tolerance
        xtol=1e-6,  # Population variable-spread stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="cmaes",  # Covariance-matrix adaptation
        problem=problem,
        sigma0=0.25,  # Initial search step size
        force_bounds=True,  # Keep sampled candidates within variable bounds
        seed=42,  # Reproducible evolution
        pop_size=20,  # Production: max(5, 4 + int(3 * log(n_vars)))
        max_iterations=20,  # Demo generations; production start: 1000
        ftol=1e-6,  # Population objective-spread stopping tolerance
        xtol=1e-6,  # Search-distribution stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="gwo",  # Grey-wolf optimization
        problem=problem,
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo population; production start: 100
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="ihs",  # Improved harmony search
        problem=problem,
        phmcr=0.85,  # Probability of reusing a harmony-memory value
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo harmony memory; production start: 100
        max_iterations=100,  # One evaluation/iteration; production start: 10000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="pso_gen",  # Generational particle-swarm optimization
        problem=problem,
        omega=0.7298,  # Inertia or constriction coefficient
        eta1=2.05,  # Attraction toward personal best positions
        eta2=2.05,  # Attraction toward neighbourhood best positions
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo swarm; production start: 40
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="xnes",  # Exponential natural evolution strategy
        problem=problem,
        sigma0=0.25,  # Initial search step size
        force_bounds=True,  # Keep sampled candidates within variable bounds
        seed=42,  # Reproducible evolution
        pop_size=20,  # Production: max(5, 4 + int(3 * log(n_vars)))
        max_iterations=20,  # Demo generations; production start: 1000
        ftol=1e-6,  # Population objective-spread stopping tolerance
        xtol=1e-6,  # Search-distribution stopping tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="sea",  # Simple evolutionary algorithm
        problem=problem,
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo parent population; production start: 100
        max_iterations=100,  # One evaluation/iteration; production start: 10000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="compass_search",  # Derivative-free coordinate search
        problem=problem,
        start_range=0.1,  # Initial step as a fraction of variable ranges
        stop_range=1e-6,  # Minimum step as a fraction of variable ranges
        pop_size=1,  # One problem-defined starting point
        max_evaluations=200,  # Demo evaluations; production start: 10000
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="moead",  # Multi-objective decomposition
        problem=problem,
        neighbours=5,  # Production: 20 neighbours with a larger population
        decomposition="tchebycheff",  # Scalar subproblem formulation
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo Pareto population; production start: 100+
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    solver.algo.set_verbosity(0)
    result = solver.algo.evolve(solver.pop)
    print(result)

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="moead_gen",  # Generational multi-objective decomposition
        problem=problem,
        neighbours=5,  # Production: 20 neighbours with a larger population
        decomposition="tchebycheff",  # Scalar subproblem formulation
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo Pareto population; production start: 100+
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    solver.algo.set_verbosity(0)
    result = solver.algo.evolve(solver.pop)
    print(result)

from iwopy.benchmarks import ParetoProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = ParetoProblem()
    solver = create_optimizer(
        family="pygmo",  # Optimizer family
        optimizer="nspso",  # Non-dominated sorting particle swarm
        problem=problem,
        omega=0.6,  # Inertia coefficient
        diversity_mechanism="crowding distance",  # Pareto diversity measure
        seed=42,  # Reproducible evolution
        pop_size=20,  # Demo Pareto swarm; production start: 100+
        max_iterations=10,  # Demo generations; production start: 1000
    )
    solver.initialize(verbosity=0)
    solver.algo.set_verbosity(0)
    result = solver.algo.evolve(solver.pop)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="cobyla",  # Derivative-free linear constraint models
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="bobyqa",  # Bound-constrained quadratic approximation
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="newuoa",  # Unconstrained quadratic-model search
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="newuoa_bound",  # Bound-constrained quadratic-model search
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="praxis",  # Principal-axis derivative-free search
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="neldermead",  # Derivative-free simplex search
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="sbplx",  # Subspace simplex search
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="mma",  # Method of moving asymptotes
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="ccsaq",  # Conservative separable quadratic models
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="slsqp",  # Sequential quadratic programming
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="lbfgs",  # Limited-memory quasi-Newton optimization
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="tnewton_precond_restart",  # Preconditioning and restarts
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="tnewton_precond",  # Preconditioned truncated Newton
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="tnewton_restart",  # Restarted truncated Newton
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="tnewton",  # Truncated Newton optimization
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="var2",  # Rank-two variable-metric optimization
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="var1",  # Rank-one variable-metric optimization
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    import pygmo

    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="auglag",  # Augmented-Lagrangian constraint handling
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    local_optimizer = pygmo.nlopt("lbfgs")
    local_optimizer.maxeval = 500  # Demo subproblem budget; production: 10000
    local_optimizer.xtol_rel = 1e-6  # Relative variable convergence tolerance
    solver.algo.extract(pygmo.nlopt).local_optimizer = local_optimizer
    result = solver.solve(verbosity=0)
    print(result)

from iwopy.benchmarks import QuadraticProblem
from iwopy import create_optimizer

if __name__ == "__main__":
    import pygmo

    problem = QuadraticProblem()
    solver = create_optimizer(
        family="nlopt",  # Optimizer family
        optimizer="auglag_eq",  # Equality-focused augmented Lagrangian
        problem=problem,
        pop_size=1,  # One problem-defined starting point
        max_evaluations=500,  # Demo evaluations; production start: 10000
        xtol_rel=1e-6,  # Relative variable convergence tolerance
        ftol_rel=1e-8,  # Relative objective convergence tolerance
    )
    solver.initialize(verbosity=0)
    local_optimizer = pygmo.nlopt("lbfgs")
    local_optimizer.maxeval = 500  # Demo subproblem budget; production: 10000
    local_optimizer.xtol_rel = 1e-6  # Relative variable convergence tolerance
    solver.algo.extract(pygmo.nlopt).local_optimizer = local_optimizer
    result = solver.solve(verbosity=0)
    print(result)