private List <KeyValuePair <Diet, double> > Evaluate(List <Diet> population, DietSummary targetDailyDiet)
{
return
(population
.Select(individual => new KeyValuePair <Diet, double>(individual, _evaluator.Evaluate(individual, targetDailyDiet)))
.ToList());
}
public List <Diet> GetDiet(List <Food> foods, DietSummary targetDiet, Configuration configuration)
{
var currentPopulation = _populationInitializer.InitializePopulation(foods, configuration);
var numberOfIndividualsToSelect = (int)(configuration.PopulationSize * configuration.SelectionFactor);
var iteration = 0;
while (iteration < configuration.MaxIterations)
{
var ahpSolver = new AhpSolver();
var ahpEvaluations = ahpSolver.Evaluate(currentPopulation, targetDiet);
var evaluations = Evaluate(currentPopulation, targetDiet);
OutputEvaluation(evaluations, iteration);
currentPopulation = _selector.Select(evaluations, numberOfIndividualsToSelect);
CrossOver(configuration, currentPopulation, numberOfIndividualsToSelect);
Mutate(currentPopulation, foods, configuration);
iteration++;
}
var endEvaluations = Evaluate(currentPopulation, targetDiet);
return(currentPopulation.OrderBy(diet => _evaluator.Evaluate(diet, targetDiet)).ToList());
}
private void AddMealSummary(DietSummary dietSummary, GroupMeal meal, int personId)
{
var mealSumamry = CreateMealSummary(meal, personId);
dietSummary.NutritionValues += mealSumamry;
dietSummary.CaloriesPerMeal.Add(mealSumamry.Calories);
}
public Criterion(List <Diet> alternatives, DietSummary targetDailyDiet)
{
var evaluator = new Evaluator(new DietAnalyzer());
_evaluations =
alternatives.Select(
alternative => new KeyValuePair <Diet, double>(alternative, evaluator.Evaluate(alternative, targetDailyDiet))).ToList();
}
private Evaluation EvaluateMacro(Diet diet, DietSummary targetDailyDiet)
{
return(new Evaluation
{
Type = ObjectiveType.Macro,
Score = diet.DailyDiets.Select(dailyDiet => EvaluateDailyMacro(dailyDiet, targetDailyDiet)).Sum()
});
}
public DietSummary SummarizeForPerson(GroupDiet diet, int personId)
{
var dietSummary = new DietSummary();
foreach (var meal in diet.Meals)
{
AddMealSummary(dietSummary, meal, personId);
}
return(dietSummary);
}
private double EvaluateDaily(DailyDiet dailyDiet, DietSummary targetDailyDiet)
{
var dailySummary = _dietAnalyzer.SummarizeDaily(dailyDiet);
var distance =
Math.Abs(targetDailyDiet.Proteins - dailySummary.Proteins) +
Math.Abs(targetDailyDiet.Fat - dailySummary.Fat) +
Math.Abs(targetDailyDiet.Calories - dailySummary.Calories) +
Math.Abs(targetDailyDiet.Carbohydrates - dailySummary.Carbohydrates);
return(distance);
//distance > 0
//? 1 / (distance)
//: 1;
}
private List <MealViewModel> GetMealsViewModel(DietSummary dietSummary, GroupDietIndividual individual, PersonalData personalData)
{
var mealViewModels = new List <MealViewModel>();
foreach (var meal in individual.GroupDiet.Meals)
{
var mealVm = new MealViewModel();
var recipes = meal.GetRecipesForPerson(personalData.Id);
var mealindex = individual.GroupDiet.Meals.IndexOf(meal);
recipes.ForEach(r => mealVm.Recipes.Add(new RecipeViewModel {
Amount = r.Item1 * r.Item2.NominalWeight, Name = r.Item2.Name
}));
mealVm.Calories = (int)dietSummary.CaloriesPerMeal[mealindex];
mealVm.IsInRange = personalData.Requirements.MealCaloriesSplit[mealindex].IsInRange(mealVm.Calories);
mealVm.DistanceToRange = (int)personalData.Requirements.MealCaloriesSplit[mealindex].GetDistanceToRange(mealVm.Calories);
mealViewModels.Add(mealVm);
}
return(mealViewModels);
}
public double Evaluate(Diet diet, DietSummary targetDailyDiet)
{
return(diet.DailyDiets.Select(dailyDiet => EvaluateDaily(dailyDiet, targetDailyDiet)).Sum() / diet.DailyDiets.Count);
}
private static Dictionary <Criterion, double[, ]> CreateComparsionMatrices(List <Criterion> criteries, List <Diet> alternatives, DietSummary targetDailyDiet)
{
var comparsionMatrices = new Dictionary <Criterion, double[, ]>();
criteries.ForEach(criterion => comparsionMatrices.Add(criterion, CreateSquareMatrix(alternatives.Count)));
foreach (var alternative in alternatives)
{
foreach (var comparingAlternative in alternatives)
{
criteries.ForEach(c => comparsionMatrices[c][alternatives.IndexOf(alternative), alternatives.IndexOf(comparingAlternative)] = c.Compare(alternative, comparingAlternative));
}
}
return(comparsionMatrices);
}
public List <KeyValuePair <Diet, double> > Evaluate(List <Diet> alternatives, DietSummary targetDailyDiet)
{
var criteries = new List <Criterion> {
new Criterion(alternatives, targetDailyDiet), new Criterion(alternatives, targetDailyDiet), new Criterion(alternatives, targetDailyDiet), new Criterion(alternatives, targetDailyDiet)
};
var criteryMatrix = CreateSquareMatrix(criteries.Count);
var comparsionMatrices = CreateComparsionMatrices(criteries, alternatives, targetDailyDiet);
var criteriesPriorityVector = GetPriorityVector(criteryMatrix);
var alternativesPriorityVectors = comparsionMatrices.Select(matrix => GetPriorityVector(matrix.Value)).ToArray();
return(GetRanking(alternatives, criteriesPriorityVector, alternativesPriorityVectors));
}
public DietEvaluator(DietAnalyzer dietAnalyzer, DietSummary targetDailyDiet)
{
_dietAnalyzer = dietAnalyzer;
_targetDailyDiet = targetDailyDiet;
}
