public void SolveSparseGivesExpectedResult(
double[,] dense,
int[] expectedColumnAssignment,
int[] expectedRowAssignment)
{
var solver = new ShortestPathSolver();
var cost = new SparseMatrixDouble(dense);
var solution = solver.Solve(cost);
Assert.Equal(expectedColumnAssignment, solution.ColumnAssignment);
Assert.Equal(expectedRowAssignment, solution.RowAssignment);
}
public void SolveThrowsForNonTrivialNonSquareInputWithoutFeasibleSolution()
{
var dense = new[, ]
{
{ .2, double.PositiveInfinity, double.PositiveInfinity },
{ .3, double.PositiveInfinity, double.PositiveInfinity }
};
var sparse = new SparseMatrixDouble(dense);
var solver = new ShortestPathSolver();
Assert.Throws <InvalidOperationException>(() => solver.Solve(dense));
Assert.Throws <InvalidOperationException>(() => solver.Solve(sparse));
}
public void TransposeCalculatesTransposeAndIsAnInvolution(
List <double> A, List <int> IA, List <int> CA, int numColumns,
List <double> At, List <int> IAt, List <int> CAt)
{
var matrix = new SparseMatrixDouble(A.ToList(), IA.ToList(), CA.ToList(), numColumns);
var transpose = matrix.Transpose();
var doubleTranspose = transpose.Transpose();
Assert.Equal(At, transpose.A);
Assert.Equal(IAt, transpose.IA);
Assert.Equal(CAt, transpose.CA);
Assert.Equal(A, doubleTranspose.A);
Assert.Equal(IA, doubleTranspose.IA);
Assert.Equal(CA, doubleTranspose.CA);
}
public void SparseMatrixConstructsProperlyForDenseIntegralInput()
{
double[,] dense = { { 0, 0, 0, 0 }, { 5, 8, 0, 0 }, { 0, 0, 3, 0 }, { 0, 6, 0, 0 } };
var sparse = new SparseMatrixDouble(dense, 0);
Assert.Equal(new List <double> {
5, 8, 3, 6
}, sparse.A);
Assert.Equal(new List <int> {
0, 0, 2, 3, 4
}, sparse.IA);
Assert.Equal(new List <int> {
0, 1, 2, 1
}, sparse.CA);
Assert.Equal(4, sparse.NumRows);
Assert.Equal(4, sparse.NumColumns);
Assert.Equal(8, sparse.MaxValue);
}
public void SparseAndDenseSolversGiveSameResult()
{
var rng = new Random(60);
const int numberOfRuns = 1000;
for (var run = 0; run < numberOfRuns; run++)
{
var numRows = rng.Next(200, 300);
var numCols = rng.Next(200, 300);
var dense = new double[numRows, numCols];
for (var i = 0; i < numRows; i++)
{
for (var j = 0; j < numCols; j++)
{
dense[i, j] = rng.NextDouble() < 0.3 ? double.PositiveInfinity : rng.Next(1, 100);
}
}
var sparse = new SparseMatrixDouble(dense);
var denseResult = Solver.Solve(dense);
var sparseResult = Solver.Solve(sparse);
// Check that the objective agrees for both solvers.
if (numRows <= numCols)
{
var denseObjective =
Enumerable.Range(0, numRows).Sum(i => dense[i, denseResult.ColumnAssignment[i]]);
var sparseObjective =
Enumerable.Range(0, numRows).Sum(i => dense[i, sparseResult.ColumnAssignment[i]]);
Assert.Equal(denseObjective, sparseObjective);
}
else
{
var denseObjective =
Enumerable.Range(0, numCols).Sum(i => dense[denseResult.RowAssignment[i], i]);
var sparseObjective =
Enumerable.Range(0, numCols).Sum(i => dense[sparseResult.RowAssignment[i], i]);
Assert.Equal(denseObjective, sparseObjective);
}
}
}
