public void TestRandomA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { // Create A. MatrixF a = new MatrixF(3, 3); RandomHelper.Random.NextMatrixF(a, 0, 1); LUDecompositionF d = new LUDecompositionF(a); if (d.IsNumericallySingular == false) { // Check solving of linear equations. MatrixF b = new MatrixF(3, 2); RandomHelper.Random.NextMatrixF(b, 0, 1); MatrixF x = d.SolveLinearEquations(b); MatrixF b2 = a * x; Assert.IsTrue(MatrixF.AreNumericallyEqual(b, b2, 0.01f)); MatrixF aPermuted = d.L * d.U; Assert.IsTrue(MatrixF.AreNumericallyEqual(aPermuted, a.GetSubmatrix(d.PivotPermutationVector, 0, 2))); } } }
public void TestMatricesWithoutFullRank() { MatrixF a = new MatrixF(3, 3); QRDecompositionF qr = new QRDecompositionF(a); Assert.AreEqual(false, qr.HasNumericallyFullRank); a = new MatrixF(new float[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 4, 5, 6 } }); qr = new QRDecompositionF(a); Assert.AreEqual(false, qr.HasNumericallyFullRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, qr.Q * qr.R)); qr = new QRDecompositionF(a.Transposed); Assert.AreEqual(false, qr.HasNumericallyFullRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a.Transposed, qr.Q * qr.R)); a = new MatrixF(new float[, ] { { 1, 2 }, { 1, 2 }, { 1, 2 } }); qr = new QRDecompositionF(a); Assert.AreEqual(false, qr.HasNumericallyFullRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, qr.Q * qr.R)); MatrixF h = qr.H; // Just call this one to see if it runs through. }
public void TestRandomSquareA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { // Create A. MatrixF a = new MatrixF(3, 3); RandomHelper.Random.NextMatrixF(a, 0, 1); QRDecompositionF d = new QRDecompositionF(a); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.Q * d.R)); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.Q * d.R)); // Second time with the cached values. // Check solving of linear equations. if (d.HasNumericallyFullRank) { MatrixF b = new MatrixF(3, 2); RandomHelper.Random.NextMatrixF(b, 0, 1); MatrixF x = d.SolveLinearEquations(b); MatrixF b2 = a * x; Assert.IsTrue(MatrixF.AreNumericallyEqual(b, b2, 0.01f)); } MatrixF h = d.H; // Just call this one to see if it runs through. h = d.H; // Call it secont time to cover code with internal caching. } }
public void TestRandomRectangularA() { RandomHelper.Random = new Random(1); // Every transpose(A) * A is SPD if A has full column rank and m>n. for (int i = 0; i < 100; i++) { // Create A. MatrixF a = new MatrixF(10, 3); RandomHelper.Random.NextMatrixF(a, 0, 1); QRDecompositionF d = new QRDecompositionF(a); MatrixF b = new MatrixF(10, 1); RandomHelper.Random.NextMatrixF(b, 0, 1); MatrixF x = d.SolveLinearEquations(b); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.Q * d.R)); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.Q * d.R)); // Second time with the cached values. // Check solving of linear equations. if (d.HasNumericallyFullRank) { // Compare with Least squares solution (Gauss-Transformation and Cholesky). MatrixF spdMatrix = a.Transposed * a; CholeskyDecompositionF ch = new CholeskyDecompositionF(spdMatrix); MatrixF x2 = ch.SolveLinearEquations(a.Transposed * b); Assert.IsTrue(MatrixF.AreNumericallyEqual(x, x2, 0.0001f)); } MatrixF h = d.H; // Just call this one to see if it runs through. } }
public void TestMatricesWithFullRank() { MatrixF a = new MatrixF(new float[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, -9 } }); SingularValueDecompositionF svd = new SingularValueDecompositionF(a); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); float condNumber = svd.ConditionNumber; svd = new SingularValueDecompositionF(a.Transposed); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; a = new MatrixF(new float[, ] { { 1, 2 }, { 4, 5 }, { 4, 5 } }); svd = new SingularValueDecompositionF(a); Assert.AreEqual(2, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; }
public void TestRandomRegularA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { VectorF column1 = new VectorF(3); RandomHelper.Random.NextVectorF(column1, 1, 2); VectorF column2 = new VectorF(3); RandomHelper.Random.NextVectorF(column2, 1, 2); // Make linearly independent. if (column1 / column1[0] == column2 / column2[0]) { column2[0]++; } // Create linearly independent third column. VectorF column3 = column1 + column2; column3[1]++; // Create A. MatrixF a = new MatrixF(3, 3); a.SetColumn(0, column1); a.SetColumn(1, column2); a.SetColumn(2, column3); SingularValueDecompositionF svd = new SingularValueDecompositionF(a); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); float condNumber = svd.ConditionNumber; } }
public void TestRandomRectangularA() { RandomHelper.Random = new Random(1); // Every transpose(A) * A is SPD if A has full column rank and m>n. for (int i = 0; i < 100; i++) { // Create A. MatrixF a = new MatrixF(4, 3); RandomHelper.Random.NextMatrixF(a, 0, 1); // Check for full rank with QRD. QRDecompositionF d = new QRDecompositionF(a); SingularValueDecompositionF svd = new SingularValueDecompositionF(a); if (d.HasNumericallyFullRank) { // Rank should be full. Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); } else { // Not full rank - we dont know much, just see if it runs through Assert.Greater(3, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); } Assert.AreEqual(svd.SingularValues[0], svd.Norm2); float condNumber = svd.ConditionNumber; } }
public void TestMatricesWithoutFullRank() { MatrixF a = new MatrixF(3, 3); SingularValueDecompositionF svd = new SingularValueDecompositionF(a); Assert.AreEqual(0, svd.NumericalRank); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); float condNumber = svd.ConditionNumber; a = new MatrixF(new float[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 4, 5, 6 } }); svd = new SingularValueDecompositionF(a); Assert.AreEqual(2, svd.NumericalRank); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); svd = new SingularValueDecompositionF(a.Transposed); Assert.AreEqual(2, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); Assert.IsTrue(MatrixF.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); // Repeat to test with cached values. Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; a = new MatrixF(new float[, ] { { 1, 2 }, { 1, 2 }, { 1, 2 } }); svd = new SingularValueDecompositionF(a); Assert.AreEqual(1, svd.NumericalRank); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; }
public void Test2() { // Every transpose(A)*A is SPD if A has full column rank and m > n. MatrixF a = new MatrixF(new float[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, -12 } }); //MatrixF a = new MatrixF(new float[,] { { 1, 2}, // { 4, 5}, // { 7, 8}}); a = a.Transposed * a; CholeskyDecompositionF d = new CholeskyDecompositionF(a); Assert.AreEqual(true, d.IsSymmetricPositiveDefinite); MatrixF l = d.L; Assert.AreEqual(0, l[0, 1]); Assert.AreEqual(0, l[0, 2]); Assert.AreEqual(0, l[1, 2]); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, l * l.Transposed)); }
public void Test1() { MatrixF a = new MatrixF(new float[, ] { { 2, -1, 0 }, { -1, 2, -1 }, { 0, -1, 2 } }); CholeskyDecompositionF d = new CholeskyDecompositionF(a); Assert.AreEqual(true, d.IsSymmetricPositiveDefinite); MatrixF l = d.L; Assert.AreEqual(0, l[0, 1]); Assert.AreEqual(0, l[0, 2]); Assert.AreEqual(0, l[1, 2]); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, l * l.Transposed)); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, l * l.Transposed)); // Check solving of linear equations. MatrixF x = new MatrixF(new float[, ] { { 1, 2 }, { 3, 4 }, { 5, 6 } }); MatrixF b = a * x; Assert.IsTrue(MatrixF.AreNumericallyEqual(x, d.SolveLinearEquations(b))); }
public void TestRandomSpdA() { RandomHelper.Random = new Random(1); // Every transpose(A) * A is SPD if A has full column rank and m>n. for (int i = 0; i < 100; i++) { VectorF column1 = new VectorF(4); RandomHelper.Random.NextVectorF(column1, 1, 2); VectorF column2 = new VectorF(4); RandomHelper.Random.NextVectorF(column2, 1, 2); // Make linearly independent. if (column1 / column1[0] == column2 / column2[0]) { column2[0]++; } // Create linearly independent third column. VectorF column3 = column1 + column2; column3[1]++; // Create A. MatrixF a = new MatrixF(4, 3); a.SetColumn(0, column1); a.SetColumn(1, column2); a.SetColumn(2, column3); MatrixF spdMatrix = a.Transposed * a; CholeskyDecompositionF d = new CholeskyDecompositionF(spdMatrix); Assert.AreEqual(true, d.IsSymmetricPositiveDefinite); MatrixF l = d.L; // Test if L is a lower triangular matrix. for (int j = 0; j < l.NumberOfRows; j++) { for (int k = 0; k < l.NumberOfColumns; k++) { if (j < k) { Assert.AreEqual(0, l[j, k]); } } } Assert.IsTrue(MatrixF.AreNumericallyEqual(spdMatrix, l * l.Transposed)); // Check solving of linear equations. MatrixF b = new MatrixF(3, 2); RandomHelper.Random.NextMatrixF(b, 0, 1); MatrixF x = d.SolveLinearEquations(b); MatrixF b2 = spdMatrix * x; Assert.IsTrue(MatrixF.AreNumericallyEqual(b, b2, 0.01f)); } }
public void Test2() { MatrixF a = new MatrixF(new float[, ] { { 0, 1, 2 }, { 1, 4, 3 }, { 2, 3, 5 } }); EigenvalueDecompositionF d = new EigenvalueDecompositionF(a); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.V * d.D * d.V.Transposed)); }
public void Test1() { MatrixF a = new MatrixF(new float[, ] { { 1, -1, 4 }, { 3, 2, -1 }, { 2, 1, -1 } }); EigenvalueDecompositionF d = new EigenvalueDecompositionF(a); Assert.IsTrue(MatrixF.AreNumericallyEqual(a * d.V, d.V * d.D)); }
public void Determinant() { MatrixF a = new MatrixF(new float[, ] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 0, 1, 2, 0 }, { 1, 0, 1, 0 } }); LUDecompositionF d = new LUDecompositionF(a); Assert.AreEqual(false, d.IsNumericallySingular); Assert.IsTrue(Numeric.AreEqual(-24, d.Determinant())); MatrixF aPermuted = d.L * d.U; Assert.IsTrue(MatrixF.AreNumericallyEqual(aPermuted, a.GetSubmatrix(d.PivotPermutationVector, 0, 3))); }
public void TestRandomRegularA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { VectorF column1 = new VectorF(3); RandomHelper.Random.NextVectorF(column1, 1, 2); VectorF column2 = new VectorF(3); RandomHelper.Random.NextVectorF(column2, 1, 2); // Make linearly independent. if (column1 / column1[0] == column2 / column2[0]) { column2[0]++; } // Create linearly independent third column. VectorF column3 = column1 + column2; column3[1]++; // Create A. MatrixF a = new MatrixF(3, 3); a.SetColumn(0, column1); a.SetColumn(1, column2); a.SetColumn(2, column3); LUDecompositionF d = new LUDecompositionF(a); MatrixF aPermuted = d.L * d.U; Assert.IsTrue(MatrixF.AreNumericallyEqual(aPermuted, a.GetSubmatrix(d.PivotPermutationVector, 0, 2))); aPermuted = d.L * d.U; // Repeat with to test cached values. Assert.IsTrue(MatrixF.AreNumericallyEqual(aPermuted, a.GetSubmatrix(d.PivotPermutationVector, 0, 2))); Assert.AreEqual(false, d.IsNumericallySingular); // Check solving of linear equations. MatrixF b = new MatrixF(3, 2); RandomHelper.Random.NextMatrixF(b, 0, 1); MatrixF x = d.SolveLinearEquations(b); MatrixF b2 = a * x; Assert.IsTrue(MatrixF.AreNumericallyEqual(b, b2, 0.01f)); } }
public void TestRandomRegularA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { VectorF column1 = new VectorF(3); RandomHelper.Random.NextVectorF(column1, 1, 2); VectorF column2 = new VectorF(3); RandomHelper.Random.NextVectorF(column2, 1, 2); // Make linearly independent. if (column1 / column1[0] == column2 / column2[0]) { column2[0]++; } // Create linearly independent third column. VectorF column3 = column1 + column2; column3[1]++; // Create A. MatrixF a = new MatrixF(3, 3); a.SetColumn(0, column1); a.SetColumn(1, column2); a.SetColumn(2, column3); QRDecompositionF d = new QRDecompositionF(a); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.Q * d.R)); Assert.IsTrue(MatrixF.AreNumericallyEqual(a, d.Q * d.R)); // Second time with the cached values. Assert.AreEqual(true, d.HasNumericallyFullRank); // Check solving of linear equations. MatrixF b = new MatrixF(3, 2); RandomHelper.Random.NextMatrixF(b, 0, 1); MatrixF x = d.SolveLinearEquations(b); MatrixF b2 = a * x; Assert.IsTrue(MatrixF.AreNumericallyEqual(b, b2, 0.01f)); MatrixF h = d.H; // Just call this one to see if it runs through. h = d.H; // Call it secont time to cover code with internal caching. } }