def run_simulation(hole_cards, num, exact, given_board, deck, verbose): num_players = len(hole_cards) # Choose whether we're running a Monte Carlo or exhaustive simulation board_length = 0 if given_board is None else len(given_board) # Create data structures to manage multiple processes: # 1) winner_list: number of times each player wins a hand # 2) result_histograms: a list for each player that shows the number of # times each type of poker hand (e.g. flush, straight) was gotten num_processes = multiprocessing.cpu_count() num_poker_hands = len(holdem_functions.hand_rankings) num_histograms = num_processes * num_players * num_poker_hands winner_list = multiprocessing.Array('i', num_processes * (num_players + 1)) result_histograms = multiprocessing.Array('i', num_histograms) # When a board is given, exact calculation is much faster than Monte Carlo # simulation, so default to exact if a board is given if exact or given_board is not None: generate_boards = holdem_functions.generate_exhaustive_boards else: generate_boards = holdem_functions.generate_random_boards if (None, None) in hole_cards: hole_cards_list = list(hole_cards) unknown_index = hole_cards.index((None, None)) deck_list = list(deck) pool = multiprocessing.Pool(processes=num_processes, initializer=unknown_simulation_init, initargs=(hole_cards_list, unknown_index, deck_list, generate_boards, num, board_length, given_board, winner_list, result_histograms)) pool.map(unknown_simulation, holdem_functions.generate_hole_cards(deck)) else: find_winner(generate_boards, deck, hole_cards, num, board_length, given_board, winner_list, result_histograms) # Go through each parallel data structure and aggregate results combined_winner_list, combined_histograms = [0] * (num_players + 1), [] for _ in range(num_players): combined_histograms.append([0] * len(holdem_functions.hand_rankings)) for index, element in enumerate(winner_list): combined_winner_list[index % (num_players + 1)] += element for index, element in enumerate(result_histograms): combined_histograms[(index / num_poker_hands) % num_players][(index % num_poker_hands)] += element if verbose: holdem_functions.print_results(hole_cards, combined_winner_list, combined_histograms) return holdem_functions.find_winning_percentage(combined_winner_list)
def run_simulation(hole_cards, num, exact, given_board, deck, verbose): num_players = len(hole_cards) # Choose whether we're running a Monte Carlo or exhaustive simulation board_length = 0 if given_board is None else len(given_board) # Create data structures to manage multiple processes: # 1) winner_list: number of times each player wins a hand # 2) result_histograms: a list for each player that shows the number of # times each type of poker hand (e.g. flush, straight) was gotten num_processes = multiprocessing.cpu_count() num_poker_hands = len(holdem_functions.hand_rankings) num_histograms = num_processes * num_players * num_poker_hands winner_list = multiprocessing.Array('i', num_processes * (num_players + 1)) result_histograms = multiprocessing.Array('i', num_histograms) # When a board is given, exact calculation is much faster than Monte Carlo # simulation, so default to exact if a board is given if exact or given_board is not None: generate_boards = holdem_functions.generate_exhaustive_boards else: generate_boards = holdem_functions.generate_random_boards if (None, None) in hole_cards: hole_cards_list = list(hole_cards) unknown_index = hole_cards.index((None, None)) deck_list = list(deck) pool = multiprocessing.Pool(processes=num_processes, initializer=unknown_simulation_init, initargs=(hole_cards_list, unknown_index, deck_list, generate_boards, num, board_length, given_board, winner_list, result_histograms)) pool.map(unknown_simulation, holdem_functions.generate_hole_cards(deck)) else: find_winner(generate_boards, deck, hole_cards, num, board_length, given_board, winner_list, result_histograms) # Go through each parallel data structure and aggregate results combined_winner_list, combined_histograms = [0] * (num_players + 1), [] for _ in xrange(num_players): combined_histograms.append([0] * len(holdem_functions.hand_rankings)) for index, element in enumerate(winner_list): combined_winner_list[index % (num_players + 1)] += element for index, element in enumerate(result_histograms): combined_histograms[(index / num_poker_hands) % num_players][ (index % num_poker_hands)] += element if verbose: holdem_functions.print_results(hole_cards, combined_winner_list, combined_histograms) return holdem_functions.find_winning_percentage(combined_winner_list)
def run_simulation(hole_cards, num, exact, given_board, deck, verbose, pad_opp=True): num_players = len(hole_cards) if pad_opp: num_players += 1 #import pdb #pdb.set_trace() # Create results data structures which track results of comparisons # 1) result_histograms: a list for each player that shows the number of # times each type of poker hand (e.g. flush, straight) was gotten # 2) winner_list: number of times each player wins the given round # 3) result_list: list of the best possible poker hand for each pair of # hole cards for a given board result_histograms, winner_list = [], [0] * (num_players + 1) for _ in range(num_players): result_histograms.append([0] * len(holdem_functions.hand_rankings)) # Choose whether we're running a Monte Carlo or exhaustive simulation board_length = 0 if given_board is None else len(given_board) # When a board is given, exact calculation is much faster than Monte Carlo # simulation, so default to exact if a board is given if exact or given_board is not None: generate_boards = holdem_functions.generate_exhaustive_boards else: generate_boards = holdem_functions.generate_random_boards if (None, None) in hole_cards: hole_cards_list = list(hole_cards) unknown_index = hole_cards.index((None, None)) for filler_hole_cards in holdem_functions.generate_hole_cards(deck): hole_cards_list[unknown_index] = filler_hole_cards deck_list = list(deck) deck_list.remove(filler_hole_cards[0]) deck_list.remove(filler_hole_cards[1]) holdem_functions.find_winner(generate_boards, tuple(deck_list), tuple(hole_cards_list), num, board_length, given_board, winner_list, result_histograms) else: holdem_functions.find_winner(generate_boards, deck, hole_cards, num, board_length, given_board, winner_list, result_histograms,pad_opp = pad_opp) if verbose: holdem_functions.print_results(hole_cards, winner_list, result_histograms) return holdem_functions.return_results(hole_cards, winner_list, result_histograms,pad_opp = pad_opp, board = given_board )
def run_simulation(hole_cards, num, exact, given_board, deck, verbose): num_players = len(hole_cards) # Create results data structures which track results of comparisons # 1) result_histograms: a list for each player that shows the number of # times each type of poker hand (e.g. flush, straight) was gotten # 2) winner_list: number of times each player wins the given round # 3) result_list: list of the best possible poker hand for each pair of # hole cards for a given board result_histograms, winner_list = [], [0] * (num_players + 1) for _ in range(num_players): result_histograms.append([0] * len(holdem_functions.hand_rankings)) # Choose whether we're running a Monte Carlo or exhaustive simulation board_length = 0 if given_board is None else len(given_board) if exact: generate_boards = holdem_functions.generate_exhaustive_boards else: generate_boards = holdem_functions.generate_random_boards if (None, None) in hole_cards: hole_cards_list = list(hole_cards) unknown_index = hole_cards.index((None, None)) for filler_hole_cards in holdem_functions.generate_hole_cards(deck): hole_cards_list[unknown_index] = filler_hole_cards deck_list = list(deck) deck_list.remove(filler_hole_cards[0]) deck_list.remove(filler_hole_cards[1]) holdem_functions.find_winner(generate_boards, tuple(deck_list), tuple(hole_cards_list), num, board_length, given_board, winner_list, result_histograms) else: holdem_functions.find_winner(generate_boards, deck, hole_cards, num, board_length, given_board, winner_list, result_histograms) if verbose: players_histograms = holdem_functions.calc_histogram( result_histograms, winner_list) return [ holdem_functions.find_winning_percentage(winner_list), players_histograms ]
def run_simulation(hole_cards, num, exact, given_board, deck, verbose): num_players = len(hole_cards) # Create results data structures which track results of comparisons # 1) result_histograms: a list for each player that shows the number of # times each type of poker hand (e.g. flush, straight) was gotten # 2) winner_list: number of times each player wins the given round # 3) result_list: list of the best possible poker hand for each pair of # hole cards for a given board result_histograms, winner_list = [], [0] * (num_players + 1) for _ in xrange(num_players): result_histograms.append([0] * len(holdem_functions.hand_rankings)) # Choose whether we're running a Monte Carlo or exhaustive simulation board_length = 0 if given_board is None else len(given_board) # When a board is given, exact calculation is much faster than Monte Carlo # simulation, so default to exact if a board is given if exact or given_board is not None: generate_boards = holdem_functions.generate_exhaustive_boards else: generate_boards = holdem_functions.generate_random_boards if (None, None) in hole_cards: hole_cards_list = list(hole_cards) unknown_index = hole_cards.index((None, None)) for filler_hole_cards in holdem_functions.generate_hole_cards(deck): hole_cards_list[unknown_index] = filler_hole_cards deck_list = list(deck) deck_list.remove(filler_hole_cards[0]) deck_list.remove(filler_hole_cards[1]) holdem_functions.find_winner(generate_boards, tuple(deck_list), tuple(hole_cards_list), num, board_length, given_board, winner_list, result_histograms) else: holdem_functions.find_winner(generate_boards, deck, hole_cards, num, board_length, given_board, winner_list, result_histograms) if verbose: holdem_functions.print_results(hole_cards, winner_list, result_histograms) return holdem_functions.find_winning_percentage(winner_list)