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.

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.

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.

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

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.

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.

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.

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.

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.

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

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.

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.

PolarGaussian 
This class provides methods for generating pseudorandom numbers
from a Gaussian distribution using the classic Polar Method.

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

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.

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.

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

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

ZigguratGaussian 
This class provides methods for generating pseudorandom numbers
from a Gaussian distribution using the Ziggurat Algorithm.
