gp_project/FunctionModifier.java at master · meskolin/gp_project · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package gp_project;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class FunctionModifier {

	private GPConfig m_config = GPConfig.getInstance();

	public void crossOver(Tree t1, Tree t2) {
		FunctionEvaluator eval = new FunctionEvaluator();
		List<Node> t1Nodes = new LinkedList<Node>();
		List<Node> t2Nodes = new LinkedList<Node>();

		eval.getPostOrderNodeList(t1.getRootNode(), t1Nodes);
		eval.getPostOrderNodeList(t2.getRootNode(), t2Nodes);

		int numNodesT1 = t1Nodes.size();
		int numNodesT2 = t2Nodes.size();

		Random rnd = GPConfig.getInstance().getRand();
		int index1 = rnd.nextInt(numNodesT1);
		int index2 = rnd.nextInt(numNodesT2);

		Node nodeT1 = t1Nodes.get(index1);
		Node nodeT2 = t2Nodes.get(index2);

		Node nodeT1Copy = new Node(nodeT1);

		// System.out.println("------------Inserting this node into T2--------------");
		// nodeT1Copy.printNode();

		nodeT1.setData(nodeT2.getData());
		nodeT1.setLeftNode(nodeT2.getLeftNode());
		nodeT1.setRightNode(nodeT2.getRightNode());
		nodeT1.setNodeType(nodeT2.getNodeType());
		// nodeT2 = nodeT1Copy;

		// nodeT2 = nodeT1;

		nodeT2.setData(nodeT1Copy.getData());
		nodeT2.setLeftNode(nodeT1Copy.getLeftNode());
		nodeT2.setRightNode(nodeT1Copy.getRightNode());
		nodeT2.setNodeType(nodeT1Copy.getNodeType());

	}

	/**
	 * Crossover a certain percentage of trees in the specified population
	 *
	 * @param pop
	 */
	public void crossoverPop(Population pop) {


		List<Tree> trees = pop.getTrees();
		int numTrees = trees.size();

		double crossPercent = m_config.getCrossoverPercent();
		long numToCross = Math.round(crossPercent * numTrees);

		// System.out.println("crossing over " + numToCross + "trees");
		for (int i = 0; i < numToCross; i += 2) {
			int index1 = m_config.getRand().nextInt(numTrees);
			int index2 = m_config.getRand().nextInt(numTrees);
			crossOver(trees.get(index1), trees.get(index2));
		}

	}


	/**
	 * Mutates a single tree
	 *
	 * @param tree
	 */
	public void mutate(Tree tree) {

		FunctionEvaluator eval = new FunctionEvaluator();
		List<Node> allNodes = new LinkedList<Node>();
		eval.getPostOrderNodeList(tree.getRootNode(), allNodes);

		int numNodes = allNodes.size();

		Random rnd = GPConfig.getInstance().getRand();
		int index = rnd.nextInt(numNodes);

		Node randNode = allNodes.get(index);

		if (randNode.getNodeType() == NodeType.OPERAND) {
			randNode.setData(m_config.getRandOperand());
		} else if (randNode.getNodeType() == NodeType.OPERATOR) {
			randNode.setData(m_config.getRandOperator());
		} else {
			throw new IllegalArgumentException("Invalid node type");
		}
	}

	/**
	 * Mutates a percentage of trees in specified population
	 *
	 * @param pop
	 */
	public void mutatePop(Population pop) {
		List<Tree> trees = pop.getTrees();
		int numTrees = trees.size();

		double mutatePercent = m_config.getMutatePercent();
		long numToMutate = Math.round(mutatePercent * numTrees);

		// System.out.println("mutating " + numToMutate + "trees");
		for (int i = 0; i < numToMutate; i++) {
			int index = m_config.getRand().nextInt(numTrees);
			mutate(trees.get(index));
		}

	}
}