API References

Main interface

Metaheuristics.optimize — Function

  optimize(
        f::Function, # objective function
        search_space,
        method::AbstractAlgorithm = ECA();
        logger::Function = (status) -> nothing,
  )

Minimize a n-dimensional function f with domain search_space (2×n matrix) using method = ECA() by default.

Example

Minimize f(x) = Σx² where x ∈ [-10, 10]³.

Solution:

julia> f(x) = sum(x.^2)
f (generic function with 1 method)

julia> bounds = [  -10.0 -10 -10; # lower bounds
                    10.0  10 10 ] # upper bounds
2×3 Array{Float64,2}:
 -10.0  -10.0  -10.0
  10.0   10.0   10.0

julia> result = optimize(f, bounds)
+=========== RESULT ==========+
  iteration: 1429
    minimum: 2.5354499999999998e-222
  minimizer: [-1.5135301653303966e-111, 3.8688354844737692e-112, 3.082095708730726e-112]
    f calls: 29989
 total time: 0.1543 s
+============================+

optimize(F, f, bounds_ul, bounds_ll, method = BCA(); logger = (status) -> nothing)

Solve a bilevel optimization problem using a heuristic or metaheuristic method.

The upper-level problem is min_x F(x, y) subject to x ∈ bounds_ul and any upper-level constraints returned by F, while y must be an optimal solution of the lower-level problem min_y f(x, y) subject to y ∈ bounds_ll and its own constraints.

Parameters

F(x, y) — upper-level objective function. Must return one of:
- scalar value (unconstrained),
- (fval, g, h) tuple where g / h are vectors of inequality / equality constraints.
f(x, y) — lower-level objective function (same signature as F).
bounds_ul — upper-level bounds, a 2 × D_ul matrix where row 1 = lower bounds, row 2 = upper bounds.
bounds_ll — lower-level bounds, a 2 × D_ll matrix (same layout).
method — a bilevel algorithm, e.g. BCA, QBCA, SABO, SMS_MOBO, etc. (default: BCA()).
logger — a function status -> ... called at the end of every iteration (useful for custom logging or visualisation).

Returns

A BLState object containing the best solution found, the final population, convergence history, and function evaluation counts. Use minimum and minimizer to extract results.

Example (single-objective, unconstrained)

F(x, y) = sum(x.^2) + sum(y.^2)
f(x, y) = sum((x - y).^2) + y[1]^2
bounds = [-ones(5)'; ones(5)']

res = optimize(F, f, bounds, bounds, BCA())
x, y = minimizer(res)
Fmin, fmin = minimum(res)

Example (constrained)

function F(x, y)
    fval = sum(x.^2) + sum(y.^2)
    g = [x[1] + x[2] - 1, x[3] - y[3] - 10]   # inequality constraints
    h = [0.0]                                     # equality constraints
    return fval, g, h
end

function f(x, y)
    fval = sum((x - y).^2) + y[1]^2
    g = [x[2] - y[1]^2 - 5]
    h = [0.0]
    return fval, g, h
end

bounds_ul = [-ones(5) ones(5)]
bounds_ll = [-ones(5) ones(5)]
res = optimize(F, f, bounds_ul, bounds_ll, BCA())

Example (multi-objective)

function F(x, y)  # two upper-level objectives
    [y[1] - x[1], y[2]], [-1.0 - sum(y)], [0.0]
end

function f(x, y)  # two lower-level objectives
    y, [-x[1]^2 + sum(y .^ 2)], [0.0]
end

bounds_ul = [0.0 1.0]'
bounds_ll = [-1 -1; 1 1.0]
res = optimize(F, f, bounds_ul, bounds_ll, SMS_MOBO())

API References

Core types

Main interface

Solution accessors

Population accessors

Validation