# All Classes and Interfaces

Class

Description

The AcceptanceBandSampling class implements a form of stochastic sampling search that uses a
constructive heuristic to guide the random decisions.

An AcceptanceTracker can be used to extract fine-grained information about the behavior of an
annealing schedule across several runs of simulated annealing.

This class implements an evolutionary algorithm with adaptive control parameters (i.e., crossover
rates and mutation rates that evolve during the search).

This class implements an mutation-only evolutionary algorithm with an adaptive mutation rate that
evolves during the search.

This class implements an adjacent swap mutation on permutations, where one mutation consists in
randomly swapping a pair of adjacent elements.

This interface specifies the required functionality for implementations of annealing schedules.

This is an implementation of the Apparent Tardiness Cost (ATC) heuristic.

This is an implementation of a variation of the Apparent Tardiness Cost (ATC) heuristic, with a
simple adjustment for setup times for problems with sequence-dependent setups.

This is an implementation of the ATCS (Apparent Tardiness Cost with Setups) heuristic.

This class serves as an abstract base class for the various classes that implement variations of
the Traveling Salesperson Problem provided by the library.

This class implements a variation of fitness proportional selection that applies a bias function
to transform the fitness values.

This class implements a variation of Stochastic Universal Sampling (SUS) that we call Biased
Stochastic Universal Sampling (Biased SUS), which integrates the use of a bias function with SUS
to enable transforming fitness values prior to the stochastic selection decisions.

This class is used by the

`BinPackingSolution`

class to represent the contents of a bin in
a solution to a `BinPacking`

problem instance.This class, and its nested classes, implements the Bin Packing problem.

Generates instances of the Bin Packing problem where the optimal solution is comprised of all
full triplet bins (each bin in optimal solution has exactly 3 items that fills the bin to
capacity).

Generates instances of the Bin Packing problem with item sizes that are generated uniformly at
random.

This class represents a solution to a

`BinPacking`

problem instance.This class implements Bit Flip Mutation, the mutation operator commonly used in genetic
algorithms, but which can also be used with other metaheuristic search algorithms such as
simulated annealing to generate random neighbors.

A BitVector is an indexable vector of bits.

Generates random

`BitVector`

objects for use in generating random initial solutions for
simulated annealing and other metaheuristics.This class implements a block interchange mutation on permutations, where one mutation consists
in swapping two randomly chosen non-overlapping "blocks" (i.e., subsequences).

This class implements a block move mutation on permutations, where one mutation consists in
removing a randomly chosen "block" (i.e., subsequence) and reinserting it at a different randomly
chosen index.

This class implements Boltzmann selection.

This class implements Boltzmann selection using Stochastic Universal Sampling (SUS).

A class for representing the input to a multivariate function, with integer values that are
bounded in some interval [min, max].

A class for representing the input to a multivariate function, with real values (floating-point)
that are bounded in some interval [min, max].

The BoundMax class is an implementation of a generalization of the well-known OneMax problem,
often used in benchmarking genetic algorithms and other metaheuristics.

This class implements Cauchy mutation.

This class represents and generates instances of a common duedate scheduling problem, in which
all jobs have both an earliness weight and a tardiness weight, and share a common duedate.

This class provides the ability to configure certain library-wide behavior.

This is the basic constant run length restart schedule, such that every restart of the multistart
metaheuristic is the same in length.

Classes implementing this interface are used as constructive heuristics for constructing
heuristic solutions to optimization problems, as well as for certain stochastic sampling search
algorithms.

This is a wrapper class for

`OptimizationProblem`

objects that enables scaling all cost
values by a positive constant.Implement the CrossoverOperator interface to implement a crossover operator for use in
evolutionary algorithms.

This class implements the Cycle(α) form of cycle mutation on permutations, where one
mutation generates a random permutation cycle.

Implementation of cycle crossover (CX).

This class implements the Cycle(kmax) form of cycle mutation on permutations, where one mutation
generates a random permutation cycle.

DefiniteBitFlipMutation implements a variation of Bit Flip Mutation.

DynamicATCS is an implementation of a variation of the ATCS (Apparent Tardiness Cost with Setups)
heuristic, which dynamically updates the average processing and setup times as it constructs the
schedule.

This is an implementation of the earliest due date heuristic.

Implementation of the Edge Recombination operator, a crossover operator for permutations.

Implementation of the Enhanced Edge Recombination operator, a crossover operator for
permutations.

A Euclidean distance function for use with

`TSP`

instances.This class implements the classic and most commonly encountered cooling schedule for simulated
annealing, the annealing schedule known as exponential cooling (sometimes referred to as
geometric cooling).

This class implements a constructive heuristic, known as EXPET, for scheduling problems involving
minimizing the sum of weighted earliness plus weighted tardiness.

This class implements exponential rank selection.

This class implements exponential rank selection using Stochastic Universal Sampling (SUS).

This class implements first descent hill climbing.

This functional interface is used to provide a bias function to the

`BiasedFitnessProportionalSelection`

operator as well as the `BiasedStochasticUniversalSampling`

operator.Fitness function interfaces.

Fitness function interface for double-valued fitnesses.

Fitness function interface for int-valued fitnesses.

This class implements fitness proportional selection, sometimes referred to as weighted roulette
wheel, for evolutionary algorithms.

FitnessShifter wraps another SelectionOperator, shifting all fitness values by the minimum
fitness minus one, such that the least fit population member's transformed fitness is equal to 1,
with the wrapped SelectionOperator than performing selection using the transformed fitnesses.

A continuous function with a single suboptimal local minimum, and a single global minimum, and a
0 derivative inflexion point, defined for inputs x in [0.0, 1.0].

This class implements Gaussian mutation.

This class implements an evolutionary algorithm with a generational model, such as is commonly
used in genetic algorithms, where a population of children are formed by applying genetic
operators to members of the parent population, and where the children replace the parents in the
next generation.

This class implements an evolutionary algorithm (EA) with a generational model, where a
population of children are formed by applying genetic operators to members of the parent
population, and where the children replace the parents in the next generation.

This class implements an evolutionary algorithm (EA) with a generational model, such as is
commonly used in genetic algorithms, where a population of children are formed by applying
mutation to members of the parent population, and where the children replace the parents in the
next generation.

This class is an implementation of a genetic algorithm (GA) with the common bit vector
representation of solutions to optimization problems, and the generational model where children
replace their parents each generation.

A continuous function with a large number of local minimums, and a single global minimum, defined
for input x in [0.5, 2.5].

Heuristic Biased Stochastic Sampling (HBSS) is a form of stochastic sampling search that uses a
constructive heuristic to bias the random decisions.

Implement this interface to implement the bias function used by HBSS.

This class generates solutions to permutation optimization problems using a constructive
heuristic.

This class generates solutions to optimization problems using a constructive heuristic.

Implementation of Holland's Royal Road problem, as described in the following paper:

Terry Jones.

Terry Jones.

A HybridConstructiveHeuristic maintains a list of

`ConstructiveHeuristic`

objects for a
problem, for use in a multiheuristic stochastic sampling search, where each full iteration of the
stochastic sampler uses a single heuristic for all decisions, but where a different heuristic is
chosen for each iteration.A HybridCrossover enables using multiple crossover operators for the evolutionary algorithm, such
that each time the

`HybridCrossover.cross(T, T)`

method is called, a randomly chosen crossover operator is
applied to the candidate solution.A HybridMutation enables using multiple mutation operators for the search, such that each time
the

`HybridMutation.mutate(T)`

method is called, a randomly chosen mutation operator is applied to the
candidate solution.A HybridMutation enables using multiple mutation operators for the search, such that each time
the

`HybridUndoableMutation.mutate(T)`

method is called, a randomly chosen mutation operator is applied to the
candidate solution.The implementations of constructive heuristics and stochastic samplers biased by constructive
heuristics in the library support incremental updates, as the solution is heuristically
assembled, to problem and/or heuristic data utilized by the heuristic.

This class implements the

`Initializer`

interface to provide metaheuristics and other
search algorithms with a way to generate initial candidate solutions to a problem, that are
themselves generated via a metaheuristic.Implement the Initializer interface to provide metaheuristics and other search algorithms with a
way to generate initial candidate solutions to a problem.

This class implements an insertion mutation on permutations, where one mutation consists in
removing a randomly chosen element and reinserting it at a different randomly chosen location.

This is a wrapper class for

`IntegerCostOptimizationProblem`

objects that enables scaling
all cost values by a positive constant.The IntegerCostOptimizationProblem interface provides search algorithms with a way to interact
with an instance of an optimization problem without the need to know the specifics of the problem
(e.g., traveling salesperson, bin packing, etc).

An interface to define the parameters to a function, where the function parameters are
represented as integers.

Generates random

`SingleInteger`

objects for use in generating random initial solutions for
simulated annealing and other metaheuristics, and for copying such objects.A simple class for representing the input to a multivariate function, with integer values.

Generating random

`IntegerVector`

objects for use in generating random initial solutions
for simulated annealing and other metaheuristics, and for copying such objects.This class provides a convenient mechanism for transforming optimization cost values to fitness
values.

Implement the IterableMutationOperator interface to define a mutation operator that enables
iterating systematically over the neighbors of a candidate solution, like one would do in a hill
climber.

Iterative sampling is the simplest possible form of a stochastic sampling search.

Implementation of K-point crossover, a classic crossover operator for BitVectors.

Implementation of K-point crossover, but for IntegerVectors.

Implementation of K-point crossover, but for RealVectors.

This class is an implementation of the Largest Common Subgraph problem, an NP-Hard combinatorial
optimization problem.

This class is used to represent edges when specifying instances of the

`LargestCommonSubgraph`

problem.This class implements the linear cooling schedule for simulated annealing.

This class implements a constructive heuristic, known as LINET, for scheduling problems involving
minimizing the sum of weighted earliness plus weighted tardiness.

This class implements linear rank selection.

This class implements linear rank selection using Stochastic Universal Sampling (SUS).

This class implements logarithmic cooling, a classic annealing schedule.

The Luby restart schedule originated with constraint satisfaction search, and was originally used
to control when to restart a backtracking constraint satisfaction search in number of backtracks.

This interface defines the required methods for implementations of metaheuristics, in particular
metaheuristics for which the maximum run length can be specified.

Implements the common scheduling cost function known as makespan.

Implements the scheduling cost function known as maximum flowtime (which we want to minimize).

Implements the scheduling cost function known as maximum lateness, which we want to minimize.

Implements the scheduling cost function known as maximum tardiness, which we want to minimize.

This is an implementation of the minimum slack time (MST) heuristic.

This class implements Ackley's Mix problem, an artificial landscape that is a mix of the OneMax,
TwoMax, Trap, and Plateau problems, which provides for a landscape that combines all of the
properties of these benchmarking problems.

This class implements an optimized variant of the Modified Lam annealing schedule.

This class implements the Modified Lam annealing schedule, which dynamically adjusts simulated
annealing's temperature parameter up and down to either decrease or increase the neighbor
acceptance rate as necessary to attempt to match a theoretically determined ideal.

This is an implementation of Montagne's heuristic heuristic.

This class is used for implementing multistart metaheuristics.

Defines an interface for iterating over all of the mutants (i.e., neighbors) of a candidate
solution to a problem.

This class is an implementation of a mutation-only genetic algorithm (GA) with the common bit
vector representation of solutions to optimization problems, and the generational model where
children replace their parents each generation.

Implement the MutationOperator interface to implement a mutation operator for use in simulated
annealing, genetic algorithms, and other evolutionary algorithms, and other metaheuristics, that
require a way to generate random neighbors of a candidate solution.

Deprecated.

This class implements a nearest city constructive heuristic for the TSP for use by stochastic
sampling algorithms.

This class implements a constructive heuristic for the TSP that prefers the first city of the
nearest pair of cities.

Implementation of non-wrapping order crossover (NWOX).

The OneMax class is an implementation of the well-known OneMax problem, often used in
benchmarking genetic algorithms and other metaheuristics.

The OneMaxAckley class is an implementation of the well-known OneMax problem, often used in
benchmarking genetic algorithms and other metaheuristics.

This class implements a (1+1)-EA.

This class implements a (1+1)-GA, a special case of a (1+1)-EA, where solutions are represented
with a vector of bits.

The OptimizationProblem interface provides search algorithms with a way to interact with an
instance of an optimization problem without the need to know the specifics of the problem (e.g.,
real-valued function optimization, traveling salesperson, bin packing, etc).

Implementation of order crossover (OX).

Implementation of the crossover operator for permutations that is often referred to as Order
Crossover 2 (OX2).

This class enables running multiple copies of a metaheuristic, or multiple metaheuristics, in
parallel with multiple threads.

This class is used for implementing parallel multistart metaheuristics.

This class is used for implementing parallel multistart metaheuristics.

The Parallel Variable Annealing Length (P-VAL) restart schedule originated, as you would expect
from the word "annealing" in its name, as a restart schedule for Simulated Annealing.

This class implements a parameter-free version of the classic cooling schedule for simulated
annealing known as exponential cooling (sometimes referred to as geometric cooling).

This class implements a parameter-free version of the linear cooling schedule for simulated
annealing.

A Partial represents a partial solution to a problem (e.g., a partial permutation or a partial
integer vector) that is being iteratively constructed as a solution to an optimization problem.

A PartialIntegerVector represents a vector of integers that is being iteratively constructed as a
solution to an optimization problem over the space of integer vectors.

Implementation of partially matched crossover (PMX).

A PartialPermutation represents a permutation that is being iteratively constructed as a solution
to an optimization problem over the space of permutations.

The Permutation in a Haystack is a family of optimization problems that can be parameterized to
the various types of permutation problem (e.g., absolute versus relative positioning).

The PermutationInitializer provides metaheuristic implementations, such as of simulated
annealing, etc, with a way to generate random initial solutions to a problem, as well as a way to
make copies of current solution configurations.

This class implements a mapping between Permutation problems and BitVector problems, enabling
using

`BitVector`

search operators to solve problems defined over the space of
`Permutation`

objects.This class implements a mapping between Permutation problems and BitVector problems, where cost
values are of type double.

This class implements a mapping between Permutation problems and BitVector problems, where cost
values are of type int.

This class implements Ackley's Plateaus problem, an artificial search landscape over the space of
bitstrings that is characterized by large flat regions known as plateaus.

This class defines polynomial root finding as an optimization problem, enabling solving via
simulated annealing or other metaheuristic optimization algorithms.

An interface to a vector of fitnesses of a population.

An interface to a vector of fitnesses, each a double, of a population.

An interface to a vector of fitnesses, each an int, of a population.

This class implements the Porcupine landscape (Ackley, 1985), which is a very rugged search
landscape, with an exponential number of local optima.

Implementation of position based crossover (PBX).

Implementation of Precedence Preservative Crossover (PPX), the two-point version.

Base interface for all interfaces defining types of problems supported by the library.

This class is used to track search algorithm progress, and supports multithreaded search
algorithms.

This class is an implementation of the Quadratic Assignment Problem (QAP), an NP-Hard
optimization problem.

This class implements a simple random selection operator that selects members of the population
uniformly at random, independent of fitness values.

This class and its nested classes implement the Traveling Salesperson Problem (TSP), and its
variant, the Asymmetric Traveling Salesperson Problem (ATSP), by generating a random distance
matrix.

This class implements the Traveling Salesperson Problem (TSP), and its variant, the Asymmetric
Traveling Salesperson Problem (ATSP), by generating a random distance matrix, with
floating-point cost edges.

This class implements the Traveling Salesperson Problem (TSP), and its variant, the Asymmetric
Traveling Salesperson Problem (ATSP), by generating a random distance matrix, with integer cost
edges.

This mutation operator is for integer valued representations, and replaces an integer value with
a different random integer value from the domain.

An interface to define the parameters to a function, where the function parameters are
represented as type double (i.e., as double precision floating point numbers).

Generating random

`SingleReal`

objects for use in generating random initial solutions for
simulated annealing and other metaheuristics, and for copying such objects.A simple class for representing the parameters to a multivariate function.

Generates random

`RealVector`

objects for use in generating random initial solutions for
simulated annealing and other metaheuristics, and for copying such objects.This interface defines the required methods for implementations of metaheuristics, for which the
maximum run length can be specified, and which have the capability of restarting from a
previously optimized solution.

This class is used for implementing multistart metaheuristics, that can be restarted at
previously found solutions.

Multistart metaheuristics involve periodically restarting the metaheuristic from a new initial
starting solution (often random).

This class implements a reversal mutation on permutations, where one mutation consists in
reversing the order of a randomly selected subpermutation.

This class implements a rotation mutation on permutations, where one mutation consists in a
random circular rotation of the permutation.

Implementation of the Royal Road problem of Mitchell, Forrest, and Holland, both the variation
with stepping stones and the one without.

This class implements a scramble mutation on permutations, where one mutation consists in
randomizing the order of a randomly selected subpermutation.

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

This class implements the Self-Tuning Lam annealing schedule, which is an improved variation of
the Modified Lam annealing schedule.

This is an implementation of the shortest process time heuristic, adjusted to include setup time.

This is an implementation of the shortest process time heuristic, adjusted to include setup time.

This is an implementation of the shortest process time heuristic.

Implements sigma scaling by wrapping your chosen selection operator.

This class is an implementation of the simple genetic algorithm (Simple GA) with the common bit
vector representation of solutions to optimization problems, and the generational model where
children replace their parents each generation.

This interface defines the required methods for implementations of simple metaheuristics that
locally optimize from some initial solution (random or otherwise) whose run length is
self-determined, such as hill climbers that terminate upon reaching a local optima.

This interface defines the required methods for implementations of simple metaheuristics whose
run length is self-determined, such as hill climbers that terminate upon reaching a local optima.

This class is an implementation of the metaheuristic known as simulated annealing.

A simple class for representing the input to a univariate function, such that the input is an
integer.

Implement this interface to define a single machine scheduling problem.

Classes that implement single machine scheduling problems should implement this interface to
enable heuristic, etc to interact with the data that defines the jobs of the scheduling instance,
such as the process times, setup times (if any), due-dates, etc of the jobs.

Implementation of single point crossover, a classic crossover operator for BitVectors.

Implementation of single point crossover, but for IntegerVectors.

Implementation of single point crossover, but for RealVectors.

A simple class for representing the input to a univariate function.

This interface defines the required methods for implementations of single-solution
metaheuristics, i.e., metaheuristics such as simulated annealing that operate one a single
candidate solution (as compared to population-based metaheuristics such as genetic algorithms.

This heuristic is smallest normalized setup.

This heuristic is the smallest setup first.

This heuristic is the smallest setup first.

This heuristic is smallest two-job setup.

An object of this class encapsulates a solution with its corresponding cost value.

The Splittable interface provides multithreaded search algorithms with the ability to generate
functionally identical copies of operators, and even entire metaheuristics, at the point of
spawning new search threads.

This class implements steepest descent hill climbing.

This class implements Stochastic Universal Sampling (SUS), a selection operator for evolutionary
algorithms.

This class implements a swap mutation on permutations, where one mutation selects two elements
uniformly at random and swaps their locations.

This class implements the classic 3-Opt neighborhood as a mutation operator for permutations.

This class is used for implementing parallel multistart metaheuristics.

This class is used for implementing parallel multistart metaheuristics.

This class implements tournament selection for evolutionary algorithms.

This interface defines the required functionality of search algorithm implementations that
support tracking search progress across multiple runs, whether multiple sequential runs, or
multiple concurrent runs in the case of a parallel metaheuristic.

This class implements Ackley's Trap function, which defines a fitness landscape with a single
global optima, and a single sub-optimal local optima, such that most of the search landscape is
within the attraction basin of the local optima.

This class implements truncation selection for evolutionary algorithms.

This class and its nested classes implement the Traveling Salesperson Problem (TSP), such that
cities are 2D points, and edge costs is the distance between them.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs are floating-point
valued.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs are floating-point
valued, and where all edge costs between pairs of cities are precomputed.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs are integer valued.

Cost function for the Traveling Salesperson Problem (TSP), where edge costs are integer valued,
and where all edge costs between pairs of cities are precomputed.

A functional interface for specifying a distance function between a pair of cities in a TSP
instance.

This class implements the classic two-change operator as a mutation operator for permutations.

This class implements the benchmarking problem known as TwoMax.

This class implements a variation of the benchmarking problem known as TwoMax.

Implementation of two-point crossover, a classic crossover operator for BitVectors.

Implementation of two-point crossover, but for IntegerVectors.

Implementation of two-point crossover, but for RealVectors.

This class implements Cauchy mutation with support for the

`UndoableMutationOperator.undo(T)`

method.This class implements Gaussian mutation with support for the

`UndoableMutationOperator.undo(T)`

method.Implement the UndoableMutationOperator interface to implement a mutation operator for use in
simulated annealing, and other metaheuristics, that require a way to generate random neighbors of
a candidate solution, and which supports an undo method.

This mutation operator (supporting the undo operation) is for integer valued representations, and
replaces an integer value with a different random integer value from the domain.

This class implements a uniform mutation with support for the

`UndoableMutationOperator.undo(T)`

method.`UndoableMutationOperator.undo(T)`

method.This class implements a scramble mutation on permutations, where one mutation consists in
randomizing the order of a non-contiguous subset of the permutation elements.

Implementation of uniform crossover, a classic crossover operator for BitVectors.

Implementation of uniform crossover, but for IntegerVectors.

Implementation of uniform crossover, but for RealVectors.

This class implements a uniform mutation.

This class implements a uniform mutation.

Implementation of uniform order-based crossover (UOBX).

Implementation of uniform partially matched crossover (UPMX).

Implementation of Precedence Preservative Crossover (PPX), the uniform version.

Value Biased Stochastic Sampling (VBSS) is a form of stochastic sampling search that uses a
constructive heuristic to bias the random decisions.

Implement this interface to implement the bias function used by VBSS.

The Variable Annealing Length (VAL) restart schedule originated, as you would expect from the
word "annealing" in its name, as a restart schedule for Simulated Annealing.

This is an implementation of the weighted COVERT heuristic.

This is an implementation of a variation of the weighted COVERT heuristic, adjusted to account
for setup times for problems with sequence-dependent setups.

This is an implementation of a variation of the weighted critical ratio heuristic.

This is an implementation of a variation of the weighted critical ratio heuristic, adjusted to
account for setup times for problems with sequence-dependent setups.

Implements the scheduling cost function known as weighted earliness plus weighted tardiness.

Implements the scheduling cost function known as weighted flowtime.

A WeightedHybridCrossover enables using multiple crossover operators, such that each time the

`WeightedHybridCrossover.cross(T, T)`

method is called, a randomly chosen crossover operator is applied to the candidate
solutions.A WeightedHybridMutation enables using multiple mutation operators for the search, such that each
time the

`WeightedHybridMutation.mutate(T)`

method is called, a randomly chosen mutation operator is applied to the
candidate solution.A WeightedHybridMutation enables using multiple mutation operators for the search, such that each
time the

`WeightedHybridUndoableMutation.mutate(T)`

method is called, a randomly chosen mutation operator is applied to the
candidate solution.Implements the scheduling cost function known as weighted lateness.

This is an implementation of the weighted longest process time heuristic.

Implements the scheduling cost function known as weighted number of tardy jobs, which we want to
minimize.

This class implements a variation the weighted shortest process time heuristic, but adjusted to
incorporate setups times for problems with sequence-dependent setups.

This class implements a variation the weighted shortest process time heuristic with non-zero
heuristic values only for late jobs, but adjusted to incorporate setups times for problems with
sequence-dependent setups.

This is an implementation of the weighted shortest process time heuristic.

This is an implementation of the weighted shortest process time heuristic.

Implements the scheduling cost function known as weighted squared tardiness.

This class provides a representation of, and means of generating, instances of single machine
scheduling problems involving weights and due dates, but without release dates (i.e., all jobs
are released at the start of the problem at time 0, thus, the term "static" in the class name).

This class provides a representation of, and means of generating, instances of single machine
scheduling problems involving weights, due dates, and sequence-dependent setup times, but without
release dates (i.e., all jobs are released at the start of the problem at time 0, thus, the term
"static" in the class name).

Implements the scheduling cost function known as weighted tardiness.

This class implements a window-limited version of the

`BlockMoveMutation`

mutation operator
on permutations.This class implements a window-limited version of the

`InsertionMutation`

mutation operator
on permutations.This class implements a window-limited version of the

`ReversalMutation`

mutation operator
on permutations.This class implements a window-limited version of the

`ScrambleMutation`

mutation operator
on permutations.This class implements a window-limited version of the

`SwapMutation`

mutation operator on
permutations.`ScrambleMutation`

mutation operator
on permutations.
IMPORTANT:This class is being introduced temporarily in support of research experiments.