org.moeaframework.util.tree
Class Rules

java.lang.Object
  org.moeaframework.util.tree.Rules

public class Rules
extends Object

The rules defining the program syntax. At a minimum, the rules must define the program return type and the set of nodes which can appear in the program.

It is also possible to define program scaffolding, which defines the fixed initial structure of the program that is not modified by any variation operators. For example, this can be used to define function prototypes (similar to automatically defined functions), so that the function appears in all programs. Any undefined arguments (i.e., null) to a node will be filled by the genetic programming algorithm.

Constructor Summary

Rules()
Constructs a new set of rules for defining program syntax.

Method Summary

void	add(Node node) Adds a node that can appear in programs produced using these rules.
Node	buildTreeFull(Class<?> type, int depth) Generates an expression tree with the given return type using the full initialization method.
Node	buildTreeFull(Node node, int depth) Generates an expression tree with the given scaffolding using the full initialization method.
Node	buildTreeGrow(Class<?> type, int depth) Generates an expression tree with the given return type using the grow initialization method.
Node	buildTreeGrow(Node node, int depth) Generates an expression tree with the given scaffolding using the grow initialization method.
List<Node>	getAvailableNodes() Returns the list of all nodes which can appear in programs produced using these rules.
double	getFunctionCrossoverProbability() Returns the probability of crossover being applied to a function (non-terminal) node.
int	getMaxInitializationDepth() Returns the maximum depth of the expression trees produced by any initialization routine.
int	getMaxVariationDepth() Returns the maximum depth of the expression trees produced by any variation operator.
Class<?>	getReturnType() Returns the return type of all programs produced using these rules.
Node	getScaffolding() Returns the program scaffolding; or null if the program has no defined scaffolding.
protected boolean	isMutationCompatible(Node original, Node mutation) Returns true if the original node can be replaced via point mutation with the given mutation node and satisfy type safety; false otherwise.
List<Node>	listAvailableCrossoverNodes(Node node, Class<?> type) Returns the list of all nodes in the tree rooted at the specified node with the given return type.
List<Node>	listAvailableFunctions(Class<?> type) Returns the list of all available function (non-terminal) nodes with the given return type.
List<Node>	listAvailableMutations(Node node) Returns the list of all available mutations to the given node.
List<Node>	listAvailableNodes(Class<?> type) Returns the list of all available nodes with the given return type.
List<Node>	listAvailableTerminals(Class<?> type) Returns the list of all available terminal nodes with the given return type.
void	populateWithArithmetic() Allows the default arithmetic nodes to appear in programs produced using these rules.
void	populateWithConstants() Allows the default constant nodes to appear in programs produced using these rules.
void	populateWithControl() Allows the default control nodes to appear in programs produced using these rules.
void	populateWithDefaults() Allows all default nodes to appear in programs.
void	populateWithLogic() Allows the default logic nodes to appear in programs produced using these rules.
void	populateWithTrig() Allows the default trigonometric nodes to appear in programs produced using these rules.
void	setFunctionCrossoverProbability(double functionCrossoverProbability) Sets the probability of crossover being applied to a function (non-terminal) node.
void	setMaxInitializationDepth(int maxInitializationDepth) Sets the maximum depth of the expression trees produced by any initialization routine.
void	setMaxVariationDepth(int maxVariationDepth) Sets the maximum depth of the expression trees produced by any variation operator.
void	setReturnType(Class<?> returnType) Sets the return type of all programs produced using these rules.
void	setScaffolding(Node scaffolding) Sets the program scaffolding.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Rules

public Rules()

Constructs a new set of rules for defining program syntax.

Method Detail

getReturnType

public Class<?> getReturnType()

Returns the return type of all programs produced using these rules.

Returns:

the return type of all programs produced using these rules

setReturnType

public void setReturnType(Class<?> returnType)

Sets the return type of all programs produced using these rules.

Parameters:

returnType - the return type of all programs produced using these rules

getScaffolding

public Node getScaffolding()

Returns the program scaffolding; or null if the program has no defined scaffolding.

Returns:

the program scaffolding; or null if the program has no defined scaffolding

setScaffolding

public void setScaffolding(Node scaffolding)

Sets the program scaffolding. Setting the program scaffolding automatically sets the return type.

Parameters:

scaffolding - the program scaffolding

getMaxInitializationDepth

public int getMaxInitializationDepth()

Returns the maximum depth of the expression trees produced by any initialization routine.

Returns:

the maximum depth of the expression trees produced by any initialization routine

setMaxInitializationDepth

public void setMaxInitializationDepth(int maxInitializationDepth)

Sets the maximum depth of the expression trees produced by any initialization routine.

Parameters:

maxInitializationDepth - the maximum depth of the expression trees produced by any initialization routine

getMaxVariationDepth

public int getMaxVariationDepth()

Returns the maximum depth of the expression trees produced by any variation operator.

Returns:

the maximum depth of the expression trees produced by any variation operator

setMaxVariationDepth

public void setMaxVariationDepth(int maxVariationDepth)

Sets the maximum depth of the expression trees produced by any variation operator.

Parameters:

maxVariationDepth - the maximum depth of the expression trees produced by any variation operator

getFunctionCrossoverProbability

public double getFunctionCrossoverProbability()

Returns the probability of crossover being applied to a function (non-terminal) node.

Returns:

the probability of crossover being applied to a function (non-terminal) node

setFunctionCrossoverProbability

public void setFunctionCrossoverProbability(double functionCrossoverProbability)

Sets the probability of crossover being applied to a function (non-terminal) node. To set an equal probability of crossing all nodes, set the function crossover probability to (No. of Functions) / (No. of Functions + No. of Terminals).

Parameters:

functionCrossoverProbability - the probability of crossover being applied to a function (non-terminal) node

add

public void add(Node node)

Adds a node that can appear in programs produced using these rules.

Parameters:

node - the node that can appear in programs produced using these rules

populateWithLogic

public void populateWithLogic()

Allows the default logic nodes to appear in programs produced using these rules. This includes And, Or, Not, Equals, GreaterThan, LessThan, GreaterThanOrEqual, LessThanOrEqual, and constants true and false.

populateWithArithmetic

public void populateWithArithmetic()

Allows the default arithmetic nodes to appear in programs produced using these rules. This includes Add, Subtract, Multiply, Divide, Modulus, Floor, Ceil, Round, Max, Min, Power, Square, SquareRoot, Abs, Log, Log10, Exp, and Sign.

populateWithTrig

public void populateWithTrig()

Allows the default trigonometric nodes to appear in programs produced using these rules. This includes Sin, Cos, Tan, Asin, Acos, Atan, Sinh, Cosh, Tanh, Asinh, Acosh, and Atanh.

populateWithControl

public void populateWithControl()

Allows the default control nodes to appear in programs produced using these rules. This includes IfElse, Sequence, and NOP. Several control nodes are not included in the defaults, such as For and While. These are not included as they can easily result in infinite loops. These other control nodes can be manually added if needed.

populateWithConstants

public void populateWithConstants()

Allows the default constant nodes to appear in programs produced using these rules. This includes the constants 0, 1, 2, 10, -1, Math.E, and Math.PI.

populateWithDefaults

public void populateWithDefaults()

Allows all default nodes to appear in programs. See populateWithLogic(), populateWithArithmetic(), populateWithTrig(), populateWithControl(), and populateWithConstants() for details.

getAvailableNodes

public List<Node> getAvailableNodes()

Returns the list of all nodes which can appear in programs produced using these rules.

Returns:

the list of all nodes which can appear in programs produced using these rules

listAvailableCrossoverNodes

public List<Node> listAvailableCrossoverNodes(Node node,
                                              Class<?> type)

Returns the list of all nodes in the tree rooted at the specified node with the given return type. This method ensures the crossover remains strongly-typed.

Parameters:

node - the root of the tree

type - the required return type

Returns:

the list of all nodes in the tree rooted at the specified node with the given return type

listAvailableMutations

public List<Node> listAvailableMutations(Node node)

Returns the list of all available mutations to the given node. This method ensures the mutation remains strongly-typed.

Parameters:

node - the node to be mutated

Returns:

the list of all available mutations to the given node

isMutationCompatible

protected boolean isMutationCompatible(Node original,
                                       Node mutation)

Returns true if the original node can be replaced via point mutation with the given mutation node and satisfy type safety; false otherwise.

Parameters:

original - the original node

mutation - the mutation node

Returns:

true if the original node can be replaced via point mutation with the given mutation node and satisfy type safety; false otherwise

listAvailableNodes

public List<Node> listAvailableNodes(Class<?> type)

Returns the list of all available nodes with the given return type.

Parameters:

type - the required return type

Returns:

the list of all available nodes with the given return type

listAvailableTerminals

public List<Node> listAvailableTerminals(Class<?> type)

Returns the list of all available terminal nodes with the given return type.

Parameters:

type - the required return type

Returns:

the list of all available terminal nodes with the given return type

listAvailableFunctions

public List<Node> listAvailableFunctions(Class<?> type)

Returns the list of all available function (non-terminal) nodes with the given return type.

Parameters:

type - the required return type

Returns:

the list of all available function (non-terminal) nodes with the given return type

buildTreeFull

public Node buildTreeFull(Class<?> type,
                          int depth)

Generates an expression tree with the given return type using the full initialization method. This method builds the tree so every leaf node is at the specified depth.

Parameters:

type - the required return type

depth - the required depth of each leaf node in the tree

Returns:

an expression tree with the given return type using the full initialization method

buildTreeGrow

public Node buildTreeGrow(Class<?> type,
                          int depth)

Generates an expression tree with the given return type using the grow initialization method. This method builds the tree such that the depth of each leaf is at most the specified maximum depth.

Parameters:

type - the required return type

depth - the maximum depth of each leaf node in the tree

Returns:

an expression tree with the given return type using the grow initialization method

buildTreeFull

public Node buildTreeFull(Node node,
                          int depth)

Generates an expression tree with the given scaffolding using the full initialization method. This method builds the tree so every leaf node is at the specified depth.

Parameters:

node - the initial scaffolding for the tree

depth - the required depth of each leaf node in the tree

Returns:

an expression tree with the given scaffolding using the full initialization method

buildTreeGrow

public Node buildTreeGrow(Node node,
                          int depth)

Generates an expression tree with the given scaffolding using the grow initialization method. This method builds the tree such that the depth of each leaf is at most the specified maximum depth.

Parameters:

node - the initial scaffolding for the tree

depth - the maximum depth of each leaf node in the tree

Returns:

an expression tree with the given scaffolding using the grow initialization method