public void Breed()
{
ConcurrentBag <Model> children = new ConcurrentBag <Model>();
int totalModelsToCreate = Math.Min(PopulationSize - Models.Count, BreedPopulationSize);
Parallel.For(0, totalModelsToCreate, bagIndex =>
{
Model child = new Model();
int parent1Index = RandomHelpers.ExponentialSelector(Math.Min(SurvivingPopulationSize, Models.Count), 2d);
int parent2Index = RandomHelpers.ExponentialSelector(Math.Min(SurvivingPopulationSize, Models.Count), 2d);
if (parent1Index != parent2Index)
{
Node parent1Expression = Models[parent1Index].Expression;
Node parent2Expression = Models[parent2Index].Expression.Clone();
List <Node> parent1Branches = parent1Expression.DescendantsAndSelf();
List <Node> parent2Branches = parent2Expression.DescendantsAndSelf();
int branchToMoveIndex = Random.Next(parent1Branches.Count);
int branchLocationToInjectAt = Random.Next(parent2Branches.Count);
Node branchToMove = parent1Branches[branchToMoveIndex].Clone();
Node branchToReplace = parent2Branches[branchLocationToInjectAt];
if (branchToReplace.Parent != null)
{
int childIndex = branchToReplace.Parent.Children.IndexOf(branchToReplace);
branchToReplace.Parent.Children.RemoveAt(childIndex);
branchToReplace.Parent.Children.Insert(childIndex, branchToMove);
branchToMove.Parent = branchToReplace.Parent;
child.Expression = parent2Expression;
child.Expression = ResetConstants(child.Expression);
child.ExpressionString = Node.Join(child.Expression);
children.Add(child);
}
}
});
Models.AddRange(children.ToList());
}
public static Node TransformRandomBranchExponentially(Node root, Transform transform, List <Operator> operators)
{
List <Node> branches = root.DescendantsAndSelf();
int branchIndex = branches.Count - 1 - RandomHelpers.ExponentialSelector(branches.Count, 1);
return(TransformBranchFunctions.TransformBranchWithTransform(root, transform, operators, branchIndex));
}
public void EliminateFs(Model model, List <Node> independents)
{
bool containsFs = true;
while (containsFs)
{
List <Node> branches = model.Expression.DescendantsAndSelf();
List <Node> fBranches = branches.Where(x => x.Children.Count == 0 && Node.Join(x) == "f").ToList();
if (fBranches.Count == 0)
{
containsFs = false;
break;
}
List <Node> replacementBranches = new List <Node>();
foreach (Node fBranch in fBranches)
{
int replacementType = Random.Next(0, 3);
if (replacementType == 0)
{
replacementBranches.Add(Node.Parse("Constant", Operators));
}
else if (replacementType == 1)
{
int independentIndex = RandomHelpers.ExponentialSelector(independents.Count, 2d);
Node independentNode = independents[CorrelationItems[independentIndex].ColumnIndex].Clone();
replacementBranches.Add(independentNode);
}
else if (replacementType == 2)
{
int transformIndex = Random.Next(0, Transforms.Count);
Transform transform = Transforms[transformIndex];
Node transformedNode = Transform.TransformNode(fBranch, transform, Operators);
replacementBranches.Add(transformedNode);
}
}
model.Expression = Node.ReplaceBranches(model.Expression, fBranches, replacementBranches);
}
model.Expression = ResetConstants(model.Expression);
model.ExpressionString = Node.Join(model.Expression);
}
public double[] GetInitialConstants()
{
double[] constants = Expression.DescendantsAndSelf().Where(x => x is VariableNode)
.Where(x => ((VariableNode)x).Variable.Substring(0, 8) == "Constant")
.Select(x => ((VariableNode)x).Number).ToArray();
for (int i = 0; i < constants.Length; i++)
{
if (double.IsNaN(constants[i]))
{
constants[i] = RandomHelpers.Exponential(1);
}
}
return(constants);
//int totalConstants = Expression.DescendantsAndSelf().Where(x => x is VariableNode)
// .Where(x => ((VariableNode)x).Variable.Substring(0, 8) == "Constant").ToList().Count;
//double[] constants = new double[totalConstants];
//for (int i = 0; i < constants.Length; i++)
//{
// constants[i] = RandomHelpers.Exponential(1);
//}
//return constants;
}
public Model CreateTransformedModel()
{
if (Models.Count == 0)
{
Model model = new Model();
model.Expression = Node.Parse("f", Operators);
model.ExpressionString = "f";
//model.TotalConstants = Regex.Matches(model.ExpressionString, "Constant").Count;
return(model);
}
else
{
int modelIndex = RandomHelpers.ExponentialSelector(Math.Min(SurvivingPopulationSize, Models.Count), 2d);
Model cloneModel = Models[modelIndex].Clone();
Node startExpression = cloneModel.Expression;
int transformIndex = Random.Next(0, Transforms.Count);
Transform transform = Transforms[transformIndex];
//cloneModel.Expression = TransformBranchFunctions.TransformRandomBranch(startExpression, transform, Operators);
cloneModel.Expression = TransformRandomBranchExponentially(startExpression, transform, Operators);
cloneModel.ExpressionString = Node.Join(cloneModel.Expression);
//cloneModel.TotalConstants = Regex.Matches(cloneModel.ExpressionString, "Constant").Count;
return(cloneModel);
}
}
