internal static void CheckNullSpace(IMatrixView unfactorizedMatrix, IReadOnlyList <double[]> nullSpaceBasis,
double tolerance)
{
var comparer = new MatrixComparer(tolerance);
// Check that each vector belongs to the nullspace
int order = unfactorizedMatrix.NumColumns;
//var zeroVector = Vector.CreateZero(order);
int nullity = nullSpaceBasis.Count;
var nullSpaceMatrix = Matrix.CreateZero(order, nullity);
for (int j = 0; j < nullity; ++j)
{
var x = Vector.CreateFromArray(nullSpaceBasis[j]);
nullSpaceMatrix.SetSubcolumn(j, x);
// Check that each vector belongs to the nullspace
IVector Ax = unfactorizedMatrix.Multiply(x);
double normAx = Ax.Norm2() / Ax.Length;
//comparer.AssertEqual(0.0, normAx);
}
// Check that the vectors are independent.
// TODO: perhaps this should be included in the LinearAlgebra project, not just for tests.
(Matrix rref, List <int> independentCols) = nullSpaceMatrix.ReducedRowEchelonForm(tolerance);
for (int j = 0; j < nullity; ++j)
{
Assert.Contains(j, independentCols);
}
}
public void Test_Matrix_Transformation_with_5X5_Matrix()
{
// prepare the input/test data
int[,] source = new int[, ] {
{ 10, 20, 30, 40, 5 },
{ 20, 30, 40, 50, 7 },
{ 20, 30, 40, 50, 8 },
{ 20, 30, 40, 50, 0 },
{ 100, 200, 300, 400, 500 }
};
// define the expected result
var expected = new int[, ] {
{ 100, 20, 20, 20, 10 },
{ 200, 30, 30, 30, 20 },
{ 300, 40, 40, 40, 30 },
{ 400, 50, 50, 50, 40 },
{ 500, 0, 8, 7, 5 }
};
// do the test
MatrixTransformations.Transform90DegreeInPlace(source);
// validate/verify the output of the method with the expected output
Assert.IsTrue(MatrixComparer.AreSame(source, expected));
}
public void TestDropZeros(int size)
{
var A = MatrixLoader.A(size);
double threshold = 1.0e-5;
var B = A.Clone() as SparseMatrix;
foreach (var item in A.EnumerateIndexed(Zeros.AllowSkip))
{
int i = item.Item1;
int j = item.Item2;
if (i != j)
{
// Make all off-diagonal entries small.
B[i, j] = threshold / 10;
}
}
var C = B.Clone() as SparseMatrix;
B.CoerceZero(threshold);
C.DropZeros(threshold);
Assert.IsTrue(MatrixComparer.Equals(B, C, EPS));
}
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);
}
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 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 void NotSameSizedMatricesTest()
{
var matrix1 = new Matrix(100, 1);
var matrix2 = new Matrix(101, 1);
Assert.IsFalse(MatrixComparer.Compare(matrix1, matrix2));
}
public void TestZeroSettingWhenMatrixHasOneZero()
{
int[,] input = new int[3, 3]
{
{
1, 0, 3
},
{
1, 2, 3
},
{
1, 2, 3
}
};
int[,] expected = new int[3, 3]
{
{
0, 0, 0
},
{
1, 0, 3
},
{
1, 0, 3
}
};
ZeroColumnRowSetter.SetZeroValue(input);
bool isEqual = MatrixComparer.Are2DEqual(input, expected);
Assert.IsTrue(isEqual);
}
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 void BigNotEqualMatricesTest()
{
var matrix1 = new Matrix(1000, 1000, 1);
var matrix2 = new Matrix(1000, 1000, 1);
matrix2[900, 34] = -1;
Assert.IsFalse(MatrixComparer.Compare(matrix1, matrix2));
}
public void EmptyMatricesTest()
{
var matrix1 = new Matrix(new int[0, 0] {
});
var matrix2 = new Matrix(new int[0, 0] {
});
Assert.IsTrue(MatrixComparer.Compare(matrix2, matrix1));
}
public void EqualMatricesTest()
{
var matrix1 = new Matrix(new int[, ] {
{ 1, 2, 3 },
{ 4, 5, 6 }
});
Assert.IsTrue(MatrixComparer.Compare(matrix1, matrix1));
}
public void NotRandomGenerationTest()
{
var matrix1 = new Matrix(2, 2, 2);
var matrix2 = new Matrix(new int[, ] {
{ 2, 2 },
{ 2, 2 }
});
Assert.IsTrue(MatrixComparer.Compare(matrix1, matrix2));
}
public void TestAdd(int size)
{
var A = MatrixLoader.A(size);
var B = MatrixLoader.B(size, false);
var C = A.Add(B);
var D = A.FastAdd(B);
Assert.IsTrue(MatrixComparer.Equals(C, D, EPS));
}
public void TestNormalizeColumns(int size)
{
var A = MatrixLoader.A(size);
var B = A.NormalizeColumns(1);
A.FastNormalizeColumns(1);
Assert.IsTrue(MatrixComparer.Equals(A, B, EPS));
}
public void TestSpiralTraversalWithMatrix_0_X_0()
{
int[,] inputArray = new int[, ] {
};
int[] expectedResult = new int[] { };
var actualResult = ArrayTraversals.TraverseArrayInSpiralOrder(inputArray);
Assert.IsTrue(MatrixComparer.AreSame(expectedResult, actualResult));
}
private void ArrayAntiDiagonalOrderTestMethod(int[,] inputArray, IList <int[]> expectedResult)
{
var actualResult = ArrayTraversals.TraverseArrayInAntiDiagonalOrder(inputArray);
Assert.AreEqual(actualResult.Count, expectedResult.Count);
for (int i = 0; i < expectedResult.Count; i++)
{
Assert.IsTrue(MatrixComparer.AreSame(expectedResult[i], actualResult[i]));
}
}
public void TestUpperTriangle(int size)
{
var A = MatrixLoader.A(size);
var B = A.UpperTriangle() as SparseMatrix;
var C = A.Clone() as SparseMatrix;
C.FastUpperTriangle();
Assert.IsTrue(MatrixComparer.Equals(B, C, EPS));
}
public void TestTranspose(int size)
{
var A = MatrixLoader.A(size);
var B = A.Transpose();
var C = CreateSparse.Zeros(A.ColumnCount, A.RowCount, A.NonZerosCount);
A.FastTranspose(C);
Assert.IsTrue(MatrixComparer.Equals(B, C, EPS));
}
public void WorkWithFileTest()
{
var matrix1 = new Matrix(new int[, ] {
{ 1, 2, 3 },
{ 1, 2, 3 }
});
matrix1.WriteToFile("Matrix1.txt");
var matrix2 = new Matrix("Matrix1.txt");
Assert.IsTrue(MatrixComparer.Compare(matrix1, matrix2));
}
public void BigMatricesMultiplicationTest()
{
const int size = 100;
var matrix1 = new Matrix(size, size, 1);
var matrix2 = new Matrix(size, size, 2);
var matrix3 = new Matrix(size, size, size * 2);
var matrix4 = MatrixMultiplier.MultiplyConcurrently(matrix1, matrix2);
var matrix5 = MatrixMultiplier.MultiplySequentally(matrix1, matrix2);
Assert.IsTrue(MatrixComparer.Compare(matrix4, matrix3));
Assert.IsTrue(MatrixComparer.Compare(matrix5, matrix3));
}
public void TestKroneckerProduct(int size)
{
var A = MatrixLoader.A(size);
var E = DenseMatrix.OfColumnMajor(2, 2, new[] { 1.0, 1.0, 1.0, 1.0 });
var S = SparseMatrix.OfMatrix(E);
var B = S.KroneckerProduct(A);
var C = S.FastKroneckerProduct(A);
Assert.IsTrue(MatrixComparer.Equals(B, C, EPS));
}
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);
});
}
public void TestInvertLowerTriangle()
{
var A = DenseMatrix.Build.Random(N, N, RAND_SEED);
var L = (DenseMatrix)A.LowerTriangle();
var S = (DenseMatrix)L.Inverse();
L.InvertLowerTriangle();
// Shouldn't use random matrix: can be ill-conditioned.
Assert.IsTrue(MatrixComparer.Equals(S, L, 1000 * EPS));
}
public void TestSpiralTraversalWithMatrix_5_X_1()
{
int[,] inputArray = new int[, ] {
{ 1 }, { 5 }, { 6 }, { 7 }, { 10 }
};
int[] expectedResult = new int[] { 1, 5, 6, 7, 10 };
var actualResult = ArrayTraversals.TraverseArrayInSpiralOrder(inputArray);
Assert.IsTrue(MatrixComparer.AreSame(expectedResult, actualResult));
}
public void EmptyMatricesTest()
{
var matrix1 = new Matrix(new int[0, 0] {
});
var matrix2 = new Matrix(new int[0, 0] {
});
var matrix3 = MatrixMultiplier.MultiplyConcurrently(matrix1, matrix2);
Assert.IsTrue(MatrixComparer.Compare(matrix3, matrix1));
var matrix4 = MatrixMultiplier.MultiplySequentally(matrix1, matrix2);
Assert.IsTrue(MatrixComparer.Compare(matrix4, matrix1));
}
public void NotEqualMatricesTest()
{
var matrix1 = new Matrix(new int[, ] {
{ 1, 2, 3 },
{ 4, 5, 6 }
});
var matrix2 = new Matrix(new int[, ] {
{ 1, 2, 3 },
{ 4, -5, 6 }
});
Assert.IsFalse(MatrixComparer.Compare(matrix1, matrix2));
}
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);
});
}
public void TestPermuteRows(int size)
{
var A = MatrixLoader.A(size);
var p = Util.Permutation(A.RowCount, RAND_SEED);
var B = A.Clone() as SparseMatrix;
var C = A.Clone() as SparseMatrix;
B.PermuteRows(new Permutation(p));
C.FastPermuteRows(p);
Assert.IsTrue(MatrixComparer.Equals(B, C, EPS));
}
