private void Helper2(IElementalAccessMatrix A, IElementalAccessVector b,
IElementalAccessVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter)
{
Random r = new Random();
double K = r.NextDouble(), f = r.NextDouble(), gl = r.NextDouble(), gr = r.NextDouble();
//assemble(A, b, K, f);
//boundary(A, b, x, gl, gr);
A.SetValue(0, 0, 1);
A.SetValue(0, 1, 1);
A.SetValue(0, 2, 1.3);
A.SetValue(1, 0, -0.5);
A.SetValue(1, 1, -0.25);
A.SetValue(1, 2, -1.25);
A.SetValue(2, 0, 2.5);
A.SetValue(2, 1, 3.25);
A.SetValue(2, 2, -1.25);
b.SetValue(0, 1.25);
b.SetValue(1, 3.75);
b.SetValue(1, -2.35);
double[] ans = solve(A, b, x, solver, M, iter);
//double[] ref_Renamed = reference(b.Length - 1, K, f, gl, gr);
//checkEqual(ans, ref_Renamed);
Console.WriteLine("!: " + solver + " " + M + " " + iter + " " + x.GetValue(0) + " " + x.GetValue(1) + " " + x.GetValue(2));
Blas.Default.Zero(A);
Blas.Default.Zero(b);
Blas.Default.Zero(x);
}
/// <summary> Column-wise assembly using setValues</summary>
/// <param name="nu">Maximum bandwidth on each column
/// </param>
/// <returns> Dense representation (not a direct copy)
/// </returns>
public static double[,] setsAssembleColumnMatrix(IElementalAccessMatrix A, int nu)
{
int n = A.RowCount, m = A.ColumnCount;
double[,] data = new double[n, m];
// for (int i = 0; i < n; i++)
// {
// data[i] = new double[m];
// }
System.Random r = new System.Random();
for (int i = 0; i < m; ++i)
{
int[] row = TesterUtilities.getIntArray(nu, r), col = TesterUtilities.getIntArray(m, r);
double[,] entry = TesterUtilities.getDoubleArray(row.Length, col.Length, r);
for (int ii = 0; ii < row.Length; ++ii)
{
for (int jj = 0; jj < col.Length; ++jj)
{
data[row[ii], col[jj]] = entry[ii, jj];
}
}
A.SetValues(row, col, entry);
}
return(data);
}
private static void repeatedAssembly(IElementalAccessMatrix A, int nu)
{
for (int i = 0; i < repeat; ++i)
{
check(A, TesterUtilities.SetAssembleRowMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.setsAssembleRowMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.AddAssembleRowMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.addsAssembleRowMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.setAssembleColumnMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.setsAssembleColumnMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.addAssembleColumnMatrix(A, nu));
Blas.Default.Zero(A);
check(A, TesterUtilities.addsAssembleColumnMatrix(A, nu));
Blas.Default.Zero(A);
}
}
private void Helper1(IElementalAccessMatrix A, IElementalAccessVector b, IElementalAccessVector x)
{
// Test of usual solvers and preconditoners
ILinearSolver[] solver = new ILinearSolver[]
{
new BiCGSolver(),
new BiCGstabSolver(),
//new CGSolver(),
new CGSSolver(),
new GMRESSolver(),
new QMRSolver()
};
IPreconditioner[] M = new IPreconditioner[]
{
new IdentityPreconditioner(),
//new ILUPreconditioner(new SparseRowMatrix(A.RowCount, A.ColumnCount))
};
DefaultLinearIteration iter = new DefaultLinearIteration();
iter.SetParameters(1e-10, 1e-50, 1e+5, 1000000);
for (int i = 0; i < solver.Length; ++i)
{
for (int j = 0; j < M.Length; ++j)
{
Helper2(A, b, x, solver[i], M[j], iter);
}
}
}
/// <summary> Column-wise assembly using set</summary>
/// <param name="nu">Maximum bandwidth on each column
/// </param>
/// <returns> Dense representation (not a direct copy)
/// </returns>
public static double[,] setAssembleColumnMatrix(IElementalAccessMatrix A, int nu)
{
int n = A.RowCount, m = A.ColumnCount;
double[,] data = new double[n, m];
// for (int i = 0; i < n; i++)
// {
// data[i] = new double[m];
// }
System.Random r = new System.Random();
// Construct the matrix
for (int i = 0; i < m; ++i)
{
for (int j = 0; j < nu; ++j)
{
int ind = TesterUtilities.getInt(n, r);
double entry = r.NextDouble();
data[ind, i] = entry;
A.SetValue(ind, i, entry);
}
}
return(data);
}
private static void HelperTranspose(IElementalAccessMatrix A, IElementalAccessMatrix B, double[,] Am)
{
Blas.Default.Transpose(A, B);
double[,] tmpArray = new double[A.ColumnCount, A.RowCount];
// for (int i2 = 0; i2 < A.ColumnCount; i2++)
// {
// tmpArray[i2] = new double[A.RowCount];
// }
double[,] Bm = Transpose(Am, tmpArray);
AreEqual(Blas.Default.GetArrayCopy(B), Bm);
}
private static void TransposeCheck(IElementalAccessMatrix A, double[,] Am)
{
int n = A.RowCount, m = A.ColumnCount;
HelperTranspose(A, new SparseRowMatrix(m, n), Am);
HelperTranspose(A, new SparseColumnMatrix(m, n), Am);
//HelperTranspose(A, new DenseRowMatrix(m, n), Am);
//HelperTranspose(A, new DenseColumnMatrix(m, n), Am);
//HelperTranspose(A, new DenseRowColumnMatrix(m, n), Am);
//HelperTranspose(A, new DenseColumnRowMatrix(m, n), Am);
HelperTranspose(A, new CoordinateMatrix(m, n), Am);
}
/// <summary> Dense representation of the matrix using getValues</summary>
public static double[,] getMatrix(IElementalAccessMatrix A)
{
int[] row = new int[A.RowCount], col = new int[A.ColumnCount];
for (int i = 0; i < row.Length; ++i)
{
row[i] = i;
}
for (int i = 0; i < col.Length; ++i)
{
col[i] = i;
}
return(A.GetValues(row, col));
}
private static void transCheck(IElementalAccessMatrix A, IElementalAccessVector x,
IElementalAccessVector y, IElementalAccessVector z, double[,] Ad)
{
double[] xd = TesterUtilities.setAssembleVector(x),
yd = TesterUtilities.setAssembleVector(y),
zd = TesterUtilities.setAssembleVector(z);
System.Random random = new System.Random();
double alpha = random.NextDouble(), beta = random.NextDouble();
Blas.Default.TransMultAdd(alpha, A, x, beta, y, z);
transMultAdd(alpha, Ad, xd, beta, yd, zd);
checkEqual(z, zd);
}
private void check(IElementalAccessMatrix A, IElementalAccessVector x,
IElementalAccessVector y, IElementalAccessVector z, double[,] Ad)
{
double[] xd = TesterUtilities.setAssembleVector(x),
yd = TesterUtilities.setAssembleVector(y),
zd = TesterUtilities.setAssembleVector(z);
Random r = new Random();
double alpha = r.NextDouble(), beta = r.NextDouble();
Blas.Default.MultAdd(alpha, A, x, beta, y, z);
multAdd(alpha, Ad, xd, beta, yd, zd);
checkEqual(z, zd);
}
/// <summary> Dense representation of the matrix using getValue</summary>
public static double[,] getElMatrix(IElementalAccessMatrix A)
{
double[,] ret = new double[A.RowCount, A.ColumnCount];
// for (int i = 0; i < A.RowCount; i++)
// {
// ret[i] = new double[A.ColumnCount];
// }
for (int i = 0; i < A.RowCount; ++i)
{
for (int j = 0; j < A.ColumnCount; ++j)
{
ret[i, j] = A.GetValue(i, j);
}
}
return(ret);
}
private void boundary(IElementalAccessMatrix A, IElementalAccessVector b,
IElementalAccessVector x, double gl, double gr)
{
int n = b.Length - 1;
int[] boundary = new int[] { 0, n };
double[] boundaryV = new double[] { gl, gr };
x.SetValues(boundary, boundaryV);
b.SetValues(boundary, boundaryV);
A.SetValue(0, 0, 1);
A.SetValue(0, 1, 0);
A.SetValue(n, n, 1);
A.SetValue(n, n - 1, 0);
}
private void assemble(IElementalAccessMatrix A, IElementalAccessVector b, double K, double f)
{
int n = b.Length - 1;
double h = 1.0 / ((double)n);
double[,] Ae = new double[, ] {
{ K / h, (-K) / h }, { (-K) / h, K / h }
};
double[] be = new double[] { f *h / 2.0, f *h / 2.0 };
for (int i = 0; i < n; ++i)
{
int[] ind = new int[] { i, i + 1 };
A.AddValues(ind, ind, Ae);
b.AddValues(ind, be);
}
}
private void grad(IElementalAccessMatrix dy, IElementalAccessVector x)
{
IElementalAccessVector y0 = new DenseVector(x.Length);
IElementalAccessVector y = new DenseVector(x.Length);
model(y0, x);
for (int i = 0; i < x.Length; i++)
{
x.AddValue(i, 0.000001);
model(y, x);
for (int j = 0; j < x.Length; j++)
{
dy.SetValue(j, i, (y.GetValue(j) - y0.GetValue(j)) / 0.000001);
}
x.AddValue(i, -0.000001);
}
}
private void Helper2(IElementalAccessMatrix A, IElementalAccessVector b,
IElementalAccessVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter)
{
Random r = new Random();
double K = r.NextDouble(), f = r.NextDouble(), gl = r.NextDouble(), gr = r.NextDouble();
assemble(A, b, K, f);
boundary(A, b, x, gl, gr);
double[] ans = solve(A, b, x, solver, M, iter);
double[] ref_Renamed = reference(b.Length - 1, K, f, gl, gr);
checkEqual(ans, ref_Renamed);
Blas.Default.Zero(A);
Blas.Default.Zero(b);
Blas.Default.Zero(x);
}
/// <summary> Row-wise assembly using add</summary>
/// <param name="nu">Maximum bandwidth on each row
/// </param>
/// <returns> Dense representation (not a direct copy)
/// </returns>
public static double[,] AddAssembleRowMatrix(IElementalAccessMatrix A, int nu)
{
int n = A.RowCount, m = A.ColumnCount;
double[,] data = new double[n, m];
// for (int i = 0; i < n; i++)
// {
// data[i] = new double[m];
// }
System.Random r = new System.Random();
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < nu; ++j)
{
int ind = TesterUtilities.getInt(m, r);
double entry = r.NextDouble();
data[i, ind] += entry;
A.AddValue(i, ind, entry);
}
}
return(data);
}
private static void rowCheck(IElementalAccessMatrix A, IElementalAccessVector x,
IElementalAccessVector y, IElementalAccessVector z, int nu)
{
double[,] Ad = TesterUtilities.SetAssembleRowMatrix(A, nu);
check(A, x, y, z, Ad);
}
private static void check(IElementalAccessMatrix A, double[,] real)
{
AreEqual(TesterUtilities.getElMatrix(A), real);
AreEqual(TesterUtilities.getMatrix(A), real);
AreEqual(TesterUtilities.getMatrixCopy(A), real);
}
private static void transColumnCheck(IElementalAccessMatrix A, IElementalAccessVector x,
IElementalAccessVector y, IElementalAccessVector z, int nu)
{
double[,] Ad = TesterUtilities.setAssembleColumnMatrix(A, nu);
transCheck(A, x, y, z, Ad);
}
