Esempio n. 1
0
        public PlayerPredictions PlayerSimulator(GamePredictions game, Players player)
        {
            List <PlayerStats> fullStats  = _getStatMethods.GetFullSeasonStatsWithPlayer(player);
            List <FullSeason>  fullSeason = _getStatMethods.GetFullSeasonList(player.Team);
            PlayerPredictions  stats      = new PlayerPredictions();

            return(stats);
        }
Esempio n. 2
0
        public int GetLatestGameNoGamePredictions()
        {
            GamePredictions game = this._dbContext.GamePredictions.OrderByDescending(x => x.ID).FirstOrDefault();

            if (game == null)
            {
                return(106);
            }
            return(game.GameNo);
        }
Esempio n. 3
0
        public GamePredictions GameCalculator(GameModel Stats, GameModel HomeAverages, GameModel AwayAverages, GameModel HomeDeviation, GameModel AwayDeviation)
        {
            double          paceofplay            = PaceofPlayCalculator(Stats);
            double          home2PP               = (Stats.HomeFGM - Stats.Home3PM) / (Stats.HomeFGA - Stats.Home3PA);
            double          away2PP               = (Stats.AwayFGM - Stats.Away3PM) / (Stats.AwayFGA - Stats.Away3PA);
            double          home3PP               = Stats.Home3PM / Stats.Home3PA;
            double          away3PP               = Stats.Away3PM / Stats.Away3PA;
            double          homeFTP               = Stats.HomeFTM / Stats.HomeFTA;
            double          awayFTP               = Stats.AwayFTM / Stats.AwayFTA;
            int             Home3PA               = DeviationApllication(Stats.Home3PA, HomeDeviation.Home3PA, HomeAverages.Home3PA);
            int             HomeTurnovers         = DeviationApllication(Stats.HomeTurnovers, HomeDeviation.HomeTurnovers, HomeAverages.HomeTurnovers);
            int             HomeOffensiveRebounds = DeviationApllication(Stats.HomeOffensiveRebounds, HomeDeviation.HomeOffensiveRebounds, HomeAverages.HomeOffensiveRebounds);
            int             HomeFTA               = DeviationApllication(Stats.HomeFTA, HomeDeviation.HomeFTA, HomeAverages.HomeFTA);
            int             Home2PA               = Convert.ToInt16(Math.Round(paceofplay / 2 - HomeFTA / 2.5 - HomeTurnovers * 0.7 - Home3PA + HomeOffensiveRebounds));
            int             Home2PM               = DeviationApllication(Home2PA * home2PP, HomeDeviation.HomeFGM - HomeDeviation.Home3PM, HomeAverages.HomeFGM - HomeAverages.Home3PM);
            int             Away3PA               = DeviationApllication(Stats.Away3PA, AwayDeviation.Away3PA, AwayAverages.Away3PA);
            int             AwayTurnovers         = DeviationApllication(Stats.AwayTurnovers, AwayDeviation.AwayTurnovers, AwayAverages.AwayTurnovers);
            int             AwayOffensiveRebounds = DeviationApllication(Stats.AwayOffensiveRebounds, AwayDeviation.AwayOffensiveRebounds, AwayAverages.AwayOffensiveRebounds);
            int             AwayFTA               = DeviationApllication(Stats.AwayFTA, AwayDeviation.AwayFTA, AwayAverages.AwayFTA);
            int             Away2PA               = Convert.ToInt16(Math.Round(paceofplay / 2 - AwayFTA / 2.5 - AwayTurnovers * 0.7 - Away3PA + AwayOffensiveRebounds));
            int             Away2PM               = DeviationApllication(Away2PA * away2PP, AwayDeviation.AwayFGM - AwayDeviation.Away3PM, AwayAverages.AwayFGM - AwayAverages.Away3PM);
            GamePredictions game = new GamePredictions
            {
                HomeFGA               = Home3PA + Home2PA,
                Home3PA               = Home3PA,
                Home3PM               = DeviationApllication(Home3PA * home3PP, HomeDeviation.Home3PA, HomeAverages.Home3PM),
                HomeFTA               = HomeFTA,
                HomeFTM               = DeviationApllication(HomeFTA * homeFTP, HomeDeviation.HomeFTM, HomeAverages.HomeFTM),
                HomeAssists           = DeviationApllication(Stats.HomeAssists, HomeDeviation.HomeAssists, HomeAverages.HomeAssists),
                HomeTurnovers         = HomeTurnovers,
                HomeOffensiveRebounds = HomeOffensiveRebounds,
                HomeDefensiveRebounds = DeviationApllication(Stats.HomeDefensiveRebounds, HomeDeviation.HomeDefensiveRebounds, HomeAverages.HomeDefensiveRebounds),
                HomeBlocks            = DeviationApllication(Stats.HomeBlocks, HomeDeviation.HomeBlocks, HomeAverages.HomeBlocks),
                HomeSteals            = DeviationApllication(Stats.HomeSteals, HomeDeviation.HomeSteals, HomeAverages.HomeSteals),
                AwayFGA               = Away3PA + Away2PA,
                Away3PA               = Away3PA,
                Away3PM               = DeviationApllication(Away3PA * away3PP, AwayDeviation.Away3PA, AwayAverages.Away3PM),
                AwayFTA               = AwayFTA,
                AwayFTM               = DeviationApllication(AwayFTA * awayFTP, AwayDeviation.AwayFTM, AwayAverages.AwayFTM),
                AwayAssists           = DeviationApllication(Stats.AwayAssists, AwayDeviation.AwayAssists, AwayAverages.AwayAssists),
                AwayTurnovers         = AwayTurnovers,
                AwayOffensiveRebounds = AwayOffensiveRebounds,
                AwayDefensiveRebounds = DeviationApllication(Stats.AwayDefensiveRebounds, AwayDeviation.AwayDefensiveRebounds, AwayAverages.AwayDefensiveRebounds),
                AwayBlocks            = DeviationApllication(Stats.AwayBlocks, AwayDeviation.AwayBlocks, AwayAverages.AwayBlocks),
                AwaySteals            = DeviationApllication(Stats.AwaySteals, AwayDeviation.AwaySteals, AwayAverages.AwaySteals)
            };

            game.HomeFGM    = game.Home3PM + Home2PM;
            game.HomePoints = game.Home3PM * 3 + Home2PM * 2 + game.HomeFTM;
            game.AwayFGM    = game.Away3PM + Away2PM;
            game.AwayPoints = game.Away3PM * 3 + Away2PM * 2 + game.AwayFTM;
            return(game);
        }
Esempio n. 4
0
        public void CoefficientOptimizerGame(int No)
        {
            int    firstgames = 0;
            int    othergames = 0;
            double Coefficient1, Coefficient2, Coefficient3, Coefficient4, Coefficient5, Coefficient6, Coefficient7;
            CoEfficientOptimizer optimizer = new CoEfficientOptimizer();

            Coefficient1 = Math.Floor((double)(No / 729));
            Coefficient2 = Math.Floor((No - Coefficient1 * 729) / 81);
            Coefficient3 = Math.Floor((No - Coefficient1 * 729 - Coefficient2 * 81) / 9);
            Coefficient4 = Math.Floor(No - Coefficient1 * 729 - Coefficient2 * 81 - Coefficient3 * 9);
            Coefficient1++;
            Coefficient2++;
            Coefficient3++;
            Coefficient4++;
            double total = Coefficient1 + Coefficient2 + Coefficient3 + Coefficient4;

            Coefficient1 = total / Coefficient1;
            Coefficient2 = total / Coefficient2;
            Coefficient3 = total / Coefficient3;
            Coefficient4 = total / Coefficient4;

            Coefficient5 = Math.Floor((double)((No % 729) / 81));
            Coefficient6 = Math.Floor((No % 729 - Coefficient5 * 81) / 9);
            Coefficient7 = Math.Floor(No % 729 - Coefficient5 * 81 - Coefficient6 * 9);
            Coefficient5++;
            Coefficient6++;
            Coefficient7++;
            total                  = Coefficient5 + Coefficient6 + Coefficient7;
            Coefficient5           = total / Coefficient5;
            Coefficient6           = total / Coefficient6;
            Coefficient7           = total / Coefficient7;
            optimizer.Coefficient1 = Coefficient1;
            optimizer.Coefficient2 = Coefficient2;
            optimizer.Coefficient3 = Coefficient3;
            optimizer.Coefficient4 = Coefficient4;
            optimizer.Coefficient5 = Coefficient5;
            optimizer.Coefficient6 = Coefficient6;
            optimizer.Coefficient7 = Coefficient7;
            for (int i = 750; i < 971; i++)
            {
                if (i == 707)
                {
                    continue;
                }
                Team            homeTeam   = _getStatMethods.GetHomeTeam1920(i);
                Team            awayTeam   = _getStatMethods.GetAwayTeam1920(i);
                GamePredictions prediction = _simulator.FullMatchSimulator1920(homeTeam, awayTeam, i, Coefficient1, Coefficient2, Coefficient3, Coefficient4, Coefficient5, Coefficient6, Coefficient7);
                FullSeason19_20 game       = _getStatMethods.GetFullSeason1920(i);
                if (prediction.FirstGame)
                {
                    firstgames++;
                    optimizer.FirstHomePoints      += Math.Abs(game.HomePoints - prediction.HomePoints) / game.HomePoints * 100;
                    optimizer.FirstHome3PA         += Math.Abs(game.Home3PA - prediction.Home3PA) / game.Home3PA * 100;
                    optimizer.FirstHome3PM         += Math.Abs(game.Home3PM - prediction.Home3PM) / game.Home3PM * 100;
                    optimizer.FirstHomeFGA         += Math.Abs(game.HomeFGA - prediction.HomeFGA) / game.HomeFGA * 100;
                    optimizer.FirstHomeFGM         += Math.Abs(game.HomeFGM - prediction.HomeFGM) / game.HomeFGM * 100;
                    optimizer.FirstHomeFTA         += Math.Abs(game.HomeFTA - prediction.HomeFTA) / game.HomeFTA * 100;
                    optimizer.FirstHomeFTM         += Math.Abs(game.HomeFTM - prediction.HomeFTM) / game.HomeFTM * 100;
                    optimizer.FirstAwayPoints      += Math.Abs(game.AwayPoints - prediction.AwayPoints) / game.AwayPoints * 100;
                    optimizer.FirstAway3PA         += Math.Abs(game.Away3PA - prediction.Away3PA) / game.Away3PA * 100;
                    optimizer.FirstAway3PM         += Math.Abs(game.Away3PM - prediction.Away3PM) / game.Away3PM * 100;
                    optimizer.FirstAwayFGA         += Math.Abs(game.AwayFGA - prediction.AwayFGA) / game.AwayFGA * 100;
                    optimizer.FirstAwayFGM         += Math.Abs(game.AwayFGM - prediction.AwayFGM) / game.AwayFGM * 100;
                    optimizer.FirstAwayFTA         += Math.Abs(game.AwayFTA - prediction.AwayFTA) / game.AwayFTA * 100;
                    optimizer.FirstAwayFTM         += Math.Abs(game.AwayFTM - prediction.AwayFTM) / game.AwayFTM * 100;
                    optimizer.FirstTotalHomePoints += Convert.ToInt16(prediction.HomePoints);
                    optimizer.FirstTotalHome3PA    += Convert.ToInt16(prediction.Home3PA);;
                    optimizer.FirstTotalHome3PM    += Convert.ToInt16(prediction.Home3PM);;
                    optimizer.FirstTotalHomeFGA    += Convert.ToInt16(prediction.HomeFGA);;
                    optimizer.FirstTotalHomeFGM    += Convert.ToInt16(prediction.HomeFGM);;
                    optimizer.FirstTotalHomeFTA    += Convert.ToInt16(prediction.HomeFTA);;
                    optimizer.FirstTotalHomeFTM    += Convert.ToInt16(prediction.HomeFTM);;
                    optimizer.FirstTotalAwayPoints += Convert.ToInt16(prediction.AwayPoints);;
                    optimizer.FirstTotalAway3PA    += Convert.ToInt16(prediction.Away3PA);;
                    optimizer.FirstTotalAway3PM    += Convert.ToInt16(prediction.Away3PM);;
                    optimizer.FirstTotalAwayFGA    += Convert.ToInt16(prediction.AwayFGA);;
                    optimizer.FirstTotalAwayFGM    += Convert.ToInt16(prediction.AwayFGM);;
                    optimizer.FirstTotalAwayFTA    += Convert.ToInt16(prediction.AwayFTA);;
                    optimizer.FirstTotalAwayFTM    += Convert.ToInt16(prediction.AwayFTM);;
                }
                else
                {
                    othergames++;
                    optimizer.HomePoints           += Math.Abs(game.HomePoints - prediction.HomePoints) / game.HomePoints * 100;
                    optimizer.Home3PA              += Math.Abs(game.Home3PA - prediction.Home3PA) / game.Home3PA * 100;
                    optimizer.Home3PM              += Math.Abs(game.Home3PM - prediction.Home3PM) / game.Home3PM * 100;
                    optimizer.HomeFGA              += Math.Abs(game.HomeFGA - prediction.HomeFGA) / game.HomeFGA * 100;
                    optimizer.HomeFGM              += Math.Abs(game.HomeFGM - prediction.HomeFGM) / game.HomeFGM * 100;
                    optimizer.HomeFTA              += Math.Abs(game.HomeFTA - prediction.HomeFTA) / game.HomeFTA * 100;
                    optimizer.HomeFTM              += Math.Abs(game.HomeFTM - prediction.HomeFTM) / game.HomeFTM * 100;
                    optimizer.AwayPoints           += Math.Abs(game.AwayPoints - prediction.AwayPoints) / game.AwayPoints * 100;
                    optimizer.Away3PA              += Math.Abs(game.Away3PA - prediction.Away3PA) / game.Away3PA * 100;
                    optimizer.Away3PM              += Math.Abs(game.Away3PM - prediction.Away3PM) / game.Away3PM * 100;
                    optimizer.AwayFGA              += Math.Abs(game.AwayFGA - prediction.AwayFGA) / game.AwayFGA * 100;
                    optimizer.AwayFGM              += Math.Abs(game.AwayFGM - prediction.AwayFGM) / game.AwayFGM * 100;
                    optimizer.AwayFTA              += Math.Abs(game.AwayFTA - prediction.AwayFTA) / game.AwayFTA * 100;
                    optimizer.AwayFTM              += Math.Abs(game.AwayFTM - prediction.AwayFTM) / game.AwayFTM * 100;
                    optimizer.FirstTotalHomePoints += Convert.ToInt16(prediction.HomePoints);
                    optimizer.FirstTotalHome3PA    += Convert.ToInt16(prediction.Home3PA);;
                    optimizer.FirstTotalHome3PM    += Convert.ToInt16(prediction.Home3PM);;
                    optimizer.FirstTotalHomeFGA    += Convert.ToInt16(prediction.HomeFGA);;
                    optimizer.FirstTotalHomeFGM    += Convert.ToInt16(prediction.HomeFGM);;
                    optimizer.FirstTotalHomeFTA    += Convert.ToInt16(prediction.HomeFTA);;
                    optimizer.FirstTotalHomeFTM    += Convert.ToInt16(prediction.HomeFTM);;
                    optimizer.FirstTotalAwayPoints += Convert.ToInt16(prediction.AwayPoints);;
                    optimizer.FirstTotalAway3PA    += Convert.ToInt16(prediction.Away3PA);;
                    optimizer.FirstTotalAway3PM    += Convert.ToInt16(prediction.Away3PM);;
                    optimizer.FirstTotalAwayFGA    += Convert.ToInt16(prediction.AwayFGA);;
                    optimizer.FirstTotalAwayFGM    += Convert.ToInt16(prediction.AwayFGM);;
                    optimizer.FirstTotalAwayFTA    += Convert.ToInt16(prediction.AwayFTA);;
                    optimizer.FirstTotalAwayFTM    += Convert.ToInt16(prediction.AwayFTM);;
                }
            }
            optimizer.FirstHomePoints /= firstgames;
            optimizer.FirstHome3PA    /= firstgames;
            optimizer.FirstHome3PM    /= firstgames;
            optimizer.FirstHomeFGA    /= firstgames;
            optimizer.FirstHomeFGM    /= firstgames;
            optimizer.FirstHomeFTA    /= firstgames;
            optimizer.FirstHomeFTM    /= firstgames;
            optimizer.FirstAwayPoints /= firstgames;
            optimizer.FirstAway3PA    /= firstgames;
            optimizer.FirstAway3PM    /= firstgames;
            optimizer.FirstAwayFGA    /= firstgames;
            optimizer.FirstAwayFGM    /= firstgames;
            optimizer.FirstAwayFTA    /= firstgames;
            optimizer.FirstAwayFTM    /= firstgames;
            optimizer.HomePoints      /= othergames;
            optimizer.Home3PA         /= othergames;
            optimizer.Home3PM         /= othergames;
            optimizer.HomeFGA         /= othergames;
            optimizer.HomeFGM         /= othergames;
            optimizer.HomeFTA         /= othergames;
            optimizer.HomeFTM         /= othergames;
            optimizer.AwayPoints      /= othergames;
            optimizer.Away3PA         /= othergames;
            optimizer.Away3PM         /= othergames;
            optimizer.AwayFGA         /= othergames;
            optimizer.AwayFGM         /= othergames;
            optimizer.AwayFTA         /= othergames;
            optimizer.AwayFTM         /= othergames;
            this._dbContext.CoEfficientOptimizer.Add(optimizer);
            this._unitOfWork.Commit();
        }
Esempio n. 5
0
        public GamePredictions FullMatchSimulator1920(Team HomeTeam, Team AwayTeam, int GameNo, double Coefficient1, double Coefficient2, double Coefficient3, double Coefficient4, double Coefficient5, double Coefficient6, double Coefficient7)
        {
            //FullSeason Lists
            List <FullSeason19_20> homeFullSeason = _getStatMethods.GetFullSeason1920TillGameNo(HomeTeam, GameNo);
            List <FullSeason19_20> awayFullSeason = _getStatMethods.GetFullSeason1920TillGameNo(AwayTeam, GameNo);

            //Standard Deviations
            GameModel TotalDeviation = new GameModel();
            GameModel HomeDeviation  = _statCalculator.DeviationCalculator(homeFullSeason, HomeTeam);

            _statCalculator.GameModelAddition(TotalDeviation, HomeDeviation);
            GameModel AwayDeviation = _statCalculator.DeviationCalculator(awayFullSeason, AwayTeam);

            _statCalculator.GameModelSwitch(AwayDeviation);
            _statCalculator.GameModelAddition(TotalDeviation, AwayDeviation);
            //Season Averages with Coefficients

            var       firstGame = true;
            GameModel HomeGames = new GameModel();
            GameModel AwayGames = new GameModel();

            List <Team> homePlayedAgainst = new List <Team>();

            foreach (var game in homeFullSeason)
            {
                if (HomeTeam == game.HomeTeam && !homePlayedAgainst.Contains(game.AwayTeam))
                {
                    homePlayedAgainst.Add(game.AwayTeam);
                }
                else if (HomeTeam == game.AwayTeam && !homePlayedAgainst.Contains(game.HomeTeam))
                {
                    homePlayedAgainst.Add(game.HomeTeam);
                }
            }
            List <Team> awayPlayedAgainst = new List <Team>();

            foreach (var game in awayFullSeason)
            {
                if (AwayTeam == game.HomeTeam && !awayPlayedAgainst.Contains(game.AwayTeam))
                {
                    awayPlayedAgainst.Add(game.AwayTeam);
                }
                else if (AwayTeam == game.AwayTeam && !awayPlayedAgainst.Contains(game.HomeTeam))
                {
                    awayPlayedAgainst.Add(game.HomeTeam);
                }
            }
            List <Team> commonTeams = new List <Team>();

            foreach (var team1 in homePlayedAgainst)
            {
                foreach (var team2 in awayPlayedAgainst)
                {
                    if (team1 == team2)
                    {
                        commonTeams.Add(team1);
                    }
                }
            }
            List <FullSeason19_20> homePlayedCommon = new List <FullSeason19_20>();
            List <FullSeason19_20> awayPlayedCommon = new List <FullSeason19_20>();

            foreach (var team in commonTeams)
            {
                homePlayedCommon.Add(homeFullSeason.FirstOrDefault(x => x.HomeTeam == team || x.AwayTeam == team));
                awayPlayedCommon.Add(awayFullSeason.FirstOrDefault(x => x.HomeTeam == team || x.AwayTeam == team));
            }
            if (homeFullSeason.FirstOrDefault(x => (x.HomeTeam == HomeTeam && x.AwayTeam == AwayTeam) ||
                                              (x.HomeTeam == AwayTeam && x.AwayTeam == HomeTeam)) != null)
            {
                firstGame = false;
                GameModel homelast5games = _statCalculator.AverageCalculator(homeFullSeason.Take(5).ToList(), HomeTeam);
                _statCalculator.GameModelDivision(homelast5games, Coefficient1);
                GameModel homeathomegames = _statCalculator.AverageCalculator(homeFullSeason.Where(x => x.HomeTeam == HomeTeam).ToList(), HomeTeam);
                _statCalculator.GameModelDivision(homeathomegames, Coefficient2);
                GameModel homeCommon = _statCalculator.AverageCalculator(homePlayedCommon, HomeTeam);
                _statCalculator.GameModelDivision(homeCommon, Coefficient3);
                GameModel awaylast5games = _statCalculator.AverageCalculator(awayFullSeason.Take(5).ToList(), AwayTeam);
                _statCalculator.GameModelDivision(awaylast5games, Coefficient1);
                GameModel awayatawaygames = _statCalculator.AverageCalculator(awayFullSeason.Where(x => x.AwayTeam == AwayTeam).ToList(), AwayTeam);
                _statCalculator.GameModelDivision(awayatawaygames, Coefficient2);
                GameModel awayCommon = _statCalculator.AverageCalculator(awayPlayedCommon, AwayTeam);
                _statCalculator.GameModelDivision(awayCommon, Coefficient3);
                GameModel seasonmatchups = _statCalculator.AverageCalculator(homeFullSeason.Where(x => (x.HomeTeam == HomeTeam && x.AwayTeam == AwayTeam) || (x.HomeTeam == AwayTeam && x.AwayTeam == HomeTeam)).ToList(), HomeTeam);
                _statCalculator.GameModelDivision(seasonmatchups, Coefficient4);

                _statCalculator.GameModelAddition(HomeGames, homelast5games);
                _statCalculator.GameModelAddition(HomeGames, homeathomegames);
                _statCalculator.GameModelAddition(HomeGames, homeCommon);
                _statCalculator.GameModelAddition(HomeGames, seasonmatchups);
                _statCalculator.GameModelAddition(AwayGames, awaylast5games);
                _statCalculator.GameModelAddition(AwayGames, awayatawaygames);
                _statCalculator.GameModelAddition(AwayGames, awayCommon);
                _statCalculator.GameModelAdditionSwitch(AwayGames, seasonmatchups);
                _statCalculator.GameModelSwitch(AwayGames);
            }
            else
            {
                GameModel homelast5games = _statCalculator.AverageCalculator(homeFullSeason.Take(5).ToList(), HomeTeam);
                _statCalculator.GameModelDivision(homelast5games, Coefficient5);
                GameModel homeCommon = _statCalculator.AverageCalculator(homePlayedCommon, HomeTeam);
                _statCalculator.GameModelDivision(homeCommon, Coefficient6);
                GameModel homeathomegames = _statCalculator.AverageCalculator(homeFullSeason.Where(x => x.HomeTeam == HomeTeam).ToList(), HomeTeam);
                _statCalculator.GameModelDivision(homeathomegames, Coefficient7);
                GameModel awaylast5games = _statCalculator.AverageCalculator(awayFullSeason.Take(5).ToList(), AwayTeam);
                _statCalculator.GameModelDivision(awaylast5games, Coefficient5);
                GameModel awayCommon = _statCalculator.AverageCalculator(awayPlayedCommon, AwayTeam);
                _statCalculator.GameModelDivision(awayCommon, Coefficient6);
                GameModel awayatawaygames = _statCalculator.AverageCalculator(awayFullSeason.Where(x => x.AwayTeam == AwayTeam).ToList(), AwayTeam);
                _statCalculator.GameModelDivision(awayatawaygames, Coefficient7);

                _statCalculator.GameModelAddition(HomeGames, homelast5games);
                _statCalculator.GameModelAddition(HomeGames, homeathomegames);
                _statCalculator.GameModelAddition(HomeGames, homeCommon);
                _statCalculator.GameModelAddition(AwayGames, awaylast5games);
                _statCalculator.GameModelAddition(AwayGames, awayatawaygames);
                _statCalculator.GameModelAddition(AwayGames, awayCommon);
                _statCalculator.GameModelSwitch(AwayGames);
            }
            _statCalculator.GameModelMultiplication(HomeGames, AwayDeviation);
            _statCalculator.GameModelMultiplication(AwayGames, HomeDeviation);
            _statCalculator.GameModelAddition(HomeGames, AwayGames);
            _statCalculator.GameModelDivision(HomeGames, TotalDeviation);
            GameModel homeSeasonAverages = _statCalculator.AverageCalculator(homeFullSeason, HomeTeam);
            GameModel awaySeasonAverages = _statCalculator.AverageCalculator(awayFullSeason, AwayTeam);

            _statCalculator.GameModelSwitch(awaySeasonAverages);
            GamePredictions Game = GameCalculator(HomeGames, homeSeasonAverages, awaySeasonAverages, HomeDeviation, AwayDeviation);

            Game.HomeTeam  = HomeTeam;
            Game.AwayTeam  = AwayTeam;
            Game.GameNo    = GameNo;
            Game.FirstGame = firstGame;
            return(Game);
        }