# All Classes and Interfaces

Class

Description

Abstract implementation of the alterer interface.

The abstract base implementation of the Chromosome interface.

This interface lets you accumulate elements of type

`T`

to a result of
type `R`

.The Alterer is responsible for the changing/recombining the Population.

Represents the result pair of a

`Alterer.alter(Seq, long)`

call, which
consists of the altered population and the number of altered individuals.`Chromosome`

implementation, which allows to create genes without
explicit implementing the `Chromosome`

interface.`Gene`

implementation, which allows to create genes without explicit
implementing the `Gene`

interface.Helper class for parsing command line arguments.

Array implementation class.

Minimal interface for accessing an underlying array structure.

Mutable reference of an underlying array

`Store`

.Helper class which contains array helper methods.

General base interface for an ordered, fixed sized, mutable, object sequence.

General base interface for an ordered, fixed sized, object sequence.

This object contains mathematical helper functions.

This class represents a fixed sized array of

*bit*or*boolean*values, backed by a`byte[]`

array.Implementation of the

*classical*BitChromosome.Implementation of a BitGene.

Some bit utils.

In this

`Selector`

, the probability for selection is defined as.Chromosome interface for

`BoundedGene`

s.Base interface for genes where the alleles are bound by a minimum and a
maximum value.

Character chromosome which represents character sequences.

Character gene implementation.

This class is used for holding the valid characters of an

`CharacterGene`

.A chromosome consists of one or more genes.

A problem

`Codec`

contains the information about how to encode a given
argument type into a `Genotype`

.This class contains factory methods for creating common problem encodings.

Alters a chromosome by replacing two genes by the result of a given

*combiner*function.This interface allows you to define constraints on single phenotypes.

This interface indicates that a class can create a copy of type

`T`

.
Performs a
Crossover of two

`Chromosome`

.This class implements the the
Kahan
summation algorithm, which significantly reduces the numerical error when
adding double values.

Numeric chromosome implementation which holds 64-bit floating point numbers.

Implementation of the NumericGene which holds a 64-bit floating point number.

*Value*objects which contains statistical moments.

A state object for collecting statistics such as count, min, max, sum, mean,
variance, skewness and kurtosis.

Double range class.

*Value*objects which contains statistical summary information.

The

`EliteSelector`

copies a small proportion of the fittest candidates,
without changes, into the next generation.Contains static

`Seq`

definitions.Genetic algorithm

*engine*which is the main class.Builder class for building GA

`Engine`

instances.This interface represents a recipe for configuring (setup) a given

`Engine.Builder`

.
Gene which holds enumerable (countable) genes.

This interface allows defining different strategies for evaluating the
fitness functions of a given population.

This class contains factory methods for creating commonly usable

`Evaluator`

implementations.This functional interface defines the evolution function, which takes an

`EvolutionStart`

object, evolves the population, and returns an
`EvolutionResult`

object.This class contains timing information about one evolution step.

Represents the initialization value of an evolution stream/iterator.

The evolution interceptor allows updating the

`EvolutionStart`

object,
*before*the evolution start, and update the`EvolutionResult`

object *after*the evolution.This class collects the parameters which control the behavior of the
evolution process.

Builder class for the evolution parameter.

Represents a state of the GA after an evolution step.

The

`Spliterator`

implementation of the `EvolutionStream`

.Represents a state of the GA at the start of an evolution step.

This class can be used to gather additional statistic information of an
evolution process.

The

`EvolutionStream`

class extends the Java `Stream`

and adds a
method for limiting the evolution by a given predicate.This interface defines the capability of creating

`EvolutionStream`

s
from a given `EvolutionStart`

object.
An alternative to the "weak"

`LinearRankSelector`

is to assign
survival probabilities to the sorted individuals using an exponential
function.This class allows forcing a reevaluation of the fitness function.

The GaussianMutator class performs the mutation of a

`NumericGene`

.Genes are the atoms of the

*Jenetics*library.The central class the GA is working with, is the

`Genotype`

.Static methods for simple and efficient hash-code calculation.

Comparator for int values.

Numeric chromosome implementation which holds 32-bit integer numbers.

NumericGene implementation which holds a 32-bit integer number.

This alterer takes two chromosomes (treating it as vectors) and creates a
linear combination of these vectors as a result.

*Value*objects which contains statistical moments.

Integer range class.

Int reference class, which allows the usage in an lambda expression.

*Value*objects which contains statistical summary information.

Class for object serialization.

Immutable, ordered, fixed sized sequence.

Class for lazy value initialization.

Interfaces and classes for handling resource (

`AutoCloseable`

) objects.Extends the

`AutoCloseable`

with methods for wrapping the thrown
exception into *unchecked*exceptions or ignoring them.This class allows collecting one or more

`AutoCloseable`

objects
into one.This class represents a

*closeable*value.This class allows collecting one or more

`AutoCloseable`

objects
into one.A method which takes an argument and can throw an exception.

A function which takes an argument and can throw an exception.

Runnable task/method, which might throw an exception

`E`

.This class represents a

*closeable*value.This class contains factory methods for creating predicates, which can be
used for limiting the evolution stream.

Extends the

`Spliterator`

interface by an additional `proceed`

predicate.
In linear-ranking selection the individuals are sorted according to their
fitness values.

Numeric chromosome implementation which holds 64-bit integer numbers.

NumericGene implementation which holds a 64-bit integer number.

*Value*objects which contains statistical moments.

Long range class.

*Value*objects which contains statistical summary information.

A mixin interface for genes which can have a mean value.

Alters a chromosome by replacing two genes by its mean value.

This

*consumer*class is used for calculating the min and max value according to the given`Comparator`

.The Monte Carlo selector selects the individuals from a given population
randomly.

Mutable, ordered, fixed sized sequence.

**Multiple point crossover**

This class is for mutating the chromosomes of a given population.

Represents the result pair of one of the four

`Mutator.mutate`

calls.Clock implementation with

*nano*second precision.Numeric chromosome interface.

Base interface for numeric genes.

This

`enum`

determines whether the GA should maximize or minimize the
fitness function.Object wrapper, which makes the wrapped value

`Comparable`

, by defining
a separate `Comparator`

.This alterer wraps a given alterer which works on a given section of the
genotype's chromosomes.

The

`PartiallyMatchedCrossover`

(PMX) guarantees that all `Gene`

s
are found exactly once in each chromosome.This chromosome can be used to model permutations of a given (sub) set of
alleles.

The

`Phenotype`

consists of a `Genotype`

, the current generation
and an optional fitness value.This class contains some common predicates

Mathematical functions regarding probabilities.

Probability selectors are a variation of fitness proportional selectors and
selects individuals from a given population based on its selection
probability

*P(i)*.This interface describes a

*problem*which can be solved by the GA evolution`Engine`

.This sorting methods doesn't sort a given array directly, instead
an index lookup array is returned which allows to access the array in a
sorted order.

The comparator used for comparing two array elements at the specified
indexes.

Implementation of the quantile estimation algorithm published by

Some places in the Java API still require a

`Random`

object instead of
the new `RandomGenerator`

.This class holds the

`RandomGenerator`

engine used for the GA.Some random helper functions.

An enhanced genetic algorithm (EGA) combine elements of existing solutions in
order to create a new solution, with some of the properties of each parent.

Some helper methods for creating hash codes and comparing values.

This simple

`Constraint`

implementation *repairs*an invalid phenotype by creating new individuals until a valid one has been created.The roulette-wheel selector is also known as fitness proportional selector,
but in the

*Jenetics*library it is implemented as probability selector.Selectors are responsible for selecting a given number of individuals from
the population.

This interface defines a

*recursive*generic type`S`

, which
represents the type of the implementing class.General interface for a ordered, fixed sized, object sequence.

Helper methods needed for implementing the Java serializations.

Object reader interface

Object writer interface.

**Single point crossover**

`StochasticUniversalSelector`

is a method for selecting a
population according to some given probability in a way that minimizes chance
fluctuations.This class allows creating a reactive

`Flow.Publisher`

from a given
Java `Stream`

.This class contains factory methods for (flat) mapping stream elements.

This class creates random subsets of size

`k`

from a set of `n`

elements.The

`SwapMutation`

changes the order of genes in a chromosome, with the
hope of bringing related genes closer together, thereby facilitating the
production of building blocks.In tournament selection the best individual from a random sample of

*s*individuals is chosen from the population*P*._{g}In truncation selection, individuals are sorted according to their fitness.

The uniform crossover uses swaps single genes between two chromosomes, instead
of whole ranges as in single- and multipoint crossover.

This interface lets you check an object for validity.