public string PredictPlace(MeetResult expectedResult, IEnumerable <MeetResult> dataset)
        {
            var sameDivisionResults = dataset
                                      .Where(result => result.Division == expectedResult.Division &&
                                             result.Equipment == expectedResult.Equipment &&
                                             result.WeightClass == expectedResult.WeightClass &&
                                             result.Sex == expectedResult.Sex &&
                                             (!expectedResult.Age.HasValue || result.Age.HasValue) &&
                                             result.Total.HasValue && result.Bodyweight.HasValue &&
                                             AreSameMovements(expectedResult, result))
                                      .ToList();

            var k = (int)Math.Sqrt(sameDivisionResults.Count);

            var nearestNeighbors = GetNearestNeighbours(expectedResult, k, sameDivisionResults);

            var place = nearestNeighbors
                        .GroupBy(n => n.Place)
                        .Select(group => new { classification = group.Key, distanceSum = group.Select(x => 1 / GetDistance(expectedResult, x)).Sum() })
                        .OrderByDescending(x => x.distanceSum)
                        .Select(x => x.classification)
                        .FirstOrDefault();

            return(place);
        }
        private bool AreSameMovements(MeetResult result, MeetResult otherResult)
        {
            // All movements
            if (result.Squat.HasValue && otherResult.Squat.HasValue &&
                result.Bench.HasValue && otherResult.Bench.HasValue &&
                result.Deadlift.HasValue && otherResult.Deadlift.HasValue)
            {
                return(true);
            }

            if ((result.Squat.HasValue && otherResult.Squat.HasValue && result.Bench.HasValue && otherResult.Bench.HasValue) ||
                (result.Squat.HasValue && otherResult.Squat.HasValue && result.Deadlift.HasValue && otherResult.Deadlift.HasValue) ||
                (result.Deadlift.HasValue && otherResult.Deadlift.HasValue && result.Bench.HasValue && otherResult.Bench.HasValue))
            {
                return(true);
            }

            if ((result.Squat.HasValue && otherResult.Squat.HasValue) ||
                (result.Deadlift.HasValue && otherResult.Deadlift.HasValue) ||
                (result.Bench.HasValue && otherResult.Bench.HasValue))
            {
                return(true);
            }

            return(false);
        }
        private ICollection <MeetResult> GetNearestNeighbours(MeetResult expectedResult, int k, IEnumerable <MeetResult> dataset)
        {
            var neighbours = dataset
                             .OrderBy(r => GetDistance(expectedResult, r))
                             .Take(k)
                             .ToList();

            return(neighbours);
        }
        private double GetDistance(MeetResult expectedResult, MeetResult result)
        {
            var distance = Math.Pow(expectedResult.Total.Value - result.Total.Value, 2);

            distance += Math.Pow(expectedResult.Bodyweight.Value - result.Bodyweight.Value, 2);

            if (expectedResult.Age.HasValue && result.Age.HasValue)
            {
                distance += Math.Pow(expectedResult.Age.Value - result.Age.Value, 2);
            }

            distance = Math.Sqrt(distance);

            return(distance);
        }
Beispiel #5
0
        public IEnumerable <MeetResult> LoadData(string filePath)
        {
            using (var reader = new CsvReader(new StreamReader(filePath), true))
            {
                var results = new List <MeetResult>();

                while (reader.ReadNextRecord())
                {
                    var result = MeetResult.Create(reader[0], reader[1], reader[2], reader[3], reader[4], reader[5], reader[6], reader[7], reader[9], reader[11], reader[13], reader[14], reader[15], reader[16]);

                    if (result.Total.HasValue && result.Bodyweight.HasValue && !string.IsNullOrEmpty(result.Division) && !string.IsNullOrEmpty(result.Equipment) && !string.IsNullOrEmpty(result.WeightClass))
                    {
                        results.Add(result);
                    }
                }

                return(results);
            }
        }
        public static MeetResult Create(string meetId, string name, string sex, string equipment, string age, string division, string bodyweight, string weightClass, string squat, string bench, string deadlift, string total, string place, string wilks)
        {
            var result = new MeetResult
            {
                MeetId      = meetId,
                Name        = name,
                Division    = division,
                Sex         = sex,
                WeightClass = weightClass,
                Equipment   = equipment,
                Place       = place,
                Age         = !string.IsNullOrEmpty(age) ? double.Parse(age) : (double?)null,
                Bodyweight  = !string.IsNullOrEmpty(bodyweight) ? double.Parse(bodyweight) : (double?)null,
                Squat       = !string.IsNullOrEmpty(squat) ? double.Parse(squat) : (double?)null,
                Bench       = !string.IsNullOrEmpty(bench) ? double.Parse(bench) : (double?)null,
                Deadlift    = !string.IsNullOrEmpty(deadlift) ? double.Parse(deadlift) : (double?)null,
                Total       = !string.IsNullOrEmpty(total) ? double.Parse(total) : (double?)null,
                Wilks       = !string.IsNullOrEmpty(wilks) ? double.Parse(wilks) : (double?)null
            };

            return(result);
        }