`BlackBoxOptim.CEC09_Unconstrained_Set`

— ConstantThe collection of CEC09 unconstrained multi-objective problems.

See http://dces.essex.ac.uk/staff/zhang/MOEAcompetition/cec09testproblem0904.pdf.pdf

`BlackBoxOptim.DefaultParameters`

— ConstantDefault parameters for all convenience methods that are exported to the end user.

See `OptRunController`

for the description.

`BlackBoxOptim.EMPTY_PARAMS`

— ConstantThe default placeholder value for parameters argument.

`BlackBoxOptim.JadeFunctionSet`

— ConstantJADE collection of optimization problems.

We skip (for now) `f12`

and `f13`

in the JADE paper since they are penalized functions which are quite nonstandard. We also skip `f8`

since we are unsure about its proper implementation.

`BlackBoxOptim.MethodNames`

— ConstantNames of optimization methods accepted by `bboptimize()`

, `:Method`

keyword argument.

`BlackBoxOptim.MultiObjectiveMethods`

— ConstantMulti-objective optimization methods accepted by `bboptimize()`

.

The values are the method initialization routines or types derived from `Optimizer`

.

`BlackBoxOptim.NO_GEN_OP`

— ConstantPlaceholder for no-effect genetic operations.

`BlackBoxOptim.PM_DefaultOptions`

— ConstantDefault parameters for `PolynomialMutation`

.

`BlackBoxOptim.SingleObjectiveMethods`

— ConstantSingle objective optimization methods accepted by `bboptimize()`

.

The values are the method initialization routines or types derived from `Optimizer`

.

`BlackBoxOptim.ZERO_SEARCH_SPACE`

— Constant0-dimensional search space. Could be used as a placeholder for optional `SearchSpace`

parameters.

`BlackBoxOptim.AbstractAsyncEvaluator`

— TypeThe abstract base type for asynchronous evaluators.

Asynchronous evaluator allows submitting fitness calculation requests via `async_update_fitness!`

method that returns `AbstractFitnessEvaluationJob`

object without waiting for the calculation completion. Job object could then be passed to `sync_update_fitness`

that waits until fitnesses for all specified jobs is calculated.

`BlackBoxOptim.AbstractFitnessEvaluationJob`

— TypeThe abstract base type for the fitness evaluation jobs returned by `async_update_fitness!`

and accepted by `sync_update_fitness`

.

One can also check whether the fitness completed with `Base.isready`

method.

`BlackBoxOptim.AbstractIndividual`

— TypeThe point of the `SearchSpace`

.

The abstract type. It allows different actual implementations to be used, e.g `Vector`

or `SubArray`

.

`BlackBoxOptim.AbstractPopulationCandidatesIterator`

— TypeIterator of the population individuals as `Candidate{F}`

object.

`BlackBoxOptim.AdaptiveDiffEvoParameters`

— TypeSpecific data and functions for adaptation An Adaptive DE typically changes parameters of the search dynamically. This is typically done in the `tell!()`

function when we know if the trial vector was better than the target vector.

`BlackBoxOptim.AdaptiveDiffEvoRandBin`

— TypeAn Adaptive DE crossover operator changes `cr`

and `f`

parameters of the search dynamically.

`BlackBoxOptim.Archive`

— Type`Archive`

saves information about promising solutions during an optimization run.

`BlackBoxOptim.ArchiveOutput`

— TypeBase class for archive-specific component of the `OptimizationResults`

.

`BlackBoxOptim.ArchivedIndividual`

— TypeBase class for individuals stored in `Archive`

.

`BlackBoxOptim.AskTellOptimizer`

— TypeBase abstract class for optimizers that perform `ask()`

→ ..eval fitness.. → `tell!()`

sequence at each step.

`BlackBoxOptim.BimodalCauchy`

— TypeA mixture of 2 Cauchy distributions. Random values are further constrained to `[0.0, 1.0]`

range either by truncating the initial unconstrained value or by generating new random value until it fits the range.

`BlackBoxOptim.BorgMOEA`

— TypeBorg MOEA algorithm.

Based on Hadka & Reed, "Borg: An Auto-Adaptive Many-Objective Evolutionary Computing Framework", Evol. Comp. 2013

`BlackBoxOptim.BorgMutantsIterator`

— TypeIterates the mutants.

`BlackBoxOptim.Candidate`

— TypeCandidate solution to the problem.

Candidate can be either a member of the population (`index`

> 0) or a standalone solution (`index`

== -1). Can carry additional information, like the `tag`

or the genetic operator applied (`extra`

).

`BlackBoxOptim.ComplexFitnessScheme`

— TypeComplex-valued fitness.

`BlackBoxOptim.ContinuousRectSearchSpace`

— Type`SearchSpace`

defined by a continuous range of valid values for each dimension.

`BlackBoxOptim.CrossoverOperator`

— TypeModifies `NC`

"children" by transferring some information from `NP`

"parents".

The concrete implementations must provide `apply!()`

method.

`BlackBoxOptim.DXNESOpt`

— TypeDX-NES: distance-weighted extensions of xNES by Fukushima et al.

`BlackBoxOptim.DictChain`

— TypeAn ordered set of dicts that are examined one after another to find the parameter value. Returns nothing if no param setting is found in any of the dicts.

`BlackBoxOptim.DirectSearcher`

— TypeA supertype for all generating set searcher-like algorithms.

`BlackBoxOptim.DirectionGenerator`

— Type`DirectionGenerator`

generates the search directions to use at each step of a GSS search.

`BlackBoxOptim.DominanceCone`

— TypeSet of points in fitness space that Pareto-dominate (`MIN`

is `true`

) or are dominated by (`MIN`

is `false`

) the given point `pt`

.

The point `pt`

itself is not part of its `DominanceCone`

.

If the goal is to maximize each individual fitness component (i.e. `is_minimizing(fs::FitnessScheme) == false`

), the cone of Pareto-dominating points should use `MIN = false`

and Pareto-dominated points should use `MIN = true`

.

`BlackBoxOptim.EmbeddingOperator`

— TypeEmbeds(projects) the individual into the search space.

The concrete implementations must provide `apply!()`

method.

`BlackBoxOptim.EpsBoxArchive`

— Typeϵ-box archive saves only the solutions that are not ϵ-box dominated by any other solutions in the archive.

It also counts the number of candidate solutions that have been added and how many ϵ-box progresses have been made.

`BlackBoxOptim.EpsBoxArchiveOutput`

— Type`EpsBoxArchive`

-specific components of the optimization results.

`BlackBoxOptim.EpsBoxDominanceFitnessScheme`

— Type`EpsBoxDominanceFitnessScheme`

defines ϵ-box dominance for `N`

-tuple (`N`

≧1) fitnesses. It operates with fitnesses of type `IndexedTupleFitness`

.

`aggregator::AGG`

is a function mapping tuple fitness to a single numerical value. Might be used for comparisons (or not, depending on the setup). Always used when printing fitness vectors though.

`BlackBoxOptim.EpsBoxFrontierIndividual`

— TypeIndividual stored in `EpsBoxArchive`

.

`BlackBoxOptim.EpsDominanceFitnessScheme`

— Typeϵ-dominance for `N`

-tuple (`N`

≧1) fitnesses.

`aggregator::AGG`

is a function mapping tuple fitness to a single numerical value. Might be used for comparisons (or not, depending on the setup). Always used when printing fitness vectors though.

`BlackBoxOptim.Evaluator`

— TypeThe abstract base for types that manage the objective function evaluation. `P`

is the optimization problem it is used for.

`BlackBoxOptim.ExponentialNaturalEvolutionStrategyOpt`

— TypeAbstract type for a family of NES methods that represent population as

`x = μ + σ B⋅Z,`

where `B`

is an exponential of some symmetric matrix `lnB`

, `tr(lnB)==0.0`

`BlackBoxOptim.FAGeneticOperatorsMixture`

— TypeFrequency-adapting genetic operators mixture.

`BlackBoxOptim.FitIndividual`

— TypeA point in the problem's search space with the corresponding fitness value.

`F`

is the original problem's fitness type

`BlackBoxOptim.FitPopulation`

— TypeThe default implementation of `PopulationWithFitness{F}`

.

`BlackBoxOptim.FitnessScheme`

— Type`FitnessScheme`

defines how fitness vectors/values are compared, presented and aggregated. `Fitness`

represents the score of one and the same individual on one or a set of evaluations. A scheme is a specific way to consider the scores in a coherent way. Type parameter `F`

specifies the type of fitness values.

`FitnessScheme`

could also be used as a function that defines the fitness ordering, i.e. `fs(x, y) == true`

iff fitness `x`

is better than `y`

.

`BlackBoxOptim.FixedDimensionSearchSpace`

— TypeA base abstract type for search spaces with a fixed finite number of dimensions. Applicable to the vast majority of problems.

`BlackBoxOptim.FixedGeneticOperatorsMixture`

— TypeRandomly selects the genetic operator from the vector according to its weight and applies it.

`BlackBoxOptim.FrequencyAdapter`

— TypeA `FrequencyAdapter`

adapts the frequencies with which a set of values/strategies/methods should be applied/tried in an optimization problem. It is based on the `Adaptive Coordinate Frequencies`

scheme described in:

T. Glasmachers and U. Dogan, "Accelerated Coordinate Descent with Adaptive Coordinate Frequencies", 2013.

but generalized so that it can support more than the adaptation of only the coordinates in a Coordinate Descent scheme. The things that are being adapted are identified by integers in 1:n, with n being the main parameter.

`BlackBoxOptim.FrontierIndividual`

— TypeIndividual representing the solution from the Pareto set.

`BlackBoxOptim.FrontierIndividualWrapper`

— TypeWrapper for `FrontierIndividual`

that allows easy access to the problem fitness.

`BlackBoxOptim.FunctionBasedProblem`

— Type`OptimizationProblem`

with the objective function defined by some Julia `Function`

and search space.

Optionally, a known optimal value could be provided to terminate the optimization once it is reached.

`BlackBoxOptim.FunctionBasedProblemFamily`

— TypeFamily of `FunctionBasedProblem`

optimization problems parameterized by the number of search space dimensions.

`BlackBoxOptim.GeneratingSetSearcher`

— TypeGenerating Set Search as described in Kolda2003: Kolda, Tamara G., Robert Michael Lewis, and Virginia Torczon. "Optimization by direct search: New perspectives on some classical and modern methods." SIAM review 45.3 (2003): 385-482.

`BlackBoxOptim.GeneticOperator`

— TypeAbstract genetic operator that transforms individuals in the population.

`BlackBoxOptim.GeneticOperatorsMixture`

— TypeA mixture of genetic operators, use `next()`

to choose the next operator from the mixture.

`BlackBoxOptim.GibbsMutationOperator`

— TypeProvides `apply()`

operator that mutates one specified dimension of a parameter vector.

`BlackBoxOptim.Hypersurface`

— Type$(N-1)$-dimensional manifold in $N$-dimensional space.

`BlackBoxOptim.IndexedTupleFitness`

— Typeϵ-box indexed representation of the N-tuple fitness.

Used together with `EpsBoxDominanceFitnessScheme`

.

`BlackBoxOptim.Individual`

— TypeThe point of the `SearchSpace`

.

The concrete type that could be used for storage.

`BlackBoxOptim.IndividualsSelector`

— TypeSelects the individuals from the population.

The concrete implementations must provide `select()`

method.

`BlackBoxOptim.MethodOutput`

— TypeBase class for method-specific component of the `OptimizationResults`

.

`BlackBoxOptim.MirroredRandomDirectionGen`

— TypeGenerate half of the directions randomly and then mirrors by negating them.

`BlackBoxOptim.MixedPrecisionRectSearchSpace`

— Type`RectSearchSpace`

that allows both continuous and discrete dimensions. Discrete dimensions are defined by the number of digits (`dimdigits(ss)`

) after decimal point (i.e. precision)

If `dimdigits(ss, i)`

is negative, `i`

-th dimension is considered continuous.

`BlackBoxOptim.MultithreadEvaluator`

— TypeFitness evaluator that asynchronously distributes calculation among several worker threads.

`BlackBoxOptim.MutationClock`

— TypeMutation clock operator is a more efficient way to mutate vectors than to generate a random value per variable in the vectors. It instead generates the number of variables to skip until the next mutation. Then it uses a sub-mutation operator to do the actual mutation. This is based on the paper: Deb and Deb (2012), "Analyzing Mutation Schemes for Real-Parameter Genetic Algorithms" but we use a Poisson distribution.

`BlackBoxOptim.MutationOperator`

— TypeModifies (mutates) one individual.

The concrete implementations must provide `apply!()`

method.

`BlackBoxOptim.MutationWrapper`

— TypeWraps the mutation operator, so that it could be used as crossover operator.

`BlackBoxOptim.NoMutation`

— Type`MutationOperator`

that does nothing.

`BlackBoxOptim.OptController`

— TypeOptimization Controller.

Applies specific optimization method to a given problem. Supports restarts and modifying parameter of the method between runs. `runcontrollers`

field maintains the list of `OptRunController`

instances applied so far.

See `OptRunController`

.

`BlackBoxOptim.OptController`

— MethodCreate `OptController`

for a given `optimizer`

and a `problem`

.

`params`

are any of `OptRunController`

parameters plus * `:RngSeed`

and `:RandomizeRngSeed`

params for controlling the random seed * `:RecoverResults`

if intermediate results are returned upon `InterruptException()`

(on by default)

`BlackBoxOptim.OptRunController`

— TypeOptimization Run Controller. Manages problem optimization using the specified method.

See `OptController`

.

`BlackBoxOptim.OptRunController`

— Method`OptRunController(optimizer::O, evaluator::E, params)`

Create `OptRunController`

for a given problem using specified `optimizer`

.

**Arguments**

`optimizer`

initialized optimization method`evaluator`

the evaluator of the problem fitness`params`

controller settings, see`DefaultParameters`

for the default values:`:MaxTime`

max time in seconds (takes precedence over the other budget-related params if specified), 0.0 disables the check`:MaxFuncEvals`

max fitness evals (takes precedence over max iterations, but not max time), 0 disables the check`:MaxSteps`

max iterations gives the least control since different optimizers have different "size" of their "iterations"`:MaxStepsWithoutProgress`

max iterations without fitness improvement`:MinDeltaFitnessTolerance`

minimum delta fitness (difference between the two consecutive best fitness improvements) we can accept before terminating`:FitnessTolerance`

stop the optimization when the best fitness found is within this distance of the actual optimum (if known)`:MaxNumStepsWithoutFuncEvals`

stop optimization if no new fitness evals in this many steps (indicates a converged/degenerate search)`:NumRepetitions`

number of repetitions to run for each optimizer for each problem`:TraceMode`

how the optimizer state is traced to the STDOUT during the optimization (one of`:silent`

,`:verbose`

)`:TraceInterval`

the trace interval (in seconds)`:SaveTrace`

whether to save it to a file (defaults to`false`

)`:SaveFitnessTraceToCsv`

whether the history of fitness changes during optimization should be save to a csv file`:SaveParameters`

save method/controller parameters to a JSON file

`BlackBoxOptim.OptimizationProblem`

— TypeThe base abstract type for all optimization problems. `FS`

is a type of a problem's `FitnessScheme`

.

`BlackBoxOptim.OptimizationResults`

— TypeThe results of running optimization method.

Returned by `run!(oc::OptRunController)`

. Should be compatible (on the API level) with the `Optim`

package. See `make_opt_results()`

.

`BlackBoxOptim.Optimizer`

— TypeBase abstract class for black-box optimization algorithms.

`BlackBoxOptim.ParallelEvaluationState`

— TypeCurrent state of fitness function evaluation for the vector of candidates.

`BlackBoxOptim.ParallelEvaluator`

— TypeFitness evaluator that distributes candidates fitness calculation among several worker processes.

`BlackBoxOptim.ParallelEvaluatorWorker`

— TypeInternal data for the worker process of the parallel evaluator.

`BlackBoxOptim.ParamBounds`

— TypeThe valid range of values for a specific dimension of `SearchSpace`

.

`BlackBoxOptim.Parameters`

— TypeThe parameters storage type for `BlackBoxOptim`

.

`BlackBoxOptim.ParamsDict`

— TypeThe default parameters storage in `BlackBoxOptim`

.

`BlackBoxOptim.ParentCentricCrossover`

— TypeParent Centric Crossover (PCX).

See Deb, K., Anand, A., and Joshi, D., "A Computationally Efficient Evolutionary Algorithm for Real-Parameter Optimization," Evolutionary Computation, vol. 10, no. 4, pp. 371-395, 2002.

`BlackBoxOptim.ParetoFitnessScheme`

— TypePareto dominance for `N`

-tuple (`N`

≧1) fitnesses.

`aggregator::AGG`

is a function mapping tuple fitness to a single numerical value. Might be used for comparisons (or not, depending on the setup). Always used when printing fitness vectors though.

`BlackBoxOptim.PolynomialMutation`

— TypePolynomial mutation as presented in the paper: Deb and Deb (2012), "Analyzing Mutation Schemes for Real-Parameter Genetic Algorithms"

`BlackBoxOptim.Population`

— TypeThe base abstract type for the collection of candidate solutions in the population-based optimization methods.

`BlackBoxOptim.PopulationCandidatesIterator`

— TypeIterates the candidates of population.

`BlackBoxOptim.PopulationMatrix`

— TypeThe simplest `Population`

implementation – a matrix of floats, each column is an individual.

`BlackBoxOptim.PopulationOptimizer`

— TypeBase class for population-based optimization methods.

`BlackBoxOptim.PopulationOptimizerOutput`

— Type`PopulationOptimizer`

-specific components of the `OptimizationResults`

. Stores the final population.

`BlackBoxOptim.PopulationWithFitness`

— TypeThe base abstract types for population that also stores the candidates fitness.

`F`

is the fitness type.

`BlackBoxOptim.ProblemEvaluator`

— TypeDefault implementation of the `Evaluator`

.

`FP`

is the original problem's fitness type `FA`

is the fitness type actually stored by the archive.

`BlackBoxOptim.ProblemFamily`

— TypeBase class for problem families.

It is an abstraction for problem parameterization (e.g by the number of the search space dimensions) that allows to instantiate `OptimizationProblem`

for the concrete parameters.

`BlackBoxOptim.RadiusLimitedSelector`

— Type`IndividualsSelector`

that implements a "trivial geography" similar to Spector and Kline (2006) by first sampling an individual randomly and then selecting additional individuals for the same tournament within a certain deme of limited size (`radius`

) for the sub-sequent individuals in the population.

The version we implement here is from: I. Harvey, "The Microbial Genetic Algorithm", in Advances in Artificial Life Darwin Meets von Neumann, Springer, 2011. The original paper is: Spector, L., and J. Klein. 2005. Trivial Geography in Genetic Programming. In Genetic Programming Theory and Practice III, edited by T. Yu, R.L. Riolo, and B. Worzel, pp. 109-124. Boston, MA: Kluwer Academic Publishers. http://faculty.hampshire.edu/lspector/pubs/trivial-geography-toappear.pdf

`BlackBoxOptim.RandomBound`

— TypeEmbedding operator that randomly samples between parent's value and the nearest parameter boundary to get the new valid value if target's parameter is out-of-bounds.

`BlackBoxOptim.RandomSearcher`

— TypeOptimize by randomly generating the candidates.

`BlackBoxOptim.RatioFitnessScheme`

— TypeIn `RatioFitnessScheme`

the fitness values can be ranked on a ratio scale so pairwise comparisons are not required. The default scale used is the aggregate of the fitness components.

`BlackBoxOptim.RealtimePlot`

— TypeSpecification of a plot for the real-time tracking of the fitness progress.

To use the *VegaLite* front-end via *BlackBoxOptimRealtimePlotServerExt* extension, *HTTP.jl* and *Sockets.jl* are required.

`BlackBoxOptim.RectSearchSpace`

— TypeCreate `RectSearchSpace`

with given number of dimensions and given range of valid values for each dimension.

`BlackBoxOptim.RectSearchSpace`

— TypeA `SearchSpace`

with `N`

-dimensional rectangle as a set of valid points. I.e. `dimmin(ss, i)`

≤ `x[i]`

≤ `dimmax(ss, i)`

for each dimension `i`

.

`BlackBoxOptim.RectSearchSpace`

— Method`RectSearchSpace(dimranges::AbstractVector; [dimdigits = nothing])`

Create `RectSearchSpace`

with given range of valid values for each dimension and, if specified, `dimdigits`

precision for each dimension. Returns `MixedPrecisionRectSearchSpace`

if there's at least one dimension with specified precision (dimdigits[i] ≥ 0), otherwise `ContinuousRectSearchSpace`

.

`BlackBoxOptim.ResamplingMemeticSearcher`

— TypeThe variants of the memetic search algorithms RS and RIS. However, we have modified them since they did not give very good performance when implemented as described in the papers below. Possibly, the papers are not unambigous and I have misinterpreted something from them...

The "Resampling Search" (RS) memetic algorithm is described in:

```
F. Caraffini, F. Neri, M. Gongora and B. N. Passow, "Re-sampling Search: A
Seriously Simple Memetic Approach with a High Performance", 2013.
```

and its close sibling "Resampling Inheritance Search" (RIS) is described in:

```
F. Caraffini, F. Neri, B. N. Passow and G. Iacca, "Re-sampled Inheritance
Search: High Performance Despite the Simplicity", 2013.
```

`BlackBoxOptim.ScalarFitnessScheme`

— Type`Float64`

-valued scalar fitness scheme. The boolean type parameter `MIN`

specifies if smaller fitness values are better (`true`

) or worse (`false`

).

`BlackBoxOptim.SearchSpace`

— TypeA base abstract type for `OptimizationProblem`

search space. A concrete `SearchSpace`

subtype specifies the valid candidate points that could be considered in a search/optimization.

`BlackBoxOptim.SeparableNESOpt`

— TypeSeparable Natural Evolution Strategy (sNES) optimizer.

`BlackBoxOptim.ShiftedAndBiasedProblem`

— TypeA `TransformedProblem`

subclass that shifts the objective argument and offsets the value: $f(x - xshift) + fitshift$ → min/max, $x$ ∈ $X$ ($X$ stays intact).

`BlackBoxOptim.SimpleSelector`

— TypeSimple random `IndividualsSelector`

.

The probabilties of all candidates are equal.

`BlackBoxOptim.SimplexCrossover`

— TypeSimplex Crossover (SPX).

`ϵ>0`

controls how the original simplex is inflated, `ϵ=1`

means no inflation.

See Tsutsui, Yamamura & Higuchi "Multi-parent recombination with simplex crossover in real coded genetic algorithms", 1999, Proc. of the Genetic and Evolutionary Computation Conference

`BlackBoxOptim.SimulatedBinaryCrossover`

— TypeSimulated Binary Crossover (SBX).

See Deb&Agrawal "Simulated binary crossover for continuous search space", 1994, Complex Systems

`BlackBoxOptim.SlidingBitset`

— TypeBitSet-based container that could be used to e.g. store the ids of completed jobs by `MultithreadEvaluator`

. Assumes there is `max_seq_el`

element, so that all *1:max seqel* elements are in the set.

`BlackBoxOptim.SteppingOptimizer`

— TypeOptimizers derived from `SteppingOptimizer`

implement classical iterative optimization scheme `step!()`

→ `step!()`

→ …

`BlackBoxOptim.StochasticApproximationOptimizer`

— Type`AskTellOptimizer`

that utilizes randomization to generate the candidates.

`BlackBoxOptim.TopListArchive`

— TypeArchive that maintains a top list of the best performing (best fitness) candidates seen so far.

The two last best fitness values could be used to estimate a confidence interval for how much improvement potential there is.

`BlackBoxOptim.TopListArchiveOutput`

— Type`TopListArchive`

-specific components of the optimization results.

`BlackBoxOptim.TopListFitness`

— TypeFitness as stored in `TopListArchive`

.

`BlackBoxOptim.TopListIndividual`

— TypeIndividual stored in `TopListArchive`

.

`BlackBoxOptim.TournamentSelector`

— TypeTournament selector.

`BlackBoxOptim.TransformedProblem`

— Type`TransformedProblem{FS, P}`

is an abstract class for optimization problems derived from some original problem of type `P`

by introducing a few changes.

The concrete derived types must implement:

`objfunc()`

method`fitness_scheme()`

and`search_space()`

`BlackBoxOptim.TupleFitnessScheme`

— TypeBase class for tuple-based fitness schemes.

Type parameters:

`N`

is the number of the objectives`F`

is the type of each objective`FA`

is the actual type of the multi-objective fitness`MIN`

if objectives should be minimized or maximized`AGG`

the type of aggregator

`BlackBoxOptim.UniformMutation`

— TypeUniform mutation of a parameter vector.

`BlackBoxOptim.UnimodalNormalDistributionCrossover`

— TypeUnimodal Normal Distribution Crossover (UNDX).

See Kita, H., Ono, I., and Kobayashi, S., "Multi-parental Extension of the Unimodal Normal Distribution Crossover for Real-coded Genetic Algorithms," Proceedings of the 1999 Congress on Evolutionary Computation, pp. 1581-1588, 1999. Deb, K., Anand, A., and Joshi, D., "A Computationally Efficient Evolutionary Algorithm for Real-Parameter Optimization," Evolutionary Computation, vol. 10, no. 4, pp. 371-395, 2002.

`BlackBoxOptim.XNESOpt`

— Type`xNES`

method.

Nice but scales badly with increasing dimensions.

`Base.in`

— Method`in(ind::AbstractIndividual, ss::SearchSpace)`

Check if given individual lies in the given search space.

`BlackBoxOptim.CEC09_UP8`

— MethodCEC09 Unconstrained Problem 8 objective function.

`BlackBoxOptim.CEC09_UP8_PF`

— MethodCEC09 Unconstrained Problem 8 Pareto Frontier. Parameterized by t[1]=f[1] and t[2]=f[2].

`BlackBoxOptim.IGD`

— Method`IGD(A::Vector{NTuple{N,F}}, B::Vector{NTuple{N,F}}, [two_sided=true])`

The average Euclidean distance from the points of `A`

to the points of `B`

.

`BlackBoxOptim.IGD`

— Method`IGD(ref::Hypersurface, sol::Vector{FitIndividual}, [two_sided=true])`

Average Euclidean distance from the exact Pareto frontier of the problem (`ref`

) to the solution (`sol`

) produced by the optimization method. If `two_sided`

is on, returns the maximum of `IGD(sol, ref)`

and `IGD(nondominated(ref), sol)`

.

`BlackBoxOptim.accept_candi!`

— MethodPut the candidate back into the pool and copy the values into the corresponding individual of the population (`candi.index`

should be set).

`BlackBoxOptim.acquire_candi`

— Method`acquire_candi(pop::FitPopulation[, {ix::Int, candi::Candidate}])`

Get individual from a pool, or create one if the pool is empty. By default the individual is not initialized, but if `ix`

or `candi`

is specified, the corresponding fields of the new candidate are set to the given values.

`BlackBoxOptim.add_candidate!`

— Method`add_candidate!(a::TopListArchive, fitness::F, candidate[, tag=0][, num_fevals=-1])`

Add a candidate with a fitness to the archive (if it is good enough).

`BlackBoxOptim.adjust!`

— MethodAdjust the parameters of the method after the candidate evaluation.

`BlackBoxOptim.adjust!`

— MethodAdjust the internal parameters of the genetic operator `op`

taking into account the fitness change.

The default implementation does nothing.

`BlackBoxOptim.aggregate`

— MethodAggregation is just the identity function for scalar fitness.

`BlackBoxOptim.apply!`

— MethodDefault implementation of `apply!()`

for operators mixture.

`BlackBoxOptim.archived_fitness`

— Method`archived_fitness(fit, a::Archive)`

Converts given fitness `fit`

to the format used by the archive `a`

.

`BlackBoxOptim.ask`

— Function`ask(ato::AskTellOptimizer)`

Ask for a new candidate solution to be generated, and a list of individuals it should be ranked with.

The individuals are supplied as an array of tuples with the individual and its index.

See also `tell!()`

`BlackBoxOptim.assign_weights!`

— Method`assign_weights!(weights, rankedCandidates, sortedWeights)`

Assigns the candidate `weights`

according to the candidate index. `rankedCandidates`

are ranked by their fitness, `sortedWeights`

are the corresponding weights.

Returns candidate weights sorted by the individual's index in the population.

`BlackBoxOptim.async_update_fitness!`

— Function```
async_update_fitness!(eval::AbstractAsyncEvaluator, candidates::Any;
force::Bool=false) ->
Union{AbstractFitnessEvaluationJob, Nothing}
```

Asynchronously calculate the fitnesses. *candidates* should support the `iterate()`

interface and return `Candidate`

elements.

Returns `AbstractFitnessEvaluationJob`

or `nothing`

if *candidates* does not contain any candidates.

**Arguments**

`force::Bool`

: force fitness calculation even if the candidate already has non-NA fitness

See also: `sync_update_fitness`

`BlackBoxOptim.bboptimize`

— Function`bboptimize(problem[, x0, parameters::Associative; kwargs...])`

Solve given optimization `problem`

. Optionally a starting point `x0`

can be specified.

See `setup_problem()`

for the types of `problem`

supported. In addition, the `problem`

could be `OptController`

containing the results of the previous optimization runs.

The optimization method parameters could be specified via `kwargs`

or `parameters`

arguments.

Returns `OptimizationResults`

instance.

See also `bbsetup()`

and `BlackBoxOptim.OptRunController`

for a full list of supported parameters.

`BlackBoxOptim.bbsetup`

— Function`bbsetup(problem[; parameters::Associative, kwargs...])`

Set up optimization method for a given problem.

See `setup_problem()`

for the types of `problem`

supported. The optimization method parameters could be specified via `kwargs`

or `parameters`

arguments.

Returns the initialized `OptController`

instance. To actually run the method call `bboptimize()`

or `run!()`

.

See also BlackBoxOptim.OptRunController for a full list of supported parameters.

`BlackBoxOptim.calculate_evol_path_params`

— MethodCalculate the parameters for evolutionary path.

Returns the tuple:

- moving threshold
- path discount
- current Z scale

`BlackBoxOptim.count_dict_report`

— FunctionReport the number of times each key was encountered in a count `dict`

.

Returns a percentage dict calculated while iterating over the counted items.

`BlackBoxOptim.de_rand_1_bin`

— FunctionThe most used `DE/rand/1/bin`

variant of differential evolution.

`BlackBoxOptim.de_rand_1_bin_radiuslimited`

— FunctionThe most used `DE/rand/1/bin`

variant with "local geography" via radius-limited sampling.

`BlackBoxOptim.deceptive_cuccu2011`

— MethodGenerator for the family of deceptive functions from the Cuccu2011 paper on novelty-based restarts. We have vectorized it to allow more than 1D versions. The Cuccu2011 paper uses the following values for

```
(l, w) = [(5, 0), (15, 0), (30, 0),
(5, 2), (15, 2), (30, 2),
(5, 10), (15, 10), (30, 10)]
```

and notes that `(15, 2)`

and `(30, 2)`

are the most difficult instances.

`BlackBoxOptim.delta_fitness`

— Method`delta_fitness(a::TopListArchive)`

The difference between the current best fitness and the former best fitness.

`BlackBoxOptim.dimdelta`

— Method`dimdelta(ss::SearchSpace, [i::Integer])`

A delta of maximal and minimal valid values for `i`

-th dimension of `ss`

(*diameter* of `i`

-th dimension), or a vector of deltas for each dimension if no `i`

given.

`BlackBoxOptim.dimmax`

— Method`dimmax(ss::SearchSpace, [i::Integer])`

A maximal valid value for `i`

-th dimension of `ss`

, or a vector of maximal valid values for each dimension of `ss`

if no `i`

was given.

`BlackBoxOptim.dimmin`

— Method`dimmin(ss::SearchSpace, [i::Integer])`

A minimal valid value for `i`

-th dimension of `ss`

, or a vector of minimal valid values for each dimension of `ss`

if no `i`

was given.

`BlackBoxOptim.dimrange`

— Method`dimrange(ss::SearchSpace, [i::Integer])`

Gets a `ParamsRange`

tuple of minimal and maximal valid values for `i`

-th dimension of `ss`

, or a vector of `ParamsRange`

tuples for each dimension if no `i`

given.

`BlackBoxOptim.distance`

— Method`distance(a::NTuple{N,F}, b::NTuple{N,F})`

Euclidean distance from `a`

to `b`

.

`BlackBoxOptim.distance_to_optimum`

— MethodGet the distance from a fitness value to the optimum/best known fitness value.

`BlackBoxOptim.ellipsoid`

— MethodSchwefel's ellipsoid.

`BlackBoxOptim.energy_tsallis1996`

— MethodFrom section 3, page 7, of Tsallis1996 paper: Tsallis and Stariolo, "Generalized simulated annealing", Physica A, 1996. available from http://www.if.ufrgs.br/~stariolo/publications/TsSt96*PhysA233*395_1996.pdf the original paper used this as a 4-dimensional problem but here it is generalized.

`BlackBoxOptim.evolved_pair`

— MethodPost-process the evolved pair.

`BlackBoxOptim.feasible`

— MethodProjects a given point onto the search space coordinate-wise.

`BlackBoxOptim.feasible`

— MethodProjects a given point onto the search space coordinate-wise.

`BlackBoxOptim.fill_block!`

— MethodFill the block of methods to apply.

`BlackBoxOptim.fitness`

— Function`fitness(params::Individual, e::ProblemEvaluator, tag::Int=0)`

Evaluate the fitness and implicitly update the archive with the provided parameters and calculated fitness.

Returns the fitness in the archived format.

`BlackBoxOptim.fitness`

— Method`fitness(x, p::OptimizationProblem)`

Evaluates the fitness of a candidate.

`BlackBoxOptim.fitness`

— Method`fitness(indi::FitIndividual)`

Gets the fitness of the individual.

`BlackBoxOptim.fitness_improvement_potential`

— Function`fitness_improvement_potential(a::Archive[, p = 0.01])`

Calculate the solution improvement potential.

The percentage improvement that can be expected from the current fitness value at a given `p`

-value. In theory, an optimization run should be terminated when this value is very small, i.e. there is little improvement potential left in the run.

`BlackBoxOptim.fitness_is_within_ftol`

— MethodChecks if the current best fitness is within the given range of a known best fitness. By default the best fitness is unknown.

`BlackBoxOptim.fitness_plot_callback`

— Method`fitness_plot_callback(plot::RealtimePlot, oc::OptRunController)`

OptController callback function that updates the real-time fitness plot.

`BlackBoxOptim.fitness_shaping_utilities_linear`

— Method`fitness_shaping_utilities_linear(n)`

Calculate the `n`

-dimensional fitness shaping utilities vector using the "steps" method.

`BlackBoxOptim.fitness_shaping_utilities_log`

— Method`fitness_shaping_utilities_log(n)`

Calculate the `n`

-dimensional fitness shaping utilities vector using the "log" method.

`BlackBoxOptim.fitness_type`

— Method```
fitness_type(fs::FitnessScheme)
fitness_type(fs_type::Type{FitnessScheme})
```

Get the type of fitness values for fitness scheme `fs`

.

`BlackBoxOptim.format_fitness`

— Method`format_fitness(fit, [problem::OptimizationProblem])`

Format fitness into a string. Calls `show_fitness()`

under the hood.

`BlackBoxOptim.generate`

— Method`generate(surf::Hypersurface, fs::EpsBoxDominanceFitnessScheme, param_step = 0.1*fs.ϵ)`

Generate the points of the hypersurface using the discretization defined by ϵ-box fitness schema.

`BlackBoxOptim.hartman`

— MethodGeneric function for `Hartman N`

problem family.

`BlackBoxOptim.hartman3`

— Method`Hartman 3D`

is a multi-minima, non-separable test problem. Our implementation is based on: http://www.sfu.ca/~ssurjano/hart3.html However, we get a different global minima than the one stated on that page. The minima should be -3.86278 but we get a different one so use that in the problem spec:

`BlackBoxOptim.hartman6`

— Method`Hartman 6D`

is a multi-minima, non-separable test problem. Our implementation is based on: http://www.sfu.ca/~ssurjano/hart6.html

`BlackBoxOptim.hat_compare`

— MethodCheck whether `f1`

or `f2`

fitness is better.

Returns

`-1`

if`f1`

is better than`f2`

`1`

if`f2`

is better than`f1`

`0`

if`f1`

and`f2`

are equal.

`BlackBoxOptim.hat_compare_ϵ_box`

— MethodReturns a tuple of `u`

and `v`

comparison:

`-1`

: u≺v`0`

: u and v non-dominating`1`

: u≻v

and whether `u`

index fully matches `v`

index.

`BlackBoxOptim.ini_xnes_B`

— MethodCalculates the initial $log B$ matrix for `xNES`

based on the deltas of each dimension.

`BlackBoxOptim.ini_xnes_B`

— MethodIdentity for generic search space

`BlackBoxOptim.instantiate`

— Method`instantiate(family::FunctionBasedProblemFamily, ndim::Int)`

Construct `FunctionBasedProblem`

with the given number of dimensions.

`BlackBoxOptim.instantiate_search_space`

— Method`instantiate(family::FunctionBasedProblemFamily, ndim::Int)`

Construct search space for `FunctionBasedProblem`

with the given number of dimensions.

`BlackBoxOptim.is_stopping`

— Function`is_stopping(eval::AbstractAsyncEvaluator) -> Bool`

Check if the evaluator is in the shutdown sequence.

When the evaluator is being shut down, it waits for the workers to finish their jobs and stop, no new jobs could be submitted.

`BlackBoxOptim.last_fitness`

— Method`last_fitness(e::Evaluator)`

Get the fitness of the last evaluated candidate.

Leads to nicer code if we can first test if it is better or worse than existing candidates and only want the fitness itself if the criteria fulfilled.

`BlackBoxOptim.magnitude_class`

— MethodGet a tuple of the sign and the magnitude of the value rounded to the first digit. Used for archiving candidates separately for each magnitude class.

`BlackBoxOptim.make_evaluator`

— FunctionCreate `Evaluator`

instance for a given `problem`

.

`BlackBoxOptim.merge_fitness_histories`

— Method`merge_fitness_histories(histories)`

Merge the collection of multiple fitness histories and calculate the `min`

, `max`

, `avg`

and `median`

values for fitness and FIR (fitness improvement ratio) at each point where the fitness is changing.

`BlackBoxOptim.next`

— Method`next(fa::FixedGeneticOperatorsMixture)`

Gets the random genetic operator from the mixture.

The probability to select an operator is proportional to its weight.

Returns a tuple of the genetic operator and its index in the mix.

`BlackBoxOptim.next`

— Method`next(fa::FrequencyAdapter)`

Give the index of the method that should be used at the next iteration.

`FrequencyAdapter`

maintains a block of randomly shuffled methods. The function takes the next available method in the block. If the block is empty, it is repopulated.

The methods are randomly shuffled each time the block is regenerated, since we need to know their effectiveness at every period of the optimization process.

`BlackBoxOptim.next_candidate!`

— MethodGet the index of the next candidate for evaluation based on the Base.pmap() code.

`BlackBoxOptim.nondominated`

— Method`nondominated(fitnesses, fit_scheme)`

Filter `fitnesses`

removing all dominated values.

`BlackBoxOptim.noprogress_streak`

— Method`noprogress_streak(a::EpsBoxArchive, [since_restart])`

Get the number of `add_candidate!()`

calls since the last ϵ-progress. If `since_restart`

is specified, the number is relative to the last restart.

`BlackBoxOptim.params`

— MethodGet the problem parameters (a point in the search space) of the individual.

`BlackBoxOptim.pareto_frontier`

— Method`pareto_frontier(a::EpsBoxArchive)`

Get the iterator to the individuals on the Pareto frontier.

`BlackBoxOptim.population`

— MethodGenerate a population for a given optimization `problem`

.

`method`

specifies a method for sampling random individuals, defaults to `:latin_hypercube`

.

`BlackBoxOptim.problem_set`

— Method`problem_set(ps::Dict{Any, FunctionBasedProblemFamily}, dims::Union{Int,Vector{Int}})`

Construct a fixed-dimensional version of each problem from `ps`

for each dimension given in `dims`

.

Returns a dictionary of problems.

`BlackBoxOptim.rand_front_elem`

— Method`rand_front_elem(a::EpsBoxArchive)`

Get random Pareto frontier element.

Returns `nothing`

if frontier is empty.

`BlackBoxOptim.rand_individual`

— MethodGenerate one random candidate.

`BlackBoxOptim.rand_individuals`

— Method`rand_individuals(ss, n; [method=:latin_hypercube])`

Generate `n`

individuals by randomly sampling in the `ss`

search space using specified sampling `method`

. The supported methods are:

`uniform`

: uniform independent sampling for each dimension`latin_hypercube`

(the default): use latin hypercube sampling method

`BlackBoxOptim.release_candi`

— MethodPut the candidate back to the pool.

`BlackBoxOptim.report_from_result_dict`

— MethodPrint a report based on a result dict from one set of repeated runs of an optimization method. Returns the success rate, i.e. number of times the termination reason was "Within fitness tolerance...".

`BlackBoxOptim.report_on_values`

— FunctionSummarize a vector of float values by stating its mean, std dev and median.

`BlackBoxOptim.reset!`

— MethodReset the current `ParallelEvaluationState`

and the vector of candidates that need fitness evaluation.

`BlackBoxOptim.reset_fitness!`

— MethodReset the candidate fitness.

Need it when the candidate parameters have changed, but the stored fitness is still for the old parameter set.

`BlackBoxOptim.restart!`

— MethodRestart Borg MOEA.

Resize and refills the population from the archive.

`BlackBoxOptim.run!`

— Method`run!(oc::OptController)`

Start a new optimization run, possibly with new parameters and report on results.

`BlackBoxOptim.run!`

— Method`run!(ctrl::OptRunController)`

Run optimization until one of the stopping conditions are satisfied.

`BlackBoxOptim.sample_unit_hypersphere`

— FunctionGenerate `num`

random vectors on the `n`

-dimensional, unit (hyper)sphere. This is the Muller-Marsaglia method as described here.

`BlackBoxOptim.select`

— Function`select(selector::IndividualsSelector, population, numSamples::Int)`

Select `numSamples`

random candidates from the `population`

.

`BlackBoxOptim.set_candidate!`

— Method`set_candidate!(o::Optimizer, x0)`

Set a candidate as a starting points for optimization. For population-based optimizers this will randomly overwrite one of the candidate solutions of the current population with `x0`

. For optimizers that maintain a single candidate that will be set to `x0`

.

`BlackBoxOptim.set_candidates!`

— Method`set_candidates!(o::Optimizer, x0)`

Set a vector of candidates as starting points for optimization. For population-based optimizers this will randomly overwrite positions in the current population. Optimizers that maintain a single candidate doesn't implement this method since it would not be clear which of the supplied starting points should be chosen.

`BlackBoxOptim.setup_problem`

— Method`setup_problem(problem, parameters::Parameters)`

Set up a fixed-dimensional optimization problem.

There are several `setup_problem()`

method that accept different type of `problem`

argument: * `OptimizationProblem`

* function (`:NumDimensions`

has to be specified in `parameters`

) * `FunctionBasedProblemFamily`

(`:NumDimensions`

has to be specified in `parameters`

)

`BlackBoxOptim.shekel`

— MethodGeneric function to define `ShekelN`

problems.

`BlackBoxOptim.shekel10`

— Method`Shekel10`

is a 4D, multi-minima, non-separable test problem. Our implementation is based on the C code in: http://www.math.ntu.edu.tw/~wwang/cola*lab/test*problems/multiple*opt/multiopt*prob/Shekel10/Shekel10.c

`BlackBoxOptim.shekel5`

— Method`Shekel5`

is a 4D, multi-minima, non-separable test problem. Our implementation is based on the C code in: http://www.math.ntu.edu.tw/~wwang/cola*lab/test*problems/multiple*opt/multiopt*prob/Shekel5/Shekel5.c

`BlackBoxOptim.shekel7`

— Method`Shekel7`

is a 4D, multi-minima, non-separable test problem. Our implementation is based on the C code in: http://www.math.ntu.edu.tw/~wwang/cola*lab/test*problems/multiple*opt/multiopt*prob/Shekel7/Shekel7.c

`BlackBoxOptim.show_fitness`

— Method`show_fitness(io, fit, [problem::OptimizationProblem])`

Output fitness to the given IO stream. `show_fitness()`

method could be overridden for a specific problem, e.g. to print the names of each objective.

`BlackBoxOptim.step!`

— Function`step!(opt::SteppingOptimizer)`

Do one iteration of the method.

`BlackBoxOptim.sync_update_fitness`

— Function```
sync_fitness_update([f], job::AbstractFitnessEvaluationJob,
eval::AbstractAsyncEvaluator)
```

Waits until fitnesses for `job`

are calculated and optionally applies `f`

function to each processed candidate.

See also: `async_update_fitness!`

, `update_fitness!`

.

`BlackBoxOptim.t_asy`

— MethodTransform symmetric `f`

into asymmetric objective function.

`BlackBoxOptim.t_diag`

— MethodTransform `f`

into objective function with ill-conditioning effect.

`BlackBoxOptim.t_irreg`

— MethodTransform `f`

into objective function with smooth local irregularities.

`BlackBoxOptim.tagcounts`

— Function`tagcounts(a::EpsBoxArchive)`

Count the tags of individuals on the ϵ-box frontier. Each restart the individual remains in the frontier discounts it by `θ`

.

Returns the `tag`

→`count`

dictionary.

`BlackBoxOptim.tell!`

— Function`tell!(ato::AskTellOptimizer, rankedCandidates)`

Tell the optimizer about the ranking of candidates. Returns the number of `rankedCandidates`

that were inserted into the population, because of the improved fitness.

See also `ask()`

.

`BlackBoxOptim.tournament`

— MethodSimulate tournament among specified `candidates`

.

Returns the index of the winner.

`BlackBoxOptim.trace_state`

— Method`trace_state(io, op::GeneticOperator, mode::Symbol)`

Trace the state of the operator. Called by `trace_progress()`

during `OptRunController`

run by some of the genetic optimizers.

Override the method to trace the state of your genetic operator.

`BlackBoxOptim.trace_state`

— Method`trace_state(io::IO, optimizer::Optimizer, mode::Symbol)`

Trace the current optimization state to a given IO stream. Called by `OptRunController`

`trace_progress()`

.

Override it for your optimizer to generate method-specific diagnostic traces.

`BlackBoxOptim.update!`

— MethodUpdate the internal model of progress and success rate of each method based on the latest progress value of one method. Progress values should be larger the larger the progress/improvement was.

`BlackBoxOptim.update_fitness!`

— Method`update_fitness!([f], eval::Evaluator, candidates; force::Bool=false)`

Calculate fitness of `candidates`

and optionally apply `f`

to each processed one. `force`

specifies if already existing non-NA fitnesses should be re-evaluated.

`BlackBoxOptim.update_fitness!`

— Method`update_fitness!([f], eval::Evaluator, candidate::Candidate; force::Bool=false) -> Candidate`

Calculate fitness of `candidate`

and optionally apply `f`

. `force`

specifies whether to re-evaluate fitness, if the candidate already has non-NA one.

`BlackBoxOptim.update_parameters!`

— Function`update_parameters!(oc::OptController, parameters::Associative)`

Update the `OptController`

parameters.

`BlackBoxOptim.update_recombination_weights!`

— MethodUpdate recombination operator probabilities based on the archive tag counts.

`BlackBoxOptim.viewer`

— Method`viewer(population, individual_index)`

Get vector-slice of the population matrix for the specified individual. Does not allocate any additional space, while still providing the same lookup performance.

`BlackBoxOptim.width_of_confidence_interval`

— FunctionCalculate the width of the confidence interval at a certain `p`

-value. This is based on the paper: Carvalho (2011), "Confidence intervals for the minimum of a function using extreme value statistics"

This means that the current estimate of the confidence interval for the minimum of the optimized function lies within the interval

`] l1 - w, l1 [`

with probability $(1-p)$ as the number of sampled function points goes to infinity, where

```
w = width_of_confidence_interval(a, p)
l1 = best_fitness(a)
```

`BlackBoxOptim.worker_finished!`

— MethodNotify that the worker process is finished and reset its busy flag.

`BlackBoxOptim.Utils.assign_ranks_within_tolerance`

— MethodAssign ranks to the values but keeps the rank the same if the values are within tolerance of each other.

`BlackBoxOptim.Utils.haltonnumber`

— Method`haltonnumber(base, index)`

Generate the `n`

-th Halton number in the sequence with base `b`

.

**Note**

```
Implementation is based on the psudo code in:
http://en.wikipedia.org/wiki/Halton_sequence
```

`BlackBoxOptim.Utils.haltonsequence`

— Method`haltonsequence(b, n)`

Generate the first `n`

numbers in Halton's sequence with base `b`

.

`BlackBoxOptim.Utils.latin_hypercube_sampling`

— Method`latin_hypercube_sampling(mins, maxs, n)`

Randomly sample `n`

vectors from the parallelogram defined by `mins`

and `maxs`

using the Latin hypercube algorithm.

Returns `dims`

×`n`

matrix.