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

Packages that use 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 mutation operators for permutations, and other operators required by simulated annealing and other related metaheuristics.
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.
Package of classes and interfaces related to representing computational problems, as well as classes implementing a variety of specific computational problems.
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

    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 
    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 
    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 
    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 
    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 
    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.
    Modifier and Type
    Class
    Description
    class 
    This class enables running multiple copies of a metaheuristic, or multiple metaheuristics, in parallel with multiple threads.
    final class 
    This class is used for implementing parallel multistart metaheuristics.
    class 
    This class enables running multiple copies of a metaheuristic, or multiple metaheuristics, in parallel with multiple threads.
    final class 
    This class is used for implementing parallel multistart metaheuristics.
    class 
    This class is used for implementing parallel multistart metaheuristics.
    final class 
    This class is used for implementing parallel multistart metaheuristics.
  • Uses of Splittable in org.cicirello.search.evo

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

    Classes in org.cicirello.search.hc that implement Splittable
    Modifier and Type
    Class
    Description
    final class 
    This class implements first descent hill climbing.
    final class 
    This class implements steepest descent hill climbing.
  • Uses of Splittable in org.cicirello.search.operators

    Modifier and Type
    Interface
    Description
    interface 
    Implement the CrossoverOperator interface to implement a crossover operator for use in evolutionary algorithms.
    interface 
    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.
    Classes in org.cicirello.search.operators that implement Splittable
    Modifier and Type
    Class
    Description
    final class 
    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 
    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 
    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 
    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 
    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 
    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 
    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

    Modifier and Type
    Class
    Description
    final 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 random BitVector 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 K-point crossover, a classic crossover operator for BitVectors.
    final class 
    Implementation of single point crossover, a classic crossover operator for BitVectors.
    final class 
    Implementation of two-point 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 Type
    Class
    Description
    class 
    Generates random SingleInteger objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.
    class 
    Generating random IntegerVector objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.
    final class 
    Implementation of K-point crossover, but for IntegerVectors.
    class 
    This mutation operator is for integer valued representations, and replaces an integer value with a different random integer value from the domain.
    final class 
    Implementation of single point crossover, but for IntegerVectors.
    final class 
    Implementation of two-point crossover, but for IntegerVectors.
    final class 
    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 
    This class implements a uniform mutation on integer valued parameters, with support for the UndoableUniformMutation.undo(T) method.
    final class 
    Implementation of uniform crossover, but for IntegerVectors.
    class 
    This class implements a uniform mutation for mutating integer values.
  • Uses of Splittable in org.cicirello.search.operators.permutations

    Modifier and Type
    Class
    Description
    final class 
    This class implements an adjacent swap mutation on permutations, where one mutation consists in randomly swapping a pair of adjacent elements.
    class 
    This class implements a block interchange mutation on permutations, where one mutation consists in swapping two randomly chosen non-overlapping "blocks" (i.e., subsequences).
    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.
    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 non-wrapping 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 Precedence Preservative Crossover (PPX), the two-point version.
    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.
    class 
    This class implements a scramble mutation on permutations, where one mutation consists in randomizing the order of a randomly selected subpermutation.
    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 3-Opt neighborhood as a mutation operator for permutations.
    final class 
    This class implements the classic two-change operator as a mutation operator for permutations.
    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 non-contiguous subset of the permutation elements.
    final class 
    Implementation of uniform order-based 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 non-contiguous subset of the permutation elements.
    final class 
    This class implements a window-limited version of the BlockMoveMutation mutation operator on permutations.
    final class 
    This class implements a window-limited version of the InsertionMutation mutation operator on permutations.
    final class 
    This class implements a window-limited version of the ReversalMutation mutation operator on permutations.
    final class 
    This class implements a window-limited version of the ScrambleMutation mutation operator on permutations.
    final class 
    This class implements a window-limited version of the SwapMutation mutation operator on permutations.
    final class 
    This class implements a window-limited version of the ScrambleMutation mutation operator on permutations.
  • Uses of Splittable in org.cicirello.search.operators.reals

    Modifier and Type
    Class
    Description
    class 
    This class implements Cauchy mutation.
    class 
    This class implements Gaussian mutation.
    final class 
    Implementation of K-point crossover, but for RealVectors.
    final class 
    Generating random SingleReal objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.
    final class 
    Generates random RealVector objects for use in generating random initial solutions for simulated annealing and other metaheuristics, and for copying such objects.
    final class 
    Implementation of single point crossover, but for RealVectors.
    final class 
    Implementation of two-point crossover, but for RealVectors.
    class 
    This class implements Cauchy mutation with support for the UndoableCauchyMutation.undo(T) method.
    class 
    This class implements Gaussian mutation with support for the UndoableGaussianMutation.undo(T) method.
    class 
    This class implements a uniform mutation with support for the UndoableUniformMutation.undo(T) method.
    final class 
    Implementation of uniform crossover, but for RealVectors.
    class 
    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 
    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 
    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 using BitVector search operators to solve problems defined over the space of Permutation 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.restarts

    Modifier and Type
    Interface
    Description
    interface 
    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 
    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 (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 
    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 Type
    Interface
    Description
    interface 
    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 
    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 
    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 parameter-free 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 parameter-free version of the linear cooling schedule for simulated annealing.
    final class 
    This class implements the Self-Tuning Lam annealing schedule, which is an improved variation of the Modified Lam annealing schedule.
    class 
    This class is an implementation of the metaheuristic known as simulated annealing.
  • Uses of Splittable in org.cicirello.search.ss

    Classes in org.cicirello.search.ss that implement Splittable
    Modifier and Type
    Class
    Description
    final class 
    The AcceptanceBandSampling class implements a form of stochastic sampling search that uses a constructive heuristic to guide the random decisions.
    final class 
    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 
    This class generates solutions to optimization problems using a constructive heuristic.
    final class 
    Iterative sampling is the simplest possible form of a stochastic sampling search.
    final class 
    Value Biased Stochastic Sampling (VBSS) is a form of stochastic sampling search that uses a constructive heuristic to bias the random decisions.