public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var p = Util.Permutation(A.RowCount, rand);
var B = (SparseMatrix)A.Clone();
var C = (SparseMatrix)A.Clone();
var result = new BenchmarkResult();
Util.Tic();
C.FastPermuteColumns(p);
result.Time2 = Util.Toc();
Util.Tic();
B.PermuteColumns(new Permutation(p));
result.Time1 = Util.Toc();
result.Success = MatrixComparer.Equals(B, C, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var B = Create.SparseMatrix(rows, cols, density, symmetric);
var result = new BenchmarkResult();
Util.Tic();
var C = A.FastAdd(B);
result.Time2 = Util.Toc();
Util.Tic();
//var D = A.Add(B);
var D = A + B;
result.Time1 = Util.Toc();
result.Success = MatrixComparer.Equals(C, D, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var S = CreateSparse.RandomSymmetric(4, 0.5);
var result = new BenchmarkResult();
Util.Tic();
var B = S.FastKroneckerProduct(A);
result.Time2 = Util.Toc();
Util.Tic();
var C = S.KroneckerProduct(A);
result.Time1 = Util.Toc();
result.Success = MatrixComparer.Equals(B, C, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var result = new BenchmarkResult();
var a = DenseVector.Create(rows, (i) => 1.0 + i);
var D = DiagonalMatrix.OfDiagonal(rows, cols, a);
var C = (SparseMatrix)A.Clone();
Util.Tic();
var B = A.Add(D);
result.Time1 = Util.Toc();
Util.Tic();
C.FastAddDiagonalMatrix(Util.GetData(a), C);
result.Time2 = Util.Toc();
result.Success = MatrixComparer.Equals(B, C, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var temp = A.RowNorms(1);
var a = DenseVector.Create(cols, i => temp[i]);
var b = Util.GetData(a);
var D = SparseMatrix.OfDiagonalVector(a);
var result = new BenchmarkResult();
Util.Tic();
var B = A.Multiply(D);
result.Time1 = Util.Toc();
Util.Tic();
A.FastScaleColumns(b, A);
result.Time2 = Util.Toc();
result.Success = MatrixComparer.Equals(A, B, EPS);
return(result);
}
private async void btnRun_Click(object sender, EventArgs e)
{
if (busy)
{
if (cts != null)
{
cts.Cancel();
}
return;
}
cts = new CancellationTokenSource();
var solver = comboSolver.SelectedItem as TypeNameProvider;
var preconditioner = comboPrecon.SelectedItem as TypeNameProvider;
var setup = new BenchmarkSetup();
setup.CancellationToken = cts.Token;
if (matrix == null)
{
matrix = MatrixHelper.CreateLaplacian(typeName, 50, 50);
}
if (typeName == "Double")
{
setup.SetMatrix <double>(matrix);
}
else
{
setup.SetMatrix <Complex>(matrix);
}
setup.Solver = cache.GetSolver(typeName, solver.Type);
setup.Preconditioner = cache.GetPreconditioner(typeName, preconditioner.Type);
setup.Tolerance = GetTolerance();
setup.IterationsLimit = GetLimit();
btnRun.Image = Properties.Resources.stop;
try
{
busy = true;
await benchmarkResultsView1.Run(setup, typeName);
}
catch (Exception ex)
{
lbInfo.Text = ex.Message;
}
finally
{
busy = false;
}
btnRun.Image = Properties.Resources.play;
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
var result = new BenchmarkResult();
if (!(config.Solver is IIterativeSolver <double>))
{
return(result);
}
if (!(config.Preconditioner is IPreconditioner <double>))
{
return(result);
}
var matrix = config.Matrix as SparseMatrix;
if (matrix == null)
{
return(result);
}
int n = matrix.ColumnCount;
var s = DenseVector.Create(n, (i) => 1.0 + ((double)i / (n - 1)));
var b = matrix.Multiply(s) as DenseVector;
var x = DenseVector.Create(n, 0.0);
var monitor = new IterationMonitor <double>();
var iterator = new Iterator <double>(
new IterationCountStopCriterion <double>(config.IterationsLimit),
//new ResidualStopCriterion<double>(config.Tolerance, b.L2Norm()),
new ResidualStopCriterion <double>(config.Tolerance),
new DivergenceStopCriterion <double>(),
new CancellationStopCriterion <double>(config.CancellationToken),
monitor
);
var solver = (IIterativeSolver <double>)config.Solver;
var preconditioner = (IPreconditioner <double>)config.Preconditioner;
preconditioner.Initialize(matrix);
Util.Tic();
solver.Solve(matrix, b, x, iterator, preconditioner);
var residual = b.Clone();
matrix.Multiply(-1.0, x, 1.0, residual);
result.Time = Util.Toc();
result.Status = iterator.Status;
result.IterationCount = monitor.LastIteration;
result.ResidualHistory = monitor.ResidualNormHistory.ToArray();
result.Error = residual.L2Norm() / b.L2Norm();
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var result = new BenchmarkResult();
var x = Create.Vector(cols, 1.0);
var y = Create.Array(cols, 1.0);
var z = (DenseVector)x.Clone();
Util.Tic();
for (int i = 0; i < repeat; i++)
{
A.TransposeMultiply(2.0, Util.GetData(x), 0.1, y);
}
result.Time2 = Util.Toc();
Util.Tic();
var temp = x.Clone();
// We really don't like to compute/allocate the transpose, but ...
A = (SparseMatrix)A.Transpose();
for (int i = 0; i < repeat; i++)
{
// z = 2.0 * A^t * x + 0.1 * z;
temp.Multiply(2.0, x);
A.Multiply(x, x);
z.Multiply(0.1, z);
z.Add(x, z);
}
result.Time1 = Util.Toc();
result.Success = Helper.Equals(z, y, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var result = new BenchmarkResult();
var x = Create.Vector(cols, 1.0);
var y = Create.Array(cols, 1.0);
var z = (DenseVector)x.Clone();
Util.Tic();
for (int i = 0; i < repeat; i++)
{
A.TransposeMultiply(2.0, Util.GetData(x), 0.1, y);
}
result.Time2 = Util.Toc();
Util.Tic();
var temp = x.Clone();
for (int i = 0; i < repeat; i++)
{
// z = 2.0 * A^t * x + 0.1 * z;
temp.Multiply(2.0, x);
// Completely unusable for large sparse matrices.
A.TransposeThisAndMultiply(x, x); // Same as A.LeftMultiply(x, x)?
z.Multiply(0.1, z);
z.Add(x, z);
}
result.Time1 = Util.Toc();
result.Success = Helper.Equals(z, y, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
DVector b;
var a = new double[A.RowCount];
var result = new BenchmarkResult();
Util.Tic();
b = A.RowNorms(1);
result.Time1 += Util.Toc();
Util.Tic();
A.FastRowNorms(1, a);
result.Time2 += Util.Toc();
result.Success = Helper.Equals(b, a, 0.0);
Util.Tic();
b = A.RowNorms(2);
result.Time1 += Util.Toc();
Util.Tic();
A.FastRowNorms(2, a);
result.Time2 += Util.Toc();
result.Success &= Helper.Equals(b, a, 0.0);
Util.Tic();
b = A.RowNorms(double.PositiveInfinity);
result.Time1 += Util.Toc();
Util.Tic();
A.FastRowNorms(0, a);
result.Time2 += Util.Toc();
result.Success &= Helper.Equals(b, a, 0.0);
return(result);
}
public async Task Run(BenchmarkSetup setup, string type)
{
if (!setup.CheckForNull())
{
return;
}
var context = new BenchmarkContext(setup, type);
var progress = new Progress <int>(i => { });
await context.Run(progress);
AddResultToList(context);
VisualizeTestResults();
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var result = new BenchmarkResult();
var rowIndices = new int[repeat];
for (int i = 0; i < repeat; i++)
{
rowIndices[i] = rand.Next(0, rows - 1);
}
var x = new DenseVector(cols);
var y = new DenseVector(cols);
Util.Tic();
for (int i = 0; i < repeat; i++)
{
A.FastGetRow(rowIndices[i], x);
}
result.Time2 = Util.Toc();
Util.Tic();
for (int i = 0; i < repeat; i++)
{
A.Row(rowIndices[i], y);
}
result.Time1 = Util.Toc();
result.Success = Helper.Equals(x, (Complex[])y, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var B = (SparseMatrix)A.Clone();
var result = new BenchmarkResult();
Util.Tic();
B.FastUpperTriangle();
result.Time2 = Util.Toc();
Util.Tic();
var C = (SparseMatrix)A.UpperTriangle();
result.Time1 = Util.Toc();
result.Success = MatrixComparer.Equals(B, C, EPS);
// Strict upper.
B = (SparseMatrix)A.Clone();
Util.Tic();
B.FastUpperTriangle(true);
result.Time2 += Util.Toc();
Util.Tic();
C = (SparseMatrix)A.StrictlyUpperTriangle();
result.Time1 += Util.Toc();
result.Success &= MatrixComparer.Equals(B, C, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var B = (SparseMatrix)A.Clone();
var S = Create.SparseMatrix(repeat, cols, 2 * density, false);
var result = new BenchmarkResult();
var rowIndices = new int[repeat];
for (int i = 0; i < repeat; i++)
{
rowIndices[i] = rand.Next(0, rows - 1);
}
Util.Tic();
A.FastSetRows(rowIndices, S);
result.Time2 = Util.Toc();
Util.Tic();
for (int i = 0; i < repeat; i++)
{
B.SetRow(rowIndices[i], S.Row(i));
}
result.Time1 = Util.Toc();
result.Success = MatrixComparer.Equals(A, B, EPS);
return(result);
}
public override BenchmarkResult Run(BenchmarkSetup config)
{
int rows = config.RowCount;
int cols = config.ColumnCount;
int repeat = config.Repeat;
double density = config.Density;
bool symmetric = config.Symmetric;
var A = Create.SparseMatrix(rows, cols, density, symmetric);
var result = new BenchmarkResult();
var columnIndices = new int[repeat];
for (int i = 0; i < repeat; i++)
{
columnIndices[i] = rand.Next(0, cols - 1);
}
Util.Tic();
var B = A.FastGetColumns(columnIndices);
result.Time2 = Util.Toc();
Util.Tic();
var C = new SparseMatrix(rows, repeat);
for (int i = 0; i < repeat; i++)
{
C.SetColumn(i, A.Column(columnIndices[i]));
}
result.Time1 = Util.Toc();
result.Success = MatrixComparer.Equals(B, C, EPS);
return(result);
}
