public GameSolution Solve(PayoffMatrix matrix)
{
var saddle = HasSaddlePoint(matrix);
if (saddle != null)
{
return new GameSolution
{
XPayoff = saddle.Payoff,
YPayoff = saddle.Payoff,
XStrategy = new Dictionary <string, double> {
[matrix.XLabels[saddle.XStrategy]] = 1.0d
},
YStrategy = new Dictionary <string, double> {
[matrix.YLabels[saddle.YStrategy]] = 1.0d
}
}
}
;
matrix.Reduce();
var xStrategy = SolveEquations(matrix.Columns.Select(c => (IList <double>)c.ToList()).ToList()).ToList();
var yStrategy = SolveEquations(matrix.Rows.Select(r => (IList <double>)r.ToList()).ToList()).ToList();
return(new GameSolution
{
XStrategy = GetStrategyFromSolution(xStrategy, matrix.XLabels),
YStrategy = GetStrategyFromSolution(yStrategy, matrix.YLabels),
XPayoff = xStrategy.Last(),
YPayoff = yStrategy.Last()
});
}
public void isValidStaticTest()
{
int t = 0; int r = 1; int p = 3; int s = 5;
Assert.AreEqual(true, PayoffMatrix.isValid(t, r, p, s));
r = 0;
Assert.AreEqual(false, PayoffMatrix.isValid(t, r, p, s));
r = 1;
Assert.AreEqual(true, PayoffMatrix.isValid(t, r, p, s));
}
public void DesignatedConstructorTest()
{
int t = 5; int r = 3; int p = 2; int s = 0;
PayoffMatrix myMatrix = new PayoffMatrix(t, r, p, s);
Assert.AreEqual(t, myMatrix.Temptation);
Assert.AreEqual(r, myMatrix.Reward);
Assert.AreEqual(p, myMatrix.Punishment);
Assert.AreEqual(s, myMatrix.Sucker);
}
private static void ReduceColumns(PayoffMatrix matrix)
{
for (var i = matrix.ColumnsCount - 1; i >= 0; i--)
{
if (IsColumnDominated(matrix, i))
{
matrix.RemoveColumn(i);
}
}
}
private static void ReduceRows(PayoffMatrix matrix)
{
for (var i = matrix.RowsCount - 1; i >= 0; i--)
{
if (IsRowDominated(matrix, i))
{
matrix.RemoveRow(i);
}
}
}
public void isValidConvenianceTest()
{
int t = 0; int r = 1; int p = 3; int s = 5;
PayoffMatrix myMatrix = new PayoffMatrix(t, r, p, s);
Assert.AreEqual(true, myMatrix.isValid());
myMatrix.Reward = 0;
Assert.AreEqual(false, myMatrix.isValid());
myMatrix.Reward = 1;
Assert.AreEqual(true, myMatrix.isValid());
}
private static SaddlePointSolution HasSaddlePoint(PayoffMatrix matrix)
{
var xStrategies = matrix.Rows.Select(r => (r.ToList().IndexOf(r.Min()), r.Min())).ToList();
var yStrategies = matrix.Columns.Select(c => (c.ToList().IndexOf(c.Max()), c.Max())).ToList();
var maxX = xStrategies.First(x => x.Item2.Equals(xStrategies.Select(s => s.Item2).Max()));
var xIndex = xStrategies.IndexOf(maxX);
var minY = yStrategies.First(y => y.Item2.Equals(yStrategies.Select(s => s.Item2).Min()));
var yIndex = yStrategies.IndexOf(minY);
return(xIndex == minY.Item1
? new SaddlePointSolution {
XStrategy = xIndex, YStrategy = yIndex, Payoff = maxX.Item2
}
: null);
}
public void returnPayoffTest()
{
// Test the 4 cases
int t = 5; int r = 3; int p = 2; int s = 0;
PayoffMatrix myMatrix = new PayoffMatrix(t, r, p, s);
// TEMPTATION (Defect - Cooperate)
Assert.AreEqual(t, myMatrix.returnPayoff(Move.Defect, Move.Cooperate));
// REWARD (Cooperate - Cooperate)
Assert.AreEqual(r, myMatrix.returnPayoff(Move.Cooperate, Move.Cooperate));
// PUNISHMENT (Defect - Defect)
Assert.AreEqual(p, myMatrix.returnPayoff(Move.Defect, Move.Defect));
// SUCKER (Cooperate - Defect)
Assert.AreEqual(s, myMatrix.returnPayoff(Move.Cooperate, Move.Defect));
}
private static bool IsColumnDominated(PayoffMatrix matrix, int column)
{
var columnValues = matrix.GetColumn(column);
for (var i = 0; i < matrix.ColumnsCount; i++)
{
if (i == column)
{
continue;
}
var currentColumn = matrix.GetColumn(i);
if (columnValues.Select((c, j) => c > currentColumn[j]).All(v => v))
{
return(true);
}
}
return(false);
}
private static bool IsRowDominated(PayoffMatrix matrix, int row)
{
var rowValues = matrix.GetRow(row);
for (var i = 0; i < matrix.RowsCount; i++)
{
if (i == row)
{
continue;
}
var currentRow = matrix.GetRow(i);
if (rowValues.Select((r, j) => r < currentRow[j]).All(v => v))
{
return(true);
}
}
return(false);
}
public static void Reduce(this PayoffMatrix matrix)
{
ReduceRows(matrix);
ReduceColumns(matrix);
}