def apply_for_iteration(self, solver, players_dict, result): current_lineup = self.lineups[self.current_iteration] unswappable_players = current_lineup.get_unswappable_players() remaining_positions = get_remaining_positions( self.optimizer.settings.positions, unswappable_players) # lock selected players for player in unswappable_players: solver.add_constraint([players_dict[player]], None, SolverSign.EQ, 1) # set remaining positions positions_combinations = set([ tuple(sorted(player.positions)) for player in players_dict.keys() if len(player.positions) > 1 ]) positions = get_positions_for_optimizer(remaining_positions, positions_combinations) players_for_optimization = set() for position, places in positions.items(): players_with_position = [ variable for player, variable in players_dict.items() if list_intersection(position, player.positions) and player not in unswappable_players ] players_for_optimization.update(players_with_position) solver.add_constraint(players_with_position, None, SolverSign.GTE, places) # Set total players for optimization solver.add_constraint(players_for_optimization, None, SolverSign.EQ, len(remaining_positions)) # Exclude players with active games for player, variable in players_dict.items(): if player not in unswappable_players and player.is_game_started: solver.add_constraint([players_dict[player]], None, SolverSign.EQ, 0) self.current_iteration += 1
def apply_for_iteration(self, solver, players_dict, result): current_lineup = self.lineups[self.current_iteration] unswappable_players = current_lineup.get_unswappable_players() positions = self.optimizer.settings.positions[:] # lock selected players for player in unswappable_players: for position in positions: if position.name == player.lineup_position: positions.remove(position) break solver.add_constraint([players_dict[player]], [1], SolverSign.EQ, 1) # set remaining positions positions = get_positions_for_optimizer(positions) for position, places in positions.items(): players_with_position = [ variable for player, variable in players_dict.items() if list_intersection(position, player.positions) and player not in unswappable_players ] coefficients = [1] * len(players_with_position) solver.add_constraint(players_with_position, coefficients, SolverSign.GTE, places) # Exclude players with active games for player, variable in players_dict.items(): if player not in unswappable_players and player.is_game_started: solver.add_constraint([players_dict[player]], [1], SolverSign.EQ, 0) self.current_iteration += 1
def apply(self, solver, players_dict): optimizer = self.optimizer extra_positions = optimizer.players_with_same_position positions_combinations = set([ tuple(sorted(player.positions)) for player in players_dict.keys() if len(player.positions) > 1 ]) for rank, rank_positions in groupby(optimizer.settings.positions, lambda pos: pos.for_rank): positions = get_positions_for_optimizer(list(rank_positions), positions_combinations) unique_positions = optimizer.available_positions players_by_positions = { position: { variable for player, variable in players_dict.items() if player.rank == rank and position in player.positions } for position in unique_positions } for position, places in positions.items(): extra = 0 if len(position) == 1: extra = extra_positions.get(position[0], 0) players_with_position = set() for pos in position: players_with_position.update(players_by_positions[pos]) solver.add_constraint(players_with_position, None, SolverSign.GTE, places + extra)
def apply(self, solver): optimizer = self.optimizer if not optimizer.available_positions: return extra_positions = optimizer.players_with_same_position positions_combinations = set([ tuple(sorted(player.positions)) for player in self.players_dict.keys() if len(player.positions) > 1 ]) positions = get_positions_for_optimizer(optimizer.settings.positions, positions_combinations) unique_positions = optimizer.available_positions players_by_positions = { position: { variable for player, variable in self.players_dict.items() if position in player.positions } for position in unique_positions } for position, places in positions.items(): extra = 0 if len(position) == 1: extra = extra_positions.get(position[0], 0) players_with_position = set() for pos in position: players_with_position.update(players_by_positions[pos]) solver.add_constraint(players_with_position, None, SolverSign.GTE, places + extra, name='positions_%s' % '_'.join(position))
def test_optimizer_positions_processing(self): optimizer = LineupOptimizer(self.TestSettings) positions = get_positions_for_optimizer(optimizer.settings.positions) self.assertEqual(len(positions), 5) self.assertEqual(positions[('1', )], 1) self.assertEqual(positions[('2', )], 1) self.assertEqual(positions[('3', )], 1) self.assertEqual(positions[('2', '3')], 4) self.assertEqual(positions[('1', '2', '3')], 7)
def __init__(self, optimizer, players_dict, context): super().__init__(optimizer, players_dict, context) self.min_exposure_players = { player: round(player.min_exposure * context.total_lineups) for player in context.players if player.min_exposure } self.positions = {} # type: Dict[Tuple[str, ...], int] if self.min_exposure_players: self.positions = get_positions_for_optimizer(optimizer.settings.positions, None)
def __init__(self, optimizer, all_players, params): super().__init__(optimizer, all_players, params) self.total_lineups = params.get('n') self.remaining_lineups = self.total_lineups self.min_exposure_players = { player: round(player.min_exposure * self.total_lineups) for player in all_players if player.min_exposure } self.positions = {} if self.min_exposure_players: self.positions = get_positions_for_optimizer(optimizer.settings.positions, None)
def test_optimizer_positions_processing_with_multipositions(self): optimizer = LineupOptimizer(self.TestSettings) positions = get_positions_for_optimizer(optimizer.settings.positions, {('1', '2'), ('2', '3'), ('1', '3')}) self.assertEqual(len(positions), 7) self.assertEqual(positions[('1', )], 1) self.assertEqual(positions[('2', )], 1) self.assertEqual(positions[('3', )], 1) self.assertEqual(positions[('2', '3')], 4) self.assertEqual(positions[('1', '2')], 2) self.assertEqual(positions[('1', '3')], 2) self.assertEqual(positions[('1', '2', '3')], 7)
def apply(self, solver, players_dict): extra_positions = self.optimizer.players_with_same_position positions = get_positions_for_optimizer( self.optimizer._settings.positions) for position, places in positions.items(): extra = 0 if len(position) == 1: extra = extra_positions.get(position[0], 0) players_with_position = [ variable for player, variable in players_dict.items() if list_intersection(position, player.positions) ] coefficients = [1] * len(players_with_position) solver.add_constraint(players_with_position, coefficients, SolverSign.GTE, places + extra)
def apply(self, solver, players_dict): extra_positions = self.optimizer.players_with_same_position positions = get_positions_for_optimizer( self.optimizer.settings.positions) unique_positions = self.optimizer.available_positions players_by_positions = { position: { variable for player, variable in players_dict.items() if position in player.positions } for position in unique_positions } for position, places in positions.items(): extra = 0 if len(position) == 1: extra = extra_positions.get(position[0], 0) players_with_position = set() for pos in position: players_with_position.update(players_by_positions[pos]) solver.add_constraint(players_with_position, None, SolverSign.GTE, places + extra)