Class 
Description 
AcceptanceBandSampling<T extends Copyable<T>> 
The AcceptanceBandSampling class implements a form of stochastic sampling
search that uses a constructive heuristic to guide the random decisions.

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

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

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

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

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

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

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

BiasedShiftedFitnessProportionalSelection 
This class implements a variation of fitness proportional selection that
uses shifted fitness values and applies
a bias function to further transform the shifted fitness values.

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

BiasedStochasticUniversalSampling 
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.

BitFlipMutation 
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.

BitVector 
A BitVector is an indexable vector of bits.

BitVectorInitializer 
Generates random BitVector objects for use in generating random initial solutions
for simulated annealing and other metaheuristics.

BlockInterchangeMutation 
This class implements a block interchange mutation on permutations, where one mutation
consists in swapping two randomly chosen nonoverlapping "blocks" (i.e., subsequences).

BlockMoveMutation 
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.

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

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

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

CauchyMutation<T extends RealValued> 
This class implements Cauchy
mutation.

CommonDuedateScheduling 
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.

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

ConstructiveHeuristic<T extends Copyable<T>> 
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.

CostFunctionScaler<T extends Copyable<T>> 
This is a wrapper class for OptimizationProblem
objects that enables scaling all cost values by a positive constant.

CrossoverOperator<T> 
Implement the CrossoverOperator interface to implement a crossover operator
for use in evolutionary algorithms.

CycleMutation 
This class implements a cycle mutation on permutations, where one mutation
generates a random permutation cycle.

DefiniteBitFlipMutation 
DefiniteBitFlipMutation implements a variation of Bit Flip Mutation.

DynamicATCS 
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.

EarliestDueDate 
This is an implementation of the earliest due date heuristic.

ExponentialCooling 
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).

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

FirstDescentHillClimber<T extends Copyable<T>> 
This class implements first descent hill climbing.

FitnessBiasFunction 

FitnessFunction<T extends Copyable<T>> 
Fitness function interfaces.

FitnessFunction.Double<T extends Copyable<T>> 
Fitness function interface for doublevalued fitnesses.

FitnessFunction.Integer<T extends Copyable<T>> 
Fitness function interface for intvalued fitnesses.

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

ForresterEtAl2008 
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].

GaussianMutation<T extends RealValued> 
This class implements Gaussian
mutation.

GenerationalEvolutionaryAlgorithm<T extends Copyable<T>> 
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.

GenerationalMutationOnlyEvolutionaryAlgorithm<T extends Copyable<T>> 
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.

GenerationalNANDOperatorsEvolutionaryAlgorithm<T extends Copyable<T>> 
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.

GeneticAlgorithm 
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.

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

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

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

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

HeuristicSolutionGenerator<T extends Copyable<T>> 
This class generates solutions to optimization
problems using a constructive heuristic.

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

HybridConstructiveHeuristic<T extends Copyable<T>> 
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.

HybridCrossover<T> 
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.

HybridMutation<T> 
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.

HybridUndoableMutation<T> 
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.

IncrementalEvaluation<T extends Copyable<T>> 
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.

InitializeBySimpleMetaheuristic<T extends Copyable<T>> 
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.

Initializer<T> 
Implement the Initializer interface to provide
metaheuristics and other search algorithms with a way
to generate initial candidate solutions to a problem.

InsertionMutation 
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.

IntegerCostFunctionScaler<T extends Copyable<T>> 

IntegerCostOptimizationProblem<T extends Copyable<T>> 
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).

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

IntegerValueInitializer 
Generates random SingleInteger objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.

IntegerVector 
A simple class for representing the input to a multivariate function,
with integer values.

IntegerVectorInitializer 
Generating random IntegerVector objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.

InverseCostFitnessFunction<T extends Copyable<T>> 
This class provides a convenient mechanism for transforming optimization cost
values to fitness values.

IterableMutationOperator<T> 
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.

IterativeSampling<T extends Copyable<T>> 
Iterative sampling is the simplest possible form of a stochastic sampling search.

KPointCrossover 
Implementation of Kpoint crossover, a classic crossover operator for
BitVectors.

KPointCrossover<T extends IntegerVector> 
Implementation of Kpoint crossover, but for IntegerVectors.

KPointCrossover<T extends RealVector> 
Implementation of Kpoint crossover, but for RealVectors.

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

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

LogarithmicCooling 
This class implements logarithmic cooling, a classic annealing
schedule.

LubyRestarts 
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.

Metaheuristic<T extends Copyable<T>> 
This interface defines the required methods for implementations
of metaheuristics, in particular metaheuristics for which the maximum run length
can be specified.

MinimizeMakespan 
Implements the common scheduling cost function known as
makespan.

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

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

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

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

Mix 
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.

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

ModifiedLamOriginal 
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.

Montagne 
This is an implementation of Montagne's heuristic
heuristic.

Multistarter<T extends Copyable<T>> 
This class is used for implementing multistart metaheuristics.

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

MutationOnlyGeneticAlgorithm 
This class is an implementation of a mutationonly 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.

MutationOperator<T> 
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.

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

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

NegativeCostFitnessFunction<T extends Copyable<T>> 
This class provides a convenient mechanism for transforming optimization cost
values to fitness values.

NegativeIntegerCostFitnessFunction<T extends Copyable<T>> 
This class provides a convenient mechanism for transforming optimization cost
values to fitness values.

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

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

OptimizationProblem<T extends Copyable<T>> 
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., realvalued function optimization,
traveling salesperson, bin packing, etc).

ParallelMetaheuristic<T extends Copyable<T>> 
This class enables running multiple copies of a metaheuristic, or multiple metaheuristics,
in parallel with multiple threads.

ParallelMultistarter<T extends Copyable<T>> 
This class is used for implementing parallel multistart metaheuristics.

ParallelReoptimizableMetaheuristic<T extends Copyable<T>> 
This class enables running multiple copies of a metaheuristic, or multiple metaheuristics,
in parallel with multiple threads.

ParallelReoptimizableMultistarter<T extends Copyable<T>> 
This class is used for implementing parallel multistart metaheuristics.

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

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

ParameterFreeLinearCooling 
This class implements a parameterfree version of the linear
cooling schedule for simulated annealing.

Partial<T extends Copyable<T>> 
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.

PartialIntegerVector 
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.

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

PermutationInAHaystack 
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).

PermutationInitializer 
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.

PermutationToBitVectorProblem 
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.

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

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

Plateaus 
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.

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

PopulationFitnessVector 
An interface to a vector of fitnesses of a population.

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

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

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

Problem<T extends Copyable<T>> 
Base interface for all interfaces defining types of problems supported
by the library.

ProgressTracker<T extends Copyable<T>> 
This class is used to track search algorithm progress, and supports
multithreaded search algorithms.

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

RandomValueChangeMutation<T extends IntegerValued> 
This mutation operator is for integer valued representations, and replaces an
integer value with a different random integer value from the domain.

RealValued 
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).

RealValueInitializer 
Generating random SingleReal objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.

RealVector 
A simple class for representing the parameters to a multivariate function.

RealVectorInitializer 
Generates random RealVector objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.

ReoptimizableMetaheuristic<T extends Copyable<T>> 
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.

ReoptimizableMultistarter<T extends Copyable<T>> 
This class is used for implementing multistart metaheuristics, that can be restarted at
previously found solutions.

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

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

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

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

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

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

SelfTuningLam 
This class implements the SelfTuning Lam annealing schedule, which is
an improved variation of the Modified Lam annealing schedule.

ShiftedFitnessProportionalSelection 
This class implements a variation of fitness proportional selection that uses
shifted fitness values.

ShiftedStochasticUniversalSampling 
This class implements a variation of Stochastic Universal Sampling (SUS) that uses
shifted fitness values.

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

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

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

SimpleGeneticAlgorithm 
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.

SimpleLocalMetaheuristic<T extends Copyable<T>> 
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 selfdetermined, such as
hill climbers that terminate upon reaching a local optima.

SimpleMetaheuristic<T extends Copyable<T>> 
This interface defines the required methods for implementations
of simple metaheuristics whose run length is selfdetermined, such as
hill climbers that terminate upon reaching a local optima.

SimulatedAnnealing<T extends Copyable<T>> 
This class is an implementation of the metaheuristic known as simulated annealing.

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

SingleMachineSchedulingProblem 
Implement this interface to define a single machine scheduling problem.

SingleMachineSchedulingProblemData 
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), duedates, etc of the jobs.

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

SinglePointCrossover<T extends IntegerVector> 
Implementation of single point crossover, but for IntegerVectors.

SinglePointCrossover<T extends RealVector> 
Implementation of single point crossover, but for RealVectors.

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

SingleSolutionMetaheuristic<T extends Copyable<T>> 
This interface defines the required methods for implementations
of singlesolution metaheuristics, i.e., metaheuristics such as simulated annealing
that operate one a single candidate solution (as compared to populationbased metaheuristics
such as genetic algorithms.

SmallestNormalizedSetup 
This heuristic is smallest normalized setup.

SmallestSetup 
This heuristic is the smallest setup first.

SmallestSetupPrecompute 
This heuristic is the smallest setup first.

SmallestTwoJobSetup 
This heuristic is smallest twojob setup.

SolutionCostPair<T extends Copyable<T>> 
An object of this class encapsulates a solution with its corresponding cost value.

Splittable<T extends Splittable<T>> 
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.

SteepestDescentHillClimber<T extends Copyable<T>> 
This class implements steepest descent hill climbing.

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

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

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

TimedParallelMultistarter<T extends Copyable<T>> 
This class is used for implementing parallel multistart metaheuristics.

TimedParallelReoptimizableMultistarter<T extends Copyable<T>> 
This class is used for implementing parallel multistart metaheuristics.

TournamentSelection 
This class implements tournament selection for evolutionary algorithms.

TrackableSearch<T extends Copyable<T>> 
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.

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

TruncationSelection 
This class implements truncation selection for evolutionary algorithms.

TSP 
This class and its nested classes implement the Traveling Salesperson Problem (TSP).

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

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

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

TSP.IntegerMatrix 
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.

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

TwoChangeMutation 
This class implements the classic twochange operator as a mutation operator
for permutations.

TwoMax 
This class implements the benchmarking problem known
as TwoMax.

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

TwoPointCrossover 
Implementation of twopoint crossover, a classic crossover operator for
BitVectors.

TwoPointCrossover<T extends IntegerVector> 
Implementation of twopoint crossover, but for IntegerVectors.

TwoPointCrossover<T extends RealVector> 
Implementation of twopoint crossover, but for RealVectors.

UndoableCauchyMutation<T extends RealValued> 

UndoableGaussianMutation<T extends RealValued> 

UndoableMutationOperator<T> 
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.

UndoableRandomValueChangeMutation<T extends IntegerValued> 
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.

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

UndoableUniformMutation<T extends IntegerValued> 

UndoableUniformMutation<T extends RealValued> 

UndoableUniformScrambleMutation 
This class implements a scramble mutation on permutations, where one mutation
consists in randomizing the order of a noncontiguous subset of the permutation
elements.

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

UniformCrossover<T extends IntegerVector> 
Implementation of uniform crossover, but for IntegerVectors.

UniformCrossover<T extends RealVector> 
Implementation of uniform crossover, but for RealVectors.

UniformMutation<T extends IntegerValued> 
This class implements a uniform
mutation for
mutating integer values.

UniformMutation<T extends RealValued> 
This class implements a uniform
mutation.

UniformScrambleMutation 
This class implements a scramble mutation on permutations, where one mutation
consists in randomizing the order of a noncontiguous subset of the permutation
elements.

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

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

VariableAnnealingLength 
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.

WeightedCostOverTime 
This is an implementation of the weighted COVERT
heuristic.

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

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

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

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

WeightedFlowtime 
Implements the scheduling cost function known as
weighted flowtime.

WeightedHybridCrossover<T> 
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.

WeightedHybridMutation<T> 
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.

WeightedHybridUndoableMutation<T> 
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.

WeightedLateness 
Implements the scheduling cost function known as
weighted lateness.

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

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

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

WeightedShortestProcessingPlusSetupTimeLateOnly 
This class implements a variation the weighted shortest process time
heuristic with nonzero heuristic values only for late jobs,
but adjusted to incorporate setups times for problems with
sequencedependent setups.

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

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

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

WeightedSquaredTardiness 
Implements the scheduling cost function known as
weighted squared tardiness.

WeightedStaticScheduling 
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).

WeightedStaticSchedulingWithSetups 
This class provides a representation of, and means of generating,
instances of single machine scheduling problems involving weights,
due dates, and sequencedependent 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).

WeightedTardiness 
Implements the scheduling cost function known as
weighted tardiness.

WindowLimitedBlockMoveMutation 
This class implements a windowlimited version of the
BlockMoveMutation mutation operator on permutations.

WindowLimitedInsertionMutation 
This class implements a windowlimited version of the
InsertionMutation mutation operator on permutations.

WindowLimitedReversalMutation 
This class implements a windowlimited version of the
ReversalMutation mutation operator on permutations.

WindowLimitedScrambleMutation 
This class implements a windowlimited version of the
ScrambleMutation mutation operator on permutations.

WindowLimitedSwapMutation 
This class implements a windowlimited version of the
SwapMutation mutation operator on permutations.

WindowLimitedUndoableScrambleMutation 
This class implements a windowlimited version of the
ScrambleMutation mutation operator on permutations.
