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.
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.
This class provides a convenient mechanism for transforming optimization cost values to fitness values.
This class provides a convenient mechanism for transforming optimization cost values to fitness values.
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 enables running multiple copies of a metaheuristic, or multiple metaheuristics, in parallel with multiple threads.
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.
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.
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.
Problem<T extends Copyable<T>>
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 scramble mutation on permutations, where one mutation consists in randomizing the order of a randomly selected subpermutation.
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.
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.
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 class implements a variation the weighted shortest process time heuristic, 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.
This class implements a window-limited version of the ScrambleMutation mutation operator on permutations.