Uses of Interface
org.cicirello.search.problems.Problem
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.
Package of classes and interfaces related to representing
computational problems, as well as classes implementing
a variety of specific computational problems.
Classes and interfaces related to the Bin Packing.
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 Problem in org.cicirello.search
Modifier and TypeMethodDescriptionTrackableSearch.getProblem()
Gets a reference to the problem that this search is solving. 
Uses of Problem in org.cicirello.search.concurrent
Modifier and TypeMethodDescriptionParallelMetaheuristic.getProblem()
TimedParallelMultistarter.getProblem()

Uses of Problem in org.cicirello.search.evo
Modifier and TypeMethodDescriptionFitnessFunction.getProblem()
Gets a reference to the problem that this fitness function is for.InverseCostFitnessFunction.getProblem()
OnePlusOneEvolutionaryAlgorithm.getProblem()

Uses of Problem in org.cicirello.search.problems
Modifier and TypeInterfaceDescriptioninterface
IntegerCostOptimizationProblem<T extends Copyable<T>>
The IntegerCostOptimizationProblem interface provides search algorithms with a way to interact with an instance of an optimization problem without the need to know the specifics of the problem (e.g., traveling salesperson, bin packing, etc).interface
OptimizationProblem<T extends Copyable<T>>
The OptimizationProblem interface provides search algorithms with a way to interact with an instance of an optimization problem without the need to know the specifics of the problem (e.g., realvalued function optimization, traveling salesperson, bin packing, etc).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
CostFunctionScaler<T extends Copyable<T>>
This is a wrapper class forOptimizationProblem
objects that enables scaling all cost values by a positive constant.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].final class
Implementation of Holland's Royal Road problem, as described in the following paper:
Terry Jones.final class
IntegerCostFunctionScaler<T extends Copyable<T>>
This is a wrapper class forIntegerCostOptimizationProblem
objects that enables scaling all cost values by a positive constant.final class
This class is an implementation of the Largest Common Subgraph problem, an NPHard combinatorial optimization problem.final class
This class implements Ackley's Mix problem, an artificial landscape that is a mix of the OneMax, TwoMax, Trap, and Plateau problems, which provides for a landscape that combines all of the properties of these benchmarking problems.final class
The OneMax class is an implementation of the wellknown OneMax problem, often used in benchmarking genetic algorithms and other metaheuristics.final class
The OneMaxAckley class is an implementation of the wellknown OneMax problem, often used in benchmarking genetic algorithms and other metaheuristics.final class
The Permutation in a Haystack is a family of optimization problems that can be parameterized to the various types of permutation problem (e.g., absolute versus relative positioning).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.final class
This class implements Ackley's Plateaus problem, an artificial search landscape over the space of bitstrings that is characterized by large flat regions known as plateaus.final class
This class defines polynomial root finding as an optimization problem, enabling solving via simulated annealing or other metaheuristic optimization algorithms.final class
This class implements the Porcupine landscape (Ackley, 1985), which is a very rugged search landscape, with an exponential number of local optima.final class
This class is an implementation of the Quadratic Assignment Problem (QAP), an NPHard optimization problem.final class
Implementation of the Royal Road problem of Mitchell, Forrest, and Holland, both the variation with stepping stones and the one without.final class
This class implements Ackley's Trap function, which defines a fitness landscape with a single global optima, and a single suboptimal local optima, such that most of the search landscape is within the attraction basin of the local optima.final class
This class implements the benchmarking problem known as TwoMax.final class
This class implements a variation of the benchmarking problem known as TwoMax. 
Uses of Problem in org.cicirello.search.problems.binpack
Modifier and TypeClassDescriptionclass
This class, and its nested classes, implements the Bin Packing problem.static final class
Generates instances of the Bin Packing problem where the optimal solution is comprised of all full triplet bins (each bin in optimal solution has exactly 3 items that fills the bin to capacity).static final class
Generates instances of the Bin Packing problem with item sizes that are generated uniformly at random. 
Uses of Problem in org.cicirello.search.problems.scheduling
Modifier and TypeInterfaceDescriptioninterface
Implement this interface to define a single machine scheduling problem.Modifier and TypeClassDescriptionfinal class
Implements the common scheduling cost function known as makespan.final class
Implements the scheduling cost function known as maximum flowtime (which we want to minimize).final class
Implements the scheduling cost function known as maximum lateness, which we want to minimize.final class
Implements the scheduling cost function known as maximum tardiness, which we want to minimize.final class
Implements the scheduling cost function known as weighted earliness plus weighted tardiness.final class
Implements the scheduling cost function known as weighted flowtime.final class
Implements the scheduling cost function known as weighted lateness.final class
Implements the scheduling cost function known as weighted number of tardy jobs, which we want to minimize.final class
Implements the scheduling cost function known as weighted squared tardiness.final class
Implements the scheduling cost function known as weighted tardiness. 
Uses of Problem in org.cicirello.search.problems.tsp
Modifier and TypeClassDescriptionclass
This class serves as an abstract base class for the various classes that implement variations of the Traveling Salesperson Problem provided by the library.class
This class and its nested classes implement the Traveling Salesperson Problem (TSP), and its variant, the Asymmetric Traveling Salesperson Problem (ATSP), by generating a random distance matrix.static final class
This class implements the Traveling Salesperson Problem (TSP), and its variant, the Asymmetric Traveling Salesperson Problem (ATSP), by generating a random distance matrix, with floatingpoint cost edges.static final class
This class implements the Traveling Salesperson Problem (TSP), and its variant, the Asymmetric Traveling Salesperson Problem (ATSP), by generating a random distance matrix, with integer cost edges.class
This class and its nested classes implement the Traveling Salesperson Problem (TSP), such that cities are 2D points, and edge costs is the distance between them.static final class
Cost function for the Traveling Salesperson Problem (TSP), where edge costs are floatingpoint valued.static final class
Cost function for the Traveling Salesperson Problem (TSP), where edge costs are floatingpoint valued, and where all edge costs between pairs of cities are precomputed.static final class
Cost function for the Traveling Salesperson Problem (TSP), where edge costs are integer valued.static final class
Cost function for the Traveling Salesperson Problem (TSP), where edge costs are integer valued, and where all edge costs between pairs of cities are precomputed.Modifier and TypeMethodDescriptionfinal Problem<Permutation>
NearestCityHeuristic.getProblem()
final Problem<Permutation>
NearestCityPairHeuristic.getProblem()

Uses of Problem in org.cicirello.search.restarts

Uses of Problem in org.cicirello.search.sa

Uses of Problem in org.cicirello.search.ss
Modifier and TypeMethodDescriptionConstructiveHeuristic.getProblem()
Gets a reference to the instance of the optimization problem that is the subject of this heuristic.HeuristicSolutionGenerator.getProblem()
HybridConstructiveHeuristic.getProblem()