diff --git a/src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
index cb2017ca..00d5fa58 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/MatrixStructureTheory.cs
@@ -28,11 +28,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
-using System.Linq;
-using MathNet.Numerics.Distributions;
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.Random;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
@@ -48,53 +44,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
     {
         [Datapoints]
         Matrix<Complex>[] _matrices = new Matrix<Complex>[]
-            {
-                DenseMatrix.OfArray(new[,] {{1d, new Complex(1.1d, -4d), 2d}, {1d, 1d, 2d}, {1d, new Complex(1d, 2d), 2d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, 1.1d, new Complex(2.2d, -1.2d)}, {-4.4d, 5.5d, 6.6d}}),
-                DenseMatrix.OfArray(new[,] {{new Complex(-1.1d, -2d), -2.2d, -3.3d, -4.4d}, {0d, 1.1d, 2.2d, 3.3d}, {1d, 2.1d, 6.2d, 4.3d}, {-4.4d, 5.5d, 6.6d, -7.7d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, new Complex(-2.2d, 3.4d), -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d}, {Complex.Zero, 1.1d}, {-4.4d, 5.5d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, new Complex(1.1d, 0.1d), 2.2d}}),
-                DenseMatrix.OfArray(new[,] {{1d, 2d, 3d}, {2d, new Complex(2d, 2d), 0d}, {3d, Complex.Zero, 3d}}),
-
-                SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {1d, 1d, 2d}, {1d, 1d + Complex.ImaginaryOne, 2d}}),
-                SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {new Complex(1d, 2d), 0d, Complex.Zero}, {-2d, 0d, 0d}}),
-                SparseMatrix.OfArray(new[,] {{-1.1d, 0d, 0d}, {0d, new Complex(1.1d, 2d), 2.2d}}),
-
-                new DiagonalMatrix(3, 3, new[] {new Complex(1d, 1d), -2d, 1.5d}),
-                new DiagonalMatrix(3, 3, new[] {new Complex(1d, 2d), 0d, -1.5d}),
-
-                new UserDefinedMatrix(new[,] {{0d, 1d, 2d}, {-1d, 7.7d, 0d}, {-2d, Complex.Zero, 0d}})
-            };
-
-        [Datapoints]
-        Complex[] scalars = new[] {new Complex(2d, 0d), new Complex(-1.5d, 3.5d), Complex.Zero};
-
-        protected override Matrix<Complex> CreateDenseZero(int rows, int columns)
         {
-            return new DenseMatrix(rows, columns);
-        }
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { 1d, new Complex(1.1d, -4d), 2d }, { 1d, 1d, 2d }, { 1d, new Complex(1d, 2d), 2d } }),
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, 1.1d, new Complex(2.2d, -1.2d) }, { -4.4d, 5.5d, 6.6d } }),
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { new Complex(-1.1d, -2d), -2.2d, -3.3d, -4.4d }, { 0d, 1.1d, 2.2d, 3.3d }, { 1d, 2.1d, 6.2d, 4.3d }, { -4.4d, 5.5d, 6.6d, -7.7d } }),
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, new Complex(-2.2d, 3.4d), -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d } }),
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d }, { Complex.Zero, 1.1d }, { -4.4d, 5.5d } }),
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, new Complex(1.1d, 0.1d), 2.2d } }),
+            Matrix<Complex>.Build.DenseOfArray(new[,] { { 1d, 2d, 3d }, { 2d, new Complex(2d, 2d), 0d }, { 3d, Complex.Zero, 3d } }),
 
-        protected override Matrix<Complex> CreateDenseRandom(int rows, int columns, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseMatrix(rows, columns, Enumerable.Range(0, rows*columns).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray());
-        }
+            Matrix<Complex>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { 1d, 1d, 2d }, { 1d, 1d + Complex.ImaginaryOne, 2d } }),
+            Matrix<Complex>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { new Complex(1d, 2d), 0d, Complex.Zero }, { -2d, 0d, 0d } }),
+            Matrix<Complex>.Build.SparseOfArray(new[,] { { -1.1d, 0d, 0d }, { 0d, new Complex(1.1d, 2d), 2.2d } }),
 
-        protected override Matrix<Complex> CreateSparseZero(int rows, int columns)
-        {
-            return new SparseMatrix(rows, columns);
-        }
+            Matrix<Complex>.Build.Diagonal(3, 3, new[] { new Complex(1d, 1d), -2d, 1.5d }),
+            Matrix<Complex>.Build.Diagonal(3, 3, new[] { new Complex(1d, 2d), 0d, -1.5d }),
 
-        protected override Vector<Complex> CreateVectorZero(int size)
-        {
-            return new DenseVector(size);
-        }
+            new UserDefinedMatrix(new[,] { { 0d, 1d, 2d }, { -1d, 7.7d, 0d }, { -2d, Complex.Zero, 0d } })
+        };
 
-        protected override Vector<Complex> CreateVectorRandom(int size, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex(dist.Sample(), dist.Sample())).ToArray());
-        }
+        [Datapoints]
+        Complex[] _scalars = new[] { new Complex(2d, 0d), new Complex(-1.5d, 3.5d), Complex.Zero };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
index 7dcf249f..968ab8ec 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixStructureTheory.cs
@@ -28,11 +28,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
-using System.Linq;
-using MathNet.Numerics.Distributions;
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.Random;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
@@ -44,53 +40,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
     {
         [Datapoints]
         Matrix<Complex32>[] _matrices = new Matrix<Complex32>[]
-            {
-                DenseMatrix.OfArray(new[,] {{1f, new Complex32(1.1f, -4f), 2f}, {1f, 1f, 2f}, {1f, new Complex32(1f, 2f), 2f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, 1.1f, new Complex32(2.2f, -1.2f)}, {-4.4f, 5.5f, 6.6f}}),
-                DenseMatrix.OfArray(new[,] {{new Complex32(-1.1f, -2f), -2.2f, -3.3f, -4.4f}, {0f, 1.1f, 2.2f, 3.3f}, {1f, 2.1f, 6.2f, 4.3f}, {-4.4f, 5.5f, 6.6f, -7.7f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, new Complex32(-2.2f, 3.4f), -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f}, {Complex32.Zero, 1.1f}, {-4.4f, 5.5f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, new Complex32(1.1f, 0.1f), 2.2f}}),
-                DenseMatrix.OfArray(new[,] {{1f, 2f, 3f}, {2f, new Complex32(2f, 2f), 0f}, {3f, Complex32.Zero, 3f}}),
-
-                SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {1f, 1f, 2f}, {1f, 1f + Complex32.ImaginaryOne, 2f}}),
-                SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {new Complex32(1f, 2f), 0f, Complex32.Zero}, {-2f, 0f, 0f}}),
-                SparseMatrix.OfArray(new[,] {{-1.1f, 0f, 0f}, {0f, new Complex32(1.1f, 2f), 2.2f}}),
-
-                new DiagonalMatrix(3, 3, new[] {new Complex32(1f, 1f), -2f, 1.5f}),
-                new DiagonalMatrix(3, 3, new[] {new Complex32(1f, 2f), 0f, -1.5f}),
-
-                new UserDefinedMatrix(new[,] {{0f, 1f, 2f}, {-1f, 7.7f, 0f}, {-2f, Complex32.Zero, 0f}})
-            };
-
-        [Datapoints]
-        Complex32[] scalars = new[] {new Complex32(2f, 0f), new Complex32(-1.5f, 3.5f), Complex32.Zero};
-
-        protected override Matrix<Complex32> CreateDenseZero(int rows, int columns)
         {
-            return new DenseMatrix(rows, columns);
-        }
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { 1f, new Complex32(1.1f, -4f), 2f }, { 1f, 1f, 2f }, { 1f, new Complex32(1f, 2f), 2f } }),
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, 1.1f, new Complex32(2.2f, -1.2f) }, { -4.4f, 5.5f, 6.6f } }),
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { new Complex32(-1.1f, -2f), -2.2f, -3.3f, -4.4f }, { 0f, 1.1f, 2.2f, 3.3f }, { 1f, 2.1f, 6.2f, 4.3f }, { -4.4f, 5.5f, 6.6f, -7.7f } }),
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, new Complex32(-2.2f, 3.4f), -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f } }),
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f }, { Complex32.Zero, 1.1f }, { -4.4f, 5.5f } }),
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, new Complex32(1.1f, 0.1f), 2.2f } }),
+            Matrix<Complex32>.Build.DenseOfArray(new[,] { { 1f, 2f, 3f }, { 2f, new Complex32(2f, 2f), 0f }, { 3f, Complex32.Zero, 3f } }),
 
-        protected override Matrix<Complex32> CreateDenseRandom(int rows, int columns, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseMatrix(rows, columns, Enumerable.Range(0, rows*columns).Select(k => new Complex32((float) dist.Sample(), (float) dist.Sample())).ToArray());
-        }
+            Matrix<Complex32>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { 1f, 1f, 2f }, { 1f, 1f + Complex32.ImaginaryOne, 2f } }),
+            Matrix<Complex32>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { new Complex32(1f, 2f), 0f, Complex32.Zero }, { -2f, 0f, 0f } }),
+            Matrix<Complex32>.Build.SparseOfArray(new[,] { { -1.1f, 0f, 0f }, { 0f, new Complex32(1.1f, 2f), 2.2f } }),
 
-        protected override Matrix<Complex32> CreateSparseZero(int rows, int columns)
-        {
-            return new SparseMatrix(rows, columns);
-        }
+            Matrix<Complex32>.Build.Diagonal(3, 3, new[] { new Complex32(1f, 1f), -2f, 1.5f }),
+            Matrix<Complex32>.Build.Diagonal(3, 3, new[] { new Complex32(1f, 2f), 0f, -1.5f }),
 
-        protected override Vector<Complex32> CreateVectorZero(int size)
-        {
-            return new DenseVector(size);
-        }
+            new UserDefinedMatrix(new[,] { { 0f, 1f, 2f }, { -1f, 7.7f, 0f }, { -2f, Complex32.Zero, 0f } })
+        };
 
-        protected override Vector<Complex32> CreateVectorRandom(int size, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseVector(Enumerable.Range(0, size).Select(k => new Complex32((float) dist.Sample(), (float) dist.Sample())).ToArray());
-        }
+        [Datapoints]
+        Complex32[] scalars = new[] { new Complex32(2f, 0f), new Complex32(-1.5f, 3.5f), Complex32.Zero };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs b/src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
index 7b083e37..4136cdad 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/MatrixStructureTheory.cs
@@ -28,11 +28,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
-using System.Linq;
-using MathNet.Numerics.Distributions;
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.Random;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
@@ -42,53 +38,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
     {
         [Datapoints]
         Matrix<double>[] _matrices = new Matrix<double>[]
-            {
-                DenseMatrix.OfArray(new[,] {{1d, 1d, 2d}, {1d, 1d, 2d}, {1d, 1d, 2d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, 1.1d, 2.2d}, {-4.4d, 5.5d, 6.6d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d, -4.4d}, {0d, 1.1d, 2.2d, 3.3d}, {1d, 2.1d, 6.2d, 4.3d}, {-4.4d, 5.5d, 6.6d, -7.7d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}, {-1.1d, -2.2d, -3.3d, -4.4d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d}, {0d, 1.1d}, {-4.4d, 5.5d}}),
-                DenseMatrix.OfArray(new[,] {{-1.1d, -2.2d, -3.3d}, {0d, 1.1d, 2.2d}}),
-                DenseMatrix.OfArray(new[,] {{1d, 2d, 3d}, {2d, 2d, 0d}, {3d, 0d, 3d}}),
-
-                SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {1d, 1d, 2d}, {1d, 1d, 2d}}),
-                SparseMatrix.OfArray(new[,] {{7d, 1d, 2d}, {1d, 0d, 0d}, {-2d, 0d, 0d}}),
-                SparseMatrix.OfArray(new[,] {{-1.1d, 0d, 0d}, {0d, 1.1d, 2.2d}}),
-
-                new DiagonalMatrix(3, 3, new[] {1d, -2d, 1.5d}),
-                new DiagonalMatrix(3, 3, new[] {1d, 0d, -1.5d}),
-
-                new UserDefinedMatrix(new[,] {{0d, 1d, 2d}, {-1d, 7.7d, 0d}, {-2d, 0d, 0d}})
-            };
-
-        [Datapoints]
-        double[] _scalars = new[] {2d, -1.5d, 0d};
-
-        protected override Matrix<double> CreateDenseZero(int rows, int columns)
         {
-            return new DenseMatrix(rows, columns);
-        }
+            Matrix<double>.Build.DenseOfArray(new[,] { { 1d, 1d, 2d }, { 1d, 1d, 2d }, { 1d, 1d, 2d } }),
+            Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, 1.1d, 2.2d }, { -4.4d, 5.5d, 6.6d } }),
+            Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d, -4.4d }, { 0d, 1.1d, 2.2d, 3.3d }, { 1d, 2.1d, 6.2d, 4.3d }, { -4.4d, 5.5d, 6.6d, -7.7d } }),
+            Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d }, { -1.1d, -2.2d, -3.3d, -4.4d } }),
+            Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d }, { 0d, 1.1d }, { -4.4d, 5.5d } }),
+            Matrix<double>.Build.DenseOfArray(new[,] { { -1.1d, -2.2d, -3.3d }, { 0d, 1.1d, 2.2d } }),
+            Matrix<double>.Build.DenseOfArray(new[,] { { 1d, 2d, 3d }, { 2d, 2d, 0d }, { 3d, 0d, 3d } }),
 
-        protected override Matrix<double> CreateDenseRandom(int rows, int columns, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseMatrix(rows, columns, dist.Samples().Take(rows*columns).ToArray());
-        }
+            Matrix<double>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { 1d, 1d, 2d }, { 1d, 1d, 2d } }),
+            Matrix<double>.Build.SparseOfArray(new[,] { { 7d, 1d, 2d }, { 1d, 0d, 0d }, { -2d, 0d, 0d } }),
+            Matrix<double>.Build.SparseOfArray(new[,] { { -1.1d, 0d, 0d }, { 0d, 1.1d, 2.2d } }),
 
-        protected override Matrix<double> CreateSparseZero(int rows, int columns)
-        {
-            return new SparseMatrix(rows, columns);
-        }
+            Matrix<double>.Build.Diagonal(3, 3, new[] { 1d, -2d, 1.5d }),
+            Matrix<double>.Build.Diagonal(3, 3, new[] { 1d, 0d, -1.5d }),
 
-        protected override Vector<double> CreateVectorZero(int size)
-        {
-            return new DenseVector(size);
-        }
+            new UserDefinedMatrix(new[,] { { 0d, 1d, 2d }, { -1d, 7.7d, 0d }, { -2d, 0d, 0d } })
+        };
 
-        protected override Vector<double> CreateVectorRandom(int size, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseVector(dist.Samples().Take(size).ToArray());
-        }
+        [Datapoints]
+        double[] _scalars = new[] { 2d, -1.5d, 0d };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs b/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
index caebcecb..6c57a374 100644
--- a/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
+++ b/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Access.cs
@@ -75,7 +75,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetRowIntoResult(Matrix<T> matrix)
         {
-            var row = CreateVectorZero(matrix.ColumnCount);
+            var row = Vector<T>.Build.Dense(matrix.ColumnCount);
             matrix.Row(0, row);
 
             for (var j = 0; j < matrix.ColumnCount; j++)
@@ -126,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetRowWithRangeIntoResult(Matrix<T> matrix)
         {
-            var row = CreateVectorZero(matrix.ColumnCount - 1);
+            var row = Vector<T>.Build.Dense(matrix.ColumnCount - 1);
             matrix.Row(0, 1, matrix.ColumnCount - 1, row);
 
             for (var j = 0; j < matrix.ColumnCount - 1; j++)
@@ -167,7 +167,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetColumnIntoResult(Matrix<T> matrix)
         {
-            var col = CreateVectorZero(matrix.RowCount);
+            var col = Vector<T>.Build.Dense(matrix.RowCount);
             matrix.Column(0, col);
 
             for (var i = 0; i < matrix.RowCount; i++)
@@ -218,7 +218,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetColumnWithRangeIntoResult(Matrix<T> matrix)
         {
-            var col = CreateVectorZero(matrix.RowCount - 1);
+            var col = Vector<T>.Build.Dense(matrix.RowCount - 1);
             matrix.Column(0, 1, matrix.RowCount - 1, col);
 
             for (var i = 0; i < matrix.RowCount - 1; i++)
@@ -261,10 +261,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid Rows
             Assert.That(() => matrix.SetRow(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
-            Assert.That(() => matrix.SetRow(-1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.SetRow(matrix.RowCount, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.SetRow(0, CreateVectorZero(matrix.ColumnCount - 1)), Throws.ArgumentException);
-            Assert.That(() => matrix.SetRow(0, CreateVectorZero(matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.SetRow(-1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.SetRow(matrix.RowCount, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.SetRow(0, Vector<T>.Build.Dense(matrix.ColumnCount - 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.SetRow(0, Vector<T>.Build.Dense(matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -272,7 +272,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             // First Row
             var m = matrix.Clone();
-            m.SetRow(0, CreateVectorZero(matrix.ColumnCount).ToArray());
+            m.SetRow(0, Vector<T>.Build.Dense(matrix.ColumnCount).ToArray());
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)
@@ -329,10 +329,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid Rows
             Assert.That(() => matrix.SetColumn(0, default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
-            Assert.That(() => matrix.SetColumn(-1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.SetColumn(matrix.ColumnCount, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.SetColumn(0, CreateVectorZero(matrix.RowCount - 1)), Throws.ArgumentException);
-            Assert.That(() => matrix.SetColumn(0, CreateVectorZero(matrix.RowCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.SetColumn(-1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.SetColumn(matrix.ColumnCount, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.SetColumn(0, Vector<T>.Build.Dense(matrix.RowCount - 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.SetColumn(0, Vector<T>.Build.Dense(matrix.RowCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -340,7 +340,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             // First Column
             var m = matrix.Clone();
-            m.SetColumn(0, CreateVectorZero(matrix.RowCount).ToArray());
+            m.SetColumn(0, Vector<T>.Build.Dense(matrix.RowCount).ToArray());
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)
@@ -384,7 +384,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetUpperTriangleIntoResult(Matrix<T> matrix)
         {
-            var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
+            var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
             matrix.UpperTriangle(dense);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -394,7 +394,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
                 }
             }
 
-            var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
+            var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
             matrix.UpperTriangle(sparse);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -405,8 +405,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             }
 
             Assert.That(() => matrix.UpperTriangle(null), Throws.Exception);
-            Assert.That(() => matrix.UpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => matrix.UpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.UpperTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => matrix.UpperTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -425,7 +425,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetLowerTriangleIntoResult(Matrix<T> matrix)
         {
-            var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
+            var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
             matrix.LowerTriangle(dense);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -435,7 +435,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
                 }
             }
 
-            var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
+            var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
             matrix.LowerTriangle(sparse);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -446,8 +446,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             }
 
             Assert.That(() => matrix.LowerTriangle(null), Throws.Exception);
-            Assert.That(() => matrix.LowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => matrix.LowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.LowerTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => matrix.LowerTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -466,7 +466,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetStrictlyUpperTriangleIntoResult(Matrix<T> matrix)
         {
-            var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
+            var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
             matrix.StrictlyUpperTriangle(dense);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -476,7 +476,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
                 }
             }
 
-            var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
+            var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
             matrix.StrictlyUpperTriangle(sparse);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -487,8 +487,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             }
 
             Assert.That(() => matrix.StrictlyUpperTriangle(null), Throws.Exception);
-            Assert.That(() => matrix.StrictlyUpperTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => matrix.StrictlyUpperTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.StrictlyUpperTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => matrix.StrictlyUpperTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -507,7 +507,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanGetStrictlyLowerTriangleIntoResult(Matrix<T> matrix)
         {
-            var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
+            var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
             matrix.StrictlyLowerTriangle(dense);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -517,7 +517,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
                 }
             }
 
-            var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
+            var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
             matrix.StrictlyLowerTriangle(sparse);
             for (var i = 0; i < matrix.RowCount; i++)
             {
@@ -528,8 +528,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             }
 
             Assert.That(() => matrix.StrictlyLowerTriangle(null), Throws.Exception);
-            Assert.That(() => matrix.StrictlyLowerTriangle(CreateSparseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => matrix.StrictlyLowerTriangle(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.StrictlyLowerTriangle(Matrix<T>.Build.Sparse(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => matrix.StrictlyLowerTriangle(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -559,8 +559,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid
             Assert.That(() => matrix.SetDiagonal(default(Vector<T>)), Throws.InstanceOf<ArgumentNullException>());
-            Assert.That(() => matrix.SetDiagonal(CreateVectorZero(Math.Min(matrix.RowCount, matrix.ColumnCount) - 1)), Throws.ArgumentException);
-            Assert.That(() => matrix.SetDiagonal(CreateVectorZero(Math.Min(matrix.RowCount, matrix.ColumnCount) + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.SetDiagonal(Vector<T>.Build.Dense(Math.Min(matrix.RowCount, matrix.ColumnCount) - 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.SetDiagonal(Vector<T>.Build.Dense(Math.Min(matrix.RowCount, matrix.ColumnCount) + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -654,16 +654,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             // Invalid
             m = matrix.Clone();
             Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, default(Matrix<T>)), Throws.InstanceOf<NullReferenceException>());
-            Assert.That(() => m.SetSubMatrix(-1, 1, 0, 1, CreateDenseZero(1,1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => m.SetSubMatrix(0, 0, 0, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => m.SetSubMatrix(0, 1, -1, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => m.SetSubMatrix(0, 1, matrix.ColumnCount, 1, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => m.SetSubMatrix(0, 1, 0, 0, CreateDenseZero(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => m.SetSubMatrix(-1, 1, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => m.SetSubMatrix(matrix.RowCount, 1, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => m.SetSubMatrix(0, 0, 0, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => m.SetSubMatrix(0, 1, -1, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => m.SetSubMatrix(0, 1, matrix.ColumnCount, 1, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => m.SetSubMatrix(0, 1, 0, 0, Matrix<T>.Build.Dense(1, 1)), Throws.InstanceOf<ArgumentOutOfRangeException>());
             
             // Usually invalid, but not for SetSubMatrix (since size is explicitly provided)
-            Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, CreateDenseZero(1, 2)), Throws.Nothing);
-            Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, CreateDenseZero(2, 1)), Throws.Nothing);
+            Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, Matrix<T>.Build.Dense(1, 2)), Throws.Nothing);
+            Assert.That(() => m.SetSubMatrix(0, 1, 0, 1, Matrix<T>.Build.Dense(2, 1)), Throws.Nothing);
         }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs b/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
index d226ed3a..76a90ea1 100644
--- a/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
+++ b/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.Reform.cs
@@ -98,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanInsertRow(Matrix<T> matrix)
         {
-            var row = CreateVectorRandom(matrix.ColumnCount, 0);
+            var row = Vector<T>.Build.Random(matrix.ColumnCount, 0);
             for (var position = 0; position < matrix.RowCount + 1; position++)
             {
                 var result = matrix.InsertRow(position, row);
@@ -125,16 +125,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid
             Assert.That(() => matrix.InsertRow(0, default(Vector<T>)), Throws.Exception);
-            Assert.That(() => matrix.InsertRow(-1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, CreateVectorZero(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.InsertRow(0, CreateVectorZero(matrix.ColumnCount - 1)), Throws.ArgumentException);
-            Assert.That(() => matrix.InsertRow(0, CreateVectorZero(matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.InsertRow(-1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.InsertRow(matrix.RowCount + 1, Vector<T>.Build.Dense(matrix.ColumnCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.InsertRow(0, Vector<T>.Build.Dense(matrix.ColumnCount - 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.InsertRow(0, Vector<T>.Build.Dense(matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
         public void CanInsertColumn(Matrix<T> matrix)
         {
-            var column = CreateVectorRandom(matrix.RowCount, 0);
+            var column = Vector<T>.Build.Random(matrix.RowCount, 0);
             for (var position = 0; position < matrix.ColumnCount + 1; position++)
             {
                 var result = matrix.InsertColumn(position, column);
@@ -161,10 +161,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid
             Assert.That(() => matrix.InsertColumn(0, default(Vector<T>)), Throws.Exception);
-            Assert.That(() => matrix.InsertColumn(-1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, CreateVectorZero(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
-            Assert.That(() => matrix.InsertColumn(0, CreateVectorZero(matrix.RowCount - 1)), Throws.ArgumentException);
-            Assert.That(() => matrix.InsertColumn(0, CreateVectorZero(matrix.RowCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.InsertColumn(-1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.InsertColumn(matrix.ColumnCount + 1, Vector<T>.Build.Dense(matrix.RowCount)), Throws.InstanceOf<ArgumentOutOfRangeException>());
+            Assert.That(() => matrix.InsertColumn(0, Vector<T>.Build.Dense(matrix.RowCount - 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.InsertColumn(0, Vector<T>.Build.Dense(matrix.RowCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -196,7 +196,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             Assume.That(left.RowCount, Is.EqualTo(right.RowCount));
 
             // THEN
-            var result = CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount);
+            var result = Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount);
             left.Append(right, result);
 
             Assert.That(result.ColumnCount, Is.EqualTo(left.ColumnCount + right.ColumnCount));
@@ -210,10 +210,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid
             Assert.That(() => left.Append(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
-            Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
-            Assert.That(() => left.Append(right, CreateDenseZero(left.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
+            Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => left.Append(right, Matrix<T>.Build.Dense(left.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -245,7 +245,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             Assume.That(top.ColumnCount, Is.EqualTo(bottom.ColumnCount));
 
             // THEN
-            var result = CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount);
+            var result = Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount);
             top.Stack(bottom, result);
 
             Assert.That(result.RowCount, Is.EqualTo(top.RowCount + bottom.RowCount));
@@ -259,10 +259,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid
             Assert.That(() => top.Stack(bottom, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
-            Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);
-            Assert.That(() => top.Stack(bottom, CreateDenseZero(top.RowCount + bottom.RowCount, top.ColumnCount - 1)), Throws.ArgumentException);
+            Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount + 1, top.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount - 1, top.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => top.Stack(bottom, Matrix<T>.Build.Dense(top.RowCount + bottom.RowCount, top.ColumnCount - 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -294,7 +294,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanDiagonalStackIntoResult(Matrix<T> left, Matrix<T> right)
         {
-            var result = CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount);
+            var result = Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount);
             left.DiagonalStack(right, result);
 
             Assert.That(result.RowCount, Is.EqualTo(left.RowCount + right.RowCount));
@@ -316,10 +316,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 
             // Invalid
             Assert.That(() => left.DiagonalStack(right, default(Matrix<T>)), Throws.InstanceOf<ArgumentNullException>());
-            Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
-            Assert.That(() => left.DiagonalStack(right, CreateDenseZero(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
+            Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount + 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount - 1, left.ColumnCount + right.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => left.DiagonalStack(right, Matrix<T>.Build.Dense(left.RowCount + right.RowCount, left.ColumnCount + right.ColumnCount - 1)), Throws.ArgumentException);
         }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs b/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
index 76b69f33..ed3e89df 100644
--- a/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/MatrixStructureTheory.cs
@@ -28,9 +28,9 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
 using MathNet.Numerics.LinearAlgebra;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
 {
@@ -38,31 +38,20 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
     public abstract partial class MatrixStructureTheory<T>
         where T : struct, IEquatable<T>, IFormattable
     {
-        protected abstract Matrix<T> CreateDenseZero(int rows, int columns);
-        protected abstract Matrix<T> CreateDenseRandom(int rows, int columns, int seed);
-        protected abstract Matrix<T> CreateSparseZero(int rows, int columns);
-        protected abstract Vector<T> CreateVectorZero(int size);
-        protected abstract Vector<T> CreateVectorRandom(int size, int seed);
-
-        protected readonly T Zero;
-
-        protected MatrixStructureTheory()
-        {
-            Zero = Matrix<T>.Build.Zero;
-        }
+        protected readonly T Zero = Matrix<T>.Build.Zero;
 
         protected Matrix<T> CreateDenseFor(Matrix<T> m, int rows = -1, int columns = -1, int seed = 1)
         {
             return m.Storage.IsFullyMutable
-                ? CreateDenseRandom(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount, seed)
-                : CreateDenseZero(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount);
+                ? Matrix<T>.Build.Random(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount, seed)
+                : Matrix<T>.Build.Dense(rows >= 0 ? rows : m.RowCount, columns >= 0 ? columns : m.ColumnCount);
         }
 
         protected Vector<T> CreateVectorFor(Matrix<T> m, int size, int seed = 1)
         {
             return m.Storage.IsFullyMutable
-                ? CreateVectorRandom(size, seed)
-                : CreateVectorZero(size);
+                ? Vector<T>.Build.Random(size, seed)
+                : Vector<T>.Build.Dense(size);
         }
 
         [Theory]
@@ -126,11 +115,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Theory]
         public void CanCopyTo(Matrix<T> matrix)
         {
-            var dense = CreateDenseZero(matrix.RowCount, matrix.ColumnCount);
+            var dense = Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount);
             matrix.CopyTo(dense);
             Assert.That(dense, Is.EqualTo(matrix));
 
-            var sparse = CreateSparseZero(matrix.RowCount, matrix.ColumnCount);
+            var sparse = Matrix<T>.Build.Sparse(matrix.RowCount, matrix.ColumnCount);
             matrix.CopyTo(sparse);
             Assert.That(sparse, Is.EqualTo(matrix));
 
@@ -138,8 +127,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             Assert.That(() => matrix.CopyTo(null), Throws.InstanceOf<ArgumentNullException>());
 
             // bad arg
-            Assert.That(() => matrix.CopyTo(CreateDenseZero(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
-            Assert.That(() => matrix.CopyTo(CreateDenseZero(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
+            Assert.That(() => matrix.CopyTo(Matrix<T>.Build.Dense(matrix.RowCount + 1, matrix.ColumnCount)), Throws.ArgumentException);
+            Assert.That(() => matrix.CopyTo(Matrix<T>.Build.Dense(matrix.RowCount, matrix.ColumnCount + 1)), Throws.ArgumentException);
         }
 
         [Theory]
@@ -211,7 +200,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         public void CanCreateSameKind(Matrix<T> matrix)
         {
             var empty = Matrix<T>.Build.SameAs(matrix, 5, 6);
-            Assert.That(empty, Is.EqualTo(CreateDenseZero(5, 6)));
+            Assert.That(empty, Is.EqualTo(Matrix<T>.Build.Dense(5, 6)));
             Assert.That(empty.Storage.IsDense, Is.EqualTo(matrix.Storage.IsDense));
 
             Assert.That(() => Matrix<T>.Build.SameAs(matrix, 0, 2), Throws.InstanceOf<ArgumentOutOfRangeException>());
@@ -222,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Test]
         public void CanCreateDenseFromMultiDimArray()
         {
-            T[,] array = CreateDenseRandom(4, 3, 0).ToArray();
+            T[,] array = Matrix<T>.Build.Random(4, 3, 0).ToArray();
             var matrix = Matrix<T>.Build.DenseOfArray(array);
             Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
             Assert.That(matrix.RowCount, Is.EqualTo(4));
@@ -235,7 +224,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Test]
         public void CanCreateSparseFromMultiDimArray()
         {
-            T[,] array = CreateDenseRandom(4, 3, 0).ToArray();
+            T[,] array = Matrix<T>.Build.Random(4, 3, 0).ToArray();
             var matrix = Matrix<T>.Build.SparseOfArray(array);
             Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
             Assert.That(matrix.RowCount, Is.EqualTo(4));
@@ -250,9 +239,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             T[][] array = new[]
                 {
-                    CreateVectorRandom(4, 0).ToArray(),
-                    CreateVectorRandom(4, 1).ToArray(),
-                    CreateVectorRandom(4, 3).ToArray()
+                    Vector<T>.Build.Random(4, 0).ToArray(),
+                    Vector<T>.Build.Random(4, 1).ToArray(),
+                    Vector<T>.Build.Random(4, 3).ToArray()
                 };
             var matrix = Matrix<T>.Build.DenseOfRows(3, 4, array);
             Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
@@ -268,9 +257,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             T[][] array = new[]
                 {
-                    CreateVectorRandom(4, 0).ToArray(),
-                    CreateVectorRandom(4, 1).ToArray(),
-                    CreateVectorRandom(4, 3).ToArray()
+                    Vector<T>.Build.Random(4, 0).ToArray(),
+                    Vector<T>.Build.Random(4, 1).ToArray(),
+                    Vector<T>.Build.Random(4, 3).ToArray()
                 };
             var matrix = Matrix<T>.Build.SparseOfRows(3, 4, array);
             Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
@@ -286,9 +275,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             var columns = new[]
                 {
-                    CreateVectorRandom(4, 0),
-                    CreateVectorRandom(4, 1),
-                    CreateVectorRandom(4, 3)
+                    Vector<T>.Build.Random(4, 0),
+                    Vector<T>.Build.Random(4, 1),
+                    Vector<T>.Build.Random(4, 3)
                 };
             var matrix = Matrix<T>.Build.DenseOfColumns(4, 3, columns);
             Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
@@ -304,9 +293,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             var columns = new[]
                 {
-                    CreateVectorRandom(4, 0),
-                    CreateVectorRandom(4, 1),
-                    CreateVectorRandom(4, 3)
+                    Vector<T>.Build.Random(4, 0),
+                    Vector<T>.Build.Random(4, 1),
+                    Vector<T>.Build.Random(4, 3)
                 };
             var matrix = Matrix<T>.Build.SparseOfColumns(4, 3, columns);
             Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
@@ -322,9 +311,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             var rows = new[]
                 {
-                    CreateVectorRandom(4, 0),
-                    CreateVectorRandom(4, 1),
-                    CreateVectorRandom(4, 3)
+                    Vector<T>.Build.Random(4, 0),
+                    Vector<T>.Build.Random(4, 1),
+                    Vector<T>.Build.Random(4, 3)
                 };
             var matrix = Matrix<T>.Build.DenseOfRows(3, 4, rows);
             Assert.That(matrix.GetType().Name, Is.EqualTo("DenseMatrix"));
@@ -340,9 +329,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         {
             var rows = new[]
                 {
-                    CreateVectorRandom(4, 0),
-                    CreateVectorRandom(4, 1),
-                    CreateVectorRandom(4, 3)
+                    Vector<T>.Build.Random(4, 0),
+                    Vector<T>.Build.Random(4, 1),
+                    Vector<T>.Build.Random(4, 3)
                 };
             var matrix = Matrix<T>.Build.SparseOfRows(3, 4, rows);
             Assert.That(matrix.GetType().Name, Is.EqualTo("SparseMatrix"));
@@ -356,7 +345,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
         [Test]
         public void CanEnumerateWithIndex()
         {
-            var dense = CreateDenseRandom(2, 3, 0);
+            var dense = Matrix<T>.Build.Random(2, 3, 0);
             int rowIdxSum = 0, colIdxSum = 0;
             foreach (var value in dense.EnumerateIndexed())
             {
diff --git a/src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs b/src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs
index 3b617eeb..3b06d2a9 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/MatrixStructureTheory.cs
@@ -28,11 +28,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
-using System.Linq;
-using MathNet.Numerics.Distributions;
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.Random;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
@@ -42,53 +38,26 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
     {
         [Datapoints]
         Matrix<float>[] _matrices = new Matrix<float>[]
-            {
-                DenseMatrix.OfArray(new[,] {{1f, 1f, 2f}, {1f, 1f, 2f}, {1f, 1f, 2f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, 1.1f, 2.2f}, {-4.4f, 5.5f, 6.6f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f, -4.4f}, {0f, 1.1f, 2.2f, 3.3f}, {1f, 2.1f, 6.2f, 4.3f}, {-4.4f, 5.5f, 6.6f, -7.7f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}, {-1.1f, -2.2f, -3.3f, -4.4f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f}, {0f, 1.1f}, {-4.4f, 5.5f}}),
-                DenseMatrix.OfArray(new[,] {{-1.1f, -2.2f, -3.3f}, {0f, 1.1f, 2.2f}}),
-                DenseMatrix.OfArray(new[,] {{1f, 2f, 3f}, {2f, 2f, 0f}, {3f, 0f, 3f}}),
-
-                SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {1f, 1f, 2f}, {1f, 1f, 2f}}),
-                SparseMatrix.OfArray(new[,] {{7f, 1f, 2f}, {1f, 0f, 0f}, {-2f, 0f, 0f}}),
-                SparseMatrix.OfArray(new[,] {{-1.1f, 0f, 0f}, {0f, 1.1f, 2.2f}}),
-
-                new DiagonalMatrix(3, 3, new[] {1f, -2f, 1.5f}),
-                new DiagonalMatrix(3, 3, new[] {1f, 0f, -1.5f}),
-
-                new UserDefinedMatrix(new[,] {{0f, 1f, 2f}, {-1f, 7.7f, 0f}, {-2f, 0f, 0f}})
-            };
-
-        [Datapoints]
-        float[] _scalars = new[] {2f, -1.5f, 0f};
-
-        protected override Matrix<float> CreateDenseZero(int rows, int columns)
         {
-            return new DenseMatrix(rows, columns);
-        }
+            Matrix<float>.Build.DenseOfArray(new[,] { { 1f, 1f, 2f }, { 1f, 1f, 2f }, { 1f, 1f, 2f } }),
+            Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, 1.1f, 2.2f }, { -4.4f, 5.5f, 6.6f } }),
+            Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f, -4.4f }, { 0f, 1.1f, 2.2f, 3.3f }, { 1f, 2.1f, 6.2f, 4.3f }, { -4.4f, 5.5f, 6.6f, -7.7f } }),
+            Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f }, { -1.1f, -2.2f, -3.3f, -4.4f } }),
+            Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f }, { 0f, 1.1f }, { -4.4f, 5.5f } }),
+            Matrix<float>.Build.DenseOfArray(new[,] { { -1.1f, -2.2f, -3.3f }, { 0f, 1.1f, 2.2f } }),
+            Matrix<float>.Build.DenseOfArray(new[,] { { 1f, 2f, 3f }, { 2f, 2f, 0f }, { 3f, 0f, 3f } }),
 
-        protected override Matrix<float> CreateDenseRandom(int rows, int columns, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseMatrix(rows, columns, dist.Samples().Select(d => (float) d).Take(rows*columns).ToArray());
-        }
+            Matrix<float>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { 1f, 1f, 2f }, { 1f, 1f, 2f } }),
+            Matrix<float>.Build.SparseOfArray(new[,] { { 7f, 1f, 2f }, { 1f, 0f, 0f }, { -2f, 0f, 0f } }),
+            Matrix<float>.Build.SparseOfArray(new[,] { { -1.1f, 0f, 0f }, { 0f, 1.1f, 2.2f } }),
 
-        protected override Matrix<float> CreateSparseZero(int rows, int columns)
-        {
-            return new SparseMatrix(rows, columns);
-        }
+            Matrix<float>.Build.Diagonal(3, 3, new[] { 1f, -2f, 1.5f }),
+            Matrix<float>.Build.Diagonal(3, 3, new[] { 1f, 0f, -1.5f }),
 
-        protected override Vector<float> CreateVectorZero(int size)
-        {
-            return new DenseVector(size);
-        }
+            new UserDefinedMatrix(new[,] { { 0f, 1f, 2f }, { -1f, 7.7f, 0f }, { -2f, 0f, 0f } })
+        };
 
-        protected override Vector<float> CreateVectorRandom(int size, int seed)
-        {
-            var dist = new Normal(new MersenneTwister(seed));
-            return new DenseVector(dist.Samples().Select(d => (float) d).Take(size).ToArray());
-        }
+        [Datapoints]
+        float[] _scalars = new[] { 2f, -1.5f, 0f };
     }
 }