Uses of Interface
org.cicirello.search.concurrent.Splittable
Package
Description
This package includes classes and interfaces related to implementing metaheuristic search
algorithms in general, rather than specific to a particular metaheuristic.
This package includes multithreaded search implementations, as well as classes and interfaces
related to implementing multithreaded metaheuristics.
This package includes classes and interfaces directly related to implementing evolutionary
algorithms.
This package includes classes and interfaces directly related to implementing hill climbers.
This package includes classes and interfaces for defining various operators required by simulated
annealing and other metaheuristics, such as mutation operators, along with other related classes
and interfaces.
This package includes classes that implement operators that create, mutate, etc, BitVectors.
This package includes classes that implement operators that create, mutate, etc, integer valued
representations.
This package includes classes that implement local search and evolutionary operators for
permutations, such as mutation operators, crossover operators, and initializers.
This package includes classes that implement operators that create, mutate, etc, the the inputs
to functions with realvalued input parameters (represented with type double), such as is
required to solve function optimization problems using simulated annealing or other
metaheuristics.
Package of classes and interfaces related to representing computational problems, as well as
classes implementing a variety of specific computational problems.
Package of classes and interfaces related to representing and solving scheduling problems, which
includes implementations of constructive heuristics for scheduling problems.
Classes and interfaces related to the Traveling Salesperson Problem (TSP).
This package includes classes and interfaces related to implementing multistart metaheuristics
(i.e., metaheuristics that periodically restart, and return the best solution across a number of
such restarts).
This package includes classes and interfaces directly related to implementing simulated
annealing.
This package includes classes and interfaces directly related to implementing stochastic sampling
algorithms.

Uses of Splittable in org.cicirello.search
Modifier and TypeInterfaceDescriptioninterface
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.interface
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.interface
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.interface
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.interface
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.interface
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. 
Uses of Splittable in org.cicirello.search.concurrent
Modifier and TypeInterfaceDescriptioninterface
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.Modifier and TypeClassDescriptionclass
ParallelMetaheuristic<T extends Copyable<T>>
This class enables running multiple copies of a metaheuristic, or multiple metaheuristics, in parallel with multiple threads.final class
ParallelMultistarter<T extends Copyable<T>>
This class is used for implementing parallel multistart metaheuristics.class
ParallelReoptimizableMetaheuristic<T extends Copyable<T>>
This class enables running multiple copies of a metaheuristic, or multiple metaheuristics, in parallel with multiple threads.final class
ParallelReoptimizableMultistarter<T extends Copyable<T>>
This class is used for implementing parallel multistart metaheuristics.class
TimedParallelMultistarter<T extends Copyable<T>>
This class is used for implementing parallel multistart metaheuristics.final class
TimedParallelReoptimizableMultistarter<T extends Copyable<T>>
This class is used for implementing parallel multistart metaheuristics. 
Uses of Splittable in org.cicirello.search.evo
Modifier and TypeInterfaceDescriptioninterface
Implement this interface to provide a selection operator for use by genetic algorithms and other forms of evolutionary computation.Modifier and TypeClassDescriptionclass
AdaptiveEvolutionaryAlgorithm<T extends Copyable<T>>
This class implements an evolutionary algorithm with adaptive control parameters (i.e., crossover rates and mutation rates that evolve during the search).class
AdaptiveMutationOnlyEvolutionaryAlgorithm<T extends Copyable<T>>
This class implements an mutationonly evolutionary algorithm with an adaptive mutation rate that evolves during the search.class
This class implements a variation of fitness proportional selection that applies a bias function to transform the fitness values.class
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.final class
This class implements Boltzmann selection.final class
This class implements Boltzmann selection using Stochastic Universal Sampling (SUS).final class
This class implements exponential rank selection.final class
This class implements exponential rank selection using Stochastic Universal Sampling (SUS).class
This class implements fitness proportional selection, sometimes referred to as weighted roulette wheel, for evolutionary algorithms.final class
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.class
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.class
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.class
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.class
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.final class
This class implements linear rank selection.final class
This class implements linear rank selection using Stochastic Universal Sampling (SUS).final class
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.class
NaiveGenerationalEvolutionaryAlgorithm<T extends Copyable<T>>
Deprecated.IMPORTANT: This class is being introduced temporarily in support of research experiments.class
OnePlusOneEvolutionaryAlgorithm<T extends Copyable<T>>
This class implements a (1+1)EA.final class
This class implements a (1+1)GA, a special case of a (1+1)EA, where solutions are represented with a vector of bits.final class
This class implements a simple random selection operator that selects members of the population uniformly at random, independent of fitness values.final class
Implements sigma scaling by wrapping your chosen selection operator.final class
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.class
This class implements Stochastic Universal Sampling (SUS), a selection operator for evolutionary algorithms.final class
This class implements tournament selection for evolutionary algorithms.final class
This class implements truncation selection for evolutionary algorithms. 
Uses of Splittable in org.cicirello.search.hc
Modifier and TypeClassDescriptionfinal class
FirstDescentHillClimber<T extends Copyable<T>>
This class implements first descent hill climbing.final class
SteepestDescentHillClimber<T extends Copyable<T>>
This class implements steepest descent hill climbing. 
Uses of Splittable in org.cicirello.search.operators
Modifier and TypeInterfaceDescriptioninterface
Implement the CrossoverOperator interface to implement a crossover operator for use in evolutionary algorithms.interface
Initializer<T>
Implement the Initializer interface to provide metaheuristics and other search algorithms with a way to generate initial candidate solutions to a problem.interface
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.interface
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.interface
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.Modifier and TypeClassDescriptionfinal class
A HybridCrossover enables using multiple crossover operators for the evolutionary algorithm, such that each time theHybridCrossover.cross(T, T)
method is called, a randomly chosen crossover operator is applied to the candidate solution.final class
A HybridMutation enables using multiple mutation operators for the search, such that each time theHybridMutation.mutate(T)
method is called, a randomly chosen mutation operator is applied to the candidate solution.final class
A HybridMutation enables using multiple mutation operators for the search, such that each time theHybridUndoableMutation.mutate(T)
method is called, a randomly chosen mutation operator is applied to the candidate solution.final class
InitializeBySimpleMetaheuristic<T extends Copyable<T>>
This class implements theInitializer
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.final class
A WeightedHybridCrossover enables using multiple crossover operators, such that each time theWeightedHybridCrossover.cross(T, T)
method is called, a randomly chosen crossover operator is applied to the candidate solutions.final class
A WeightedHybridMutation enables using multiple mutation operators for the search, such that each time theWeightedHybridMutation.mutate(T)
method is called, a randomly chosen mutation operator is applied to the candidate solution.final class
A WeightedHybridMutation enables using multiple mutation operators for the search, such that each time theWeightedHybridUndoableMutation.mutate(T)
method is called, a randomly chosen mutation operator is applied to the candidate solution. 
Uses of Splittable in org.cicirello.search.operators.bits
Modifier and TypeClassDescriptionfinal class
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.final class
Generates randomBitVector
objects for use in generating random initial solutions for simulated annealing and other metaheuristics.final class
DefiniteBitFlipMutation implements a variation of Bit Flip Mutation.final class
Implementation of Kpoint crossover, a classic crossover operator for BitVectors.final class
Implementation of single point crossover, a classic crossover operator for BitVectors.final class
Implementation of twopoint crossover, a classic crossover operator for BitVectors.final class
Implementation of uniform crossover, a classic crossover operator for BitVectors. 
Uses of Splittable in org.cicirello.search.operators.integers
Modifier and TypeClassDescriptionclass
Generates randomSingleInteger
objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.class
Generating randomIntegerVector
objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.final class
KPointCrossover<T extends IntegerVector>
Implementation of Kpoint crossover, but for IntegerVectors.class
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.final class
SinglePointCrossover<T extends IntegerVector>
Implementation of single point crossover, but for IntegerVectors.final class
TwoPointCrossover<T extends IntegerVector>
Implementation of twopoint crossover, but for IntegerVectors.final class
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.class
UndoableUniformMutation<T extends IntegerValued>
This class implements a uniform mutation with support for theUndoableMutationOperator.undo(T)
method.final class
UniformCrossover<T extends IntegerVector>
Implementation of uniform crossover, but for IntegerVectors.class
UniformMutation<T extends IntegerValued>
This class implements a uniform mutation. 
Uses of Splittable in org.cicirello.search.operators.permutations
Modifier and TypeClassDescriptionfinal class
This class implements an adjacent swap mutation on permutations, where one mutation consists in randomly swapping a pair of adjacent elements.final class
This class implements a block interchange mutation on permutations, where one mutation consists in swapping two randomly chosen nonoverlapping "blocks" (i.e., subsequences).final class
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.final class
This class implements the Cycle(α) form of cycle mutation on permutations, where one mutation generates a random permutation cycle.final class
Implementation of cycle crossover (CX).final class
This class implements the Cycle(kmax) form of cycle mutation on permutations, where one mutation generates a random permutation cycle.final class
Implementation of the Edge Recombination operator, a crossover operator for permutations.final class
Implementation of the Enhanced Edge Recombination operator, a crossover operator for permutations.final class
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.final class
Implementation of nonwrapping order crossover (NWOX).final class
Implementation of order crossover (OX).final class
Implementation of the crossover operator for permutations that is often referred to as Order Crossover 2 (OX2).final class
Implementation of partially matched crossover (PMX).final class
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.final class
Implementation of position based crossover (PBX).final class
Implementation of Precedence Preservative Crossover (PPX), the twopoint version.final class
This class implements a reversal mutation on permutations, where one mutation consists in reversing the order of a randomly selected subpermutation.final class
This class implements a rotation mutation on permutations, where one mutation consists in a random circular rotation of the permutation.final class
This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a randomly selected subpermutation.final class
This class implements a swap mutation on permutations, where one mutation selects two elements uniformly at random and swaps their locations.final class
This class implements the classic 3Opt neighborhood as a mutation operator for permutations.final class
This class implements the classic twochange operator as a mutation operator for permutations.final class
This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a randomly selected subpermutation.final class
This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a noncontiguous subset of the permutation elements.final class
Implementation of uniform orderbased crossover (UOBX).final class
Implementation of uniform partially matched crossover (UPMX).final class
Implementation of Precedence Preservative Crossover (PPX), the uniform version.final class
This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a noncontiguous subset of the permutation elements.final class
This class implements a windowlimited version of theBlockMoveMutation
mutation operator on permutations.final class
This class implements a windowlimited version of theInsertionMutation
mutation operator on permutations.final class
This class implements a windowlimited version of theReversalMutation
mutation operator on permutations.final class
This class implements a windowlimited version of theScrambleMutation
mutation operator on permutations.final class
This class implements a windowlimited version of theSwapMutation
mutation operator on permutations.final class
This class implements a windowlimited version of theScrambleMutation
mutation operator on permutations. 
Uses of Splittable in org.cicirello.search.operators.reals
Modifier and TypeClassDescriptionclass
CauchyMutation<T extends RealValued>
This class implements Cauchy mutation.class
GaussianMutation<T extends RealValued>
This class implements Gaussian mutation.final class
KPointCrossover<T extends RealVector>
Implementation of Kpoint crossover, but for RealVectors.final class
Generating randomSingleReal
objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.final class
Generates randomRealVector
objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.final class
SinglePointCrossover<T extends RealVector>
Implementation of single point crossover, but for RealVectors.final class
TwoPointCrossover<T extends RealVector>
Implementation of twopoint crossover, but for RealVectors.class
UndoableCauchyMutation<T extends RealValued>
This class implements Cauchy mutation with support for theUndoableMutationOperator.undo(T)
method.final class
UndoableGaussianMutation<T extends RealValued>
This class implements Gaussian mutation with support for theUndoableMutationOperator.undo(T)
method.class
UndoableUniformMutation<T extends RealValued>
This class implements a uniform mutation with support for theUndoableMutationOperator.undo(T)
method.final class
UniformCrossover<T extends RealVector>
Implementation of uniform crossover, but for RealVectors.class
UniformMutation<T extends RealValued>
This class implements a uniform mutation. 
Uses of Splittable in org.cicirello.search.problems
Modifier and TypeClassDescriptionfinal class
The BoundMax class is an implementation of a generalization of the wellknown OneMax problem, often used in benchmarking genetic algorithms and other metaheuristics.final class
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].final class
A continuous function with a large number of local minimums, and a single global minimum, defined for input x in [0.5, 2.5].class
This class implements a mapping between Permutation problems and BitVector problems, enabling usingBitVector
search operators to solve problems defined over the space ofPermutation
objects.static final class
This class implements a mapping between Permutation problems and BitVector problems, where cost values are of type double.static final class
This class implements a mapping between Permutation problems and BitVector problems, where cost values are of type int. 
Uses of Splittable in org.cicirello.search.problems.scheduling
Modifier and TypeClassDescriptionfinal class
This is an implementation of the Apparent Tardiness Cost (ATC) heuristic.final class
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.final class
This is an implementation of the ATCS (Apparent Tardiness Cost with Setups) heuristic.final class
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.final class
This is an implementation of the earliest due date heuristic.final class
This class implements a constructive heuristic, known as EXPET, for scheduling problems involving minimizing the sum of weighted earliness plus weighted tardiness.final class
This class implements a constructive heuristic, known as LINET, for scheduling problems involving minimizing the sum of weighted earliness plus weighted tardiness.final class
This is an implementation of the minimum slack time (MST) heuristic.final class
This is an implementation of Montagne's heuristic heuristic.final class
This is an implementation of the shortest process time heuristic, adjusted to include setup time.final class
This is an implementation of the shortest process time heuristic, adjusted to include setup time.final class
This is an implementation of the shortest process time heuristic.final class
This heuristic is smallest normalized setup.final class
This heuristic is the smallest setup first.final class
This heuristic is the smallest setup first.final class
This heuristic is smallest twojob setup.final class
This is an implementation of the weighted COVERT heuristic.final class
This is an implementation of a variation of the weighted COVERT heuristic, adjusted to account for setup times for problems with sequencedependent setups.final class
This is an implementation of a variation of the weighted critical ratio heuristic.final class
This is an implementation of a variation of the weighted critical ratio heuristic, adjusted to account for setup times for problems with sequencedependent setups.final class
This is an implementation of the weighted longest process time heuristic.class
This class implements a variation the weighted shortest process time heuristic, but adjusted to incorporate setups times for problems with sequencedependent setups.final class
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.class
This class implements a variation the weighted shortest process time heuristic, but adjusted to incorporate setups times for problems with sequencedependent setups.class
This is an implementation of the weighted shortest process time heuristic.final class
This is an implementation of the weighted shortest process time heuristic. 
Uses of Splittable in org.cicirello.search.problems.tsp
Modifier and TypeClassDescriptionfinal class
This class implements a nearest city constructive heuristic for the TSP for use by stochastic sampling algorithms.final class
This class implements a constructive heuristic for the TSP that prefers the first city of the nearest pair of cities. 
Uses of Splittable in org.cicirello.search.restarts
Modifier and TypeInterfaceDescriptioninterface
Multistart metaheuristics involve periodically restarting the metaheuristic from a new initial starting solution (often random).Modifier and TypeClassDescriptionfinal class
This is the basic constant run length restart schedule, such that every restart of the multistart metaheuristic is the same in length.final class
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.class
Multistarter<T extends Copyable<T>>
This class is used for implementing multistart metaheuristics.final class
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.final class
ReoptimizableMultistarter<T extends Copyable<T>>
This class is used for implementing multistart metaheuristics, that can be restarted at previously found solutions.final class
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. 
Uses of Splittable in org.cicirello.search.sa
Modifier and TypeInterfaceDescriptioninterface
This interface specifies the required functionality for implementations of annealing schedules.Modifier and TypeClassDescriptionfinal class
An AcceptanceTracker can be used to extract finegrained information about the behavior of an annealing schedule across several runs of simulated annealing.final class
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).final class
This class implements the linear cooling schedule for simulated annealing.final class
This class implements logarithmic cooling, a classic annealing schedule.final class
This class implements an optimized variant of the Modified Lam annealing schedule.final class
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.final class
This class implements a parameterfree version of the classic cooling schedule for simulated annealing known as exponential cooling (sometimes referred to as geometric cooling).final class
This class implements a parameterfree version of the linear cooling schedule for simulated annealing.final class
This class implements the SelfTuning Lam annealing schedule, which is an improved variation of the Modified Lam annealing schedule.final class
SimulatedAnnealing<T extends Copyable<T>>
This class is an implementation of the metaheuristic known as simulated annealing. 
Uses of Splittable in org.cicirello.search.ss
Modifier and TypeInterfaceDescriptioninterface
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.Modifier and TypeClassDescriptionfinal class
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.final class
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.final class
This class generates solutions to permutation optimization problems using a constructive heuristic.class
HeuristicSolutionGenerator<T extends Copyable<T>>
This class generates solutions to optimization problems using a constructive heuristic.final class
HybridConstructiveHeuristic<T extends Copyable<T>>
A HybridConstructiveHeuristic maintains a list ofConstructiveHeuristic
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.final class
IterativeSampling<T extends Copyable<T>>
Iterative sampling is the simplest possible form of a stochastic sampling search.final class
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.