private List <Individual> CrossOverIndividuals(Individual mutatedMother, Individual mutatedFather)
{
// Descendants are created by randomly switching a randomly generated amount of hours
// Only corresponding hours may be switched and only when both individuals have the same machines running
Individual fatherClone = Individual.CloneRepresentation(mutatedFather);
Individual motherClone = Individual.CloneRepresentation(mutatedMother);
Random random = new Random();
double chance = random.NextDouble();
for (int i = 0; i < fatherClone.Schedule.Count; i++)
{
double value = random.NextDouble();
if (value >= chance)
{
if (IsCrossOverApplicable(fatherClone.Schedule[i], motherClone.Schedule[i]))
{
List <Machine> temp = fatherClone.Schedule[i];
fatherClone.Schedule[i] = motherClone.Schedule[i];
motherClone.Schedule[i] = temp;
}
}
}
ReviseMachineStatus(fatherClone);
ReviseMachineStatus(motherClone);
List <Individual> descendants = new List <Individual>();
if (StaticOperations.ValidateIndividualWithGroups(motherClone) == false)
{
descendants.Add(mutatedMother);
}
else
{
descendants.Add(motherClone);
}
if (StaticOperations.ValidateIndividualWithGroups(fatherClone) == false)
{
descendants.Add(mutatedFather);
}
else
{
descendants.Add(fatherClone);
}
return(descendants);
}
public List <Individual> GenerateDescendants(Individual mother, Individual father)
{
Individual motherClone = Individual.CloneRepresentation(mother);
Individual fatherClone = Individual.CloneRepresentation(father);
Individual mutatedMother = MutateIndividual(motherClone);
Individual mutatedFather = MutateIndividual(fatherClone);
if (StaticOperations.ValidateIndividualWithGroups(mutatedMother) == false)
{
mutatedMother = Individual.CloneRepresentation(mother);
}
if (StaticOperations.ValidateIndividualWithGroups(mutatedFather) == false)
{
mutatedFather = Individual.CloneRepresentation(father);
}
List <Individual> descendants = CrossOverIndividuals(mutatedMother, mutatedFather);
return(descendants);
}
public void RealiseGroupEvolution()
{
// Initialisation
GroupInitialisation initialisation = new GroupInitialisation(initialPopulationCount, scale);
List <Individual> population = null;
if (mode == 1)
{
population = initialisation.GenerateGroupInitialPopulation();
}
if (mode == 2)
{
population = initialisation.GenerateRandomGroupInitialPopulation();
}
// Validation
foreach (Individual representation in population)
{
if (StaticOperations.ValidateIndividualWithGroups(representation) == false)
{
throw new NotSupportedException();
}
}
// Evaluation
Evaluation evaluation = new Evaluation(scale);
foreach (Individual representation in population)
{
evaluation.EvaluateIndividual(representation);
}
// Evolution cycles
for (int i = 0; i < evolutionCycles; i++)
{
Console.Write("Epoch #" + i + " ");
// Selection
Selection selection = new Selection(initialPopulationCount, population);
List <Individual> parents = null;
if (mode == 1)
{
parents = selection.SelectParents(2);
}
if (mode == 2)
{
parents = selection.SelectDiverseParents(2, 5);
}
// Genetic operators
List <Individual> descendants = new List <Individual>();
GroupGeneticOperators geneticOperators = new GroupGeneticOperators(scale);
for (int j = 0; j < parents.Count; j = j + 2)
{
descendants.AddRange(geneticOperators.GenerateDescendants(parents[j], parents[j + 1]));
}
// Evaluation
foreach (Individual representation in descendants)
{
evaluation.EvaluateIndividual(representation);
}
// Replacement
Replacement replacement = new Replacement(population, descendants, initialPopulationCount);
population = replacement.NextGeneration();
List <Individual> orderedPopulation = population.OrderBy(item => item.Fitness).ToList();
Console.WriteLine("Best individual has fitness: " + orderedPopulation[0].Fitness);
}
SaveBestIndividualIntoFile(population[0]);
}
private Individual MutateIndividual(Individual individual)
{
Individual individualClone = Individual.CloneRepresentation(individual);
// Every hour needs to be mutated separately
// after mutating one of the hours, values for
// turned on time on machines need to be revised
// Revision is needed only if start/terminate operators are used
Random random = new Random();
for (int i = 0; i < individualClone.Schedule.Count; i++)
{
double mutationChange = random.NextDouble();
if (mutationChange <= 0.25)
{
int mutationEffect = random.Next(0, 3);
// Increase mutation
if (mutationEffect == 0)
{
individualClone.Schedule[i] = IncreaseMutation(individualClone.Schedule[i],
i == 0 ? null : individualClone.Schedule[i - 1], random);
if (StaticOperations.ValidateIndividualWithGroups(individualClone) == false)
{
individualClone.Schedule[i] = StaticOperations.CloneMachineList(individual.Schedule[i]);
}
}
// Decrease mutation
if (mutationEffect == 1)
{
individualClone.Schedule[i] = DecreaseMutation(individualClone.Schedule[i],
i == 0 ? null : individualClone.Schedule[i - 1], random);
if (StaticOperations.ValidateIndividualWithGroups(individualClone) == false)
{
individualClone.Schedule[i] = StaticOperations.CloneMachineList(individual.Schedule[i]);
}
}
// Start mutation
if (mutationEffect == 2)
{
individualClone.Schedule[i] = StartMutation(individualClone.Schedule[i],
i == 0 ? null : individualClone.Schedule[i - 1], random, individual.groups);
if (StaticOperations.ValidateIndividualWithGroups(individualClone) == false)
{
individualClone.Schedule[i] = StaticOperations.CloneMachineList(individual.Schedule[i]);
}
ReviseMachineStatus(individualClone);
}
// Terminate mutation
if (mutationEffect == 3)
{
individualClone.Schedule[i] = TerminateMutation(individualClone.Schedule[i],
i == 0 ? null : individualClone.Schedule[i - 1], random, individual.groups);
if (StaticOperations.ValidateIndividualWithGroups(individualClone) == false)
{
individualClone.Schedule[i] = StaticOperations.CloneMachineList(individual.Schedule[i]);
}
ReviseMachineStatus(individualClone);
}
}
}
return(individualClone);
}
