From 3a08ed3463d1c91f9c1410419a87f7a1659ddcb8 Mon Sep 17 00:00:00 2001 From: Marcus Cuda Date: Mon, 4 Apr 2011 19:30:59 +0800 Subject: [PATCH] tests: removed redundant matrix copying from factorization test to speed things up --- .../Complex/Factorization/CholeskyTests.cs | 12 +++--- .../Complex/Factorization/EvdTests.cs | 37 +++++++++------- .../Complex/Factorization/GramSchmidtTests.cs | 42 ++++++++++--------- .../Complex/Factorization/QRTests.cs | 31 +++++++------- .../Complex/Factorization/SvdTests.cs | 38 ++++++++++------- .../Factorization/UserCholeskyTests.cs | 12 +++--- .../Complex/Factorization/UserEvdTests.cs | 41 ++++++++++-------- .../Factorization/UserGramSchmidtTests.cs | 42 ++++++++++--------- .../Complex/Factorization/UserQRTests.cs | 32 +++++++------- .../Complex/Factorization/UserSvdTests.cs | 38 ++++++++++------- .../Complex32/Factorization/CholeskyTests.cs | 12 +++--- .../Complex32/Factorization/EvdTests.cs | 39 ++++++++++------- .../Factorization/GramSchmidtTests.cs | 42 ++++++++++--------- .../Complex32/Factorization/QRTests.cs | 33 ++++++++------- .../Complex32/Factorization/SvdTests.cs | 38 ++++++++++------- .../Factorization/UserCholeskyTests.cs | 12 +++--- .../Complex32/Factorization/UserEvdTests.cs | 41 ++++++++++-------- .../Factorization/UserGramSchmidtTests.cs | 42 ++++++++++--------- .../Complex32/Factorization/UserQRTests.cs | 33 ++++++++------- .../Complex32/Factorization/UserSvdTests.cs | 38 ++++++++++------- .../Double/Factorization/CholeskyTests.cs | 12 +++--- .../Double/Factorization/EvdTests.cs | 41 ++++++++++-------- .../Double/Factorization/GramSchmidtTests.cs | 38 +++++++++-------- .../Double/Factorization/QRTests.cs | 31 +++++++------- .../Double/Factorization/SvdTests.cs | 38 ++++++++++------- .../Double/Factorization/UserCholeskyTests.cs | 12 +++--- .../Double/Factorization/UserEvdTests.cs | 41 ++++++++++-------- .../Factorization/UserGramSchmidtTests.cs | 40 ++++++++++-------- .../Double/Factorization/UserQRTests.cs | 31 +++++++------- .../Double/Factorization/UserSvdTests.cs | 38 ++++++++++------- .../Single/Factorization/CholeskyTests.cs | 12 +++--- .../Single/Factorization/EvdTests.cs | 41 ++++++++++-------- .../Single/Factorization/GramSchmidtTests.cs | 40 ++++++++++-------- .../Single/Factorization/QRTests.cs | 31 +++++++------- .../Single/Factorization/SvdTests.cs | 38 ++++++++++------- .../Single/Factorization/UserCholeskyTests.cs | 12 +++--- .../Single/Factorization/UserEvdTests.cs | 41 ++++++++++-------- .../Factorization/UserGramSchmidtTests.cs | 40 ++++++++++-------- .../Single/Factorization/UserQRTests.cs | 31 +++++++------- .../Single/Factorization/UserSvdTests.cs | 38 ++++++++++------- 40 files changed, 731 insertions(+), 570 deletions(-) diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs index 4d9adf1e..af861a5c 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs @@ -45,16 +45,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = DenseMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex.One : Complex.Zero, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? Complex.One : Complex.Zero, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs index daf08d58..edc99226 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs @@ -56,16 +56,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = DenseMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -78,16 +81,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); Assert.AreEqual(order, factorEvd.D().RowCount); Assert.AreEqual(order, factorEvd.D().ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * factorEvd.D(); for (var i = 0; i < matrixAv.RowCount; i++) { @@ -112,15 +116,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order); var factorEvd = matrixA.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().ConjugateTranspose(); + var matrix = eigenVectors * d * eigenVectors.ConjugateTranspose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs index 52e18b6d..1f7660ed 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs @@ -65,36 +65,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = DenseMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex.One, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex.One, r[i, j]); } else { - Assert.AreEqual(Complex.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex.One, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex.One, q[i, j]); } else { - Assert.AreEqual(Complex.Zero, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex.Zero, q[i, j]); } } } @@ -122,29 +124,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) @@ -154,7 +158,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization } // Make sure the Q is unitary --> (Q*)x(Q) = I - var matrixQсtQ = factorGramSchmidt.Q.ConjugateTranspose() * factorGramSchmidt.Q; + var matrixQсtQ = q.ConjugateTranspose() * q; for (var i = 0; i < matrixQсtQ.RowCount; i++) { for (var j = 0; j < matrixQсtQ.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs index b5454abc..605cd190 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs @@ -65,21 +65,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = DenseMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorQR.R[i, j].Magnitude); + Assert.AreEqual(1.0, r[i, j].Magnitude); } else { - Assert.AreEqual(Complex.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } @@ -107,29 +108,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs index 15b35793..15609d40 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs @@ -56,21 +56,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = DenseMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex.One : Complex.Zero, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? Complex.One : Complex.Zero, w[i, j]); } } } @@ -85,21 +88,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs index 223e2627..2b4d5480 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs @@ -44,16 +44,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = UserDefinedMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex.One : Complex.Zero, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? Complex.One : Complex.Zero, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs index ac21cfa2..b39fd976 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs @@ -55,16 +55,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -77,16 +80,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * d; for (var i = 0; i < matrixAv.RowCount; i++) { @@ -106,15 +111,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().ConjugateTranspose(); + var matrix = eigenVectors * d * eigenVectors.ConjugateTranspose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs index bb6c417b..7a830d26 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs @@ -63,36 +63,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex.One, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex.One, r[i, j]); } else { - Assert.AreEqual(Complex.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex.One, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex.One, q[i, j]); } else { - Assert.AreEqual(Complex.Zero, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex.Zero, q[i, j]); } } } @@ -120,29 +122,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) @@ -152,7 +156,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization } // Make sure the Q is unitary --> (Q*)x(Q) = I - var matrixQсtQ = factorGramSchmidt.Q.ConjugateTranspose() * factorGramSchmidt.Q; + var matrixQсtQ = q.ConjugateTranspose() * q; for (var i = 0; i < matrixQсtQ.RowCount; i++) { for (var j = 0; j < matrixQсtQ.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs index 7007e944..d5d9779f 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs @@ -64,21 +64,23 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorQR = matrixI.QR(); + var q = factorQR.Q; + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(-Complex.One, factorQR.R[i, j]); + Assert.AreEqual(-Complex.One, r[i, j]); } else { - Assert.AreEqual(Complex.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } @@ -106,29 +108,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs index 69d23718..94e8b6ff 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs @@ -55,21 +55,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex.One : Complex.Zero, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? Complex.One : Complex.Zero, w[i, j]); } } } @@ -84,21 +87,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/CholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/CholeskyTests.cs index 1496ef23..8f387257 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/CholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/CholeskyTests.cs @@ -44,16 +44,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = DenseMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs index f9c48e96..ba705c01 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs @@ -57,16 +57,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = DenseMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); for (var i = 0; i < factorEvd.EigenValues().Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -79,16 +82,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * factorEvd.D(); for (var i = 0; i < matrixAv.RowCount; i++) { @@ -108,15 +113,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().ConjugateTranspose(); + var matrix = eigenVectors * d * eigenVectors.ConjugateTranspose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs index 213b7f46..5098b102 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs @@ -65,36 +65,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = DenseMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex32.One, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex32.One, r[i, j]); } else { - Assert.AreEqual(Complex32.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex32.One, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex32.One, q[i, j]); } else { - Assert.AreEqual(Complex32.Zero, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex32.Zero, q[i, j]); } } } @@ -122,29 +124,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex32.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) @@ -155,7 +159,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization } // Make sure the Q is unitary --> (Q*)x(Q) = I - var matrixQсtQ = factorGramSchmidt.Q.ConjugateTranspose() * factorGramSchmidt.Q; + var matrixQсtQ = q.ConjugateTranspose() * q; for (var i = 0; i < matrixQсtQ.RowCount; i++) { for (var j = 0; j < matrixQсtQ.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs index b35ee38a..bdcd95da 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs @@ -65,21 +65,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = DenseMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorQR.R[i, j].Magnitude); + Assert.AreEqual(1.0, r[i, j].Magnitude); } else { - Assert.AreEqual(Complex32.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } @@ -107,29 +108,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex32.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) @@ -140,7 +143,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization } // Make sure the Q is unitary --> (Q*)x(Q) = I - var matrixQсtQ = factorQR.Q.ConjugateTranspose() * factorQR.Q; + var matrixQсtQ = q.ConjugateTranspose() * q; for (var i = 0; i < matrixQсtQ.RowCount; i++) { for (var j = 0; j < matrixQсtQ.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/SvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/SvdTests.cs index f72ee5cd..b875d72e 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/SvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/SvdTests.cs @@ -56,21 +56,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = DenseMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, w[i, j]); } } } @@ -85,21 +88,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserCholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserCholeskyTests.cs index 5d2f68c5..0c9abbea 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserCholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserCholeskyTests.cs @@ -44,16 +44,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = UserDefinedMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserEvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserEvdTests.cs index e9e07a13..d492fc34 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserEvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserEvdTests.cs @@ -56,16 +56,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -78,16 +81,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * d; for (var i = 0; i < matrixAv.RowCount; i++) { @@ -108,15 +113,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().ConjugateTranspose(); + var matrix = eigenVectors * d * eigenVectors.ConjugateTranspose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserGramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserGramSchmidtTests.cs index 0aa03595..3c804a0a 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserGramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserGramSchmidtTests.cs @@ -63,36 +63,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex32.One, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex32.One, r[i, j]); } else { - Assert.AreEqual(Complex32.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(Complex32.One, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex32.One, q[i, j]); } else { - Assert.AreEqual(Complex32.Zero, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(Complex32.Zero, q[i, j]); } } } @@ -120,29 +122,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex32.Zero, factorGramSchmidt.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) @@ -153,7 +157,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization } // Make sure the Q is unitary --> (Q*)x(Q) = I - var matrixQсtQ = factorGramSchmidt.Q.ConjugateTranspose() * factorGramSchmidt.Q; + var matrixQсtQ = q.ConjugateTranspose() * q; for (var i = 0; i < matrixQсtQ.RowCount; i++) { for (var j = 0; j < matrixQсtQ.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserQRTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserQRTests.cs index 5e5cc037..d7565196 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserQRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserQRTests.cs @@ -64,21 +64,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(-Complex32.One, factorQR.R[i, j]); + Assert.AreEqual(-Complex32.One, r[i, j]); } else { - Assert.AreEqual(Complex32.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } @@ -106,29 +107,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(Complex32.Zero, factorQR.R[i, j]); + Assert.AreEqual(Complex32.Zero, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) @@ -139,7 +142,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization } // Make sure the Q is unitary --> (Q*)x(Q) = I - var matrixQсtQ = factorQR.Q.ConjugateTranspose() * factorQR.Q; + var matrixQсtQ = q.ConjugateTranspose() * q; for (var i = 0; i < matrixQсtQ.RowCount; i++) { for (var j = 0; j < matrixQсtQ.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserSvdTests.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserSvdTests.cs index b1b6dd28..45fe36b3 100644 --- a/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserSvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserSvdTests.cs @@ -55,21 +55,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? Complex32.One : Complex32.Zero, w[i, j]); } } } @@ -84,21 +87,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs index cd39b576..e184e9e2 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs @@ -44,16 +44,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = DenseMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs index 8b518570..53191ffe 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs @@ -56,16 +56,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = DenseMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -78,16 +81,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * factorEvd.D(); for (var i = 0; i < matrixAv.RowCount; i++) { @@ -107,15 +112,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().Transpose(); + var matrix = eigenVectors * d * eigenVectors.Transpose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs index 3d0a83c1..8a56fa64 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs @@ -64,36 +64,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = DenseMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(1.0, r[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(1.0, q[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(0.0, q[i, j]); } } } @@ -121,19 +123,21 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { @@ -143,7 +147,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs index d4587037..dbed8f2a 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs @@ -64,21 +64,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = DenseMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, Math.Abs(factorQR.R[i, j])); + Assert.AreEqual(1.0, Math.Abs(r[i, j])); } else { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } @@ -106,29 +107,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs index 62bfd864..19f7323d 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs @@ -55,21 +55,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = DenseMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, w[i, j]); } } } @@ -84,21 +87,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserCholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserCholeskyTests.cs index 28900291..8e01b2ab 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserCholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserCholeskyTests.cs @@ -43,16 +43,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = UserDefinedMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserEvdTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserEvdTests.cs index d6276ef5..c7231895 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserEvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserEvdTests.cs @@ -55,16 +55,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -77,16 +80,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * d; for (var i = 0; i < matrixAv.RowCount; i++) { @@ -106,15 +111,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().Transpose(); + var matrix = eigenVectors * d * eigenVectors.Transpose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserGramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserGramSchmidtTests.cs index 162b0850..2782920f 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserGramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserGramSchmidtTests.cs @@ -62,36 +62,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(1.0, r[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(1.0, q[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(0.0, q[i, j]); } } } @@ -119,29 +121,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserQRTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserQRTests.cs index 02aa9f7c..0b60fc81 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserQRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserQRTests.cs @@ -63,21 +63,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(-1.0, factorQR.R[i, j]); + Assert.AreEqual(-1.0, r[i, j]); } else { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } @@ -105,29 +106,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserSvdTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserSvdTests.cs index 0e816ea3..3d983ccb 100644 --- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserSvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/UserSvdTests.cs @@ -54,21 +54,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, w[i, j]); } } } @@ -83,21 +86,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/CholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/CholeskyTests.cs index 92a97b3b..27a7a53e 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/CholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/CholeskyTests.cs @@ -44,16 +44,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = DenseMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/EvdTests.cs index 130b5bd4..0cd58c18 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/EvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/EvdTests.cs @@ -56,16 +56,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = DenseMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -78,16 +81,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * d; for (var i = 0; i < matrixAv.RowCount; i++) { @@ -107,15 +112,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().Transpose(); + var matrix = eigenVectors * d * eigenVectors.Transpose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs index 979f8712..9b1c3f7c 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs @@ -64,36 +64,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = DenseMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(1.0, r[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(1.0, q[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(0.0, q[i, j]); } } } @@ -121,29 +123,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs index 1f6ff133..be891fc5 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs @@ -64,21 +64,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = DenseMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, Math.Abs(factorQR.R[i, j])); + Assert.AreEqual(1.0, Math.Abs(r[i, j])); } else { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } @@ -106,29 +107,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/SvdTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/SvdTests.cs index 3f9f42f2..75d5a085 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/SvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/SvdTests.cs @@ -55,21 +55,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = DenseMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, w[i, j]); } } } @@ -84,21 +87,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserCholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserCholeskyTests.cs index 1584a290..e8b44fb0 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserCholeskyTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserCholeskyTests.cs @@ -43,16 +43,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization public void CanFactorizeIdentity([Values(1, 10, 100)] int order) { var matrixI = UserDefinedMatrix.Identity(order); - var factorC = matrixI.Cholesky(); + var factorC = matrixI.Cholesky().Factor; - Assert.AreEqual(matrixI.RowCount, factorC.Factor.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorC.Factor.ColumnCount); + Assert.AreEqual(matrixI.RowCount, factorC.RowCount); + Assert.AreEqual(matrixI.ColumnCount, factorC.ColumnCount); - for (var i = 0; i < factorC.Factor.RowCount; i++) + for (var i = 0; i < factorC.RowCount; i++) { - for (var j = 0; j < factorC.Factor.ColumnCount; j++) + for (var j = 0; j < factorC.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorC.Factor[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, factorC[i, j]); } } } diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserEvdTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserEvdTests.cs index 1cac0174..9c8c4b76 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserEvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserEvdTests.cs @@ -55,16 +55,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorEvd = matrixI.Evd(); + var eigenValues = factorEvd.EigenValues(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(matrixI.RowCount, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.RowCount); + Assert.AreEqual(matrixI.RowCount, eigenVectors.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorEvd.D().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, d.RowCount); + Assert.AreEqual(matrixI.ColumnCount, d.ColumnCount); - for (var i = 0; i < factorEvd.EigenValues().Count; i++) + for (var i = 0; i < eigenValues.Count; i++) { - Assert.AreEqual(Complex.One, factorEvd.EigenValues()[i]); + Assert.AreEqual(Complex.One, eigenValues[i]); } } @@ -77,16 +80,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A*V = λ*V - var matrixAv = matrixA * factorEvd.EigenVectors(); - var matrixLv = factorEvd.EigenVectors() * factorEvd.D(); + var matrixAv = matrixA * eigenVectors; + var matrixLv = eigenVectors * d; for (var i = 0; i < matrixAv.RowCount; i++) { @@ -106,15 +111,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order); var factorEvd = matrixA.Evd(); + var eigenVectors = factorEvd.EigenVectors(); + var d = factorEvd.D(); - Assert.AreEqual(order, factorEvd.EigenVectors().RowCount); - Assert.AreEqual(order, factorEvd.EigenVectors().ColumnCount); + Assert.AreEqual(order, eigenVectors.RowCount); + Assert.AreEqual(order, eigenVectors.ColumnCount); - Assert.AreEqual(order, factorEvd.D().RowCount); - Assert.AreEqual(order, factorEvd.D().ColumnCount); + Assert.AreEqual(order, d.RowCount); + Assert.AreEqual(order, d.ColumnCount); // Make sure the A = V*λ*VT - var matrix = factorEvd.EigenVectors() * factorEvd.D() * factorEvd.EigenVectors().Transpose(); + var matrix = eigenVectors * d * eigenVectors.Transpose(); for (var i = 0; i < matrix.RowCount; i++) { diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserGramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserGramSchmidtTests.cs index 6f45ebe8..5f117153 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserGramSchmidtTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserGramSchmidtTests.cs @@ -62,36 +62,38 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorGramSchmidt = matrixI.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; - Assert.AreEqual(matrixI.RowCount, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(matrixI.RowCount, q.RowCount); + Assert.AreEqual(matrixI.ColumnCount, q.ColumnCount); - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(1.0, r[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } - for (var i = 0; i < factorGramSchmidt.Q.RowCount; i++) + for (var i = 0; i < q.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.Q.ColumnCount; j++) + for (var j = 0; j < q.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(1.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(1.0, q[i, j]); } else { - Assert.AreEqual(0.0, factorGramSchmidt.Q[i, j]); + Assert.AreEqual(0.0, q[i, j]); } } } @@ -119,29 +121,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorGramSchmidt = matrixA.GramSchmidt(); + var q = factorGramSchmidt.Q; + var r = factorGramSchmidt.R; // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorGramSchmidt.Q.RowCount); - Assert.AreEqual(column, factorGramSchmidt.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(column, q.ColumnCount); // Make sure the R has the right dimensions. - Assert.AreEqual(column, factorGramSchmidt.R.RowCount); - Assert.AreEqual(column, factorGramSchmidt.R.ColumnCount); + Assert.AreEqual(column, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorGramSchmidt.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorGramSchmidt.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorGramSchmidt.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorGramSchmidt.Q * factorGramSchmidt.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserQRTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserQRTests.cs index 38b87234..fa3c32b7 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserQRTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserQRTests.cs @@ -63,21 +63,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorQR = matrixI.QR(); + var r = factorQR.R; - Assert.AreEqual(matrixI.RowCount, factorQR.R.RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorQR.R.ColumnCount); + Assert.AreEqual(matrixI.RowCount, r.RowCount); + Assert.AreEqual(matrixI.ColumnCount, r.ColumnCount); - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i == j) { - Assert.AreEqual(-1.0, factorQR.R[i, j]); + Assert.AreEqual(-1.0, r[i, j]); } else { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } @@ -105,29 +106,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorQR = matrixA.QR(); + var q = factorQR.Q; + var r = factorQR.R; // Make sure the R has the right dimensions. - Assert.AreEqual(row, factorQR.R.RowCount); - Assert.AreEqual(column, factorQR.R.ColumnCount); + Assert.AreEqual(row, r.RowCount); + Assert.AreEqual(column, r.ColumnCount); // Make sure the Q has the right dimensions. - Assert.AreEqual(row, factorQR.Q.RowCount); - Assert.AreEqual(row, factorQR.Q.ColumnCount); + Assert.AreEqual(row, q.RowCount); + Assert.AreEqual(row, q.ColumnCount); // Make sure the R factor is upper triangular. - for (var i = 0; i < factorQR.R.RowCount; i++) + for (var i = 0; i < r.RowCount; i++) { - for (var j = 0; j < factorQR.R.ColumnCount; j++) + for (var j = 0; j < r.ColumnCount; j++) { if (i > j) { - Assert.AreEqual(0.0, factorQR.R[i, j]); + Assert.AreEqual(0.0, r[i, j]); } } } // Make sure the Q*R is the original matrix. - var matrixQfromR = factorQR.Q * factorQR.R; + var matrixQfromR = q * r; for (var i = 0; i < matrixQfromR.RowCount; i++) { for (var j = 0; j < matrixQfromR.ColumnCount; j++) diff --git a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserSvdTests.cs b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserSvdTests.cs index ee873b40..8c6057a2 100644 --- a/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserSvdTests.cs +++ b/src/UnitTests/LinearAlgebraTests/Single/Factorization/UserSvdTests.cs @@ -54,21 +54,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixI = UserDefinedMatrix.Identity(order); var factorSvd = matrixI.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().RowCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.U().ColumnCount); + Assert.AreEqual(matrixI.RowCount, u.RowCount); + Assert.AreEqual(matrixI.RowCount, u.ColumnCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.VT().ColumnCount); + Assert.AreEqual(matrixI.ColumnCount, vt.RowCount); + Assert.AreEqual(matrixI.ColumnCount, vt.ColumnCount); - Assert.AreEqual(matrixI.RowCount, factorSvd.W().RowCount); - Assert.AreEqual(matrixI.ColumnCount, factorSvd.W().ColumnCount); + Assert.AreEqual(matrixI.RowCount, w.RowCount); + Assert.AreEqual(matrixI.ColumnCount, w.ColumnCount); - for (var i = 0; i < factorSvd.W().RowCount; i++) + for (var i = 0; i < w.RowCount; i++) { - for (var j = 0; j < factorSvd.W().ColumnCount; j++) + for (var j = 0; j < w.ColumnCount; j++) { - Assert.AreEqual(i == j ? 1.0 : 0.0, factorSvd.W()[i, j]); + Assert.AreEqual(i == j ? 1.0 : 0.0, w[i, j]); } } } @@ -83,21 +86,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization { var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column); var factorSvd = matrixA.Svd(true); + var u = factorSvd.U(); + var vt = factorSvd.VT(); + var w = factorSvd.W(); // Make sure the U has the right dimensions. - Assert.AreEqual(row, factorSvd.U().RowCount); - Assert.AreEqual(row, factorSvd.U().ColumnCount); + Assert.AreEqual(row, u.RowCount); + Assert.AreEqual(row, u.ColumnCount); // Make sure the VT has the right dimensions. - Assert.AreEqual(column, factorSvd.VT().RowCount); - Assert.AreEqual(column, factorSvd.VT().ColumnCount); + Assert.AreEqual(column, vt.RowCount); + Assert.AreEqual(column, vt.ColumnCount); // Make sure the W has the right dimensions. - Assert.AreEqual(row, factorSvd.W().RowCount); - Assert.AreEqual(column, factorSvd.W().ColumnCount); + Assert.AreEqual(row, w.RowCount); + Assert.AreEqual(column, w.ColumnCount); // Make sure the U*W*VT is the original matrix. - var matrix = factorSvd.U() * factorSvd.W() * factorSvd.VT(); + var matrix = u * w * vt; for (var i = 0; i < matrix.RowCount; i++) { for (var j = 0; j < matrix.ColumnCount; j++)