Пример #1
0
        private GroupDiet CreateRandomDailyDiet()
        {
            var diet = new GroupDiet();

            for (var j = 0; j < _numberOfMealsPerDay; j++)
            {
                var meal = new GroupMeal {
                    MealType = (MealType)j
                };
                diet.Meals.Add(meal);
            }

            List <int> idsWithDeficiency;

            while ((idsWithDeficiency = _personalData.Where(p => p.Requirements.CaloriesAllowedRange.Lower > _dietAnalyzer.SummarizeForPerson(diet, p.Id).NutritionValues.Calories).Select(pd => pd.Id).ToList()).Any())
            {
                var meal            = diet.Meals.GetRandomItem();
                var includedRecipes = diet.Meals.SelectMany(m => m.Recipes).Select(r => r.Recipe).Distinct().ToList();
                var split           = GetRanodmNotInvlolvedRecipe(includedRecipes, meal.MealType);

                split.Adjustments.RemoveAll(a => !idsWithDeficiency.Contains(a.PersonId));
                meal.Recipes.Add(split);
            }

            return(diet);
        }
Пример #2
0
        private double EvaluateDailyMacro(GroupDiet diet, out bool feasible)
        {
            var distance = 0.0;

            feasible = true;
            foreach (var personalData in _personalData)
            {
                var dailySummary = _dietAnalyzer.SummarizeForPerson(diet, personalData.Id);

                var distanceForPerson =
                    Math.Abs(personalData.Requirements.ProteinRange.GetDistanceToRange(dailySummary.NutritionValues.Proteins)) +
                    Math.Abs(personalData.Requirements.FatRange.GetDistanceToRange(dailySummary.NutritionValues.Fat)) +
                    Math.Abs(personalData.Requirements.CarbohydratesRange.GetDistanceToRange(dailySummary.NutritionValues.Carbohydrates));

                for (var mealIndex = 0; mealIndex < dailySummary.CaloriesPerMeal.Count; mealIndex++)
                {
                    distanceForPerson +=
                        Math.Abs(
                            personalData.Requirements
                            .MealCaloriesSplit[mealIndex]
                            .GetDistanceToRange(dailySummary.CaloriesPerMeal[mealIndex]));
                }

                if (!personalData.Requirements.CaloriesAllowedRange.IsInRange(dailySummary.NutritionValues.Calories) || Math.Abs(distanceForPerson) > 200)
                {
                    feasible = false;
                }

                distance += distanceForPerson;
            }

            return(distance);
        }
Пример #3
0
        private GroupDiet GetDiet()
        {
            var groupDiet = new GroupDiet();

            groupDiet.Meals.Add(new GroupMeal());
            groupDiet.Meals.Add(new GroupMeal());
            groupDiet.Meals.Add(new GroupMeal());
            groupDiet.Meals.Add(new GroupMeal());
            groupDiet.Meals.Add(new GroupMeal());

            var split = new RecipeGroupSplit(2);

            split.Adjustments.RemoveAt(1);
            split.Recipe = new Recipe
            {
                NominalWeight   = 100,
                NutritionValues = new NutritionValues
                {
                    Calories = 250,
                    Proteins = 250
                }
            };
            groupDiet.Meals[2].Recipes.Add(split);

            return(groupDiet);
        }
Пример #4
0
 private Evaluation EvaluateMacro(GroupDiet groupDiet, out bool feasible)
 {
     return(new Evaluation
     {
         Type = ObjectiveType.Macro,
         Direction = Direction.Minimize,
         Score = EvaluateDailyMacro(groupDiet, out feasible)
     });
 }
Пример #5
0
        public void ApplyCorrection(GroupDiet diet)
        {
            var includedRecipes = diet.Meals.SelectMany(m => m.Recipes).Select(r => r.Recipe).ToList();
            var differences     = GetDifferences(diet);
            var mealDifferences = GetMealDifferences(diet);

            while (differences.All(d => d.Calories > 200))
            {
                var totalMealDifference = new List <double>();

                for (int i = 0; i < mealDifferences.First().Count; i++)
                {
                    totalMealDifference.Add(mealDifferences.Select(md => md[i]).Sum());
                }

                var mealWithBiggestDifference = totalMealDifference.IndexOf(totalMealDifference.Min());
                var recipe = GetRanodmNotInvlolvedRecipe(includedRecipes);

                diet.Meals[mealWithBiggestDifference].Recipes.Add(recipe);
                includedRecipes.Add(recipe.Recipe);
                differences     = GetDifferences(diet);
                mealDifferences = GetMealDifferences(diet);
            }

            foreach (var id in _personalData.Select(pd => pd.Id))
            {
                for (var i = 0; i < mealDifferences[id].Count; i++)
                {
                    if (mealDifferences[id][i] < 100)
                    {
                        var adjustments = diet.Meals[i].Recipes.SelectMany(r => r.Adjustments).Where(a => a.PersonId == id)
                                          .Where(a => RecipeGroupSplit.Multipliers.Last() > a.AmountMultiplier).ToList();

                        if (adjustments.Any())
                        {
                            IncreaseAjustment(adjustments.GetRandomItem());
                        }
                    }
                    else if (mealDifferences[id][i] > -100)
                    {
                        var adjustments = diet.Meals[i].Recipes.SelectMany(r => r.Adjustments).Where(a => a.PersonId == id)
                                          .Where(a => RecipeGroupSplit.Multipliers.First() < a.AmountMultiplier).ToList();

                        if (adjustments.Any())
                        {
                            DecreaseAjustment(adjustments.GetRandomItem());
                        }
                    }
                }
            }

            //  var idsWithNotEnoughCalories = differences.Where(d => d.Calories < -100).Select(d => differences.IndexOf(d)).ToList();
            // var idsWithToMuchCalories = differences.Where(d => d.Calories > 0).Select(d => differences.IndexOf(d)).ToList();
        }
Пример #6
0
        public static GroupDiet Copy(GroupDiet source)
        {
            var copy = new GroupDiet();

            foreach (var sourceMeal in source.Meals)
            {
                copy.Meals.Add(CopyMeal(sourceMeal));
            }

            return(copy);
        }
Пример #7
0
        private bool AreThereDuplicates(GroupDiet individual)
        {
            var meals = individual.Meals.Select(m => m);

            foreach (var meal in meals)
            {
                var recipes = meal.Recipes.Select(r => r.Recipe.Name);
                if (recipes.GroupBy(x => x).Any(g => g.Count() > 1))
                {
                    return(true);
                }
            }
            return(false);
        }
Пример #8
0
        private List <List <double> > GetMealDifferences(GroupDiet diet)
        {
            var mealDifferences = new List <List <double> >();

            foreach (var personalData in _personalData)
            {
                var personMealDifferences = new List <double>();
                var dietSummary           = _dietAnalyzer.SummarizeForPerson(diet, personalData.Id);

                for (int i = 0; i < dietSummary.CaloriesPerMeal.Count; i++)
                {
                    personMealDifferences.Add(personalData.Requirements.MealCaloriesSplit[i].GetDistanceToRange(dietSummary.CaloriesPerMeal[i]));
                }
                mealDifferences.Add(personMealDifferences);
            }
            return(mealDifferences);
        }
Пример #9
0
        private List <NutritionValues> GetDifferences(GroupDiet diet)
        {
            var allDifferences = new List <NutritionValues>();

            foreach (var personalData in _personalData)
            {
                var dietSummary = _dietAnalyzer.SummarizeForPerson(diet, personalData.Id);

                allDifferences.Add(new NutritionValues
                {
                    Calories      = personalData.Requirements.CaloriesAllowedRange.GetDistanceToRange(dietSummary.NutritionValues.Calories),
                    Fat           = personalData.Requirements.FatRange.GetDistanceToRange(dietSummary.NutritionValues.Fat),
                    Proteins      = personalData.Requirements.FatRange.GetDistanceToRange(dietSummary.NutritionValues.Proteins),
                    Carbohydrates = personalData.Requirements.FatRange.GetDistanceToRange(dietSummary.NutritionValues.Carbohydrates)
                });
            }

            return(allDifferences);
        }
Пример #10
0
        private Tuple <GroupDiet, GroupDiet> GetChild(GroupDiet parent1, GroupDiet parent2)
        {
            var child1 = new GroupDiet();
            var child2 = new GroupDiet();

            AreThereDuplicates(parent1);
            AreThereDuplicates(parent1);

            for (var i = 0; i < parent1.Meals.Count; i++)
            {
                var crossOverMeals = CrossOverMeal(parent1.Meals[i], parent2.Meals[i]);
                child1.Meals.Add(crossOverMeals.Item1);
                child2.Meals.Add(crossOverMeals.Item2);
            }

            if (!AreThereDuplicates(parent1) && AreThereDuplicates(child1))
            {
                throw new ApplicationException();
            }

            return(new Tuple <GroupDiet, GroupDiet>(child1, child2));
        }
Пример #11
0
 public GroupDietIndividual(GroupDiet groupDiet)
 {
     GroupDiet = groupDiet;
 }