public Solution GenerateRandomSolution()
{
bool isValidSolutionFound = false;
Solution solution;
do
{
Random random = new Random();
solution = new Solution();
Dictionary <double, double> copyOfOrder = new Dictionary <double, double>(order.OrderItems);
// not loving the use of goto but oh well
KeepIterating:
foreach (KeyValuePair <double, double> orderItem in order.OrderItems)
{
if (copyOfOrder[orderItem.Key] <= 0)
{
continue;
}
StockItem stockItem = stockList.StockItemList.ElementAt(random.Next(0, stockList.StockItemList.Count));
double chance = random.NextDouble();
Activity activity = materialCutter.ProduceActivity(stockItem, orderItem.Key, orderItem.Value);
copyOfOrder[orderItem.Key] -= activity.PositionsToCutAt.Count;
solution.Activities.Add(activity);
}
foreach (KeyValuePair <double, double> checkCopyOfOrder in copyOfOrder)
{
if (checkCopyOfOrder.Value > 0)
{
goto KeepIterating;
}
}
if (solutionValidation.IsValidSolution(solution))
{
solution.SolutionCost = solutionEvaluator.GetCostOfSolution(solution);
isValidSolutionFound = true;
}
} while (isValidSolutionFound == false);
return(solution);
}
private Solution RecombineParentsToFormOneChild(Solution parentOne, Solution parentTwo)
{
int numberOfActivitiesParentOne = parentOne.Activities.Count;
int numberOfActivitiesParentTwo = parentTwo.Activities.Count;
int iteationLimit = Math.Min(numberOfActivitiesParentOne, numberOfActivitiesParentTwo);
Solution offspring = new Solution();
Random random = new Random();
for (int index = 0; index < iteationLimit; index++)
{
// Take from parent one
if (random.NextDouble() > 0.5)
{
offspring.Activities.Add(parentOne.Activities.ElementAt(index));
}
// Take from parent two
else
{
offspring.Activities.Add(parentOne.Activities.ElementAt(index));
}
}
if (solutionValidation.IsValidSolution(offspring))
{
double recombinedSolutionCost = solutionEvaluator.GetCostOfSolution(offspring);
offspring.SolutionCost = recombinedSolutionCost;
SumOfCostOfRecombinedIndividuals += recombinedSolutionCost;
return(offspring);
}
if (random.NextDouble() > 0.5)
{
return(parentOne);
}
return(parentTwo);
}
public void MutateSolution(Solution solution)
{
Random random = new Random();
if (random.NextDouble() < EvolutionaryAlgorithmConstants.MUTATION_CHANCE)
{
return;
}
List <Activity> copyOfActivities = new List <Activity>(solution.Activities);
Mutate(solution);
if (solutionValidation.IsValidSolution(solution))
{
double mutatedSolutionCost = solutionEvaluator.GetCostOfSolution(solution);
solution.SolutionCost = mutatedSolutionCost;
SumOfCostOfMutatedIndividuals += mutatedSolutionCost;
return;
}
solution.Activities.Clear();
solution.Activities.AddRange(copyOfActivities);
}
