static void
digit_help(char *s, long flag)
{
long n = atoi(s);
if (n < 0 || n > MAX_SECTION+4)
pari_err(e_SYNTAX,"no such section in help: ?",s,s);
if (n == MAX_SECTION+1)
community();
else if (flag & h_LONG)
external_help(s,3);
else
commands(n);
return;
}
int sagent::handle_input(ACE_HANDLE fd)
{
ACE_TRACE("sagent::handle_input");
transaction tr(iv_snmp_session_); // this section needs a better design
tr.handle_input(fd);
char rcv_com_str[MAX_COMM_STR_LEN];
if (tr.result(pdu_, rcv_com_str) < 0)
return 0;
OctetStr community(rcv_com_str);
const ACE_INET_Addr &ta = tr.get_from_addr();
ACE_TCHAR buf_tmp[MAXHOSTNAMELEN + 1];
ta.addr_to_string (buf_tmp, MAXHOSTNAMELEN);
UdpAddress ra (ACE_TEXT_ALWAYS_CHAR (buf_tmp));
tgt_.set_address(ra);
// process msg here by calling subclass's implementation
switch (pdu_.get_type()){
case sNMP_PDU_GET:
tgt_.set_read_community(community);
this->handle_get(pdu_, tgt_);
break;
case sNMP_PDU_GETNEXT:
tgt_.set_read_community(community);
this->handle_get_next(pdu_, tgt_);
break;
case sNMP_PDU_SET:
tgt_.set_write_community(community);
this->handle_set(pdu_, tgt_);
break;
default:
ACE_ASSERT(0);
}
return 0;
}
// Run a Monte-Carlo simulation of a game with 6 players.
// Simulate 1,000,000 games.
// Record the winning hole cards of each game.
// Then count the winning frequency of each hole cards.
void simulate(int num_players, int num_simulations)
{
std::mt19937 engine;
//std::uniform_int_distribution<int> d(0, 51);
auto gen = [&](int n) -> int {
return std::uniform_int_distribution<int>(0, n - 1)(engine);
};
// Keep track of the number of occurrences and winning of each combination
// of hole cards.
struct hole_stat_t
{
char type[4]; // e.g. "AKs"
int num_occur[MAX_PLAYERS]; // number of occurrence given n opponents
int num_win[MAX_PLAYERS]; // number of winning given n opponents
double odds(int num_players) const
{
return (double)(num_occur[num_players] - num_win[num_players])
/ num_win[num_players];
}
};
hole_stat_t stat[HOLE_CARD_COMBINATIONS];
for (int i = 0; i < HOLE_CARD_COMBINATIONS; i++)
{
format_hole_index(stat[i].type, i);
memset(stat[i].num_occur, 0, sizeof(stat[i].num_occur));
memset(stat[i].num_win, 0, sizeof(stat[i].num_win));
}
// Initialize a deck of cards.
Hand deck[52];
for (int i = 0; i < 52; i++)
{
Card card((Rank)(i / 4), (Suit)(i % 4));
deck[i] = Hand(card);
}
for (int i = 0; i < num_simulations; i++)
{
// Shuffle the deck.
std::random_shuffle(deck + 0, deck + 52, gen);
// Store the winning hand and hole cards.
HandStrength win_strength;
// Use the first five cards as community cards.
Hand community(deck, 5);
// Use each of the next two cards as hole cards for the players.
for (int j = 0; j < num_players; j++)
{
Hand hole;
hole += deck[5 + j * 2];
hole += deck[5 + j * 2 + 1];
// Update the occurrence of this combination of hole cards.
stat[compute_hole_index(hole)].num_occur[j]++;
// Find the best 5-card combination from these 7 cards.
HandStrength strength = EvaluateHand(community + hole);
// Update the winning hand statistics for a game with j+1 players.
if (j == 0 || strength > win_strength)
{
win_strength = strength;
stat[compute_hole_index(hole)].num_win[j]++;
}
}
// Note that we do not process tie here. This needs to be fixed.
}
#if 1
printf("r1 r2 s Hole");
for (int n = 2; n <= num_players; n++)
{
printf(" %6d", n);
}
printf("\n");
for (int hole = 0; hole < 169; hole++)
{
char t = stat[hole].type[2];
printf("%2d %2d %c %s ", hole / 13, hole % 13,
(t == ' ')? 'p' : t, stat[hole].type);
for (int n = 2; n <= num_players; n++)
{
double prob = (double)stat[hole].num_win[n-1] / stat[hole].num_occur[n-1];
printf(" %.4lf", prob);
}
printf("\n");
}
//printf("----------------\n");
#endif
#if 0
// Display a rectangular table.
printf("O\\S");
for (int r2 = Rank_Ace; r2 >= Rank_Duce; r2--)
{
printf("%5c", format_rank((Rank)r2));
}
printf("\n");
for (int r1 = Rank_Ace; r1 >= Rank_Duce; r1--)
{
// Label
printf("%c: ", format_rank((Rank)r1));
// Off suit (r1, r2) for r1 <= r2.
for (int r2 = Rank_Ace; r2 >= Rank_Duce; r2--)
{
int index = r1 * 13 + r2;
printf((r1 == r2)? " *%3.1lf" : "%5.1lf", stat[index].odds());
}
// Pair (r1, r1).
// Same-suit (r1, r2) for r1 > r2.
printf("\n");
}
#endif
#if 0
// Sort the statistics by winning count (strongest hand first).
std::sort(stat, stat + HOLE_CARD_COMBINATIONS,
[](const hole_stat_t &s1, const hole_stat_t &s2) -> bool
{
double p1 = (double)s1.num_win / (s1.num_occur + 0.0001);
double p2 = (double)s2.num_win / (s2.num_occur + 0.0001);
return p1 > p2;
});
// Display statistics.
for (int i = 0; i < HOLE_CARD_COMBINATIONS; i++)
{
double percentage = 100.0 * stat[i].num_win / (stat[i].num_occur + 0.0001);
// printf("%s %.2lf%%\n", stat[i].type, percentage);
printf("%s %.1lf\n", stat[i].type, (100-percentage)/percentage);
}
#endif
}
