Uses of Interface
org.cicirello.search.concurrent.Splittable

Packages that use Splittable

Package	Description
org.cicirello.search	This package includes classes and interfaces related to implementing metaheuristic search algorithms in general, rather than specific to a particular metaheuristic.
org.cicirello.search.concurrent	This package includes multithreaded search implementations, as well as classes and interfaces related to implementing multithreaded metaheuristics.
org.cicirello.search.evo	This package includes classes and interfaces directly related to implementing evolutionary algorithms.
org.cicirello.search.hc	This package includes classes and interfaces directly related to implementing hill climbers.
org.cicirello.search.operators	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.
org.cicirello.search.operators.bits	This package includes classes that implement operators that create, mutate, etc, BitVectors.
org.cicirello.search.operators.integers	This package includes classes that implement operators that create, mutate, etc, integer valued representations.
org.cicirello.search.operators.permutations	This package includes classes that implement local search and evolutionary operators for permutations, such as mutation operators, crossover operators, and initializers.
org.cicirello.search.operators.reals	This package includes classes that implement operators that create, mutate, etc, the the inputs to functions with real-valued input parameters (represented with type double), such as is required to solve function optimization problems using simulated annealing or other metaheuristics.
org.cicirello.search.problems	Package of classes and interfaces related to representing computational problems, as well as classes implementing a variety of specific computational problems.
org.cicirello.search.problems.scheduling	Package of classes and interfaces related to representing and solving scheduling problems, which includes implementations of constructive heuristics for scheduling problems.
org.cicirello.search.problems.tsp	Classes and interfaces related to the Traveling Salesperson Problem (TSP).
org.cicirello.search.restarts	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).
org.cicirello.search.sa	This package includes classes and interfaces directly related to implementing simulated annealing.
org.cicirello.search.ss	This package includes classes and interfaces directly related to implementing stochastic sampling algorithms.

Uses of Splittable in org.cicirello.search

Subinterfaces of Splittable in org.cicirello.search

Modifier and Type	Interface	Description
interface	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 self-determined, 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 self-determined, 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 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.
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

Classes in org.cicirello.search.concurrent with type parameters of type Splittable

Modifier and Type	Interface	Description
interface	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.

Classes in org.cicirello.search.concurrent that implement Splittable

Modifier and Type	Class	Description
class	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

Subinterfaces of Splittable in org.cicirello.search.evo

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

Classes in org.cicirello.search.evo that implement Splittable

Modifier and Type	Class	Description
class	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 mutation-only evolutionary algorithm with an adaptive mutation rate that evolves during the search.
class	BiasedFitnessProportionalSelection	This class implements a variation of fitness proportional selection that applies a bias function to transform the fitness values.
class	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.
final class	BoltzmannSelection	This class implements Boltzmann selection.
final class	BoltzmannStochasticUniversalSampling	This class implements Boltzmann selection using Stochastic Universal Sampling (SUS).
final class	ExponentialRankSelection	This class implements exponential rank selection.
final class	ExponentialRankStochasticUniversalSampling	This class implements exponential rank selection using Stochastic Universal Sampling (SUS).
class	FitnessProportionalSelection	This class implements fitness proportional selection, sometimes referred to as weighted roulette wheel, for evolutionary algorithms.
final class	FitnessShifter	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	GenerationalEvolutionaryAlgorithmMutuallyExclusiveOperators<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.
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	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.
final class	LinearRankSelection	This class implements linear rank selection.
final class	LinearRankStochasticUniversalSampling	This class implements linear rank selection using Stochastic Universal Sampling (SUS).
final class	MutationOnlyGeneticAlgorithm	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.
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	OnePlusOneGeneticAlgorithm	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	RandomSelection	This class implements a simple random selection operator that selects members of the population uniformly at random, independent of fitness values.
final class	SigmaScaling	Implements sigma scaling by wrapping your chosen selection operator.
final class	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.
class	StochasticUniversalSampling	This class implements Stochastic Universal Sampling (SUS), a selection operator for evolutionary algorithms.
final class	TournamentSelection	This class implements tournament selection for evolutionary algorithms.
final class	TruncationSelection	This class implements truncation selection for evolutionary algorithms.

Uses of Splittable in org.cicirello.search.hc

Classes in org.cicirello.search.hc that implement Splittable

Modifier and Type	Class	Description
final 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

Subinterfaces of Splittable in org.cicirello.search.operators

Modifier and Type	Interface	Description
interface	CrossoverOperator<T>	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	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.
interface	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.
interface	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.

Classes in org.cicirello.search.operators that implement Splittable

Modifier and Type	Class	Description
final class	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.
final class	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.
final class	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.
final class	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.
final class	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.
final class	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.
final class	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.

Uses of Splittable in org.cicirello.search.operators.bits

Classes in org.cicirello.search.operators.bits that implement Splittable

Modifier and Type	Class	Description
final class	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.
final class	BitVectorInitializer	Generates random BitVector objects for use in generating random initial solutions for simulated annealing and other metaheuristics.
final class	DefiniteBitFlipMutation	DefiniteBitFlipMutation implements a variation of Bit Flip Mutation.
final class	KPointCrossover	Implementation of K-point crossover, a classic crossover operator for BitVectors.
final class	SinglePointCrossover	Implementation of single point crossover, a classic crossover operator for BitVectors.
final class	TwoPointCrossover	Implementation of two-point crossover, a classic crossover operator for BitVectors.
final class	UniformCrossover	Implementation of uniform crossover, a classic crossover operator for BitVectors.

Uses of Splittable in org.cicirello.search.operators.integers

Classes in org.cicirello.search.operators.integers that implement Splittable

Modifier and Type	Class	Description
class	IntegerValueInitializer	Generates random SingleInteger objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.
class	IntegerVectorInitializer	Generating random IntegerVector 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 K-point 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 two-point 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 the UndoableMutationOperator.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

Classes in org.cicirello.search.operators.permutations that implement Splittable

Modifier and Type	Class	Description
final class	AdjacentSwapMutation	This class implements an adjacent swap mutation on permutations, where one mutation consists in randomly swapping a pair of adjacent elements.
final class	BlockInterchangeMutation	This class implements a block interchange mutation on permutations, where one mutation consists in swapping two randomly chosen non-overlapping "blocks" (i.e., subsequences).
final class	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.
final class	CycleAlphaMutation	This class implements the Cycle(α) form of cycle mutation on permutations, where one mutation generates a random permutation cycle.
final class	CycleCrossover	Implementation of cycle crossover (CX).
final class	CycleMutation	This class implements the Cycle(kmax) form of cycle mutation on permutations, where one mutation generates a random permutation cycle.
final class	EdgeRecombination	Implementation of the Edge Recombination operator, a crossover operator for permutations.
final class	EnhancedEdgeRecombination	Implementation of the Enhanced Edge Recombination operator, a crossover operator for permutations.
final class	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.
final class	NonWrappingOrderCrossover	Implementation of non-wrapping order crossover (NWOX).
final class	OrderCrossover	Implementation of order crossover (OX).
final class	OrderCrossoverTwo	Implementation of the crossover operator for permutations that is often referred to as Order Crossover 2 (OX2).
final class	PartiallyMatchedCrossover	Implementation of partially matched crossover (PMX).
final class	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.
final class	PositionBasedCrossover	Implementation of position based crossover (PBX).
final class	PrecedencePreservativeCrossover	Implementation of Precedence Preservative Crossover (PPX), the two-point version.
final class	ReversalMutation	This class implements a reversal mutation on permutations, where one mutation consists in reversing the order of a randomly selected subpermutation.
final class	RotationMutation	This class implements a rotation mutation on permutations, where one mutation consists in a random circular rotation of the permutation.
final class	ScrambleMutation	This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a randomly selected subpermutation.
final class	SwapMutation	This class implements a swap mutation on permutations, where one mutation selects two elements uniformly at random and swaps their locations.
final class	ThreeOptMutation	This class implements the classic 3-Opt neighborhood as a mutation operator for permutations.
final class	TwoChangeMutation	This class implements the classic two-change operator as a mutation operator for permutations.
final class	UndoableScrambleMutation	This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a randomly selected subpermutation.
final class	UndoableUniformScrambleMutation	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.
final class	UniformOrderBasedCrossover	Implementation of uniform order-based crossover (UOBX).
final class	UniformPartiallyMatchedCrossover	Implementation of uniform partially matched crossover (UPMX).
final class	UniformPrecedencePreservativeCrossover	Implementation of Precedence Preservative Crossover (PPX), the uniform version.
final class	UniformScrambleMutation	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.
final class	WindowLimitedBlockMoveMutation	This class implements a window-limited version of the BlockMoveMutation mutation operator on permutations.
final class	WindowLimitedInsertionMutation	This class implements a window-limited version of the InsertionMutation mutation operator on permutations.
final class	WindowLimitedReversalMutation	This class implements a window-limited version of the ReversalMutation mutation operator on permutations.
final class	WindowLimitedScrambleMutation	This class implements a window-limited version of the ScrambleMutation mutation operator on permutations.
final class	WindowLimitedSwapMutation	This class implements a window-limited version of the SwapMutation mutation operator on permutations.
final class	WindowLimitedUndoableScrambleMutation	This class implements a window-limited version of the ScrambleMutation mutation operator on permutations.

Uses of Splittable in org.cicirello.search.operators.reals

Classes in org.cicirello.search.operators.reals that implement Splittable

Modifier and Type	Class	Description
class	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 K-point crossover, but for RealVectors.
final class	RealValueInitializer	Generating random SingleReal objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.
final class	RealVectorInitializer	Generates random RealVector 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 two-point crossover, but for RealVectors.
class	UndoableCauchyMutation<T extends RealValued>	This class implements Cauchy mutation with support for the UndoableMutationOperator.undo(T) method.
final class	UndoableGaussianMutation<T extends RealValued>	This class implements Gaussian mutation with support for the UndoableMutationOperator.undo(T) method.
class	UndoableUniformMutation<T extends RealValued>	This class implements a uniform mutation with support for the UndoableMutationOperator.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

Classes in org.cicirello.search.problems that implement Splittable

Modifier and Type	Class	Description
final class	BoundMax	The BoundMax class is an implementation of a generalization of the well-known OneMax problem, often used in benchmarking genetic algorithms and other metaheuristics.
final class	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].
final class	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].
class	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.
static final class	PermutationToBitVectorProblem.DoubleCost	This class implements a mapping between Permutation problems and BitVector problems, where cost values are of type double.
static final class	PermutationToBitVectorProblem.IntegerCost	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

Classes in org.cicirello.search.problems.scheduling that implement Splittable

Modifier and Type	Class	Description
final class	ApparentTardinessCost	This is an implementation of the Apparent Tardiness Cost (ATC) heuristic.
final class	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 sequence-dependent setups.
final class	ATCS	This is an implementation of the ATCS (Apparent Tardiness Cost with Setups) heuristic.
final class	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.
final class	EarliestDueDate	This is an implementation of the earliest due date heuristic.
final class	ExponentialEarlyTardyHeuristic	This class implements a constructive heuristic, known as EXPET, for scheduling problems involving minimizing the sum of weighted earliness plus weighted tardiness.
final class	LinearEarlyTardyHeuristic	This class implements a constructive heuristic, known as LINET, for scheduling problems involving minimizing the sum of weighted earliness plus weighted tardiness.
final class	MinimumSlackTime	This is an implementation of the minimum slack time (MST) heuristic.
final class	Montagne	This is an implementation of Montagne's heuristic heuristic.
final class	ShortestProcessingPlusSetupTime	This is an implementation of the shortest process time heuristic, adjusted to include setup time.
final class	ShortestProcessingPlusSetupTimePrecompute	This is an implementation of the shortest process time heuristic, adjusted to include setup time.
final class	ShortestProcessingTime	This is an implementation of the shortest process time heuristic.
final class	SmallestNormalizedSetup	This heuristic is smallest normalized setup.
final class	SmallestSetup	This heuristic is the smallest setup first.
final class	SmallestSetupPrecompute	This heuristic is the smallest setup first.
final class	SmallestTwoJobSetup	This heuristic is smallest two-job setup.
final class	WeightedCostOverTime	This is an implementation of the weighted COVERT heuristic.
final class	WeightedCostOverTimeSetupAdjusted	This is an implementation of a variation of the weighted COVERT heuristic, adjusted to account for setup times for problems with sequence-dependent setups.
final class	WeightedCriticalRatio	This is an implementation of a variation of the weighted critical ratio heuristic.
final class	WeightedCriticalRatioSetupAdjusted	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.
final class	WeightedLongestProcessingTime	This is an implementation of the weighted longest process time heuristic.
class	WeightedShortestProcessingPlusSetupTime	This class implements a variation the weighted shortest process time heuristic, but adjusted to incorporate setups times for problems with sequence-dependent setups.
final class	WeightedShortestProcessingPlusSetupTimeLateOnly	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.
class	WeightedShortestProcessingPlusSetupTimePrecompute	This class implements a variation the weighted shortest process time heuristic, but adjusted to incorporate setups times for problems with sequence-dependent setups.
class	WeightedShortestProcessingTime	This is an implementation of the weighted shortest process time heuristic.
final class	WeightedShortestProcessingTimeLateOnly	This is an implementation of the weighted shortest process time heuristic.

Uses of Splittable in org.cicirello.search.problems.tsp

Classes in org.cicirello.search.problems.tsp that implement Splittable

Modifier and Type	Class	Description
final class	NearestCityHeuristic	This class implements a nearest city constructive heuristic for the TSP for use by stochastic sampling algorithms.
final class	NearestCityPairHeuristic	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

Subinterfaces of Splittable in org.cicirello.search.restarts

Modifier and Type	Interface	Description
interface	RestartSchedule	Multistart metaheuristics involve periodically restarting the metaheuristic from a new initial starting solution (often random).

Classes in org.cicirello.search.restarts that implement Splittable

Modifier and Type	Class	Description
final class	ConstantRestartSchedule	This is the basic constant run length restart schedule, such that every restart of the multistart metaheuristic is the same in length.
final class	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.
class	Multistarter<T extends Copyable<T>>	This class is used for implementing multistart metaheuristics.
final class	ParallelVariableAnnealingLength	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.
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	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.

Uses of Splittable in org.cicirello.search.sa

Subinterfaces of Splittable in org.cicirello.search.sa

Modifier and Type	Interface	Description
interface	AnnealingSchedule	This interface specifies the required functionality for implementations of annealing schedules.

Classes in org.cicirello.search.sa that implement Splittable

Modifier and Type	Class	Description
final class	AcceptanceTracker	An AcceptanceTracker can be used to extract fine-grained information about the behavior of an annealing schedule across several runs of simulated annealing.
final class	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).
final class	LinearCooling	This class implements the linear cooling schedule for simulated annealing.
final class	LogarithmicCooling	This class implements logarithmic cooling, a classic annealing schedule.
final class	ModifiedLam	This class implements an optimized variant of the Modified Lam annealing schedule.
final class	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.
final class	ParameterFreeExponentialCooling	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).
final class	ParameterFreeLinearCooling	This class implements a parameter-free version of the linear cooling schedule for simulated annealing.
final class	SelfTuningLam	This class implements the Self-Tuning 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

Subinterfaces of Splittable in org.cicirello.search.ss

Modifier and Type	Interface	Description
interface	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.

Classes in org.cicirello.search.ss that implement Splittable

Modifier and Type	Class	Description
final 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	HeuristicPermutationGenerator	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 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.
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.