All Types

An Argument is essentially just the value of a particular Register, but in the context of an

A simple collection of Arguments.

The arity of an operation, specifying how many arguments it can take.

Thrown when the Arity of an Operation does not match the number of lgp.core.evolution.registers.Arguments given to it.

A base arity implementation that provides arity for instructions with one or two arguments.

An operation that has an arity of two (i.e. its function takes 2 arguments).

Performs Binary Tournament Selection as described in Linear Genetic Programming (Brameier, M., Banzhaf, W. 2001).

A Module that is able to load components.

A builder that can build a ComponentLoader.

Represents the parameters that can be set for the an LGP environment.

An extended ComponentLoader that is responsible for loading Configuration instances.

An extended ComponentLoader that loads a collection of values of type T to be used as constants.

A function that can be used to mutate a constant value.

A collection of ConstantMutationFunction implementations for use by a MicroMutationOperator.

A mapping for core modules to a module type value.

Loads a collection of samples and their target values from a CSV file.

A basic data set composed of a vector of input Samples and a collection of output Targets.

An extended ComponentLoader that loads a Dataset.

A simple operation loader implementation that simply loads a set of operations specified by the name of the package + class it can be found in.

An implementation will be able to provide default values to some consumer.

A collection of useful DefaultValueProvider implementations.

Trains the model for a given number of runs, in a parallel manner.

Represents an asynchronous distributed training operation.

An implementation of ConstantLoader that loads constants as a collection of Doubles.

A central repository for core components made available to the LGP system.

An evaluation of a program on a set of fitness cases.

A model that can be used to perform evolution within in a specific environment.

The best individual and final population from the result of evolution.

A container for any statistics from evolution.

Represents a result that is able to be exported from the system.

A feature of a sample in some data set.

A case to evaluate a programs fitness on.

Provides a way to map a program to fitness cases using a given fitness function.

Provides a way to evaluate the fitness of a program.

Provides the functionality to compute the fitness of an individual program on a set of input-output examples.

A function that provides a FitnessFunction implementation on request.

A collection of standard fitness functions.

The type of function that operations perform.

An implementation of ConstantLoader that can load raw constants into a specified type.

An instruction in an LGP program.

A generator of instructions in an LGP system.

Exception given when a CSV file that does not match the criteria the system expects is given to a CsvDatasetLoader instance.

Represents the state entered when the load of an invalid module is attempted.

An implementation of ConfigurationLoader that loads configuration from a JSON file.

A RecombinationOperator that implements Linear Crossover for two individuals.

kotlin.collections.List (extensions in package

A MutationOperator implementation that performs effective macro mutations.

A MutationOperator implementation that performs effective micro mutations.

Exception thrown when no Module is registered for a requested RegisteredModuleType.

A collection of built-in evolution models.

A module in the LGP system.

Exception thrown when a Module is cast as a type that is not valid for it.

A container that provides modules that need to be registered with an environment.

Each Module should have some information with it describing what the Module does/what it is for.

Facilitates fitness evaluation for programs which have multiple outputs.

A FitnessFunction for lgp.core.program.Programs with multiple outputs.

kotlin.collections.MutableList (extensions in package

A search operator used during evolution to mutate an individual from a population.

An operation has an Arity and some function that it can perform on Arguments given to it.

Loads a collection of Operations in some way defined by the implementer.

Represents the output of a Program.

A collection of built-in Output implementations.

Provides a collection of parsing functions that can be used by a CsvDatasetLoader instance.

Defines a problem and the components that should be used to solve that problem.

Exception given when a problem is attempted to be solved when it hasn't been completely initialised.

An LGP program that is composed of instructions that operate on registers.

Generates Program instances to be used in an LGP population.

Module that can be used to translate programs to external representations.

java.util.Random (extensions in package

Generates an infinite random sequence of registers from the register set given.

A search operator used during evolution to combine two individuals from a population.

A register that is available to an LGP program.

Thrown when a write operation is attempted on a RegisterType.Constant register.

Represents a collection of Registers.

Represents the type of a register.

Thrown when the number of values being written to a particular register range, does not match the size of the range.

Represents the different modules that are able to be registered with an environment.

A module that can collect ExportableResult instances for later export from the system.

A collection of built-in ResultAggregator implementations.

Provides the ability to output results from a ResultAggregator.

A collection of ResultOutputProvider implementations for common scenarios.

An ExportableResult implementation that represents evolution statistics for a particular run.

A sample in a Dataset made up of a collection of Features.

A search operator used during evolution to select a subset of individuals from a population.

Can generate a sequence of values evenly spread between a range.

Trains the model for a given number of runs, in a sequential manner.

Represents an asynchronous sequential training operation.

Facilitates fitness evaluation for programs which have a single output.

A FitnessFunction for lgp.core.program.Programs with a single output.

Represents a solution to a problem.

A target output in a Dataset.

A collection of built-in Target implementations

A result given when calling EvolutionModel.test.

A SelectionOperator implementation that selects individuals using Tournament Selection.

A service capable of training evolutionary models in a particular environment.

Represents an asynchronous training operation.

Contains the different messages that can be sent from a Trainer when training asynchronously.

Represents the result of training a model using a runner.

A message sent from a Trainer to a subscriber (by calling TrainingJob.subscribeToUpdates.

An operation that has an arity of one (i.e. its function takes 1 argument).

Can generate a number of uniformly distributed values.