Tests: refactoring towards generic builder 2

src/UnitTests/DistributionTests/Multivariate/InverseWishartTests.cs

@@ -24,14 +24,15 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.Distributions;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Double;
+using MathNet.Numerics.Random;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
 {
-    using System;
-    using Distributions;
-    using LinearAlgebra.Double;
-    using LinearAlgebraTests.Double;
-    using NUnit.Framework;
-
     /// <summary>
     /// Inverse Wishart tests.
     /// </summary>
@@ -57,7 +58,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void CanCreateInverseWishart(double nu, int order)
         {
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             var d = new InverseWishart(nu, matrix);
 
             Assert.AreEqual(nu, d.DegreesOfFreedom);
@@ -80,7 +81,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void FailSCreateInverseWishart(double nu, int order)
         {
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             matrix[0, 0] = 0.0;
 
             Assert.Throws<ArgumentOutOfRangeException>(() => new InverseWishart(nu, matrix));
@@ -95,7 +96,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(Double.NaN, 5)]
         public void FailNuCreateInverseWishart(double nu, int order)
         {
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             Assert.Throws<ArgumentOutOfRangeException>(() => new InverseWishart(nu, matrix));
         }
 
@@ -105,7 +106,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void HasRandomSource()
         {
-            var d = new InverseWishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new InverseWishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.IsNotNull(d.RandomSource);
         }
 
@@ -115,16 +116,16 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSetRandomSource()
         {
-            new InverseWishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2))
+            new InverseWishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1))
             {
-                RandomSource = new Random(0)
+                RandomSource = new System.Random(0)
             };
         }
 
         [Test]
         public void HasRandomSourceEvenAfterSetToNull()
         {
-            var d = new InverseWishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new InverseWishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.DoesNotThrow(() => d.RandomSource = null);
             Assert.IsNotNull(d.RandomSource);
         }
@@ -135,7 +136,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void ValidateToString()
         {
-            var d = new InverseWishart(1d, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new InverseWishart(1d, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.AreEqual("InverseWishart(ν = 1, Rows = 2, Columns = 2)", d.ToString());
         }
 
@@ -148,7 +149,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0)]
         public void CanGetNu(double nu)
         {
-            var d = new InverseWishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new InverseWishart(nu, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.AreEqual(nu, d.DegreesOfFreedom);
         }
 
@@ -161,7 +162,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0)]
         public void CanSetNu(double nu)
         {
-            new InverseWishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2))
+            new InverseWishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1))
             {
                 DegreesOfFreedom = nu
             };
@@ -174,7 +175,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         public void CanGetS()
         {
             const int Order = 2;
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(Order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(Order, 1);
             var d = new InverseWishart(1.0, matrix);
 
             for (var i = 0; i < Order; i++)
@@ -192,9 +193,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSetS()
         {
-            new InverseWishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2))
+            new InverseWishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1))
             {
-                Scale = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2)
+                Scale = Matrix<double>.Build.RandomPositiveDefinite(2, 1)
             };
         }
 
@@ -208,7 +209,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void ValidateMean(double nu, int order)
         {
-            var d = new InverseWishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order));
+            var d = new InverseWishart(nu, Matrix<double>.Build.RandomPositiveDefinite(order, 1));
 
             var mean = d.Mean;
             for (var i = 0; i < d.Scale.RowCount; i++)
@@ -230,7 +231,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void ValidateMode(double nu, int order)
         {
-            var d = new InverseWishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order));
+            var d = new InverseWishart(nu, Matrix<double>.Build.RandomPositiveDefinite(order, 1));
 
             var mode = d.Mode;
             for (var i = 0; i < d.Scale.RowCount; i++)
@@ -252,7 +253,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void ValidateVariance(double nu, int order)
         {
-            var d = new InverseWishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order));
+            var d = new InverseWishart(nu, Matrix<double>.Build.RandomPositiveDefinite(order, 1));
 
             var variance = d.Variance;
             for (var i = 0; i < d.Scale.RowCount; i++)
@@ -293,7 +294,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSample()
         {
-            var d = new InverseWishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new InverseWishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             d.Sample();
         }
 
@@ -303,7 +304,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSampleStatic()
         {
-            InverseWishart.Sample(new Random(0), 1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            InverseWishart.Sample(new System.Random(0), 1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
         }
 
         /// <summary>
@@ -312,7 +313,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void FailSampleStatic()
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => InverseWishart.Sample(new Random(0), -1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => InverseWishart.Sample(new System.Random(0), -1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1)));
         }
     }
 }

src/UnitTests/DistributionTests/Multivariate/MatrixNormalTests.cs

@@ -24,14 +24,14 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.Distributions;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Double;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
 {
-    using System;
-    using Distributions;
-    using LinearAlgebra.Double;
-    using LinearAlgebraTests.Double;
-    using NUnit.Framework;
-
     /// <summary>
     /// Matrix Normal tests.
     /// </summary>
@@ -48,9 +48,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanCreateMatrixNormal(int n, int p)
         {
-            var matrixM = MatrixLoader.GenerateRandomDenseMatrix(n, p);
-            var matrixV = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n);
-            var matrixK = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p);
+            var matrixM = Matrix<double>.Build.Random(n, p, 1);
+            var matrixV = Matrix<double>.Build.RandomPositiveDefinite(n, 1);
+            var matrixK = Matrix<double>.Build.RandomPositiveDefinite(p, 1);
             var d = new MatrixNormal(matrixM, matrixV, matrixK);
 
             for (var i = 0; i < matrixM.RowCount; i++)
@@ -97,9 +97,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5, 2, 5, 5, 2, 3)]
         public void FailCreateMatrixNormal(int rowsOfM, int columnsOfM, int rowsOfV, int columnsOfV, int rowsOfK, int columnsOfK)
         {
-            var matrixM = MatrixLoader.GenerateRandomDenseMatrix(rowsOfM, columnsOfM);
-            var matrixV = MatrixLoader.GenerateRandomDenseMatrix(rowsOfV, columnsOfV);
-            var matrixK = MatrixLoader.GenerateRandomDenseMatrix(rowsOfK, columnsOfK);
+            var matrixM = Matrix<double>.Build.Random(rowsOfM, columnsOfM, 1);
+            var matrixV = Matrix<double>.Build.Random(rowsOfV, columnsOfV, 1);
+            var matrixK = Matrix<double>.Build.Random(rowsOfK, columnsOfK, 1);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => new MatrixNormal(matrixM, matrixV, matrixK));
         }
@@ -112,7 +112,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         {
             const int N = 2;
             const int P = 3;
-            var d = new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(N, P), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(N), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(P));
+            var d = new MatrixNormal(Matrix<double>.Build.Random(N, P, 1), Matrix<double>.Build.RandomPositiveDefinite(N, 1), Matrix<double>.Build.RandomPositiveDefinite(P, 1));
             Assert.IsNotNull(d.RandomSource);
         }
 
@@ -124,9 +124,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         {
             const int N = 2;
             const int P = 3;
-            new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(N, P), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(N), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(P))
+            new MatrixNormal(Matrix<double>.Build.Random(N, P, 1), Matrix<double>.Build.RandomPositiveDefinite(N, 1), Matrix<double>.Build.RandomPositiveDefinite(P, 1))
             {
-                RandomSource = new Random(0)
+                RandomSource = new System.Random(0)
             };
         }
 
@@ -135,7 +135,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         {
             const int N = 2;
             const int P = 3;
-            var d = new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(N, P), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(N), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(P));
+            var d = new MatrixNormal(Matrix<double>.Build.Random(N, P, 1), Matrix<double>.Build.RandomPositiveDefinite(N, 1), Matrix<double>.Build.RandomPositiveDefinite(P, 1));
             Assert.DoesNotThrow(() => d.RandomSource = null);
             Assert.IsNotNull(d.RandomSource);
         }
@@ -148,7 +148,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         {
             const int N = 2;
             const int P = 5;
-            var d = new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(N, P), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(N), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(P));
+            var d = new MatrixNormal(Matrix<double>.Build.Random(N, P, 1), Matrix<double>.Build.RandomPositiveDefinite(N, 1), Matrix<double>.Build.RandomPositiveDefinite(P, 1));
             Assert.AreEqual("MatrixNormal(Rows = 2, Columns = 5)", d.ToString());
         }
 
@@ -162,8 +162,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanGetM(int n, int p)
         {
-            var matrixM = MatrixLoader.GenerateRandomDenseMatrix(n, p);
-            var d = new MatrixNormal(matrixM, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p));
+            var matrixM = Matrix<double>.Build.Random(n, p, 1);
+            var d = new MatrixNormal(matrixM, Matrix<double>.Build.RandomPositiveDefinite(n, 1), Matrix<double>.Build.RandomPositiveDefinite(p, 1));
             for (var i = 0; i < matrixM.RowCount; i++)
             {
                 for (var j = 0; j < matrixM.ColumnCount; j++)
@@ -183,9 +183,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanSetM(int n, int p)
         {
-            new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(n, p), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p))
+            new MatrixNormal(Matrix<double>.Build.Random(n, p, 1), Matrix<double>.Build.RandomPositiveDefinite(n, 1), Matrix<double>.Build.RandomPositiveDefinite(p, 1))
             {
-                Mean = MatrixLoader.GenerateRandomDenseMatrix(n, p)
+                Mean = Matrix<double>.Build.Random(n, p, 1)
             };
         }
 
@@ -199,8 +199,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanGetV(int n, int p)
         {
-            var matrixV = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n);
-            var d = new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(n, p), matrixV, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p));
+            var matrixV = Matrix<double>.Build.RandomPositiveDefinite(n, 1);
+            var d = new MatrixNormal(Matrix<double>.Build.Random(n, p, 1), matrixV, Matrix<double>.Build.RandomPositiveDefinite(p, 1));
             for (var i = 0; i < matrixV.RowCount; i++)
             {
                 for (var j = 0; j < matrixV.ColumnCount; j++)
@@ -220,9 +220,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanSetV(int n, int p)
         {
-            new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(n, p), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p))
+            new MatrixNormal(Matrix<double>.Build.Random(n, p, 1), Matrix<double>.Build.RandomPositiveDefinite(n, 1), Matrix<double>.Build.RandomPositiveDefinite(p, 1))
             {
-                RowCovariance = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n)
+                RowCovariance = Matrix<double>.Build.RandomPositiveDefinite(n, 1)
             };
         }
 
@@ -236,8 +236,8 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanGetK(int n, int p)
         {
-            var matrixK = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p);
-            var d = new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(n, p), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), matrixK);
+            var matrixK = Matrix<double>.Build.RandomPositiveDefinite(p, 1);
+            var d = new MatrixNormal(Matrix<double>.Build.Random(n, p, 1), Matrix<double>.Build.RandomPositiveDefinite(n, 1), matrixK);
             for (var i = 0; i < matrixK.RowCount; i++)
             {
                 for (var j = 0; j < matrixK.ColumnCount; j++)
@@ -257,9 +257,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanSetK(int n, int p)
         {
-            new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(n, p), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p))
+            new MatrixNormal(Matrix<double>.Build.Random(n, p, 1), Matrix<double>.Build.RandomPositiveDefinite(n, 1), Matrix<double>.Build.RandomPositiveDefinite(p, 1))
             {
-                ColumnCovariance = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p)
+                ColumnCovariance = Matrix<double>.Build.RandomPositiveDefinite(p, 1)
             };
         }
 
@@ -307,7 +307,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanSample(int n, int p)
         {
-            var d = new MatrixNormal(MatrixLoader.GenerateRandomDenseMatrix(n, p), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p));
+            var d = new MatrixNormal(Matrix<double>.Build.Random(n, p, 1), Matrix<double>.Build.RandomPositiveDefinite(n, 1), Matrix<double>.Build.RandomPositiveDefinite(p, 1));
             d.Sample();
         }
 
@@ -321,7 +321,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(10, 10)]
         public void CanSampleStatic(int n, int p)
         {
-            MatrixNormal.Sample(new Random(0), MatrixLoader.GenerateRandomDenseMatrix(n, p), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(n), MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(p));
+            MatrixNormal.Sample(new System.Random(0), Matrix<double>.Build.Random(n, p, 1), Matrix<double>.Build.RandomPositiveDefinite(n, 1), Matrix<double>.Build.RandomPositiveDefinite(p, 1));
         }
 
         /// <summary>
@@ -343,7 +343,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5, 2, 5, 5, 2, 3)]
         public void FailSampleStatic(int rowsOfM, int columnsOfM, int rowsOfV, int columnsOfV, int rowsOfK, int columnsOfK)
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => MatrixNormal.Sample(new Random(0), MatrixLoader.GenerateRandomDenseMatrix(rowsOfM, columnsOfM), MatrixLoader.GenerateRandomDenseMatrix(rowsOfV, columnsOfV), MatrixLoader.GenerateRandomDenseMatrix(rowsOfK, columnsOfK)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => MatrixNormal.Sample(new System.Random(0), Matrix<double>.Build.Random(rowsOfM, columnsOfM, 1), Matrix<double>.Build.Random(rowsOfV, columnsOfV, 1), Matrix<double>.Build.Random(rowsOfK, columnsOfK, 1)));
         }
     }
 }

src/UnitTests/DistributionTests/Multivariate/WishartTests.cs

@@ -24,14 +24,14 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.Distributions;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Double;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
 {
-    using System;
-    using Distributions;
-    using LinearAlgebra.Double;
-    using LinearAlgebraTests.Double;
-    using NUnit.Framework;
-
     /// <summary>
     /// <c>Wishart</c> distribution tests.
     /// </summary>
@@ -57,7 +57,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void CanCreateWishart(double nu, int order)
         {
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
 
             var d = new Wishart(nu, matrix);
 
@@ -82,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void FailSCreateWishart(double nu, int order)
         {
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             matrix[0, 0] = 0.0;
 
             Assert.Throws<ArgumentOutOfRangeException>(() => new Wishart(nu, matrix));
@@ -97,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(Double.NaN, 5)]
         public void FailNuCreateWishart(double nu, int order)
         {
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             Assert.Throws<ArgumentOutOfRangeException>(() => new InverseWishart(nu, matrix));
         }
 
@@ -107,7 +107,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void HasRandomSource()
         {
-            var d = new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.IsNotNull(d.RandomSource);
         }
 
@@ -117,9 +117,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSetRandomSource()
         {
-            new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2))
+            new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1))
             {
-                RandomSource = new Random(0)
+                RandomSource = new System.Random(0)
             };
         }
 
@@ -129,7 +129,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void FailSetRandomSourceWithNullReference()
         {
-            var d = new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.Throws<ArgumentNullException>(() => d.RandomSource = null);
         }
 
@@ -139,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void ValidateToString()
         {
-            var d = new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.AreEqual("Wishart(DegreesOfFreedom = 1, Rows = 2, Columns = 2)", d.ToString());
         }
 
@@ -152,7 +152,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0)]
         public void CanGetNu(double nu)
         {
-            var d = new Wishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new Wishart(nu, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             Assert.AreEqual(nu, d.DegreesOfFreedom);
         }
 
@@ -165,7 +165,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0)]
         public void CanSetNu(double nu)
         {
-            new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2))
+            new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1))
             {
                 DegreesOfFreedom = nu
             };
@@ -178,7 +178,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         public void CanGetS()
         {
             const int Order = 2;
-            var matrix = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(Order);
+            var matrix = Matrix<double>.Build.RandomPositiveDefinite(Order, 1);
             var d = new Wishart(1.0, matrix);
 
             for (var i = 0; i < Order; i++)
@@ -196,9 +196,9 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSetS()
         {
-            new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2))
+            new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1))
             {
-                Scale = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2)
+                Scale = Matrix<double>.Build.RandomPositiveDefinite(2, 1)
             };
         }
 
@@ -212,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void ValidateMean(double nu, int order)
         {
-            var d = new Wishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order));
+            var d = new Wishart(nu, Matrix<double>.Build.RandomPositiveDefinite(order, 1));
 
             var mean = d.Mean;
             for (var i = 0; i < d.Scale.RowCount; i++)
@@ -234,7 +234,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void ValidateMode(double nu, int order)
         {
-            var d = new Wishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order));
+            var d = new Wishart(nu, Matrix<double>.Build.RandomPositiveDefinite(order, 1));
 
             var mode = d.Mode;
             for (var i = 0; i < d.Scale.RowCount; i++)
@@ -256,7 +256,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [TestCase(5.0, 5)]
         public void ValidateVariance(double nu, int order)
         {
-            var d = new Wishart(nu, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order));
+            var d = new Wishart(nu, Matrix<double>.Build.RandomPositiveDefinite(order, 1));
 
             var variance = d.Variance;
             for (var i = 0; i < d.Scale.RowCount; i++)
@@ -295,7 +295,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSample()
         {
-            var d = new Wishart(1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            var d = new Wishart(1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
             d.Sample();
         }
 
@@ -305,7 +305,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void CanSampleStatic()
         {
-            Wishart.Sample(new Random(0), 1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2));
+            Wishart.Sample(new System.Random(0), 1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1));
         }
 
         /// <summary>
@@ -314,7 +314,7 @@ namespace MathNet.Numerics.UnitTests.DistributionTests.Multivariate
         [Test]
         public void FailSampleStatic()
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => Wishart.Sample(new Random(0), -1.0, MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(2)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => Wishart.Sample(new System.Random(0), -1.0, Matrix<double>.Build.RandomPositiveDefinite(2, 1)));
         }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/DenseMatrixTests.cs

@@ -68,27 +68,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             return DenseMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(int size)
-        {
-            return new DenseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(Complex[] data)
-        {
-            return new DenseVector(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs

@@ -68,7 +68,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             TestMatrices = new Dictionary<string, Matrix<Complex>>();
             foreach (var name in TestData2D.Keys)
             {
-                TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
+                TestMatrices.Add(name, DiagonalMatrix.OfArray(TestData2D[name]));
             }
         }
 
@@ -93,27 +93,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             return DiagonalMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(int size)
-        {
-            return new SparseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(Complex[] data)
-        {
-            return SparseVector.OfEnumerable(data);
-        }
-
         /// <summary>
         /// Can create a matrix from a diagonal array.
         /// </summary>
@@ -239,7 +218,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void PermuteMatrixRowsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteRows(permutation));
         }
@@ -250,7 +229,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void PermuteMatrixColumnsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteColumns(permutation));
         }

src/UnitTests/LinearAlgebraTests/Complex/Factorization/CholeskyTests.cs

@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
 {
@@ -113,7 +114,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixX = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -153,10 +154,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<Complex>.Build.Random(order, 1);
             var x = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.Count, x.Count);
@@ -192,10 +193,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(row);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<Complex>.Build.Random(row, col, 1);
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -234,10 +235,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<Complex>.Build.Random(order, 1);
             var matrixBCopy = matrixB.Clone();
             var x = new DenseVector(order);
             chol.Solve(matrixB, x);
@@ -281,10 +282,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(row);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<Complex>.Build.Random(row, col, 1);
             var matrixBCopy = matrixB.Clone();
             var matrixX = new DenseMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/EvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using NUnit.Framework;
 
@@ -79,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
 
@@ -114,7 +115,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
@@ -147,7 +148,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -206,12 +207,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -247,12 +248,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -295,11 +296,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -341,12 +342,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/GramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Factorization;
 using NUnit.Framework;
@@ -126,7 +127,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -191,11 +192,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -230,11 +231,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -276,10 +277,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -322,11 +323,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -374,11 +375,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [Test]
         public void CanSolveForMatrixWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<Complex>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -413,11 +414,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [Test]
         public void CanSolveForVectorWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<Complex>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Complex/Factorization/LUTests.cs

@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
 {
@@ -114,7 +115,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixX = Matrix<Complex>.Build.Random(order, order, 1);
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -169,11 +170,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -208,11 +209,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -254,10 +255,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -300,11 +301,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -358,7 +359,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Complex/Factorization/QRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Factorization;
 using MathNet.Numerics.LinearAlgebra.Factorization;
@@ -143,7 +144,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -211,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -278,11 +279,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -317,11 +318,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -363,10 +364,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -409,11 +410,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -467,11 +468,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -506,11 +507,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -552,10 +553,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -598,11 +599,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -652,11 +653,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForMatrixWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<Complex>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -693,11 +694,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForVectorWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<Complex>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Complex/Factorization/SvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using NUnit.Framework;
 
@@ -87,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -126,7 +127,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -145,7 +146,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -190,10 +191,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 9);
+            var matrixA = Matrix<Complex>.Build.Random(10, 9, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(10, 9);
+            var matrixB = Matrix<Complex>.Build.Random(10, 9, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -203,10 +204,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 9);
+            var matrixA = Matrix<Complex>.Build.Random(10, 9, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(9);
+            var vectorb = Vector<Complex>.Build.Random(9, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -223,11 +224,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<Complex>.Build.Random(row, 1);
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -263,11 +264,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<Complex>.Build.Random(row, column, 1);
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -310,10 +311,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<Complex>.Build.Random(row, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -355,11 +356,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<Complex>.Build.Random(row, column, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserCholeskyTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
@@ -112,7 +113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixX = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -152,10 +153,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var x = chol.Solve(b);
 
             Assert.AreEqual(b.Count, x.Count);
@@ -191,10 +192,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, col, 1).ToArray());
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -233,10 +234,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var matrixBCopy = b.Clone();
             var x = new UserDefinedVector(order);
             chol.Solve(b, x);
@@ -280,10 +281,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, col, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
             var matrixX = new UserDefinedMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserEvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
@@ -78,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -114,7 +115,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -146,7 +147,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -204,11 +205,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -243,11 +244,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -289,10 +290,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -333,11 +334,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserGramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex.Factorization;
 using NUnit.Framework;
 
@@ -125,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -190,11 +191,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -229,11 +230,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -275,10 +276,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -321,11 +322,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserLUTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
@@ -113,7 +114,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixX = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -168,11 +169,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -207,11 +208,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -253,10 +254,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -299,11 +300,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -357,7 +358,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserQRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex.Factorization;
 using MathNet.Numerics.LinearAlgebra.Factorization;
 using NUnit.Framework;
@@ -143,7 +144,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -192,7 +193,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -240,11 +241,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -279,11 +280,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -325,10 +326,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -371,11 +372,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -429,11 +430,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -468,11 +469,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -514,10 +515,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -560,11 +561,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex/Factorization/UserSvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
@@ -86,7 +87,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -125,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -144,7 +145,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(order, order, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -189,10 +190,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 9);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(10, 9, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 9);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(10, 9, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -202,10 +203,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 9);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(10, 9, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(9);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(9, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -222,11 +223,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(row, 1).ToArray());
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -262,11 +263,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -309,10 +310,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<Complex>.Build.Random(row, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -354,11 +355,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex>.Build.Random(row, column, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Complex/MatrixLoader.cs

@@ -70,21 +70,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         /// <returns>A matrix with the given values.</returns>
         protected abstract Matrix<Complex> CreateMatrix(Complex[,] data);
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<Complex> CreateVector(int size);
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<Complex> CreateVector(Complex[] data);
-
         /// <summary>
         /// Setup test matrices.
         /// </summary>
@@ -108,35 +93,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
                 TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
             }
         }
-
-        public static Matrix<Complex> GenerateRandomDenseMatrix(int row, int col)
-        {
-            return Matrix<Complex>.Build.Random(row, col, 1);
-        }
-
-        public static Matrix<Complex> GenerateRandomPositiveDefiniteHermitianDenseMatrix(int order)
-        {
-            return Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
-        }
-
-        public static Vector<Complex> GenerateRandomDenseVector(int order)
-        {
-            return Vector<Complex>.Build.Random(order, 1);
-        }
-
-        public static Matrix<Complex> GenerateRandomUserDefinedMatrix(int row, int col)
-        {
-            return new UserDefinedMatrix(GenerateRandomDenseMatrix(row, col).ToArray());
-        }
-
-        public static Matrix<Complex> GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(int order)
-        {
-            return new UserDefinedMatrix(GenerateRandomPositiveDefiniteHermitianDenseMatrix(order).ToArray());
-        }
-
-        public static Vector<Complex> GenerateRandomUserDefinedVector(int order)
-        {
-            return new UserDefinedVector(GenerateRandomDenseVector(order).ToArray());
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/MatrixTests.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [TestCase("Wide2x3")]
         public void CanTransposeMatrix(string name)
         {
-            var matrix = CreateMatrix(TestData2D[name]);
+            var matrix = TestMatrices[name];
             var transpose = matrix.Transpose();
 
             Assert.AreNotSame(matrix, transpose);
@@ -70,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [TestCase("Wide2x3")]
         public void CanConjugateTransposeMatrix(string name)
         {
-            var matrix = CreateMatrix(TestData2D[name]);
+            var matrix = TestMatrices[name];
             var transpose = matrix.ConjugateTranspose();
 
             Assert.AreNotSame(matrix, transpose);

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/BiCgStabTest.cs

@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -253,8 +254,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),
@@ -284,8 +285,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs

@@ -256,8 +256,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),
@@ -287,8 +287,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -256,8 +256,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),
@@ -287,8 +287,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs

@@ -256,8 +256,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var vectorb = Vector<Complex>.Build.Random(order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),
@@ -287,8 +287,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex>.Build.Random(order, order, 1);
+            var matrixB = Matrix<Complex>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<Complex>(
                 new IterationCountStopCriterium<Complex>(1000),

src/UnitTests/LinearAlgebraTests/Complex/SparseMatrixTests.cs

@@ -68,27 +68,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             return SparseMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(int size)
-        {
-            return new SparseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(Complex[] data)
-        {
-            return SparseVector.OfEnumerable(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Complex/UserDefinedMatrixTests.cs

@@ -59,26 +59,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         {
             return new UserDefinedMatrix(data);
         }
-
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(int size)
-        {
-            return new UserDefinedVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex> CreateVector(Complex[] data)
-        {
-            return new UserDefinedVector(data);
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/DenseMatrixTests.cs

@@ -64,27 +64,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             return DenseMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(int size)
-        {
-            return new DenseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(Complex32[] data)
-        {
-            return new DenseVector(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs

@@ -64,7 +64,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             TestMatrices = new Dictionary<string, Matrix<Complex32>>();
             foreach (var name in TestData2D.Keys)
             {
-                TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
+                TestMatrices.Add(name, DiagonalMatrix.OfArray(TestData2D[name]));
             }
         }
 
@@ -89,27 +89,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             return DiagonalMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(int size)
-        {
-            return new SparseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(Complex32[] data)
-        {
-            return SparseVector.OfEnumerable(data);
-        }
-
         /// <summary>
         /// Can create a matrix from a diagonal array.
         /// </summary>
@@ -235,7 +214,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void PermuteMatrixRowsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteRows(permutation));
         }
@@ -246,7 +225,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void PermuteMatrixColumnsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteColumns(permutation));
         }

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/CholeskyTests.cs

@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
 {
@@ -108,7 +109,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixX = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -149,10 +150,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<Complex32>.Build.Random(order, 1);
             var x = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.Count, x.Count);
@@ -189,10 +190,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(row);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<Complex32>.Build.Random(row, col, 1);
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -232,10 +233,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<Complex32>.Build.Random(order, 1);
             var matrixBCopy = matrixB.Clone();
             var x = new DenseVector(order);
             chol.Solve(matrixB, x);
@@ -280,10 +281,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(row);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<Complex32>.Build.Random(row, col, 1);
             var matrixBCopy = matrixB.Clone();
             var matrixX = new DenseMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/EvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using NUnit.Framework;
 
@@ -81,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -112,7 +113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
@@ -145,7 +146,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -203,12 +204,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(50)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -244,12 +245,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(50)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -292,11 +293,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(50)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -339,12 +340,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianDenseMatrix(order);
+            var matrixA = Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceConjugateSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/GramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Factorization;
 using NUnit.Framework;
@@ -122,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -190,11 +191,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -230,11 +231,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -277,10 +278,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -324,11 +325,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -377,11 +378,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void CanSolveForMatrixWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex32>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<Complex32>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -416,11 +417,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void CanSolveForVectorWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex32>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<Complex32>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/LUTests.cs

@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
 {
@@ -110,7 +111,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixX = Matrix<Complex32>.Build.Random(order, order, 1);
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -166,11 +167,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -206,11 +207,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -253,10 +254,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -300,11 +301,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -359,7 +360,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/QRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Factorization;
 using MathNet.Numerics.LinearAlgebra.Factorization;
@@ -140,7 +141,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -277,11 +278,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -317,11 +318,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -364,10 +365,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -411,11 +412,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -470,11 +471,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -509,11 +510,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -556,10 +557,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<Complex32>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -602,11 +603,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -657,11 +658,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForMatrixWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex32>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<Complex32>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -698,11 +699,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForVectorWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<Complex32>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<Complex32>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/SvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using NUnit.Framework;
 
@@ -83,7 +84,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -123,7 +124,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -142,7 +143,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -187,10 +188,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 3);
+            var matrixA = Matrix<Complex32>.Build.Random(10, 3, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(10, 3);
+            var matrixB = Matrix<Complex32>.Build.Random(10, 3, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -200,10 +201,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 3);
+            var matrixA = Matrix<Complex32>.Build.Random(10, 3, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(3);
+            var vectorb = Vector<Complex32>.Build.Random(3, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -220,11 +221,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<Complex32>.Build.Random(row, 1);
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -261,11 +262,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<Complex32>.Build.Random(row, column, 1);
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -309,10 +310,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<Complex32>.Build.Random(row, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -355,11 +356,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<Complex32>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<Complex32>.Build.Random(row, column, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserCholeskyTests.cs

@@ -24,11 +24,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
 {
-    using System;
-    using NUnit.Framework;
-    using Complex32 = Numerics.Complex32;
+    using Numerics;
 
     /// <summary>
     /// Cholesky factorization tests for a user matrix.
@@ -107,7 +109,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixX = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -148,10 +150,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var x = chol.Solve(b);
 
             Assert.AreEqual(b.Count, x.Count);
@@ -188,10 +190,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, col, 1).ToArray());
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -231,10 +233,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var matrixBCopy = b.Clone();
             var x = new UserDefinedVector(order);
             chol.Solve(b, x);
@@ -279,10 +281,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, col, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
             var matrixX = new UserDefinedMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserEvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
@@ -80,7 +81,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -112,7 +113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test, Ignore]
         public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10, 50, 100)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -145,7 +146,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -198,11 +199,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test, Ignore]
         public void CanSolveForRandomVectorAndSymmetricMatrix([Values(1, 2, 5, 10, 50, 100)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -238,11 +239,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -280,10 +281,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test, Ignore]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven([Values(1, 2, 5, 10, 50, 100)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -325,11 +326,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserGramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32.Factorization;
 using NUnit.Framework;
 
@@ -121,7 +122,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -189,11 +190,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -229,11 +230,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -276,10 +277,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -323,11 +324,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserLUTests.cs

@@ -24,11 +24,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
 {
-    using System;
-    using NUnit.Framework;
-    using Complex32 = Numerics.Complex32;
+    using Numerics;
 
     /// <summary>
     /// LU factorization tests for a user matrix.
@@ -108,7 +110,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixX = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -164,11 +166,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -204,11 +206,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -251,10 +253,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -298,11 +300,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -357,7 +359,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserQRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32.Factorization;
 using MathNet.Numerics.LinearAlgebra.Factorization;
 using NUnit.Framework;
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -207,7 +208,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -256,11 +257,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -296,11 +297,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -343,10 +344,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -390,11 +391,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -449,11 +450,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -489,11 +490,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -536,10 +537,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -583,11 +584,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Complex32/Factorization/UserSvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
@@ -82,7 +83,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -122,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -141,7 +142,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(order, order, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -186,10 +187,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 3);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(10, 3, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 3);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(10, 3, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -199,10 +200,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 3);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(10, 3, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(3);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(3, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -219,11 +220,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(row, 1).ToArray());
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -260,11 +261,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -308,10 +309,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<Complex32>.Build.Random(row, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -354,11 +355,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<Complex32>.Build.Random(row, column, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Complex32/MatrixLoader.cs

@@ -66,21 +66,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         /// <returns>A matrix with the given values.</returns>
         protected abstract Matrix<Complex32> CreateMatrix(Complex32[,] data);
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<Complex32> CreateVector(int size);
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<Complex32> CreateVector(Complex32[] data);
-
         /// <summary>
         /// Setup test matrices.
         /// </summary>
@@ -104,35 +89,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
                 TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
             }
         }
-
-        public static Matrix<Complex32> GenerateRandomDenseMatrix(int row, int col)
-        {
-            return Matrix<Complex32>.Build.Random(row, col, 1);
-        }
-
-        public static Matrix<Complex32> GenerateRandomPositiveDefiniteHermitianDenseMatrix(int order)
-        {
-            return Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
-        }
-
-        public static Vector<Complex32> GenerateRandomDenseVector(int order)
-        {
-            return Vector<Complex32>.Build.Random(order, 1);
-        }
-
-        public static Matrix<Complex32> GenerateRandomUserDefinedMatrix(int row, int col)
-        {
-            return new UserDefinedMatrix(GenerateRandomDenseMatrix(row, col).ToArray());
-        }
-
-        public static Matrix<Complex32> GenerateRandomPositiveDefiniteHermitianUserDefinedMatrix(int order)
-        {
-            return new UserDefinedMatrix(GenerateRandomPositiveDefiniteHermitianDenseMatrix(order).ToArray());
-        }
-
-        public static Vector<Complex32> GenerateRandomUserDefinedVector(int order)
-        {
-            return new UserDefinedVector(GenerateRandomDenseVector(order).ToArray());
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/MatrixTests.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [TestCase("Wide2x3")]
         public void CanTransposeMatrix(string name)
         {
-            var matrix = CreateMatrix(TestData2D[name]);
+            var matrix = TestMatrices[name];
             var transpose = matrix.Transpose();
 
             Assert.AreNotSame(matrix, transpose);
@@ -70,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [TestCase("Wide2x3")]
         public void CanConjugateTransposeMatrix(string name)
         {
-            var matrix = CreateMatrix(TestData2D[name]);
+            var matrix = TestMatrices[name];
             var transpose = matrix.ConjugateTranspose();
 
             Assert.AreNotSame(matrix, transpose);

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/BiCgStabTest.cs

@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -251,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var vectorb = Vector<Complex32>.Build.Random(order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),
@@ -293,8 +294,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs

@@ -252,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var vectorb = Vector<Complex32>.Build.Random(order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -252,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var vectorb = Vector<Complex32>.Build.Random(order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),
@@ -294,8 +294,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs

@@ -252,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var vectorb = Vector<Complex32>.Build.Random(order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),
@@ -294,8 +294,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         {
             for (var iteration = 5; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<Complex32>.Build.Random(order, order, 1);
+                var matrixB = Matrix<Complex32>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<Complex32>(
                     new IterationCountStopCriterium<Complex32>(1000),

src/UnitTests/LinearAlgebraTests/Complex32/SparseMatrixTests.cs

@@ -64,27 +64,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             return SparseMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(int size)
-        {
-            return new SparseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(Complex32[] data)
-        {
-            return SparseVector.OfEnumerable(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Complex32/UserDefinedMatrixTests.cs

@@ -55,26 +55,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         {
             return new UserDefinedMatrix(data);
         }
-
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(int size)
-        {
-            return new UserDefinedVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<Complex32> CreateVector(Complex32[] data)
-        {
-            return new UserDefinedVector(data);
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs

@@ -62,27 +62,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             return Matrix<double>.Build.DenseOfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(int size)
-        {
-            return Vector<double>.Build.Dense(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(double[] data)
-        {
-            return Vector<double>.Build.Dense(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs

@@ -62,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             TestMatrices = new Dictionary<string, Matrix<double>>();
             foreach (var name in TestData2D.Keys)
             {
-                TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
+                TestMatrices.Add(name, DiagonalMatrix.OfArray(TestData2D[name]));
             }
         }
 
@@ -87,27 +87,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             return DiagonalMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(int size)
-        {
-            return Vector<double>.Build.Dense(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(double[] data)
-        {
-            return Vector<double>.Build.Dense(data);
-        }
-
         /// <summary>
         /// Can create a matrix from a diagonal array.
         /// </summary>
@@ -234,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void PermuteMatrixRowsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteRows(permutation));
         }
@@ -245,7 +224,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void PermuteMatrixColumnsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteColumns(permutation));
         }

src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs

@@ -108,7 +108,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixX = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -148,10 +148,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<double>.Build.Random(order, 1);
             var x = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.Count, x.Count);
@@ -187,10 +187,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(row);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<double>.Build.Random(row, col, 1);
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -229,10 +229,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<double>.Build.Random(order, 1);
             var matrixBCopy = matrixB.Clone();
             var x = new DenseVector(order);
             chol.Solve(matrixB, x);
@@ -276,10 +276,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(row);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<double>.Build.Random(row, col, 1);
             var matrixBCopy = matrixB.Clone();
             var matrixX = new DenseMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs

@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -116,7 +116,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
@@ -149,7 +149,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -208,12 +208,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -250,12 +250,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
 
             var matrixX = factorEvd.Solve(matrixB);
 
@@ -299,11 +299,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -345,12 +345,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<double>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs

@@ -121,7 +121,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -169,11 +169,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -208,11 +208,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -254,10 +254,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -300,11 +300,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -352,11 +352,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void CanSolveForMatrixWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<double>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<double>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -391,11 +391,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void CanSolveForVectorWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<double>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<double>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Double/Factorization/LUTests.cs

@@ -109,7 +109,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixX = Matrix<double>.Build.Random(order, order, 1);
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -164,11 +164,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -203,11 +203,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -249,10 +249,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -295,11 +295,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -353,7 +353,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs

@@ -138,7 +138,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -204,7 +204,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -269,11 +269,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -308,11 +308,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -354,10 +354,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -400,11 +400,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -458,11 +458,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -497,11 +497,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -543,10 +543,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<double>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -589,11 +589,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -643,11 +643,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForMatrixWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<double>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<double>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -684,11 +684,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForVectorWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<double>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<double>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs

@@ -82,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -121,7 +121,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -140,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -185,10 +185,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 10);
+            var matrixA = Matrix<double>.Build.Random(10, 10, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(10, 10);
+            var matrixB = Matrix<double>.Build.Random(10, 10, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -198,10 +198,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 10);
+            var matrixA = Matrix<double>.Build.Random(10, 10, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(10);
+            var vectorb = Vector<double>.Build.Random(10, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -218,11 +218,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<double>.Build.Random(row, 1);
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -258,11 +258,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<double>.Build.Random(row, column, 1);
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -305,10 +305,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<double>.Build.Random(row, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -350,11 +350,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<double>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<double>.Build.Random(row, column, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Double/Factorization/UserCholeskyTests.cs

@@ -24,11 +24,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
 {
-    using System;
-    using NUnit.Framework;
-
     /// <summary>
     /// Cholesky factorization tests for a user matrix.
     /// </summary>
@@ -106,7 +107,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixX = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -146,10 +147,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var x = chol.Solve(b);
 
             Assert.AreEqual(b.Count, x.Count);
@@ -185,10 +186,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(row, col, 1).ToArray());
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -227,10 +228,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var matrixBCopy = b.Clone();
             var x = new UserDefinedVector(order);
             chol.Solve(b, x);
@@ -274,10 +275,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(row, col, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
             var matrixX = new UserDefinedMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Double/Factorization/UserEvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
@@ -78,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -114,7 +115,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -146,7 +147,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -204,11 +205,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -243,11 +244,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -289,10 +290,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -333,11 +334,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Double/Factorization/UserGramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double.Factorization;
 using NUnit.Framework;
 
@@ -119,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -167,11 +168,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -206,11 +207,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -252,10 +253,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -298,11 +299,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Double/Factorization/UserLUTests.cs

@@ -24,11 +24,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
 {
-    using System;
-    using NUnit.Framework;
-
     /// <summary>
     /// LU factorization tests for a user matrix.
     /// </summary>
@@ -107,7 +108,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixX = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -162,11 +163,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -201,11 +202,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -247,10 +248,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -293,11 +294,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -351,7 +352,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Double/Factorization/UserQRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double.Factorization;
 using MathNet.Numerics.LinearAlgebra.Factorization;
 using NUnit.Framework;
@@ -136,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -185,7 +186,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -233,11 +234,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -272,11 +273,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -318,10 +319,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -364,11 +365,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -422,11 +423,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -461,11 +462,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -507,10 +508,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -553,11 +554,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Double/Factorization/UserSvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
@@ -80,7 +81,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -119,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(order, order, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -183,10 +184,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 10);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(10, 10, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 10);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(10, 10, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -196,10 +197,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 10);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(10, 10, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(10);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(10, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -216,11 +217,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(row, 1).ToArray());
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -256,11 +257,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -303,10 +304,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<double>.Build.Random(row, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -348,11 +349,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<double>.Build.Random(row, column, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Double/MatrixLoader.cs

@@ -64,21 +64,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given values.</returns>
         protected abstract Matrix<double> CreateMatrix(double[,] data);
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<double> CreateVector(int size);
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<double> CreateVector(double[] data);
-
         /// <summary>
         /// Setup test matrices.
         /// </summary>
@@ -102,35 +87,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
                 TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
             }
         }
-
-        public static Matrix<double> GenerateRandomDenseMatrix(int row, int col)
-        {
-            return Matrix<double>.Build.Random(row, col, 1);
-        }
-
-        public static Matrix<double> GenerateRandomPositiveDefiniteDenseMatrix(int order)
-        {
-            return Matrix<double>.Build.RandomPositiveDefinite(order, 1);
-        }
-
-        public static Vector<double> GenerateRandomDenseVector(int order)
-        {
-            return Vector<double>.Build.Random(order, 1);
-        }
-
-        public static Matrix<double> GenerateRandomUserDefinedMatrix(int row, int col)
-        {
-            return new UserDefinedMatrix(GenerateRandomDenseMatrix(row, col).ToArray());
-        }
-
-        public static Matrix<double> GenerateRandomPositiveDefiniteUserDefinedMatrix(int order)
-        {
-            return new UserDefinedMatrix(GenerateRandomPositiveDefiniteDenseMatrix(order).ToArray());
-        }
-
-        public static Vector<double> GenerateRandomUserDefinedVector(int order)
-        {
-            return new UserDefinedVector(GenerateRandomDenseVector(order).ToArray());
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Double/MatrixTests.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase("Wide2x3")]
         public void CanTransposeMatrix(string name)
         {
-            var matrix = CreateMatrix(TestData2D[name]);
+            var matrix = TestMatrices[name];
             var transpose = matrix.Transpose();
 
             Assert.AreNotSame(matrix, transpose);

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs

@@ -250,8 +250,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var vectorb = Vector<double>.Build.Random(order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),
@@ -280,8 +280,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs

@@ -250,8 +250,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var vectorb = Vector<double>.Build.Random(order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),
@@ -280,8 +280,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -250,8 +250,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var vectorb = Vector<double>.Build.Random(order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),
@@ -280,8 +280,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs

@@ -250,8 +250,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var vectorb = Vector<double>.Build.Random(order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),
@@ -280,8 +280,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         [TestCase(10)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<double>.Build.Random(order, order, 1);
+            var matrixB = Matrix<double>.Build.Random(order, order, 1);
 
             var monitor = new Iterator<double>(
                 new IterationCountStopCriterium<double>(1000),

src/UnitTests/LinearAlgebraTests/Double/SparseMatrixTests.cs

@@ -62,27 +62,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             return Matrix<double>.Build.SparseOfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(int size)
-        {
-            return Vector<double>.Build.Sparse(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(double[] data)
-        {
-            return Vector<double>.Build.SparseOfEnumerable(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Double/UserDefinedMatrixTests.cs

@@ -53,26 +53,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             return new UserDefinedMatrix(data);
         }
-
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(int size)
-        {
-            return new UserDefinedVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<double> CreateVector(double[] data)
-        {
-            return new UserDefinedVector(data);
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/DenseMatrixTests.cs

@@ -62,27 +62,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             return DenseMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(int size)
-        {
-            return new DenseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(float[] data)
-        {
-            return new DenseVector(data);
-        }
-
         /// <summary>
         /// Can create a matrix form array.
         /// </summary>

src/UnitTests/LinearAlgebraTests/Single/DiagonalMatrixTests.cs

@@ -62,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             TestMatrices = new Dictionary<string, Matrix<float>>();
             foreach (var name in TestData2D.Keys)
             {
-                TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
+                TestMatrices.Add(name, DiagonalMatrix.OfArray(TestData2D[name]));
             }
         }
 
@@ -87,27 +87,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             return DiagonalMatrix.OfArray(data);
         }
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(int size)
-        {
-            return new DenseVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(float[] data)
-        {
-            return new DenseVector(data);
-        }
-
         /// <summary>
         /// Can create a matrix from a diagonal array.
         /// </summary>
@@ -233,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void PermuteMatrixRowsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteRows(permutation));
         }
@@ -244,7 +223,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void PermuteMatrixColumnsThrowsInvalidOperationException()
         {
-            var matrixp = CreateMatrix(TestData2D["Singular3x3"]);
+            var matrixp = DiagonalMatrix.OfArray(TestData2D["Singular3x3"]);
             var permutation = new Permutation(new[] {2, 0, 1});
             Assert.Throws<InvalidOperationException>(() => matrixp.PermuteColumns(permutation));
         }

src/UnitTests/LinearAlgebraTests/Single/Factorization/CholeskyTests.cs

@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
 {
@@ -107,7 +108,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixX = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -147,10 +148,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<float>.Build.Random(order, 1);
             var x = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.Count, x.Count);
@@ -186,10 +187,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(row);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<float>.Build.Random(row, col, 1);
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -228,10 +229,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseVector(order);
+            var matrixB = Vector<float>.Build.Random(order, 1);
             var matrixBCopy = matrixB.Clone();
             var x = new DenseVector(order);
             chol.Solve(matrixB, x);
@@ -275,10 +276,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(row);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(row, 1);
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, col);
+            var matrixB = Matrix<float>.Build.Random(row, col, 1);
             var matrixBCopy = matrixB.Clone();
             var matrixX = new DenseMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Single/Factorization/EvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using NUnit.Framework;
 
@@ -74,7 +75,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void CanFactorizeRandomMatrix([Values(1, 2, 5, 10, 50, 100)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -105,7 +106,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10, 50)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -196,12 +197,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -237,12 +238,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -285,11 +286,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -331,12 +332,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteDenseMatrix(order);
+            var matrixA = Matrix<float>.Build.RandomPositiveDefinite(order, 1);
             MatrixHelpers.ForceSymmetric(matrixA);
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Single/Factorization/GramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Factorization;
 using NUnit.Framework;
@@ -120,7 +121,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -168,11 +169,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -207,11 +208,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -253,10 +254,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -299,11 +300,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -351,11 +352,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void CanSolveForMatrixWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<float>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<float>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -390,11 +391,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void CanSolveForVectorWithTallRandomMatrix()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<float>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.GramSchmidt();
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<float>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Single/Factorization/LUTests.cs

@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
 {
@@ -108,7 +109,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixX = Matrix<float>.Build.Random(order, order, 1);
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -163,11 +164,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -202,11 +203,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -248,10 +249,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -294,11 +295,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -352,7 +353,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Single/Factorization/QRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Factorization;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Factorization;
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -205,7 +206,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -270,11 +271,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -309,11 +310,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -355,10 +356,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -401,11 +402,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -458,11 +459,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -497,11 +498,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -543,10 +544,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+            var vectorb = Vector<float>.Build.Random(order, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -589,11 +590,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixB = Matrix<float>.Build.Random(order, order, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(order, order);
@@ -643,11 +644,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForMatrixWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<float>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(20, 5);
+            var matrixB = Matrix<float>.Build.Random(20, 5, 1);
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -684,11 +685,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(QRMethod.Thin)]
         public void CanSolveForVectorWithTallRandomMatrix(QRMethod method)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(20, 10);
+            var matrixA = Matrix<float>.Build.Random(20, 10, 1);
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(method);
 
-            var vectorB = MatrixLoader.GenerateRandomDenseVector(20);
+            var vectorB = Vector<float>.Build.Random(20, 1);
             var vectorX = factorQR.Solve(vectorB);
 
             // The solution x dimension is equal to the column dimension of A

src/UnitTests/LinearAlgebraTests/Single/Factorization/SvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using NUnit.Framework;
 
@@ -81,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -120,7 +121,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -139,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+            var matrixA = Matrix<float>.Build.Random(order, order, 1);
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -184,10 +185,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 10);
+            var matrixA = Matrix<float>.Build.Random(10, 10, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(10, 10);
+            var matrixB = Matrix<float>.Build.Random(10, 10, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -197,10 +198,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(10, 10);
+            var matrixA = Matrix<float>.Build.Random(10, 10, 1);
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(10);
+            var vectorb = Vector<float>.Build.Random(10, 1);
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -217,11 +218,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<float>.Build.Random(row, 1);
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -257,11 +258,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<float>.Build.Random(row, column, 1);
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -304,10 +305,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomDenseVector(row);
+            var vectorb = Vector<float>.Build.Random(row, 1);
             var vectorbCopy = vectorb.Clone();
             var resultx = new DenseVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -349,11 +350,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixA = Matrix<float>.Build.Random(row, column, 1);
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomDenseMatrix(row, column);
+            var matrixB = Matrix<float>.Build.Random(row, column, 1);
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new DenseMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Single/Factorization/UserCholeskyTests.cs

@@ -24,11 +24,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
 {
-    using System;
-    using NUnit.Framework;
-
     /// <summary>
     /// Cholesky factorization tests for a user matrix.
     /// </summary>
@@ -106,7 +107,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixX = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var chol = matrixX.Cholesky();
             var factorC = chol.Factor;
 
@@ -146,10 +147,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var x = chol.Solve(b);
 
             Assert.AreEqual(b.Count, x.Count);
@@ -185,10 +186,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrix(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(row, col, 1).ToArray());
             var matrixX = chol.Solve(matrixB);
 
             Assert.AreEqual(matrixB.RowCount, matrixX.RowCount);
@@ -227,10 +228,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var b = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var b = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var matrixBCopy = b.Clone();
             var x = new UserDefinedVector(order);
             chol.Solve(b, x);
@@ -274,10 +275,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int col)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(row);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(row, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var chol = matrixA.Cholesky();
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, col);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(row, col, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
             var matrixX = new UserDefinedMatrix(row, col);
             chol.Solve(matrixB, matrixX);

src/UnitTests/LinearAlgebraTests/Single/Factorization/UserEvdTests.cs

@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
@@ -78,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -109,7 +110,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test, Ignore]
         public void CanFactorizeRandomSymmetricMatrix([Values(1, 2, 5, 10, 50, 100)] int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var factorEvd = matrixA.Evd();
             var eigenVectors = factorEvd.EigenVectors;
             var d = factorEvd.D;
@@ -141,7 +142,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var factorEvd = matrixA.Evd();
 
             Assert.AreEqual(factorEvd.Rank, order);
@@ -199,11 +200,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var resultx = factorEvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -238,11 +239,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorEvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -284,10 +285,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorAndSymmetricMatrixWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorEvd.Solve(vectorb, resultx);
@@ -328,11 +329,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixAndSymmetricMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomPositiveDefiniteUserDefinedMatrix(order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.RandomPositiveDefinite(order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorEvd = matrixA.Evd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Single/Factorization/UserGramSchmidtTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single.Factorization;
 using NUnit.Framework;
 
@@ -119,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var factorGramSchmidt = matrixA.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -167,11 +168,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var resultx = factorGramSchmidt.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -206,11 +207,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorGramSchmidt.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -252,10 +253,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorGramSchmidt.Solve(vectorb, resultx);
@@ -298,11 +299,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorGramSchmidt = matrixA.GramSchmidt();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Single/Factorization/UserLUTests.cs

@@ -24,11 +24,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
 {
-    using System;
-    using NUnit.Framework;
-
     /// <summary>
     /// LU factorization tests for a user matrix.
     /// </summary>
@@ -107,7 +108,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanFactorizeRandomMatrix(int order)
         {
-            var matrixX = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixX = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var factorLU = matrixX.LU();
             var matrixL = factorLU.L;
             var matrixU = factorLU.U;
@@ -162,11 +163,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var resultx = factorLU.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -201,11 +202,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorLU.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -247,10 +248,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorLU.Solve(vectorb, resultx);
@@ -293,11 +294,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -351,7 +352,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanInverse(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorLU = matrixA.LU();
 

src/UnitTests/LinearAlgebraTests/Single/Factorization/UserQRTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Factorization;
 using MathNet.Numerics.LinearAlgebra.Single.Factorization;
 using NUnit.Framework;
@@ -136,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Full);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -185,7 +186,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrixUsingThinQR(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var factorQR = matrixA.QR(QRMethod.Thin);
             var q = factorQR.Q;
             var r = factorQR.R;
@@ -233,11 +234,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVector(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -272,11 +273,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrix(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -318,10 +319,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -364,11 +365,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);
@@ -422,11 +423,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var resultx = factorQR.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -461,11 +462,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixX = factorQR.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -507,10 +508,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomVectorWhenResultVectorGivenUsingThinQR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(order);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(order, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(order);
             factorQR.Solve(vectorb, resultx);
@@ -553,11 +554,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGivenUsingThinAR(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorQR = matrixA.QR(QRMethod.Thin);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(order, order);

src/UnitTests/LinearAlgebraTests/Single/Factorization/UserSvdTests.cs

@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
@@ -80,7 +81,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 98)]
         public void CanFactorizeRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
@@ -119,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(100, 93)]
         public void CanCheckRankOfNonSquare(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             var mn = Math.Min(row, column);
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(90)]
         public void CanCheckRankSquare(int order)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(order, order);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(order, order, 1).ToArray());
             var factorSvd = matrixA.Svd();
 
             if (factorSvd.Determinant != 0)
@@ -183,10 +184,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void SolveMatrixIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 10);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(10, 10, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 10);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(10, 10, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(matrixB));
         }
 
@@ -196,10 +197,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [Test]
         public void SolveVectorIfVectorsNotComputedThrowsInvalidOperationException()
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(10, 10);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(10, 10, 1).ToArray());
             var factorSvd = matrixA.Svd(false);
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(10);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(10, 1).ToArray());
             Assert.Throws<InvalidOperationException>(() => factorSvd.Solve(vectorb));
         }
 
@@ -216,11 +217,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVector(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(row, 1).ToArray());
             var resultx = factorSvd.Solve(vectorb);
 
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
@@ -256,11 +257,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrix(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var matrixX = factorSvd.Solve(matrixB);
 
             // The solution X row dimension is equal to the column dimension of A
@@ -303,10 +304,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(90, 100)]
         public void CanSolveForRandomVectorWhenResultVectorGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
-            var vectorb = MatrixLoader.GenerateRandomUserDefinedVector(row);
+            var vectorb = new UserDefinedVector(Vector<float>.Build.Random(row, 1).ToArray());
             var vectorbCopy = vectorb.Clone();
             var resultx = new UserDefinedVector(column);
             factorSvd.Solve(vectorb, resultx);
@@ -348,11 +349,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Factorization
         [TestCase(80, 100)]
         public void CanSolveForRandomMatrixWhenResultMatrixGiven(int row, int column)
         {
-            var matrixA = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixA = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var matrixACopy = matrixA.Clone();
             var factorSvd = matrixA.Svd();
 
-            var matrixB = MatrixLoader.GenerateRandomUserDefinedMatrix(row, column);
+            var matrixB = new UserDefinedMatrix(Matrix<float>.Build.Random(row, column, 1).ToArray());
             var matrixBCopy = matrixB.Clone();
 
             var matrixX = new UserDefinedMatrix(column, column);

src/UnitTests/LinearAlgebraTests/Single/MatrixLoader.cs

@@ -64,21 +64,6 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         /// <returns>A matrix with the given values.</returns>
         protected abstract Matrix<float> CreateMatrix(float[,] data);
 
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<float> CreateVector(int size);
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected abstract Vector<float> CreateVector(float[] data);
-
         /// <summary>
         /// Setup test matrices.
         /// </summary>
@@ -102,35 +87,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
                 TestMatrices.Add(name, CreateMatrix(TestData2D[name]));
             }
         }
-
-        public static Matrix<float> GenerateRandomDenseMatrix(int row, int col)
-        {
-            return Matrix<float>.Build.Random(row, col, 1);
-        }
-
-        public static Matrix<float> GenerateRandomPositiveDefiniteDenseMatrix(int order)
-        {
-            return Matrix<float>.Build.RandomPositiveDefinite(order, 1);
-        }
-
-        public static Vector<float> GenerateRandomDenseVector(int order)
-        {
-            return Vector<float>.Build.Random(order, 1);
-        }
-
-        public static Matrix<float> GenerateRandomUserDefinedMatrix(int row, int col)
-        {
-            return new UserDefinedMatrix(GenerateRandomDenseMatrix(row, col).ToArray());
-        }
-
-        public static Matrix<float> GenerateRandomPositiveDefiniteUserDefinedMatrix(int order)
-        {
-            return new UserDefinedMatrix(GenerateRandomPositiveDefiniteDenseMatrix(order).ToArray());
-        }
-
-        public static Vector<float> GenerateRandomUserDefinedVector(int order)
-        {
-            return new UserDefinedVector(GenerateRandomDenseVector(order).ToArray());
-        }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/MatrixTests.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [TestCase("Wide2x3")]
         public void CanTransposeMatrix(string name)
         {
-            var matrix = CreateMatrix(TestData2D[name]);
+            var matrix = TestMatrices[name];
             var transpose = matrix.Transpose();
 
             Assert.AreNotSame(matrix, transpose);

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs

@@ -252,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 3 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var vectorb = Vector<float>.Build.Random(order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),
@@ -292,8 +292,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 3 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var matrixB = Matrix<float>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs

@@ -252,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 3 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var vectorb = Vector<float>.Build.Random(order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),
@@ -292,8 +292,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 3 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var matrixB = Matrix<float>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -269,8 +269,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 4 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var vectorb = Vector<float>.Build.Random(order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),
@@ -311,8 +311,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 4 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var matrixB = Matrix<float>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs

@@ -252,8 +252,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 3 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var vectorb = Vector<float>.Build.Random(order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),
@@ -292,8 +292,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             // That's why we will do 4 tries and downgrade stop criterium each time
             for (var iteration = 6; iteration > 3; iteration--)
             {
-                var matrixA = MatrixLoader.GenerateRandomDenseMatrix(order, order);
-                var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
+                var matrixA = Matrix<float>.Build.Random(order, order, 1);
+                var matrixB = Matrix<float>.Build.Random(order, order, 1);
 
                 var monitor = new Iterator<float>(
                     new IterationCountStopCriterium<float>(MaximumIterations),

src/UnitTests/LinearAlgebraTests/Single/SparseMatrixTests.cs

@@ -68,7 +68,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         /// <param name="size">The size of the vector to create.
         /// </param>
         /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(int size)
+        protected virtual Vector<float> CreateVector(int size)
         {
             return new SparseVector(size);
         }
@@ -78,7 +78,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         /// </summary>
         /// <param name="data">The array to create this vector from.</param>
         /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(float[] data)
+        protected virtual Vector<float> CreateVector(float[] data)
         {
             return SparseVector.OfEnumerable(data);
         }

src/UnitTests/LinearAlgebraTests/Single/UserDefinedMatrixTests.cs

@@ -53,26 +53,5 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         {
             return new UserDefinedMatrix(data);
         }
-
-        /// <summary>
-        /// Creates a vector of the given size.
-        /// </summary>
-        /// <param name="size">The size of the vector to create.
-        /// </param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(int size)
-        {
-            return new UserDefinedVector(size);
-        }
-
-        /// <summary>
-        /// Creates a vector from an array.
-        /// </summary>
-        /// <param name="data">The array to create this vector from.</param>
-        /// <returns>The new vector. </returns>
-        protected override Vector<float> CreateVector(float[] data)
-        {
-            return new UserDefinedVector(data);
-        }
     }
 }