Internal API

EvaluateInitialPoint(p::DSProblem)

Evaluate the initial point.

Throws an error if the initial point is not feasible.

EvaluatePoint!(p::DSProblem{FT}, trial_points)::IterationOutcome where {FT<:AbstractFloat}

Determine whether the set of trial points result in a dominating, improving, or unsuccesful algorithm iteration. Update the feasible and infeasible incumbent points of p.

EvaluatePointSequential(p::DSProblem{FT}, trial_points::Vector{Vector{FT}})::IterationOutcome where {FT<:AbstractFloat}

Single-threaded evaluation of set of trial points.

EvaluatePointParallel!(p::DSProblem{FT}, trial_points::Vector{Vector{FT}})::IterationOutcome where {FT<:AbstractFloat}

Multi-threaded evaluation of set of trial points. Uses the number of threads that Julia was started with.

function_evaluation(p::DSProblem{T}, trial_point::Vector{T})::(T, Bool) where T

Evaluate a single trial point with the objective function of p.

By default calls the function with the trial point and returns the result. Override to provide custom evaluation behaviour.

function_evaluation_parallel(p::DSProblem{T}, trial_point::Vector{T})::Tuple{T, Bool} where T

Evaluate a single trial point with the objective function of p using multiple threads.

@enum IterationOutcome

Has values Dominating, Improving, or Unsuccessful. Corresponding to the three iteration outcomes in MADS-PB.

@enum ConstraintOutcome

Has the values Feasible, WeakInfeasible, or StrongInfeasible to classify the outcome of the constraint evaluations of a single point.

A Feasible point meets the requirement of all constraints with no relaxation.

A WeakInfeasible outcome has at least one relaxable constraint violated but no unrelaxable constraints violated.

A StrongInfeasible outcome indicates at least one unrelaxable constraint has been violated or the relaxable constraint violation is reater than hmax.

CollectionIndex

An Int wrapper that is used for indexing constraint collections within a Constraints object.

CollectionIndex

An Int wrapper that is used for indexing constraints within a ConstraintCollection object.

ConstraintCollection{FT,C}(h_max::FT,
                           h_max_update::Function,
                           aggregator::Function
                          ) where {FT<:AbstractFloat,C<:AbstractConstraint}

Contains multiple constraints of the same type that have the same settings applied to them.

h_max is the initial hmax value. h_max_update is a function that should update h_max given an IterationOutcome value. aggregator is a function that will bring all constraint violations of a collection into a single h result.

Defaults for each of these values are set in the AddProgressiveCollection and AddExtremeCollection functions.

AbstractProgressiveConstraint <: AbstractConstraint

Parent type for progressive contraints.

ProgressiveConstraint(f::Function)

Create a progressive barrier constraint.

Argument f is a function that should take a single vector argument and return a value that gives the amount the constraint function has been violated.

A value greater than 0 indicates the function has been violated, 0 shows that the input lies on the constraint, and negative numbers show a feasible value.

Negative numbers may be truncated to 0 without affecting the algorithm.

ExtremeConstraint(f::Function)

Create an extreme barrier constraint. Function f should take a vector argument and return true or false to indicate if the vector meets the constraint.

Constraints{FT<:AbstractFloat}()

Create an object that constains multiple ConstraintCollection objects and their corresponding ConstraintCache.

Upon creation Constraints is automaticvally populated with two constraint collections, an ExtremeCollection and a ProgressiveCollection.

CollectionTypeCount(c::Constraints{T}, C::AbstractConstraint)::Int where T

Return the total number of constraints of type C that are stored in all collections.

ConstraintEvaluation(constraints::Constraints{T}, p::Vector{T})::Tuple{ConstraintOutcome,T} where T

Evaluate point p over all constraint collections in constraints. Returns a ConstraintOutcome indicating the result of the evaluation:

Feasible: p evaluated as feasible for all constraints (extreme and progressive barrier)

WeakInfeasible: p evaluated as feasible for all extreme barrier constraints, and had no progressive barrier constraint violations greater than h_max

StrongInfeasible: At least one extreme barrier constraint evaluated as infeasible, or at least one progressive barrier constraint had a violation greater than h_max

The second returned value is the sum of h_max values evaluated during the constraint checks.

abstract type AbstractMesh end

Parent type of any struct implementing the construction of a mesh. To maintain compatibility with other aspects of the package, the naming convention for variables within structs must be followed. These respect the notation used within Audet, Le Digabel & Tribes 2019.

MeshSetup!(p::DSProblem)

Set up the mesh with the parameters defined for problem.

MeshSetup!(p::DSProblem, m::AnisotropicMesh)

Set up the anisotropic mesh with the parameters defined for problem.

MeshUpdate!(p::DSProblem, result::IterationOutcome)

Update the mesh in p based on the outcome of the most recent iteration.

MeshUpdate!(mesh::AnisotropicMesh, ::AbstractPoll, result::IterationOutcome, dir::Union{Vector,Nothing})

Implements update rule from Audet, Le Digabel & Tribes 2019 adapted for progressive barrier constraints with Audet & Dennis 2009 expression 2.4.

dir is the direction of success of the iteration, equal to nothing, if there is none.

MeshUpdate!(m::IsotropicMesh, ::AbstractPoll, result::IterationOutcome, ::Union{Vector,Nothing})

Implements update rule for the isotropic mesh m with a generic polling scheme using Audet & Dennis 2006 pg. 23, with slight modifications to handle progressive barrier constrained optimization from Audet & Dennis 2009 expression 2.4.

MeshUpdate!(m::IsotropicMesh, o::OrthoMADS, result::IterationOutcome, ::Union{Vector,Nothing})

Implements the OrthoMads update rules for the Isotropic mesh.

get_poll_size_estimate(x⁰::T, lower_bound::Union{T,Nothing}, upper_bound::Union{T,Nothing})::T where T

Calculates the initial poll size, as given in Audet, Le Digabel & Tribes 2019 expression 3.3, using the initial point and variable bounds, if specified.

Poll(p::DSProblem{T})::IterationOutcome where T

Generate points and call evaluate on them.

GeneratePollPoints(p::DSProblem{T}, ::AbstractMesh)::Vector{Vector{T}} where T

Generate a set of directions with the configured polling algorithm, then return the set of points these directions give from the incumbent points.

GenerateDirections(p::DSProblem)

Generate a set of directions with the configured polling algorithm.

ScaleDirection(p::AnisotropicMesh, dir::Vector{T}) where T

Scale the direction vector dir using the scaling information in the mesh m. On Anistropic meshes, this uses the vector ρ, which is the mesh ratio.

ScaleDirection(m::IsotropicMesh, dir::Vector{T}) where T

Scale the direction vector dir using the scaling information in the mesh m. For the isotropic mesh, this operation is a nop because the mesh has no scaling applied.

Search(p::DSProblem{T})::IterationOutcome  where T

Generate search points and call evaluate on them.

GenerateSearchPoints(p::DSProblem{T})::Vector{Vector{T}} where T

Calls GenerateSearchPoints for the search step within p.

GenerateSearchPoints(p::DSProblem{T}, ::RandomSearch)::Vector{Vector{T}} where T

Finds points that are Δᵐ distance from any point in the mesh in a uniformly random direction.

GenerateSearchPoints(p::DSProblem, ::NullSearch)

Search method that returns an empty vector.

Use when no search method is desired.

GenerateDirections(p::AbstractProblem, DG::LTMADS{T})::Matrix{T}

Generates columns and forms a basis matrix for direction generation.

GenerateDirections(p::DSProblem{T}, DG::LTMADS{T})::Vector{Vector{T}}

Generates columns and forms a basis matrix for direction generation.

abstract type AbstractCache end

Parent type of any struct implementing the cache.

PointCache{T} <: AbstractCache

An abstract cache subtype that contains a dictionary of points/costs and a vector that stores the order of incumbent points.

CachePush(p::AbstractProblem, x::Vector, cost)

Add point x and its cost cost to the cache of p.

CachePush(p::AbstractProblem)

Add the feasible and infeasible incumbent points (assuming neither are nothing) to the cache.

CacheQuery(p::AbstractProblem, x::Vector)

Query the cache of p to find if it has a cost value for point x. Alias to haskey.

CacheGet(p::AbstractProblem, x::Vector)

Return the cost of point x in the cache of p. Does not check if x is in the cache, use CacheQuery to check.

CacheRandomSample(p::AbstractProblem, n::Int)

Returns a uniformly sampled collection of n points from the cache. Points can be repeated in the sample.

CacheInitialPoint(p::AbstractProblem)

Return a tuple of the initial point added to the cache and its cost.

CacheGetRange(p::AbstractProblem, points::Vector)::Vector{Vector}

Return a vector of costs corresponding to the vector of points.

CacheFilter(p::AbstractProblem{T}, points::Vector{T})::Tuple{Vector{Vector{T}},Vector{Vector{T}}} where T

Return a tuple where the first entry is the set of input points in the cache and the second is the set of input points not in the cache.