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); }); }