Defines the generics classes for executing a tree-based genetic program.
Genetic programming is a computer science method, inspired by evolutionary biology, for automatically solving problems, without having to know or define the form or structure of optimum problem structure beforehand. You define the basic building blocks (functions, constants, and variables) of the problem and then the component does the rest. Genetic programming solves problems by evolving a group or population of candidate individuals through successive generations, selecting fitter (or better) child individuals for each generation, until a solution is found. It uses evolutionary biology techniques such as inheritance, mutation, selection, and crossover (also called recombination).
|
Name
|
Description
|
|
TRSGPBinaryNode<T>
|
Defines the generics node for tree-based genetic programming which can contain at most 2 children. Each node represents one function or terminal (constant, variable) in a genetic program. It has one Parent (or nil if root node) and 0 or more Child nodes (terminals have no children).
 Note
|
If your instructions have arity greater than 2, use the TRSGPTreeNode<T> class instead.
|
|
|
TRSGPContext<T>
|
Defines the context (state of the program, i.e., variables and world) for executing or evaluating a genetic program. Every function node OnExecute in a genetic program can read and write to this context. Every variable terminal node will read from this context OnExecute.
 Notes to Inheritors
|
By default, a genetic programming context contains a list of variables and their values in the base type specified. Extend the TRSGPContext class to add other context such as world properties (e.g., the map for the ant trail problem)
|
Note
|
The TRSGPContext<T> is a generic class. Its type will change with the genetic programming type.
|
|
|
TRSGPInstruction<T>
|
Defines one instruction (function, variable, or constant) in the genetic program.
Note
|
When the instruction executes, it needs no information beyond the nodes and the values passed in, so it may be multi-threaded as long as the values are copied and unless the OnExecute event does something unsafe.
|
|
|
TRSGPInstructions<T>
|
Defines the set of instructions allowed in a genetic program, including all functions, variables and constants. When the genetic programming component is evolving the population of genetic programs, it uses this collection to select a function, variable or constant.
|
|
TRSGPNode<T>
|
Defines the generics node for tree-based genetic programming. Each node represents one function or terminal (constant, variable) in a genetic program. It has one Parent (or nil if root node) and 0 or more Child nodes (terminals have no children).
|
|
TRSGPTreeNode<T>
|
Defines the generics node for tree-based genetic programming which can contain an arbitrary number of children. Each node represents one function or terminal (constant, variable) in a genetic program. It has one Parent (or nil if root node) and 0 or more Child nodes (terminals have no children).
Note
|
For the TRSGPTreeNode<T> class, the children are stored in a list. If you restrict your instructions to 2 or less children, it is recommended to use the TRSGPBinaryNode<T> as it uses slightly less memory and is slightly faster.
|
|
|
TRSGPValues<T>
|
Represents type TRSGPValues<T>.
|
Top
|
|
Name
|
Description
|
|
IRSGeneticProgramEngine<T>
|
Defines the interface for a genetic programming component that can execute genetic programs as well as read and write them
Note
|
The IRSGeneticProgramEngine<T> is a generic interface. There can be multiple versions of this interface based on type T.
|
|
|
IRSGeneticProgramReaderWriter
|
Defines an interface for a genetic programming reader and writer, i.e., an object that can read genetic programming problems from file, stream, or xml and write genetic programming problems to file, stream or xml.
 Warning
|
A genetic programming reader/writer reads and writes the metadata about instructions (i.e., name, arity, comment) but does not actually read or write the OnExecute code themselves. After reading a genetic programming scenario, you need to add OnExecute event handlers to instructions.
|
Important Note
|
When reading a genetic programming scenario, the reader will attempt to match currently existing instructions to instruction names in the scenario. IF an instruction is found, the instruction will be preserved (including its OnExecute event).
After reading the scenario, any previous instructions not found in the scenario will be deleted.
|
|
Top
|
|
Name
|
Description
|
|
TNodeEvent<T>
|
Defines the event handler signature for a node execute event (usually OnExecute). The Node parameter supplies the node that is executing, and the Context parameter supplies the context (state of the world and variables). The aResult parameters is where the result of the execution should be set.
|
|
TNodeNotifyEvent<T>
|
Defines the event handler signature for a node notification event
|
Top
|
