tests: removed redundant matrix copying from factorization test to speed things up

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)

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

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++)
             {

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++)

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++)

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++)