/// <summary>
/// Computes a preference matrix with preference probability based on maximum of pocket equity
/// for given pairs (0 or 1). Pocket equity is given by PocketEquity class.
/// </summary>
public static double[,] ComputePreferenceMatrixPeMax(HePocketKind [] pockets)
{
int n = pockets.Length;
double[] cardProbabs = PocketHelper.GetProbabDistr(pockets);
double[,] ptMax = new double[n, n];
for (int i = 0; i < n; ++i)
{
HePocketKind p1 = pockets[i];
for (int j = 0; j <= i; ++j)
{
HePocketKind p2 = pockets[j];
PocketEquity.Result r = PocketEquity.CalculateFast(p1, p2);
if (i == j || r.Equity == 0.5)
{
ptMax[i, j] = 0.5;
}
else
{
ptMax[i, j] = r.Equity > 0.5 ? 1 : 0;
}
ptMax[j, i] = 1 - ptMax[i, j];
}
}
return(ptMax);
}
/// <summary>
/// Computes a preference matrix with preference probability based on pocket equity
/// given by PocketEquity class.
/// </summary>
public static double[,] ComputePreferenceMatrixPe(HePocketKind[] pockets)
{
int n = pockets.Length;
double[] cardProbabs = PocketHelper.GetProbabDistr(pockets);
double[,] ptEq = new double[n, n];
for (int i = 0; i < n; ++i)
{
HePocketKind p1 = pockets[i];
for (int j = 0; j <= i; ++j)
{
HePocketKind p2 = pockets[j];
PocketEquity.Result r = PocketEquity.CalculateFast(p1, p2);
ptEq[i, j] = r.Equity;
ptEq[j, i] = 1 - ptEq[i, j];
}
}
return(ptEq);
}
private ChanceTree CreateCt(HePocketKind[] sbCards, HePocketKind[] bbCards)
{
int nodeCount = 1 + sbCards.Length + sbCards.Length * bbCards.Length;
ChanceTree ct = new ChanceTree(nodeCount);
ct.PlayersCount = 2;
ct.Nodes[0].Probab = 1;
ct.SetDepth(0, 0);
int totalCombSB = 0;
foreach (HePocketKind p in sbCards)
{
totalCombSB += HePocket.KindToRange(p).Length;
}
for (int c0 = 0; c0 < sbCards.Length; ++c0)
{
int sbNode = 1 + c0 * (bbCards.Length + 1);
HePocketKind sbPocket = sbCards[c0];
ct.SetDepth(sbNode, 1);
ct.Nodes[sbNode].Position = 0;
ct.Nodes[sbNode].Probab = (double)HePocket.KindToRange(sbPocket).Length / totalCombSB;
ct.Nodes[sbNode].Card = c0;
double[] oppDealProbabCond = PocketHelper.GetProbabDistr(bbCards, HePocket.KindToCardSet(sbPocket));
for (int c1 = 0; c1 < bbCards.Length; ++c1)
{
int bbNode = sbNode + 1 + c1;
ct.SetDepth(bbNode, 2);
ct.Nodes[bbNode].Position = 1;
ct.Nodes[bbNode].Probab = ct.Nodes[sbNode].Probab * oppDealProbabCond[c1];
ct.Nodes[bbNode].Card = c1;
PocketEquity.Result pe = PocketEquity.CalculateFast(sbPocket, bbCards[c1]);
var potShare = new double[] { pe.Equity, 1 - pe.Equity };
ct.Nodes[bbNode].SetPotShare(3, potShare);
}
}
VerifyChanceTree.VerifyS(ct, 1e-5);
return(ct);
}
/// <summary>
/// A heuristic to correct opponent probabilies based on the card dealt to the hero.
/// </summary>
private static double[] CorrectOpponentProbab(HePocketKind[] pockets, int heroCard, double[] dealProbab, double[] oppCardProbab)
{
int n = pockets.Length;
// Calculate card distribution for opponents with condition that the hero received heroCard.
double[] oppDealProbabCond = PocketHelper.GetProbabDistr(pockets, HePocket.KindToCardSet(pockets[heroCard]));
// Calculate a corrected probability of opponent cards.
double[] corrOppProbab = new double[n];
double sum = 0;
for (int i = 0; i < n; ++i)
{
double condCoeff = oppDealProbabCond[i] / dealProbab[i];
corrOppProbab[i] = oppCardProbab[i] * condCoeff;
sum += corrOppProbab[i];
}
// Normalize the probability of opponent cards.
for (int i = 0; i < n; ++i)
{
corrOppProbab[i] /= sum;
}
return(corrOppProbab);
}
public static ChanceTree CreateCt(HePocketKind [] pockets, double [] oppCardProbab)
{
int n = pockets.Count();
double[] dealProbab = PocketHelper.GetProbabDistr(pockets);
int nodeCount = 1 + n + n * n;
ChanceTree ct = new ChanceTree(nodeCount);
ct.PlayersCount = 2;
ct.Nodes[0].Probab = 1;
ct.SetDepth(0, 0);
for (int c0 = 0; c0 < n; ++c0)
{
int heroNode = 1 + c0 * (n + 1);
ct.SetDepth(heroNode, 1);
ct.Nodes[heroNode].Position = 0;
ct.Nodes[heroNode].Probab = dealProbab[c0];
ct.Nodes[heroNode].Card = c0;
double[] corrOppProbab = CorrectOpponentProbab(pockets, c0, dealProbab, oppCardProbab);
for (int c1 = 0; c1 < n; ++c1)
{
int oppNode = heroNode + 1 + c1;
ct.SetDepth(oppNode, 2);
ct.Nodes[oppNode].Position = 1;
ct.Nodes[oppNode].Probab = ct.Nodes[heroNode].Probab * corrOppProbab[c1];
ct.Nodes[oppNode].Card = c1;
PocketEquity.Result pe = PocketEquity.CalculateFast(pockets[c0], pockets[c1]);
var potShare = new double[] { pe.Equity, 1 - pe.Equity };
ct.Nodes[oppNode].SetPotShare(3, potShare);
}
}
VerifyChanceTree.VerifyS(ct, 1e-5);
return(ct);
}
