private static void TestRowAddition()
{
Skip.IfNot(TestSettings.TestSuiteSparse, TestSettings.MessageWhenSkippingSuiteSparse);
Matrix original = Matrix.CreateFromArray(SparsePosDef10by10.Matrix);
Vector rhs = Vector.CreateFromArray(SparsePosDef10by10.Rhs);
// Start the matrix as diagonal
var matrixExpected = Matrix.CreateIdentity(original.NumColumns);
var dok = DokSymmetric.CreateIdentity(SparsePosDef10by10.Order);
var factor = CholeskySuiteSparse.Factorize(dok.BuildSymmetricCscMatrix(true), false);
for (int i = 0; i < matrixExpected.NumRows; ++i)
{
// Reference solution
#region minors are not positive definite this way
//matrixExpected.SetRow(i, newRowVector);
//matrixExpected.SetColumn(i, newRowVector);
#endregion
matrixExpected.SetSubmatrix(0, 0, original.GetSubmatrix(0, i + 1, 0, i + 1)); //this way they are
//Console.WriteLine($"\nOnly dofs [0, {i}]");
//matrixWriter.WriteToConsole(matrixExpected);
// Update matrix
Vector newRowVector = matrixExpected.GetRow(i);
factor.AddRow(i, SparseVector.CreateFromDense(newRowVector));
// Solve new linear system
Vector solutionExpected = matrixExpected.FactorCholesky(false).SolveLinearSystem(rhs);
Vector solutionComputed = factor.SolveLinearSystem(rhs);
comparer.AssertEqual(solutionExpected, solutionComputed);
}
}
private static void TestArray1()
{
string path = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName
+ @"\MGroup.LinearAlgebra.Tests\Resources\Array1DSingleLineAndLength.txt";
var reader = new Array1DReader(true);
comparer.AssertEqual(expectedArray, reader.ReadFile(path));
}
private static void TestReorderingAmdCSparseNet()
{
var pattern = SparsityPatternSymmetric.CreateFromDense(Matrix.CreateFromArray(SparsePosDef10by10.Matrix));
var orderingAlg = new OrderingAmdCSparseNet();
(int[] permutation, bool oldToNew) = orderingAlg.FindPermutation(pattern);
comparer.AssertEqual(SparsePosDef10by10.MatlabPermutationAMD, permutation);
}
private static void TestArray1()
{
string path = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName
+ @"\Resources\Array2DBare.txt";
var reader = new Array2DReader(false);
comparer.AssertEqual(expectedArray, reader.ReadFile(path));
}
private static void TestFactorizeFullUpper1()
{
// positive definite
var A1 = Matrix.CreateFromArray(SymmPosDef10by10.Matrix);
var expectedU1 = Matrix.CreateFromArray(SymmPosDef10by10.FactorU);
CholeskyFactorizations.FactorizeFullUpper1(A1.NumColumns, A1, pivotTolerance);
var computedU1 = Matrix.CreateFromArray(Conversions.FullUpperColMajorToArray2D(A1.RawData, false));
comparer.AssertEqual(expectedU1, computedU1);
}
private static void TestDeterminant(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// positive definite
var A = Matrix.CreateFromArray(SymmPosDef10by10.Matrix);
CholeskyFull factorization = A.FactorCholesky(true);
double detComputed = factorization.CalcDeterminant();
comparer.AssertEqual(SymmPosDef10by10.Determinant, detComputed);
});
}
private static void TestArrayCopy()
{
// positive definite
var A1 = SymmetricMatrix.CreateFromArray(SymmPosDef10by10.Matrix);
comparer.AssertEqual(SymmPosDef10by10.Matrix, A1.CopyToArray2D());
// singular
var A2 = SymmetricMatrix.CreateFromArray(SymmSingular10by10.Matrix);
comparer.AssertEqual(SymmSingular10by10.Matrix, A2.CopyToArray2D());
}
private static void TestFactorization()
{
//TestSettings.RunMultiproviderTest(providers, delegate () {
//
var skyline = SkylineMatrix.CreateFromArrays(SparsePosDef10by10.Order, SparsePosDef10by10.SkylineValues,
SparsePosDef10by10.SkylineDiagOffsets, true, true);
var expectedU = Matrix.CreateFromArray(SparsePosDef10by10.CholeskyU);
CholeskySkyline factorization = skyline.FactorCholesky(false);
TriangularUpper computedU = factorization.GetFactorU();
comparer.AssertEqual(expectedU, computedU);
//});
}
private static void TestArrayCopy()
{
var skyline = SkylineMatrix.CreateFromArrays(SparsePosDef10by10.Order,
SparsePosDef10by10.SkylineValues, SparsePosDef10by10.SkylineDiagOffsets, true, true);
comparer.AssertEqual(SparsePosDef10by10.Matrix, skyline.CopyToArray2D());
}
private static void TestAddSubmatrix()
{
var k1 = Matrix.CreateFromArray(GlobalMatrixAssembly.SubMatrix1);
var k2 = Matrix.CreateFromArray(GlobalMatrixAssembly.SubMatrix2);
var k3 = Matrix.CreateFromArray(GlobalMatrixAssembly.SubMatrix3);
var expectedK = Matrix.CreateFromArray(GlobalMatrixAssembly.GlobalMatrix);
var computedK = DokSymmetric.CreateEmpty(GlobalMatrixAssembly.GlobalOrder);
computedK.AddSubmatrixSymmetric(k1, GlobalMatrixAssembly.IndicesDictionary1);
computedK.AddSubmatrixSymmetric(k2, GlobalMatrixAssembly.IndicesDictionary2);
computedK.AddSubmatrixSymmetric(k3, GlobalMatrixAssembly.IndicesDictionary3);
comparer.AssertEqual(expectedK, computedK);
}
private static void TestBuildCSR()
{
var dense = Matrix.CreateFromArray(SparseRectangular10by5.Matrix);
DokColMajor dok = CreateDok(SparseRectangular10by5.Matrix);
// CSR with sorted col indices of each row
CscMatrix cscSorted = dok.BuildCscMatrix(true);
comparer.AssertEqual(dense, cscSorted);
// CSR without sorting
CscMatrix cscUnsorted = dok.BuildCscMatrix(false);
comparer.AssertEqual(dense, cscUnsorted);
}
private static void TestPosDefSystemSolution()
{
double pivotTolerance = 0.5;
int order = SparsePosDef10by10.Order;
var skyline = SkylineMatrix.CreateFromArrays(order, SparsePosDef10by10.SkylineValues,
SparsePosDef10by10.SkylineDiagOffsets, true, true);
var dok = DokColMajor.CreateFromSparseMatrix(skyline);
var b = Vector.CreateFromArray(SparsePosDef10by10.Rhs);
var xExpected = Vector.CreateFromArray(SparsePosDef10by10.Lhs);
(double[] cscValues, int[] cscRowIndices, int[] cscColOffsets) = dok.BuildCscArrays(true);
var factor = LUCSparseNet.Factorize(order, cscValues.Length, cscValues, cscRowIndices, cscColOffsets, pivotTolerance);
Vector xComputed = factor.SolveLinearSystem(b);
comparer.AssertEqual(xExpected, xComputed);
}
private static void TestFactorsLQ(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var A = Matrix.CreateFromArray(RectangularFullRank10by5.Matrix).Transpose();
Matrix expectedL = Matrix.CreateFromArray(RectangularFullRank10by5.LQFactorL);
Matrix expectedQ = Matrix.CreateFromArray(RectangularFullRank10by5.LQFactorQ);
LQFactorization factorization = A.FactorLQ();
Matrix computedL = factorization.GetFactorL();
Matrix computedQ = factorization.GetFactorQ();
comparer.AssertEqual(expectedL, computedL);
comparer.AssertEqual(expectedQ, computedQ);
});
}
private static void TestAxpy()
{
Skip.IfNot(TestSettings.TestMkl, TestSettings.MessageWhenSkippingMKL);
int n = 5;
double[] a = { 1, 2, 3, 4, 5 };
double[] b = { 10, 20, 30, 40, 50 };
double[] cExpected = MatrixOperations.LinearCombination(1.0, a, 1.0, b);
double[] cComputed = new double[5];
Array.Copy(b, cComputed, n);
CBlas.Daxpy(a.Length, 1.0, ref a[0], 1, ref cComputed[0], 1);
comparer.AssertEqual(cExpected, cComputed);
}
private static void TestDenseSystem(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var A = Matrix.CreateFromArray(SymmPosDef10by10.Matrix);
var b = Vector.CreateFromArray(SymmPosDef10by10.Rhs);
var xExpected = Vector.CreateFromArray(SymmPosDef10by10.Lhs);
var builder = new CGAlgorithm.Builder();
builder.ResidualTolerance = 1E-7;
builder.MaxIterationsProvider = new PercentageMaxIterationsProvider(1.0);
var cg = builder.Build();
var xComputed = Vector.CreateZero(A.NumRows);
IterativeStatistics stats = cg.Solve(A, b, xComputed, true);
comparer.AssertEqual(xExpected, xComputed);
});
}
private static void TestLinearCombination(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var v1 = Vector.CreateFromArray(TestVectors.Vector1);
var v2 = Vector.CreateFromArray(TestVectors.Vector2);
var expected = 2.5 * v1 + -3.5 * v2;
var comparer = new MatrixComparer();
// LinearCombination()
comparer.AssertEqual(expected, v1.LinearCombination(2.5, v2, -3.5));
// LinearCombinationIntoThis()
var temp = Vector.CreateFromVector(v1);
temp.LinearCombinationIntoThis(2.5, v2, -3.5);
comparer.AssertEqual(expected, temp);
});
}
private static void TestPosDefDenseSystem(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var A = Matrix.CreateFromArray(SymmPosDef10by10.Matrix);
var b = Vector.CreateFromArray(SymmPosDef10by10.Rhs);
var xExpected = Vector.CreateFromArray(SymmPosDef10by10.Lhs);
var builder = new PcgAlgorithm.Builder();
builder.ResidualTolerance = 1E-7;
builder.MaxIterationsProvider = new PercentageMaxIterationsProvider(1.0);
var pcg = builder.Build();
var M = new JacobiPreconditioner(A.GetDiagonalAsArray());
Vector xComputed = Vector.CreateZero(A.NumRows);
IterativeStatistics stats = pcg.Solve(A, M, b, xComputed, true, () => Vector.CreateZero(b.Length));
comparer.AssertEqual(xExpected, xComputed);
});
}
private static void TestAxpy(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var sparse = SparseVector.CreateFromArrays(SparseVector10.Length, SparseVector10.NonZeroValues,
SparseVector10.NonZeroIndices, true, false);
var dense = Vector.CreateFromArray(SparseVector10.OtherVector);
var expected = Vector.CreateFromArray(SparseVector10.OtherVectorPlusThisVectorTimes3);
// Axpy()
comparer.AssertEqual(expected, dense.Axpy(sparse, 3.0));
// AxpyIntoThis
var temp = Vector.CreateFromVector(dense);
temp.AxpyIntoThis(sparse, 3.0);
comparer.AssertEqual(expected, temp);
});
}
private static void TestMultipleSystemsSolution(/*LinearAlgebraProviderChoice providers*/)
{
//TestSettings.RunMultiproviderTest(providers, delegate () {
//
var skyline = SkylineMatrix.CreateFromArrays(SparsePosDef10by10.Order, SparsePosDef10by10.SkylineValues,
SparsePosDef10by10.SkylineDiagOffsets, true, true);
LdlSkyline factor = skyline.FactorLdl(false);
var identity = Matrix.CreateIdentity(SparsePosDef10by10.Order);
var inverse = Matrix.CreateZero(SparsePosDef10by10.Order, SparsePosDef10by10.Order);
factor.SolveLinearSystems(identity, inverse);
var matrixTimesInverse = MatrixOperations.MatrixTimesMatrix(SparsePosDef10by10.Matrix, inverse.CopyToArray2D());
comparer.AssertEqual(identity.CopyToArray2D(), matrixTimesInverse);
//});
}
private static void TestNearbyProblems(double noiseWidth, int maxIterations, int numRhsVectors)
{
int order = SymmPosDef10by10.Order;
var A = Matrix.CreateFromArray(SymmPosDef10by10.Matrix);
var builder = new ReorthogonalizedPcg.Builder();
builder.ResidualTolerance = 1E-6;
builder.MaxIterationsProvider = new PercentageMaxIterationsProvider(1.0);
builder.Convergence = new RhsNormalizedConvergence();
var pcg = builder.Build();
var M = new JacobiPreconditioner(A.GetDiagonalAsArray());
// Initial run
Vector x0 = Vector.CreateWithValue(order, 1);
Vector x0Expected = x0.Copy();
Vector b0 = A * x0Expected;
Vector x0Computed = Vector.CreateZero(A.NumRows);
IterativeStatistics stats0 = pcg.Solve(A, M, b0, x0Computed, true, () => Vector.CreateZero(order));
Debug.WriteLine($"Initial run: iterations = {stats0.NumIterationsRequired}");
comparer.AssertEqual(x0Expected, x0Computed);
// Subsequent runs
int seed = 345;
for (int i = 0; i < numRhsVectors; ++i)
{
Vector dx = Vector.CreateFromArray(RandomMatrices.CreateRandomVector(order, seed));
Vector xExpected = x0 + noiseWidth * dx;
Vector b = A * xExpected;
pcg.Clear(); //TODO: preferably do not call this.
//pcg.ReorthoCache.Clear();
Vector xComputed = Vector.CreateZero(A.NumRows);
IterativeStatistics stats = pcg.Solve(A, M, b, xComputed, true, () => Vector.CreateZero(b.Length));
Debug.WriteLine($"Subsequent run: iterations = {stats.NumIterationsRequired}");
comparer.AssertEqual(xExpected, xComputed);
Assert.InRange(stats.NumIterationsRequired, 1, maxIterations);
}
}
private static void TestIndefiniteSystem(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var comparer = new MatrixComparer(1E-4);
double residualTolerance = 1e-8;
(Matrix A, Vector b, Vector xExpected, IPreconditioner M) = DiagonalIndefinite.BuildIndefiniteSystem(20);
var minres = new MinRes(A.NumRows, residualTolerance, 0, false, false);
(IVector xComputed, MinresStatistics stats) = minres.Solve(A, b);
comparer.AssertEqual(xExpected, xComputed);
});
}
private static void TestCholeskySolver()
{
Skip.IfNot(TestSettings.TestSuiteSparse, TestSettings.MessageWhenSkippingSuiteSparse);
// Define linear system
const int n = 4;
const int nnz = 7;
int[] colOffsets = new int[n + 1] {
0, 1, 2, 5, nnz
};
int[] rowIndices = new int[nnz] {
0, 1, 0, 1, 2, 1, 3
};
double[] values = new double[nnz] {
4.0, 10.0, 2.0, 1.0, 8.0, 3.0, 9.0
};
double[] rhs = new double[n] {
6.0, 14.0, 11.0, 12.0
};
double[] solutionExpected = { 1.0, 1.0, 1.0, 1.0 };
double[] solution = new double[n];
// Solve it using SuiteSparse
IntPtr handle = SuiteSparsePInvokes.CreateCommon(0, 0);
int status = SuiteSparsePInvokes.FactorizeCSCUpper(n, nnz, values, rowIndices, colOffsets, out IntPtr factor, handle);
Assert.True(status == -1);
int nnzFactor = SuiteSparsePInvokes.GetFactorNonZeros(factor);
Console.WriteLine($"Before factorization: nnz = {nnz}");
Console.WriteLine($"After factorization: nnz = {nnzFactor}");
SuiteSparsePInvokes.Solve(0, n, 1, factor, rhs, solution, handle);
comparer.AssertEqual(solutionExpected, solution);
SuiteSparsePInvokes.DestroyFactor(ref factor, handle);
SuiteSparsePInvokes.DestroyCommon(ref handle);
}
private static void TestNormInf()
{
var A = Matrix.CreateFromArray(new double[, ]
{
{ -3, 5, 7 },
{ 2, 6, 4 },
{ 0, 2, 8 }
});
double normExpected = 15.0;
double normComputed = A.NormInf();
comparer.AssertEqual(normExpected, normComputed);
}
private static void TestPosDefSparseSystem(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var comparer = new MatrixComparer(1E-6);
int n = SparsePosDef10by10.Order;
var A = Matrix.CreateFromArray(SparsePosDef10by10.Matrix);
var b = Vector.CreateFromArray(SparsePosDef10by10.Rhs);
var xExpected = Vector.CreateFromArray(SparsePosDef10by10.Lhs);
var minres = new MinRes(n, 1e-10, 0, false, false);
(IVector xComputed, MinresStatistics stats) = minres.Solve(A, b);
comparer.AssertEqual(xExpected, xComputed);
});
}
private static void TestEigenvaluesAndEigenvectors(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
var A = Matrix.CreateFromArray(SymmPosDef10by10.Matrix);
var eigenvaluesExpected = Vector.CreateFromArray(SymmPosDef10by10.Eigenvalues);
var eigenvectorsExpected = Matrix.CreateFromArray(SymmPosDef10by10.Eigenvectors);
var eigensystem = SymmetricEigensystemFull.Create(A.NumRows, A.RawData, true);
// Check
comparer.AssertEqual(eigenvaluesExpected, eigensystem.EigenvaluesReal);
comparer.AssertEqual(eigenvectorsExpected, eigensystem.EigenvectorsRight);
Assert.True(eigensystem.EigenvaluesImaginary == null);
Assert.True(eigensystem.EigenvectorsLeft == null);
});
}
private static void TestConstruction()
{
// matrix 1
var A1Expected = Matrix.CreateFromArray(SignedBoolean5by10.A1);
SignedBooleanMatrixRowMajor A1Computed = CreateMatrix(SignedBoolean5by10.A1);
comparer.AssertEqual(A1Expected, A1Computed);
// matrix 2
var A2Expected = Matrix.CreateFromArray(SignedBoolean5by10.A2);
SignedBooleanMatrixRowMajor A2Computed = CreateMatrix(SignedBoolean5by10.A2);
comparer.AssertEqual(A2Expected, A2Computed);
}
private static void TestEconomyFactorsQ1R1(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
int m = RectangularFullRank10by5.NumRows;
int n = RectangularFullRank10by5.NumCols;
var A = Matrix.CreateFromArray(RectangularFullRank10by5.Matrix);
Matrix expectedQ1 = Matrix.CreateFromArray(RectangularFullRank10by5.QRFactorQ).GetSubmatrix(0, m, 0, n);
Matrix expectedR1 = Matrix.CreateFromArray(RectangularFullRank10by5.QRqrFactorR).GetSubmatrix(0, n, 0, n);
QRFactorization factorization = A.FactorQR();
Matrix computedQ1 = factorization.GetEconomyFactorQ();
TriangularUpper computedR1 = factorization.GetEconomyFactorR();
comparer.AssertEqual(expectedQ1, computedQ1);
comparer.AssertEqual(expectedR1, computedR1);
});
}
public static void TestLinearSystemSolution()
{
// Load matrix from a file.
var A = MatrixMarketReader.ReadMatrix <double>(PosDefMatrixPath);
int m = A.RowCount;
int n = A.ColumnCount;
Assert.True(m == n);
// Create test data.
var xExpected = CSparse.Double.Vector.Create(n, 1.0);
var b = new double[m];
// Compute right hand side vector b.
A.Multiply(1.0, xExpected, 0.0, b);
// Apply column ordering to A to reduce fill-in.
var order = ColumnOrdering.MinimumDegreeAtPlusA;
// Factorize
var xComputed = new double[n];
var chol = SparseCholesky.Create(A, order);
// Solve Ax = b (do not overwrite x).
chol.Solve(b, xComputed);
// Check the solution
comparer.AssertEqual(xExpected, xComputed);
// Compute residual b - Ax (do not overwrite b).
var r = new double[m];
Array.Copy(b, r, m);
A.Multiply(-1.0, xComputed, 1.0, r);
}
private static void TestArrayCopy()
{
// invertible
var A1 = TriangularLower.CreateFromArray(LowerInvertible10by10.Matrix);
comparer.AssertEqual(LowerInvertible10by10.Matrix, A1.CopyToArray2D());
// singular
var A2 = TriangularLower.CreateFromArray(LowerSingular10by10.Matrix);
comparer.AssertEqual(LowerSingular10by10.Matrix, A2.CopyToArray2D());
}
private static void TestDeterminantInvertiblePositive(LinearAlgebraProviderChoice providers)
{
TestSettings.RunMultiproviderTest(providers, delegate()
{
// invertible (rank = 10) with positive det
var A = Matrix.CreateFromArray(SquareInvertible10by10.Matrix);
LUFactorization factorization = A.FactorLU();
double det = factorization.CalcDeterminant();
comparer.AssertEqual(SquareInvertible10by10.Determinant, det);
});
}
