public List <Dictionary <int, int> > calculate(Func <int, String, int, int, int, int, int> createRowFunc)
        {
            Dictionary <int, int> balanceLefties  = new Dictionary <int, int>();
            Dictionary <int, int> balanceRighties = new Dictionary <int, int>();

            String[] types          = { "9L", "8L", "7L", "6L", "5L", "4L", "3L", "2L", "1L", "E", "1R", "2R", "3R", "4R", "5R", "6R", "7R", "8R", "9R" };
            int      rowCount       = 1;
            int      totalStarterIP = teamReportFile.getTotalStarterIP(targetTeam);

            //      int totalPitcherIP = teamReportFile.getTotalPitcherIP();

            foreach (String type in types)
            {
                int           ip_for_lefties  = 0;
                int           ip_for_righties = 0;
                List <Player> players         = teamReportFile.getBalanceData()[type];
                foreach (Player player in players)
                {
                    if (player.GS > 1 && !player.Team.Abrv.Equals(targetTeam.Abrv))
                    {
                        if (player.Throws.Equals("L"))
                        {
                            ip_for_lefties += player.IP;
                        }
                        else if (player.Throws.Equals("R"))
                        {
                            ip_for_righties += player.IP;
                        }
                    }
                }

                // THIS BUILDS THE ESTIMATED BATTER AT BATS PER TYPE TABLE
                int valueLAB = CalculateColumnUtil.calculateColumn(ip_for_lefties, totalStarterIP);
                int valueRAB = CalculateColumnUtil.calculateColumn(ip_for_righties, totalStarterIP);

                if (createRowFunc != null)
                {
                    createRowFunc(rowCount, type, ip_for_lefties, valueLAB, ip_for_righties, valueRAB);
                }

                balanceLefties.Add(rowCount - 1, valueLAB);
                balanceRighties.Add(rowCount - 1, valueRAB);
                rowCount++;
            }

            List <Dictionary <int, int> > returnValue = new List <Dictionary <int, int> >();

            returnValue.Add(balanceLefties);
            returnValue.Add(balanceRighties);
            return(returnValue);
        }
Example #2
0
        public List <Dictionary <int, int> > calculate(Func <int, String, int, int, int, int, int> createRowFunc)
        {
            if (inDivision == 0 || outDivision == 0)
            {
                throw new Exception("Error, in and Out Division needs to be defined");
            }

            // Initial local variables
            double teamsInDivision = 0, teamsOutDivision = 0, gamesInDivision = 0, gamesOutDivision = 0, totalGames = 0;

            // Count the number of Games in and out of division
            foreach (Team opponentTeam in teamReportFile.getTeams())
            {
                if (!targetTeam.Abrv.Equals(opponentTeam.Abrv))
                {
                    if (targetTeam.Division.Equals(opponentTeam.Division))
                    {
                        gamesInDivision += inDivision;
                        totalGames      += inDivision;
                        teamsInDivision++;
                    }
                    else
                    {
                        gamesOutDivision += outDivision;
                        totalGames       += outDivision;
                        teamsOutDivision++;
                    }
                }
            }

            // Percentage of Games In and Out of division.
            double pctGamesInDivisionPerTeam  = inDivision / totalGames;
            double pctGamesOutDivisionPerTeam = outDivision / totalGames;
            double overallPctInDivision       = pctGamesInDivisionPerTeam * teamsInDivision;
            double overallPctOutDivision      = pctGamesOutDivisionPerTeam * teamsOutDivision;

            Dictionary <String, int> total_LeftybalanceData_in   = new Dictionary <String, int>();
            Dictionary <String, int> total_RightybalanceData_in  = new Dictionary <String, int>();
            Dictionary <String, int> total_LeftybalanceData_out  = new Dictionary <String, int>();
            Dictionary <String, int> total_RightybalanceData_out = new Dictionary <String, int>();

            double totalLeftIP_in   = 0;
            double totalRightIP_in  = 0;
            double totalLeftIP_out  = 0;
            double totalRightIP_out = 0;

            foreach (Team opponentTeam in teamReportFile.getTeams())
            {
                if (!opponentTeam.Abrv.Equals(targetTeam.Abrv))
                {
                    bool opponentInDivision = opponentTeam.Division.Equals(targetTeam.Division);

                    List <Player> opponentPitchers = teamReportFile.getTeamPitchers(opponentTeam.Abrv);

                    if (opponentInDivision)
                    {
                        totalLeftIP_in += addTeamsBalanceDataToTotal(total_LeftybalanceData_in,
                                                                     teamReportFile.getTeamBalanceCount("L", opponentPitchers));

                        totalRightIP_in += addTeamsBalanceDataToTotal(total_RightybalanceData_in,
                                                                      teamReportFile.getTeamBalanceCount("R", opponentPitchers));
                    }
                    else
                    {
                        totalLeftIP_out += addTeamsBalanceDataToTotal(total_LeftybalanceData_out,
                                                                      teamReportFile.getTeamBalanceCount("L", opponentPitchers));

                        totalRightIP_out += addTeamsBalanceDataToTotal(total_RightybalanceData_out,
                                                                       teamReportFile.getTeamBalanceCount("R", opponentPitchers));
                    }
                }
            }


            Dictionary <String, int> est_LeftybalanceData_in   = new Dictionary <String, int>();
            Dictionary <String, int> est_RightybalanceData_in  = new Dictionary <String, int>();
            Dictionary <String, int> est_LeftybalanceData_out  = new Dictionary <String, int>();
            Dictionary <String, int> est_RightybalanceData_out = new Dictionary <String, int>();

//            int adjustedTotalLeftStarterIP = Convert.ToInt32(totalLeftIP_in);
//           int adjustedTotalRightStarterIP = Convert.ToInt32(totalRightIP_in )*;

            int totalStarterIP = (int)((totalLeftIP_in * overallPctInDivision) +
                                       (totalRightIP_in * overallPctInDivision) +
                                       (totalLeftIP_out * overallPctOutDivision) +
                                       (totalRightIP_out * overallPctOutDivision));

            foreach (String type in types)
            {
                est_LeftybalanceData_in[type]   = CalculateColumnUtil.calculateColumn(total_LeftybalanceData_in[type], overallPctInDivision, totalStarterIP);
                est_RightybalanceData_in[type]  = CalculateColumnUtil.calculateColumn(total_RightybalanceData_in[type], overallPctInDivision, totalStarterIP);
                est_LeftybalanceData_out[type]  = CalculateColumnUtil.calculateColumn(total_LeftybalanceData_out[type], overallPctOutDivision, totalStarterIP);
                est_RightybalanceData_out[type] = CalculateColumnUtil.calculateColumn(total_RightybalanceData_out[type], overallPctOutDivision, totalStarterIP);
            }

            Dictionary <int, int> balanceLefties  = new Dictionary <int, int>();
            Dictionary <int, int> balanceRighties = new Dictionary <int, int>();

            int rowCount = 1;

            foreach (String type in types)
            {
                int ip_for_lefties  = est_LeftybalanceData_in[type] + est_LeftybalanceData_out[type];
                int ip_for_righties = est_RightybalanceData_in[type] + est_RightybalanceData_out[type];
                if (createRowFunc != null)
                {
                    createRowFunc(rowCount, type,
                                  (int)(total_LeftybalanceData_in[type] + total_LeftybalanceData_out[type]), ip_for_lefties,
                                  (int)(total_RightybalanceData_in[type] + total_RightybalanceData_out[type]), ip_for_righties);
                }

                balanceLefties.Add(rowCount - 1, ip_for_lefties);
                balanceRighties.Add(rowCount - 1, ip_for_righties);
                rowCount++;
            }

            List <Dictionary <int, int> > returnValue = new List <Dictionary <int, int> >();

            returnValue.Add(balanceLefties);
            returnValue.Add(balanceRighties);

            return(returnValue);
        }