# All Classes and Interfaces

Class

Description

The AcceptanceBandSampling class implements a form of stochastic sampling
search that uses a constructive heuristic to guide the random decisions.

An AcceptanceTracker can be used to extract fine-grained information
about the behavior of an annealing schedule across several runs of
simulated annealing.

This class implements an adjacent swap mutation on permutations, where one mutation
consists in randomly swapping a pair of adjacent elements.

This interface specifies the required functionality for implementations of
annealing schedules.

This is an implementation of the Apparent Tardiness Cost (ATC)
heuristic.

This is an implementation of a variation of
the Apparent Tardiness Cost (ATC) heuristic, with a
simple adjustment for setup times for problems
with sequence-dependent setups.

This is an implementation of the ATCS (Apparent Tardiness Cost with Setups)
heuristic.

This class serves as an abstract base class for the various
classes that implement variations of the Traveling Salesperson
Problem provided by the library.

This class implements a variation of fitness proportional selection that applies
a bias function to transform the fitness values.

This class implements a variation of Stochastic Universal Sampling (SUS) that we call
Biased Stochastic Universal Sampling (Biased SUS), which integrates the use of a bias function
with SUS to enable transforming fitness values prior to the stochastic selection decisions.

This class is used by the

`BinPackingSolution`

class to represent the
contents of a bin in a solution to a `BinPacking`

problem instance.This class, and its nested classes, implements the Bin Packing problem.

Generates instances of the Bin Packing problem where the optimal solution
is comprised of all full triplet bins (each bin in optimal solution has exactly
3 items that fills the bin to capacity).

Generates instances of the Bin Packing problem with item sizes that are
generated uniformly at random.

This class represents a solution to a

`BinPacking`

problem instance.This class implements Bit Flip Mutation, the mutation operator commonly used
in genetic algorithms, but which can also be used with other metaheuristic search
algorithms such as simulated annealing to generate random neighbors.

A BitVector is an indexable vector of bits.

Generates random

`BitVector`

objects for use in generating random initial solutions
for simulated annealing and other metaheuristics.This class implements a block interchange mutation on permutations, where one mutation
consists in swapping two randomly chosen non-overlapping "blocks" (i.e., subsequences).

This class implements a block move mutation on permutations, where one mutation
consists in removing a randomly chosen "block" (i.e., subsequence) and reinserting it
at a different randomly chosen index.

This class implements Boltzmann selection.

This class implements Boltzmann selection using Stochastic Universal Sampling (SUS).

A class for representing the input to a multivariate function,
with integer values that are bounded in some interval [min, max].

A class for representing the input to a multivariate function,
with real values (floating-point)
that are bounded in some interval [min, max].

The BoundMax class is an implementation of a generalization of
the well-known OneMax problem, often used in benchmarking genetic
algorithms and other metaheuristics.

This class implements Cauchy
mutation.

This class represents and generates instances of a common duedate
scheduling problem, in which all jobs have both an earliness weight
and a tardiness weight, and share a common duedate.

This is the basic constant run length restart schedule, such that every restart
of the multistart metaheuristic is the same in length.

Classes implementing this interface are used
as constructive heuristics for constructing heuristic solutions
to optimization problems, as well as for
certain stochastic sampling search algorithms.

This is a wrapper class for

`OptimizationProblem`

objects that enables scaling all cost values by a positive constant.Implement the CrossoverOperator interface to implement a crossover operator
for use in evolutionary algorithms.

This class implements the Cycle(α) form of cycle mutation on permutations, where one mutation
generates a random permutation cycle.

Implementation of cycle crossover (CX).

This class implements the Cycle(kmax) form of cycle mutation on permutations, where one mutation
generates a random permutation cycle.

DefiniteBitFlipMutation implements a variation of Bit Flip Mutation.

DynamicATCS is an implementation of a variation of the ATCS
(Apparent Tardiness Cost with Setups) heuristic, which dynamically
updates the average processing and setup times as it constructs the schedule.

This is an implementation of the earliest due date heuristic.

Implementation of the Edge Recombination operator, a crossover operator for permutations.

Implementation of the Enhanced Edge Recombination operator, a crossover operator for permutations.

This class implements the classic and most commonly encountered
cooling schedule for simulated annealing, the annealing schedule known
as exponential cooling (sometimes referred to as geometric cooling).

This class implements a constructive heuristic, known as EXPET, for scheduling problems
involving minimizing the sum of weighted earliness plus weighted tardiness.

This class implements exponential rank selection.

This class implements exponential rank selection using Stochastic Universal Sampling (SUS).

This class implements first descent hill climbing.

This functional interface is used to provide a bias function to the

`BiasedFitnessProportionalSelection`

operator as well as the
`BiasedStochasticUniversalSampling`

operator.Fitness function interfaces.

Fitness function interface for double-valued fitnesses.

Fitness function interface for int-valued fitnesses.

This class implements fitness proportional selection, sometimes referred to as weighted
roulette wheel, for evolutionary algorithms.

FitnessShifter wraps another SelectionOperator, shifting all
fitness values by the minimum fitness minus one, such that the least fit population member's
transformed fitness is equal to 1, with the wrapped SelectionOperator than performing
selection using the transformed fitnesses.

A continuous function with a single suboptimal local minimum, and
a single global minimum, and a 0 derivative inflexion point, defined
for inputs x in [0.0, 1.0].

This class implements Gaussian
mutation.

This class implements an evolutionary algorithm with a generational
model, such as is commonly used in genetic algorithms, where a
population of children are formed by applying genetic operators to
members of the parent population, and where the children replace the
parents in the next generation.

This class implements an evolutionary algorithm (EA) with a generational
model, where a population of children are formed by applying genetic operators to
members of the parent population, and where the children replace the
parents in the next generation.

This class implements an evolutionary algorithm (EA) with a generational
model, such as is commonly used in genetic algorithms, where a
population of children are formed by applying mutation to
members of the parent population, and where the children replace the
parents in the next generation.

This class is an implementation of a genetic algorithm (GA) with the common
bit vector representation of solutions to optimization problems, and the
generational model where children replace their parents each generation.

A continuous function with a large number of local minimums, and
a single global minimum, defined for input x in [0.5, 2.5].

Heuristic Biased Stochastic Sampling (HBSS) is a form of stochastic sampling
search that uses a constructive heuristic to bias the random decisions.

Implement this interface to implement the bias function
used by HBSS.

This class generates solutions to permutation optimization
problems using a constructive heuristic.

This class generates solutions to optimization
problems using a constructive heuristic.

Implementation of Holland's Royal Road problem, as described in the following
paper:

Terry Jones.

Terry Jones.

A HybridConstructiveHeuristic maintains a list of

`ConstructiveHeuristic`

objects for a problem,
for use in a multiheuristic stochastic sampling search,
where each full iteration of the stochastic sampler
uses a single heuristic for all decisions, but where
a different heuristic is chosen for each iteration.A HybridCrossover enables using multiple crossover operators for the
evolutionary algorithm, such that each time the

`HybridCrossover.cross(T, T)`

method is called,
a randomly chosen crossover operator is applied to the candidate
solution.A HybridMutation enables using multiple mutation operators for the
search, such that each time the

`HybridMutation.mutate(T)`

method is called,
a randomly chosen mutation operator is applied to the candidate
solution.A HybridMutation enables using multiple mutation operators for the
search, such that each time the

`HybridUndoableMutation.mutate(T)`

method is called,
a randomly chosen mutation operator is applied to the candidate
solution.The implementations of constructive heuristics and
stochastic samplers biased by constructive heuristics
in the library support incremental updates,
as the solution is heuristically assembled,
to problem and/or heuristic data utilized by the heuristic.

This class implements the

`Initializer`

interface to provide
metaheuristics and other search algorithms with a way
to generate initial candidate solutions to a problem, that are themselves
generated via a metaheuristic.Implement the Initializer interface to provide
metaheuristics and other search algorithms with a way
to generate initial candidate solutions to a problem.

This class implements an insertion mutation on permutations, where one mutation
consists in removing a randomly chosen element and reinserting it
at a different randomly chosen location.

This is a wrapper class for

`IntegerCostOptimizationProblem`

objects that enables scaling all cost values by a positive constant.The IntegerCostOptimizationProblem interface provides search algorithms with a way
to interact with an instance of an optimization problem without the need
to know the specifics of the problem (e.g.,
traveling salesperson, bin packing, etc).

An interface to define the parameters to a function,
where the function parameters are represented as integers.

Generates random

`SingleInteger`

objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.A simple class for representing the input to a multivariate function,
with integer values.

Generating random

`IntegerVector`

objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.This class provides a convenient mechanism for transforming optimization cost
values to fitness values.

Implement the IterableMutationOperator interface to define a mutation
operator that enables iterating systematically over the neighbors of
a candidate solution, like one would do in a hill climber.

Iterative sampling is the simplest possible form of a stochastic sampling search.

Implementation of K-point crossover, a classic crossover operator for
BitVectors.

Implementation of K-point crossover, but for IntegerVectors.

Implementation of K-point crossover, but for RealVectors.

This class is an implementation of the Largest Common Subgraph
problem, an NP-Hard combinatorial optimization problem.

This class is used to represent edges when specifying
instances of the

`LargestCommonSubgraph`

problem.This class implements the linear
cooling schedule for simulated annealing.

This class implements a constructive heuristic, known as LINET, for scheduling problems
involving minimizing the sum of weighted earliness plus weighted tardiness.

This class implements linear rank selection.

This class implements linear rank selection using Stochastic Universal Sampling (SUS).

This class implements logarithmic cooling, a classic annealing
schedule.

The Luby restart schedule originated with constraint satisfaction search, and
was originally used to control when to restart a backtracking constraint satisfaction
search in number of backtracks.

This interface defines the required methods for implementations
of metaheuristics, in particular metaheuristics for which the maximum run length
can be specified.

Implements the common scheduling cost function known as
makespan.

Implements the scheduling cost function known as
maximum flowtime (which we want to minimize).

Implements the scheduling cost function known as
maximum lateness, which we want to minimize.

Implements the scheduling cost function known as
maximum tardiness, which we want to minimize.

This is an implementation of the minimum slack time (MST)
heuristic.

This class implements Ackley's Mix problem, an artificial landscape that
is a mix of the OneMax, TwoMax, Trap, and Plateau problems, which provides
for a landscape that combines all of the properties of these benchmarking
problems.

This class implements an optimized variant of the Modified Lam annealing schedule.

This class implements the Modified Lam annealing schedule, which dynamically
adjusts simulated annealing's temperature parameter up and down to either decrease
or increase the neighbor acceptance rate as necessary to attempt to match
a theoretically determined ideal.

This is an implementation of Montagne's heuristic
heuristic.

This class is used for implementing multistart metaheuristics.

Defines an interface for iterating over all of the mutants (i.e., neighbors)
of a candidate solution to a problem.

This class is an implementation of a mutation-only genetic algorithm (GA) with the common
bit vector representation of solutions to optimization problems, and the
generational model where children replace their parents each generation.

Implement the MutationOperator interface to implement a mutation operator
for use in simulated annealing, genetic algorithms, and other evolutionary algorithms,
and other metaheuristics, that require a
way to generate random neighbors of a candidate solution.

This class implements a nearest city constructive heuristic for the TSP
for use by stochastic sampling algorithms.

This class implements a constructive heuristic for the TSP that prefers the
first city of the nearest pair of cities.

Implementation of non-wrapping order crossover (NWOX).

The OneMax class is an implementation of
the well-known OneMax problem, often used in benchmarking genetic
algorithms and other metaheuristics.

The OneMaxAckley class is an implementation of
the well-known OneMax problem, often used in benchmarking genetic
algorithms and other metaheuristics.

This class implements a (1+1)-EA.

This class implements a (1+1)-GA, a special case of a (1+1)-EA, where solutions
are represented with a vector of bits.

The OptimizationProblem interface provides search algorithms with a way
to interact with an instance of an optimization problem without the need
to know the specifics of the problem (e.g., real-valued function optimization,
traveling salesperson, bin packing, etc).

Implementation of order crossover (OX).

Implementation of the crossover operator for permutations that is often referred to as Order Crossover 2 (OX2).

This class enables running multiple copies of a metaheuristic, or multiple metaheuristics,
in parallel with multiple threads.

This class is used for implementing parallel multistart metaheuristics.

This class is used for implementing parallel multistart metaheuristics.

The Parallel Variable Annealing Length (P-VAL) restart schedule originated,
as you would expect from the word "annealing" in its name, as a
restart schedule for Simulated Annealing.

This class implements a parameter-free version of the classic
cooling schedule for simulated annealing known
as exponential cooling (sometimes referred to as geometric cooling).

This class implements a parameter-free version of the linear
cooling schedule for simulated annealing.

A Partial represents a partial solution to a problem (e.g.,
a partial permutation or a partial integer vector) that is being
iteratively constructed as a solution to an optimization problem.

A PartialIntegerVector represents a vector of integers that is being
iteratively constructed as a solution to an optimization problem
over the space of integer vectors.

Implementation of partially matched crossover (PMX).

A PartialPermutation represents a permutation that is being
iteratively constructed as a solution to an optimization problem
over the space of permutations.

The Permutation in a Haystack is a family of optimization problems
that can be parameterized to the various types of permutation problem
(e.g., absolute versus relative positioning).

The PermutationInitializer provides metaheuristic implementations, such
as of simulated annealing, etc, with a way to generate random initial solutions
to a problem, as well as a way to make copies of current solution configurations.

This class implements a mapping between Permutation problems and BitVector problems,
enabling using

`BitVector`

search operators to solve problems defined over the space of
`Permutation`

objects.This class implements a mapping between Permutation problems and BitVector problems, where cost values are
of type double.

This class implements a mapping between Permutation problems and BitVector problems, where cost values are
of type int.

This class implements Ackley's Plateaus problem, an
artificial search landscape over the space of bitstrings
that is characterized by large flat regions known as plateaus.

This class defines polynomial root finding as an optimization problem, enabling
solving via simulated annealing or other metaheuristic optimization algorithms.

An interface to a vector of fitnesses of a population.

An interface to a vector of fitnesses, each a double, of a population.

An interface to a vector of fitnesses, each an int, of a population.

This class implements the Porcupine landscape (Ackley, 1985), which
is a very rugged search landscape, with an exponential number of local
optima.

Implementation of Precedence Preservative Crossover (PPX), the two-point version.

Base interface for all interfaces defining types of problems supported
by the library.

This class is used to track search algorithm progress, and supports
multithreaded search algorithms.

This class is an implementation of the Quadratic Assignment Problem (QAP), an NP-Hard
optimization problem.

This class implements a simple random selection operator that selects
members of the population uniformly at random, independent of fitness
values.

This class and its nested classes implement the Traveling Salesperson Problem (TSP),
and its variant, the Asymmetric Traveling Salesperson Problem (ATSP),
by generating a random distance matrix.

This class implements the Traveling Salesperson Problem (TSP),
and its variant, the Asymmetric Traveling Salesperson Problem (ATSP),
by generating a random distance matrix, with floating-point cost edges.

This class implements the Traveling Salesperson Problem (TSP),
and its variant, the Asymmetric Traveling Salesperson Problem (ATSP),
by generating a random distance matrix, with integer cost edges.

This mutation operator is for integer valued representations, and replaces an
integer value with a different random integer value from the domain.

An interface to define the parameters to a function,
where the function parameters are represented as type double
(i.e., as double precision floating point numbers).

Generating random

`SingleReal`

objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.A simple class for representing the parameters to a multivariate function.

Generates random

`RealVector`

objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.This interface defines the required methods for implementations
of metaheuristics, for which the maximum run length
can be specified, and which have the capability of restarting
from a previously optimized solution.

This class is used for implementing multistart metaheuristics, that can be restarted at
previously found solutions.

Multistart metaheuristics involve periodically restarting the metaheuristic
from a new initial starting solution (often random).

This class implements a reversal mutation on permutations, where one mutation
consists in reversing the order of a randomly selected subpermutation.

This class implements a rotation mutation on permutations, where one mutation
consists in a random circular rotation of the permutation.

Implementation of the Royal Road problem of Mitchell, Forrest, and Holland,
both the variation with stepping stones and the one without.

This class implements a scramble mutation on permutations, where one mutation
consists in randomizing the order of a randomly selected subpermutation.

Implement this interface to provide a selection operator
for use by genetic algorithms and other forms of
evolutionary computation.

This class implements the Self-Tuning Lam annealing schedule, which is
an improved variation of the Modified Lam annealing schedule.

This is an implementation of the shortest process time
heuristic, adjusted to include setup time.

This is an implementation of the shortest process time
heuristic, adjusted to include setup time.

This is an implementation of the shortest process time
heuristic.

Implements sigma scaling by wrapping your chosen selection operator.

This class is an implementation of the simple genetic algorithm (Simple GA) with the common
bit vector representation of solutions to optimization problems, and the
generational model where children replace their parents each generation.

This interface defines the required methods for implementations
of simple metaheuristics that locally optimize from some initial solution
(random or otherwise) whose run length is self-determined, such as
hill climbers that terminate upon reaching a local optima.

This interface defines the required methods for implementations
of simple metaheuristics whose run length is self-determined, such as
hill climbers that terminate upon reaching a local optima.

This class is an implementation of the metaheuristic known as simulated annealing.

A simple class for representing the input to a univariate function, such that
the input is an integer.

Implement this interface to define a single machine scheduling problem.

Classes that implement single machine scheduling problems should
implement this interface to enable heuristic, etc to interact with the
data that defines the jobs of the scheduling instance, such as the
process times, setup times (if any), due-dates, etc of the jobs.

Implementation of single point crossover, a classic crossover operator for
BitVectors.

Implementation of single point crossover, but for IntegerVectors.

Implementation of single point crossover, but for RealVectors.

A simple class for representing the input to a univariate function.

This interface defines the required methods for implementations
of single-solution metaheuristics, i.e., metaheuristics such as simulated annealing
that operate one a single candidate solution (as compared to population-based metaheuristics
such as genetic algorithms.

This heuristic is smallest normalized setup.

This heuristic is the smallest setup first.

This heuristic is the smallest setup first.

This heuristic is smallest two-job setup.

An object of this class encapsulates a solution with its corresponding cost value.

The Splittable interface provides multithreaded search algorithms
with the ability to generate functionally identical copies
of operators, and even entire metaheuristics, at the point of spawning new search threads.

This class implements steepest descent hill climbing.

This class implements Stochastic Universal Sampling (SUS), a selection operator
for evolutionary algorithms.

This class implements a swap mutation on permutations, where one mutation
selects two elements uniformly at random and swaps their locations.

This class implements the classic 3-Opt neighborhood as a mutation operator
for permutations.

This class is used for implementing parallel multistart metaheuristics.

This class is used for implementing parallel multistart metaheuristics.

This class implements tournament selection for evolutionary algorithms.

This interface defines the required functionality of
search algorithm implementations that support tracking search
progress across multiple runs, whether multiple sequential runs,
or multiple concurrent runs in the case of a parallel metaheuristic.

This class implements Ackley's Trap function, which defines
a fitness landscape with a single global optima, and a single
sub-optimal local optima, such that most of the search landscape
is within the attraction basin of the local optima.

This class implements truncation selection for evolutionary algorithms.

This class and its nested classes implement the Traveling Salesperson Problem (TSP),
such that cities are 2D points, and edge costs is the distance between them.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs
are floating-point valued.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs
are floating-point valued, and where all edge costs between pairs of cities
are precomputed.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs
are integer valued.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs
are integer valued, and where all edge costs between pairs of cities
are precomputed.

A functional interface for specifying a distance function between a
pair of cities in a TSP instance.

This class implements the classic two-change operator as a mutation operator
for permutations.

This class implements the benchmarking problem known
as TwoMax.

This class implements a variation of the benchmarking problem known
as TwoMax.

Implementation of two-point crossover, a classic crossover operator for
BitVectors.

Implementation of two-point crossover, but for IntegerVectors.

Implementation of two-point crossover, but for RealVectors.

This class implements Cauchy
mutation with support for the

`UndoableCauchyMutation.undo(T)`

method.This class implements Gaussian
mutation with support for the

`UndoableGaussianMutation.undo(T)`

method.Implement the UndoableMutationOperator interface to implement a mutation operator
for use in simulated annealing, and other metaheuristics, that require a
way to generate random neighbors of a candidate solution, and which supports
an undo method.

This mutation operator (supporting the undo operation)
is for integer valued representations, and replaces an
integer value with a different random integer value from the domain.

This class implements a uniform
mutation on integer valued parameters, with support for the

`UndoableUniformMutation.undo(T)`

method.This class implements a uniform
mutation with support for the

`UndoableUniformMutation.undo(T)`

method.This class implements a scramble mutation on permutations, where one mutation
consists in randomizing the order of a non-contiguous subset of the permutation
elements.

Implementation of uniform crossover, a classic crossover operator for
BitVectors.

Implementation of uniform crossover, but for IntegerVectors.

Implementation of uniform crossover, but for RealVectors.

This class implements a uniform
mutation for
mutating integer values.

This class implements a uniform
mutation.

Implementation of uniform order-based crossover (UOBX).

Implementation of uniform partially matched crossover (UPMX).

Implementation of Precedence Preservative Crossover (PPX), the uniform version.

Value Biased Stochastic Sampling (VBSS) is a form of stochastic sampling
search that uses a constructive heuristic to bias the random decisions.

Implement this interface to implement the bias function
used by VBSS.

The Variable Annealing Length (VAL) restart schedule originated,
as you would expect from the word "annealing" in its name, as a
restart schedule for Simulated Annealing.

This is an implementation of the weighted COVERT
heuristic.

This is an implementation of a variation of the weighted COVERT
heuristic, adjusted to account for setup times for problems with
sequence-dependent setups.

This is an implementation of a variation of the weighted critical ratio
heuristic.

This is an implementation of a variation of the weighted critical ratio
heuristic, adjusted to account for setup times for problems with
sequence-dependent setups.

Implements the scheduling cost function known as
weighted earliness plus weighted tardiness.

Implements the scheduling cost function known as
weighted flowtime.

A WeightedHybridCrossover enables using multiple crossover operators,
such that each time the

`WeightedHybridCrossover.cross(T, T)`

method is called,
a randomly chosen crossover operator is applied to the candidate
solutions.A WeightedHybridMutation enables using multiple mutation operators for the
search, such that each time the

`WeightedHybridMutation.mutate(T)`

method is called,
a randomly chosen mutation operator is applied to the candidate
solution.A WeightedHybridMutation enables using multiple mutation operators for the
search, such that each time the

`WeightedHybridUndoableMutation.mutate(T)`

method is called,
a randomly chosen mutation operator is applied to the candidate
solution.Implements the scheduling cost function known as
weighted lateness.

This is an implementation of the weighted longest process time
heuristic.

Implements the scheduling cost function known as
weighted number of tardy jobs, which we want to minimize.

This class implements a variation the weighted shortest process time
heuristic, but adjusted to incorporate setups times for problems with
sequence-dependent setups.

This class implements a variation the weighted shortest process time
heuristic with non-zero heuristic values only for late jobs,
but adjusted to incorporate setups times for problems with
sequence-dependent setups.

This is an implementation of the weighted shortest process time
heuristic.

This is an implementation of the weighted shortest process time
heuristic.

Implements the scheduling cost function known as
weighted squared tardiness.

This class provides a representation of, and means of generating,
instances of single machine scheduling problems involving weights
and due dates, but without release
dates (i.e., all jobs are released at the start of the problem at time 0,
thus, the term "static" in the class name).

This class provides a representation of, and means of generating,
instances of single machine scheduling problems involving weights,
due dates, and sequence-dependent setup times, but without release
dates (i.e., all jobs are released at the start of the problem at time 0,
thus, the term "static" in the class name).

Implements the scheduling cost function known as
weighted tardiness.

This class implements a window-limited version of the

`BlockMoveMutation`

mutation operator on permutations.This class implements a window-limited version of the

`InsertionMutation`

mutation operator on permutations.This class implements a window-limited version of the

`ReversalMutation`

mutation operator on permutations.This class implements a window-limited version of the

`ScrambleMutation`

mutation operator on permutations.This class implements a window-limited version of the

`SwapMutation`

mutation operator on permutations.`ScrambleMutation`

mutation operator on permutations.