public void TestRandomRegularA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { VectorD column1 = new VectorD(3); RandomHelper.Random.NextVectorD(column1, 1, 2); VectorD column2 = new VectorD(3); RandomHelper.Random.NextVectorD(column2, 1, 2); // Make linearly independent. if (column1 / column1[0] == column2 / column2[0]) { column2[0]++; } // Create linearly independent third column. VectorD column3 = column1 + column2; column3[1]++; // Create A. MatrixD a = new MatrixD(3, 3); a.SetColumn(0, column1); a.SetColumn(1, column2); a.SetColumn(2, column3); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; } }
public void TestMatricesWithoutFullRank() { MatrixD a = new MatrixD(3, 3); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); Assert.AreEqual(0, svd.NumericalRank); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; a = new MatrixD(new double[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 4, 5, 6 } }); svd = new SingularValueDecompositionD(a); Assert.AreEqual(2, svd.NumericalRank); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); svd = new SingularValueDecompositionD(a.Transposed); Assert.AreEqual(2, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); Assert.IsTrue(MatrixD.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 MatrixD(new double[, ] { { 1, 2 }, { 1, 2 }, { 1, 2 } }); svd = new SingularValueDecompositionD(a); Assert.AreEqual(1, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; }
public void TestMatricesWithFullRank() { MatrixD a = new MatrixD(new double[, ] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, -9 } }); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; svd = new SingularValueDecompositionD(a.Transposed); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; a = new MatrixD(new double[, ] { { 1, 2 }, { 4, 5 }, { 4, 5 } }); svd = new SingularValueDecompositionD(a); Assert.AreEqual(2, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); 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. MatrixD a = new MatrixD(4, 3); RandomHelper.Random.NextMatrixD(a, 0, 1); // Check for full rank with QRD. QRDecompositionD d = new QRDecompositionD(a); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); if (d.HasNumericallyFullRank) { // Rank should be full. Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.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(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); } Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; } }
public void TestMatricesWithoutFullRank() { MatrixD a = new MatrixD(3, 3); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); Assert.AreEqual(0, svd.NumericalRank); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; a = new MatrixD(new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 4, 5, 6 } }); svd = new SingularValueDecompositionD(a); Assert.AreEqual(2, svd.NumericalRank); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); svd = new SingularValueDecompositionD(a.Transposed); Assert.AreEqual(2, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); Assert.IsTrue(MatrixD.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 MatrixD(new double[,] { { 1, 2 }, { 1, 2 }, { 1, 2 } }); svd = new SingularValueDecompositionD(a); Assert.AreEqual(1, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; }
public void TestMatricesWithFullRank() { MatrixD a = new MatrixD(new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, -9 } }); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; svd = new SingularValueDecompositionD(a.Transposed); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; a = new MatrixD(new double[,] { { 1, 2 }, { 4, 5 }, { 4, 5 } }); svd = new SingularValueDecompositionD(a); Assert.AreEqual(2, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); condNumber = svd.ConditionNumber; }
public void TestWithNaNValues() { MatrixD a = new MatrixD(new[, ] { { 0, double.NaN, 2 }, { 1, 4, 3 }, { 2, 3, 5 } }); var d = new SingularValueDecompositionD(a); foreach (var element in d.SingularValues.ToList()) { Assert.IsNaN(element); } foreach (var element in d.U.ToList(MatrixOrder.RowMajor)) { Assert.IsNaN(element); } foreach (var element in d.V.ToList(MatrixOrder.RowMajor)) { Assert.IsNaN(element); } d = new SingularValueDecompositionD(new MatrixD(4, 3, double.NaN)); foreach (var element in d.SingularValues.ToList()) { Assert.IsNaN(element); } foreach (var element in d.U.ToList(MatrixOrder.RowMajor)) { Assert.IsNaN(element); } foreach (var element in d.V.ToList(MatrixOrder.RowMajor)) { Assert.IsNaN(element); } }
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. MatrixD a = new MatrixD(4, 3); RandomHelper.Random.NextMatrixD(a, 0, 1); // Check for full rank with QRD. QRDecompositionD d = new QRDecompositionD(a); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); if (d.HasNumericallyFullRank) { // Rank should be full. Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.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(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); } Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; } }
public void TestWithNaNValues() { MatrixD a = new MatrixD(new[,] {{ 0, double.NaN, 2 }, { 1, 4, 3 }, { 2, 3, 5}}); var d = new SingularValueDecompositionD(a); foreach (var element in d.SingularValues.ToList()) Assert.IsNaN(element); foreach (var element in d.U.ToList(MatrixOrder.RowMajor)) Assert.IsNaN(element); foreach (var element in d.V.ToList(MatrixOrder.RowMajor)) Assert.IsNaN(element); d = new SingularValueDecompositionD(new MatrixD(4, 3, double.NaN)); foreach (var element in d.SingularValues.ToList()) Assert.IsNaN(element); foreach (var element in d.U.ToList(MatrixOrder.RowMajor)) Assert.IsNaN(element); foreach (var element in d.V.ToList(MatrixOrder.RowMajor)) Assert.IsNaN(element); }
public void TestRandomRegularA() { RandomHelper.Random = new Random(1); for (int i = 0; i < 100; i++) { VectorD column1 = new VectorD(3); RandomHelper.Random.NextVectorD(column1, 1, 2); VectorD column2 = new VectorD(3); RandomHelper.Random.NextVectorD(column2, 1, 2); // Make linearly independent. if (column1 / column1[0] == column2 / column2[0]) column2[0]++; // Create linearly independent third column. VectorD column3 = column1 + column2; column3[1]++; // Create A. MatrixD a = new MatrixD(3, 3); a.SetColumn(0, column1); a.SetColumn(1, column2); a.SetColumn(2, column3); SingularValueDecompositionD svd = new SingularValueDecompositionD(a); Assert.AreEqual(3, svd.NumericalRank); Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed)); Assert.AreEqual(svd.SingularValues[0], svd.Norm2); double condNumber = svd.ConditionNumber; } }