diff --git a/src/Examples/LinearAlgebra/VectorInitialization.cs b/src/Examples/LinearAlgebra/VectorInitialization.cs
index 284c15eb..f1e823d8 100644
--- a/src/Examples/LinearAlgebra/VectorInitialization.cs
+++ b/src/Examples/LinearAlgebra/VectorInitialization.cs
@@ -26,7 +26,7 @@
 
 using System;
 using System.Globalization;
-using MathNet.Numerics.LinearAlgebra.Double;
+using MathNet.Numerics.LinearAlgebra;
 
 namespace Examples.LinearAlgebraExamples
 {
@@ -63,16 +63,16 @@ namespace Examples.LinearAlgebraExamples
         public void Run()
         {
             // 1. Initialize a new instance of the empty vector with a given size
-            var vector1 = new DenseVector(5);
+            var vector1 = Vector<double>.Build.Dense(5);
 
             // 2. Initialize a new instance of the vector with a given size and each element set to the given value
-            var vector2 = DenseVector.Create(5, i => 3.0);
+            var vector2 = Vector<double>.Build.Dense(5, i => i + 3.0);
 
             // 3. Initialize a new instance of the vector from an array.
-            var vector3 = new DenseVector(new[] { 1.0, 2.0, 3.0, 4.0, 5.0 });
+            var vector3 = Vector<double>.Build.Dense(new[] { 1.0, 2.0, 3.0, 4.0, 5.0 });
 
             // 4. Initialize a new instance of the vector by copying the values from another.
-            var vector4 = DenseVector.OfVector(vector3);
+            var vector4 = Vector<double>.Build.DenseOfVector(vector3);
 
             // Format vector output to console
             var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
diff --git a/src/Numerics/Distributions/MatrixNormal.cs b/src/Numerics/Distributions/MatrixNormal.cs
index 71d2f94b..b886a922 100644
--- a/src/Numerics/Distributions/MatrixNormal.cs
+++ b/src/Numerics/Distributions/MatrixNormal.cs
@@ -284,7 +284,7 @@ namespace MathNet.Numerics.Distributions
             var chol = covariance.Cholesky();
 
             // Sample a standard normal variable.
-            var v = DenseVector.CreateRandom(mean.Count, new Normal(rnd));
+            var v = Vector<double>.Build.Random(mean.Count, new Normal(rnd));
 
             // Return the transformed variable.
             return mean + (chol.Factor*v);
diff --git a/src/Numerics/LinearAlgebra/Builder.cs b/src/Numerics/LinearAlgebra/Builder.cs
index e5220f70..de30b3fa 100644
--- a/src/Numerics/LinearAlgebra/Builder.cs
+++ b/src/Numerics/LinearAlgebra/Builder.cs
@@ -478,6 +478,16 @@ namespace MathNet.Numerics.LinearAlgebra
             return a.TransposeThisAndMultiply(a);
         }
 
+        /// <summary>
+        /// Create a new positive definite dense matrix where each value is the product
+        /// of two samples from the provided random distribution.
+        /// </summary>
+        public Matrix<T> RandomPositiveDefinite(int order, int seed)
+        {
+            var a = Random(order, order, new Normal(new MersenneTwister(seed, true)));
+            return a.TransposeThisAndMultiply(a);
+        }
+
         /// <summary>
         /// Create a new dense matrix straight from an initialized matrix storage instance.
         /// The storage is used directly without copying.
diff --git a/src/Numerics/LinearAlgebra/Double/SparseVector.cs b/src/Numerics/LinearAlgebra/Double/SparseVector.cs
index 578b9d3b..b1337963 100644
--- a/src/Numerics/LinearAlgebra/Double/SparseVector.cs
+++ b/src/Numerics/LinearAlgebra/Double/SparseVector.cs
@@ -116,7 +116,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// </summary>
         public static SparseVector Create(int length, double value)
         {
-            if (value == 0d) return new SparseVector(length);
+            if (value == 0d) return new SparseVector(new SparseVectorStorage<double>(length));
             return new SparseVector(SparseVectorStorage<double>.OfInit(length, i => value));
         }
 
@@ -907,7 +907,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             var tokens = value.Split(new[] { formatProvider.GetTextInfo().ListSeparator, " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
             var data = tokens.Select(t => double.Parse(t, NumberStyles.Any, formatProvider)).ToList();
             if (data.Count == 0) throw new FormatException();
-            return OfEnumerable(data);
+            return new SparseVector(SparseVectorStorage<double>.OfEnumerable(data));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs b/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs
index 32a75a8b..256e7e36 100644
--- a/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs
+++ b/src/UnitTests/LinearAlgebraProviderTests/Double/LinearAlgebraProviderTests.cs
@@ -48,12 +48,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         /// <summary>
         /// The Y double test vector.
         /// </summary>
-        readonly double[] _y = new[] {1.1, 2.2, 3.3, 4.4, 5.5};
+        readonly double[] _y = {1.1, 2.2, 3.3, 4.4, 5.5};
 
         /// <summary>
         /// The X double test vector.
         /// </summary>
-        readonly double[] _x = new[] {6.6, 7.7, 8.8, 9.9, 10.1};
+        readonly double[] _x = {6.6, 7.7, 8.8, 9.9, 10.1};
 
         static readonly IContinuousDistribution Dist = new Normal();
 
@@ -61,17 +61,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraProviderTests.Double
         /// Test matrix to use.
         /// </summary>
         readonly IDictionary<string, DenseMatrix> _matrices = new Dictionary<string, DenseMatrix>
-            {
-                {"Singular3x3", DenseMatrix.OfArray(new[,] {{1.0, 1.0, 2.0}, {1.0, 1.0, 2.0}, {1.0, 1.0, 2.0}})},
-                {"Square3x3", DenseMatrix.OfArray(new[,] {{-1.1, -2.2, -3.3}, {0.0, 1.1, 2.2}, {-4.4, 5.5, 6.6}})},
-                {"Square4x4", DenseMatrix.OfArray(new[,] {{-1.1, -2.2, -3.3, -4.4}, {0.0, 1.1, 2.2, 3.3}, {1.0, 2.1, 6.2, 4.3}, {-4.4, 5.5, 6.6, -7.7}})},
-                {"Singular4x4", DenseMatrix.OfArray(new[,] {{-1.1, -2.2, -3.3, -4.4}, {-1.1, -2.2, -3.3, -4.4}, {-1.1, -2.2, -3.3, -4.4}, {-1.1, -2.2, -3.3, -4.4}})},
-                {"Tall3x2", DenseMatrix.OfArray(new[,] {{-1.1, -2.2}, {0.0, 1.1}, {-4.4, 5.5}})},
-                {"Wide2x3", DenseMatrix.OfArray(new[,] {{-1.1, -2.2, -3.3}, {0.0, 1.1, 2.2}})},
-                {"Tall50000x10", DenseMatrix.CreateRandom(50000, 10, Dist)},
-                {"Wide10x50000", DenseMatrix.CreateRandom(10, 50000, Dist)},
-                {"Square1000x1000", DenseMatrix.CreateRandom(1000, 1000, Dist)}
-            };
+        {
+            { "Singular3x3", (DenseMatrix)Matrix<double>.Build.DenseOfArray(new[,] { { 1.0, 1.0, 2.0 }, { 1.0, 1.0, 2.0 }, { 1.0, 1.0, 2.0 } }) },
+            { "Square3x3", (DenseMatrix)Matrix<double>.Build.DenseOfArray(new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 }, { -4.4, 5.5, 6.6 } }) },
+            { "Square4x4", (DenseMatrix)Matrix<double>.Build.DenseOfArray(new[,] { { -1.1, -2.2, -3.3, -4.4 }, { 0.0, 1.1, 2.2, 3.3 }, { 1.0, 2.1, 6.2, 4.3 }, { -4.4, 5.5, 6.6, -7.7 } }) },
+            { "Singular4x4", (DenseMatrix)Matrix<double>.Build.DenseOfArray(new[,] { { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 } }) },
+            { "Tall3x2", (DenseMatrix)Matrix<double>.Build.DenseOfArray(new[,] { { -1.1, -2.2 }, { 0.0, 1.1 }, { -4.4, 5.5 } }) },
+            { "Wide2x3", (DenseMatrix)Matrix<double>.Build.DenseOfArray(new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 } }) },
+            { "Tall50000x10", (DenseMatrix)Matrix<double>.Build.Random(50000, 10, Dist) },
+            { "Wide10x50000", (DenseMatrix)Matrix<double>.Build.Random(10, 50000, Dist) },
+            { "Square1000x1000", (DenseMatrix)Matrix<double>.Build.Random(1000, 1000, Dist) }
+        };
 
         /// <summary>
         /// Can add a vector to scaled vector
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorArithmeticTheory.cs
index 564fcdda..35904805 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/DenseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Complex;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
@@ -44,13 +43,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
     public class DenseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<Complex>[] denseVectors = new Vector<Complex>[]
-            {
-                new DenseVector(new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1) }),
-                new DenseVector(new[] { new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0) })
-            };
+        Vector<Complex>[] denseVectors =
+        {
+            Vector<Complex>.Build.Dense(new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1) }),
+            Vector<Complex>.Build.Dense(new[] { new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0) })
+        };
 
         [Datapoints]
-        private Complex[] scalars = new[] { new Complex(2d, -1d) };
+        Complex[] scalars = { new Complex(2d, -1d) };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/MatrixLoader.cs b/src/UnitTests/LinearAlgebraTests/Complex/MatrixLoader.cs
index becc1fef..03b95c84 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/MatrixLoader.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/MatrixLoader.cs
@@ -29,10 +29,7 @@
 // </copyright>
 
 using System.Collections.Generic;
-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
@@ -95,15 +92,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public virtual void SetupMatrices()
         {
             TestData2D = new Dictionary<string, Complex[,]>
-                {
-                    {"Singular3x3", new[,] {{new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)}, {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)}, {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)}}},
-                    {"Square3x3", new[,] {{new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1)}, {Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1)}, {new Complex(-4.4, 1), new Complex(5.5, 1), new Complex(6.6, 1)}}},
-                    {"Square4x4", new[,] {{new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1)}, {Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1), new Complex(3.3, 1)}, {new Complex(1.0, 1), new Complex(2.1, 1), new Complex(6.2, 1), new Complex(4.3, 1)}, {new Complex(-4.4, 1), new Complex(5.5, 1), new Complex(6.6, 1), new Complex(-7.7, 1)}}},
-                    {"Singular4x4", new[,] {{new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1)}, {new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1)}, {new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1)}, {new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1)}}},
-                    {"Tall3x2", new[,] {{new Complex(-1.1, 1), new Complex(-2.2, 1)}, {Complex.Zero, new Complex(1.1, 1)}, {new Complex(-4.4, 1), new Complex(5.5, 1)}}},
-                    {"Wide2x3", new[,] {{new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1)}, {Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1)}}},
-                    {"Symmetric3x3", new[,] {{Complex.One, 2.0, 3.0}, {2.0, 2.0, 0.0}, {3.0, 0.0, 3.0}}}
-                };
+            {
+                { "Singular3x3", new[,] { { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) }, { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) }, { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) } } },
+                { "Square3x3", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1) }, { Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1) }, { new Complex(-4.4, 1), new Complex(5.5, 1), new Complex(6.6, 1) } } },
+                { "Square4x4", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1), new Complex(3.3, 1) }, { new Complex(1.0, 1), new Complex(2.1, 1), new Complex(6.2, 1), new Complex(4.3, 1) }, { new Complex(-4.4, 1), new Complex(5.5, 1), new Complex(6.6, 1), new Complex(-7.7, 1) } } },
+                { "Singular4x4", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) }, { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1), new Complex(-4.4, 1) } } },
+                { "Tall3x2", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1) }, { Complex.Zero, new Complex(1.1, 1) }, { new Complex(-4.4, 1), new Complex(5.5, 1) } } },
+                { "Wide2x3", new[,] { { new Complex(-1.1, 1), new Complex(-2.2, 1), new Complex(-3.3, 1) }, { Complex.Zero, new Complex(1.1, 1), new Complex(2.2, 1) } } },
+                { "Symmetric3x3", new[,] { { Complex.One, 2.0, 3.0 }, { 2.0, 2.0, 0.0 }, { 3.0, 0.0, 3.0 } } }
+            };
 
             TestMatrices = new Dictionary<string, Matrix<Complex>>();
             foreach (var name in TestData2D.Keys)
@@ -114,18 +111,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
 
         public static Matrix<Complex> GenerateRandomDenseMatrix(int row, int col)
         {
-            return DenseMatrix.CreateRandom(row, col, new Normal(new MersenneTwister(1)));
+            return Matrix<Complex>.Build.Random(row, col, 1);
         }
 
         public static Matrix<Complex> GenerateRandomPositiveDefiniteHermitianDenseMatrix(int order)
         {
-            var a = DenseMatrix.CreateRandom(order, order, new Normal(new MersenneTwister(1)));
-            return a.ConjugateTranspose()*a;
+            return Matrix<Complex>.Build.RandomPositiveDefinite(order, 1);
         }
 
         public static Vector<Complex> GenerateRandomDenseVector(int order)
         {
-            return DenseVector.CreateRandom(order, new Normal(new MersenneTwister(1)));
+            return Vector<Complex>.Build.Random(order, 1);
         }
 
         public static Matrix<Complex> GenerateRandomUserDefinedMatrix(int row, int col)
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs
index 0aefbe3a..c56ce757 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.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;
@@ -94,7 +95,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
@@ -215,7 +216,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs
index 3d017114..cf7af6bc 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.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;
@@ -94,7 +95,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
@@ -215,7 +216,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs
index 13e0e59f..2651730c 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.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;
@@ -94,7 +95,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
@@ -138,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
@@ -215,7 +216,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex>(
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs
index 0821ae51..6f54e2e7 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs
@@ -30,6 +30,7 @@
 
 using System;
 using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -57,9 +58,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
             var iterator = new Iterator<Complex>();
             Assert.DoesNotThrow(() => iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 5),
+                Vector<Complex>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -79,9 +80,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 5),
+                Vector<Complex>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -102,17 +103,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, iterator.Status, "Incorrect status");
         }
 
@@ -134,9 +135,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             iterator.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 9290acd3..f9c864bc 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -29,8 +29,8 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -88,9 +88,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new DivergenceStopCriterium<Complex>(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 5),
+                Vector<Complex>.Build.Dense(3, 6)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 59883944..84327056 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -66,7 +67,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium<Complex>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<Complex>.Build.Dense(3, 4), Vector<Complex>.Build.Dense(3, 5), Vector<Complex>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -78,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium<Complex>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, Vector<Complex>.Build.Dense(3, 4), Vector<Complex>.Build.Dense(3, 6), Vector<Complex>.Build.Dense(4, 4)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index 8d602171..2264708f 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -90,7 +91,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium<Complex>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<Complex>.Build.Dense(3, 1), Vector<Complex>.Build.Dense(3, 2), Vector<Complex>.Build.Dense(3, 3)));
         }
 
         /// <summary>
@@ -102,10 +103,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium<Complex>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<Complex>.Build.Dense(3, 1), Vector<Complex>.Build.Dense(3, 2), Vector<Complex>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
-            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status2 = criterium.DetermineStatus(10, Vector<Complex>.Build.Dense(3, 1), Vector<Complex>.Build.Dense(3, 2), Vector<Complex>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, status2, "Should be finished");
         }
 
@@ -118,7 +119,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium<Complex>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<Complex>.Build.Dense(3, 1), Vector<Complex>.Build.Dense(3, 2), Vector<Complex>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
             criterium.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 0a00e631..0f48daaa 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.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;
@@ -88,9 +89,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 5),
+                Vector<Complex>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -103,9 +104,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<Complex>.Build.Dense(4, 4),
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -118,9 +119,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(4, 4),
+                Vector<Complex>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -133,9 +134,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4)));
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(3, 4),
+                Vector<Complex>.Build.Dense(4, 4)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorArithmeticTheory.cs
index bcbdb56e..3e3c5531 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/SparseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Complex;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
@@ -44,15 +43,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
     public class SparseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<Complex>[] denseVectors = new Vector<Complex>[]
-            {
-                SparseVector.OfEnumerable(new[] {new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1)}),
-                SparseVector.OfEnumerable(new[] {new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0)}),
-                new SparseVector(5),
-                new SparseVector(int.MaxValue)
-            };
+        Vector<Complex>[] denseVectors =
+        {
+            Vector<Complex>.Build.SparseOfEnumerable(new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1) }),
+            Vector<Complex>.Build.SparseOfEnumerable(new[] { new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0) }),
+            Vector<Complex>.Build.Sparse(5),
+            Vector<Complex>.Build.Sparse(int.MaxValue)
+        };
 
         [Datapoints]
-        Complex[] scalars = new[] {new Complex(2d, -1d)};
+        Complex[] scalars = { new Complex(2d, -1d) };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorArithmeticTheory.cs
index 0ca81bc3..c2989804 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Complex32;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
@@ -40,13 +39,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
     public class DenseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<Complex32>[] denseVectors = new Vector<Complex32>[]
-            {
-                new DenseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }),
-                new DenseVector(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) })
-            };
+        Vector<Complex32>[] denseVectors =
+        {
+            Vector<Complex32>.Build.Dense(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }),
+            Vector<Complex32>.Build.Dense(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) })
+        };
 
         [Datapoints]
-        private Complex32[] scalars = new[] { new Complex32(2f, -1f) };
+        Complex32[] scalars = { new Complex32(2f, -1f) };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixLoader.cs b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixLoader.cs
index 539d506c..9f53a8ac 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/MatrixLoader.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/MatrixLoader.cs
@@ -29,10 +29,7 @@
 // </copyright>
 
 using System.Collections.Generic;
-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
@@ -91,15 +88,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public virtual void SetupMatrices()
         {
             TestData2D = new Dictionary<string, Complex32[,]>
-                {
-                    {"Singular3x3", new[,] {{new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)}, {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)}, {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)}}},
-                    {"Square3x3", new[,] {{new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1)}, {Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1)}, {new Complex32(-4.4f, 1), new Complex32(5.5f, 1), new Complex32(6.6f, 1)}}},
-                    {"Square4x4", new[,] {{new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1)}, {Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1), new Complex32(3.3f, 1)}, {new Complex32(1.0f, 1), new Complex32(2.1f, 1), new Complex32(6.2f, 1), new Complex32(4.3f, 1)}, {new Complex32(-4.4f, 1), new Complex32(5.5f, 1), new Complex32(6.6f, 1), new Complex32(-7.7f, 1)}}},
-                    {"Singular4x4", new[,] {{new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1)}, {new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1)}, {new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1)}, {new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1)}}},
-                    {"Tall3x2", new[,] {{new Complex32(-1.1f, 1), new Complex32(-2.2f, 1)}, {Complex32.Zero, new Complex32(1.1f, 1)}, {new Complex32(-4.4f, 1), new Complex32(5.5f, 1)}}},
-                    {"Wide2x3", new[,] {{new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1)}, {Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1)}}},
-                    {"Symmetric3x3", new[,] {{Complex32.One, 2.0f, 3.0f}, {2.0f, 2.0f, 0.0f}, {3.0f, 0.0f, 3.0f}}}
-                };
+            {
+                { "Singular3x3", new[,] { { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) }, { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) }, { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) } } },
+                { "Square3x3", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1) }, { Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1) }, { new Complex32(-4.4f, 1), new Complex32(5.5f, 1), new Complex32(6.6f, 1) } } },
+                { "Square4x4", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1), new Complex32(3.3f, 1) }, { new Complex32(1.0f, 1), new Complex32(2.1f, 1), new Complex32(6.2f, 1), new Complex32(4.3f, 1) }, { new Complex32(-4.4f, 1), new Complex32(5.5f, 1), new Complex32(6.6f, 1), new Complex32(-7.7f, 1) } } },
+                { "Singular4x4", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) }, { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1), new Complex32(-4.4f, 1) } } },
+                { "Tall3x2", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1) }, { Complex32.Zero, new Complex32(1.1f, 1) }, { new Complex32(-4.4f, 1), new Complex32(5.5f, 1) } } },
+                { "Wide2x3", new[,] { { new Complex32(-1.1f, 1), new Complex32(-2.2f, 1), new Complex32(-3.3f, 1) }, { Complex32.Zero, new Complex32(1.1f, 1), new Complex32(2.2f, 1) } } },
+                { "Symmetric3x3", new[,] { { Complex32.One, 2.0f, 3.0f }, { 2.0f, 2.0f, 0.0f }, { 3.0f, 0.0f, 3.0f } } }
+            };
 
             TestMatrices = new Dictionary<string, Matrix<Complex32>>();
             foreach (var name in TestData2D.Keys)
@@ -110,18 +107,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
 
         public static Matrix<Complex32> GenerateRandomDenseMatrix(int row, int col)
         {
-            return DenseMatrix.CreateRandom(row, col, new Normal(new MersenneTwister(1)));
+            return Matrix<Complex32>.Build.Random(row, col, 1);
         }
 
         public static Matrix<Complex32> GenerateRandomPositiveDefiniteHermitianDenseMatrix(int order)
         {
-            var a = DenseMatrix.CreateRandom(order, order, new Normal(new MersenneTwister(1)));
-            return a.ConjugateTranspose()*a;
+            return Matrix<Complex32>.Build.RandomPositiveDefinite(order, 1);
         }
 
         public static Vector<Complex32> GenerateRandomDenseVector(int order)
         {
-            return DenseVector.CreateRandom(order, new Normal(new MersenneTwister(1)));
+            return Vector<Complex32>.Build.Random(order, 1);
         }
 
         public static Matrix<Complex32> GenerateRandomUserDefinedMatrix(int row, int col)
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs
index 333eadaf..a85196cf 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.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;
@@ -90,7 +91,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
@@ -134,7 +135,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
@@ -211,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs
index 7aec9c43..b01ec206 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.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;
@@ -90,7 +91,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
@@ -134,7 +135,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
@@ -211,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs
index be3cef67..60cfa7a9 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.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;
@@ -90,7 +91,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
@@ -134,7 +135,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
@@ -211,7 +212,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<Complex32>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<Complex32>(
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs
index 54d75dd8..61dfc2b3 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs
@@ -30,6 +30,7 @@
 
 using System;
 using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -53,9 +54,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
             var iterator = new Iterator<Complex32>();
             Assert.DoesNotThrow(() => iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 5),
+                Vector<Complex32>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -75,9 +76,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 5),
+                Vector<Complex32>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -98,17 +99,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, iterator.Status, "Incorrect status");
         }
 
@@ -130,9 +131,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             iterator.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index a84c9098..82a78b44 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -29,8 +29,8 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -84,9 +84,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new DivergenceStopCriterium<Complex32>(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 5),
+                Vector<Complex32>.Build.Dense(3, 6)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 2bb1512f..29a68f8e 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -62,7 +63,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium<Complex32>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<Complex32>.Build.Dense(3, 4), Vector<Complex32>.Build.Dense(3, 5), Vector<Complex32>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -74,7 +75,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium<Complex32>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, Vector<Complex32>.Build.Dense(3, 4), Vector<Complex32>.Build.Dense(3, 6), Vector<Complex32>.Build.Dense(4, 4)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index e01c8b9f..f72e8978 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -86,7 +87,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium<Complex32>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<Complex32>.Build.Dense(3, 1), Vector<Complex32>.Build.Dense(3, 2), Vector<Complex32>.Build.Dense(3, 3)));
         }
 
         /// <summary>
@@ -98,10 +99,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium<Complex32>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<Complex32>.Build.Dense(3, 1), Vector<Complex32>.Build.Dense(3, 2), Vector<Complex32>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
-            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status2 = criterium.DetermineStatus(10, Vector<Complex32>.Build.Dense(3, 1), Vector<Complex32>.Build.Dense(3, 2), Vector<Complex32>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, status2, "Should be finished");
         }
 
@@ -114,7 +115,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium<Complex32>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<Complex32>.Build.Dense(3, 1), Vector<Complex32>.Build.Dense(3, 2), Vector<Complex32>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
             criterium.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 5317452f..74449674 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -29,8 +29,8 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -84,9 +84,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 5),
+                Vector<Complex32>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -99,9 +99,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<Complex32>.Build.Dense(4, 4),
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -114,9 +114,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(4, 4),
+                Vector<Complex32>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -129,8 +129,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
+                Vector<Complex32>.Build.Dense(3, 4),
+                Vector<Complex32>.Build.Dense(3, 4),
                 DenseVector.Create(4, i => 4)));
         }
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorArithmeticTheory.cs
index 71e765d5..5d9d2619 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Complex32;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
@@ -40,15 +39,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
     public class SparseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<Complex32>[] denseVectors = new Vector<Complex32>[]
-            {
-                SparseVector.OfEnumerable(new[] {new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1)}),
-                SparseVector.OfEnumerable(new[] {new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0)}),
-                new SparseVector(5),
-                new SparseVector(int.MaxValue)
-            };
+        Vector<Complex32>[] denseVectors =
+        {
+            Vector<Complex32>.Build.SparseOfEnumerable(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }),
+            Vector<Complex32>.Build.SparseOfEnumerable(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) }),
+            Vector<Complex32>.Build.Sparse(5),
+            Vector<Complex32>.Build.Sparse(int.MaxValue)
+        };
 
         [Datapoints]
-        Complex32[] scalars = new[] {new Complex32(2f, -1f)};
+        Complex32[] scalars = { new Complex32(2f, -1f) };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs
index b8ecd9d4..a55d1012 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/DenseMatrixTests.cs
@@ -49,7 +49,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given dimensions.</returns>
         protected override Matrix<double> CreateMatrix(int rows, int columns)
         {
-            return new DenseMatrix(rows, columns);
+            return Matrix<double>.Build.Dense(rows, columns);
         }
 
         /// <summary>
@@ -59,7 +59,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given values.</returns>
         protected override Matrix<double> CreateMatrix(double[,] data)
         {
-            return DenseMatrix.OfArray(data);
+            return Matrix<double>.Build.DenseOfArray(data);
         }
 
         /// <summary>
@@ -70,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector<double> CreateVector(int size)
         {
-            return new DenseVector(size);
+            return Vector<double>.Build.Dense(size);
         }
 
         /// <summary>
@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector<double> CreateVector(double[] data)
         {
-            return new DenseVector(data);
+            return Vector<double>.Build.Dense(data);
         }
 
         /// <summary>
@@ -122,7 +122,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void MatrixFrom2DArrayIsCopy()
         {
-            var matrix = DenseMatrix.OfArray(TestData2D["Singular3x3"]);
+            var matrix = Matrix<double>.Build.DenseOfArray(TestData2D["Singular3x3"]);
+            Assert.That(matrix, Is.TypeOf<DenseMatrix>());
             matrix[0, 0] = 10.0;
             Assert.AreEqual(1.0, TestData2D["Singular3x3"][0, 0]);
         }
@@ -139,7 +140,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase("Wide2x3")]
         public void CanCreateMatrixFrom2DArray(string name)
         {
-            var matrix = DenseMatrix.OfArray(TestData2D[name]);
+            var matrix = Matrix<double>.Build.DenseOfArray(TestData2D[name]);
+            Assert.That(matrix, Is.TypeOf<DenseMatrix>());
             for (var i = 0; i < TestData2D[name].GetLength(0); i++)
             {
                 for (var j = 0; j < TestData2D[name].GetLength(1); j++)
@@ -155,7 +157,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateMatrixWithUniformValues()
         {
-            var matrix = DenseMatrix.Create(10, 10, (i, j) => 10.0);
+            var matrix = Matrix<double>.Build.Dense(10, 10, (i, j) => 10.0);
+            Assert.That(matrix, Is.TypeOf<DenseMatrix>());
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)
@@ -171,7 +174,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateIdentity()
         {
-            var matrix = DenseMatrix.CreateIdentity(5);
+            var matrix = Matrix<double>.Build.DenseIdentity(5);
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)
@@ -189,7 +192,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase(-1)]
         public void IdentityWithWrongOrderThrowsArgumentOutOfRangeException(int order)
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => DenseMatrix.CreateIdentity(order));
+            Assert.Throws<ArgumentOutOfRangeException>(() => Matrix<double>.Build.DenseIdentity(order));
         }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/DenseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Double/DenseVectorArithmeticTheory.cs
index acbf3802..f6ecf9c7 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/DenseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/DenseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Double;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
@@ -38,14 +37,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
     public class DenseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<double>[] denseVectors = new Vector<double>[]
-            {
-                new DenseVector(new double[] { 1, 2, 3, 4, 5 }),
-                new DenseVector(new double[] { 2, 0, 0, -5, 0 }),
-            };
+        Vector<double>[] denseVectors =
+        {
+            Vector<double>.Build.Dense(new double[] { 1, 2, 3, 4, 5 }),
+            Vector<double>.Build.Dense(new double[] { 2, 0, 0, -5, 0 }),
+        };
 
         [Datapoints]
-        private double[] scalars = new[] { 2d };
-
+        double[] scalars = { 2d };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTests.cs b/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTests.cs
index daf0e5c4..c9901f74 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/DenseVectorTests.cs
@@ -48,7 +48,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new <c>Vector</c>.</returns>
         protected override Vector<double> CreateVector(int size)
         {
-            return new DenseVector(size);
+            return Vector<double>.Build.Dense(size);
         }
 
         /// <summary>
@@ -58,7 +58,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new <c>Vector</c>.</returns>
         protected override Vector<double> CreateVector(IList<double> data)
         {
-            var vector = new DenseVector(data.Count);
+            var vector = Vector<double>.Build.Dense(data.Count);
             for (var index = 0; index < data.Count; index++)
             {
                 vector[index] = data[index];
@@ -75,7 +75,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             var data = new double[Data.Length];
             Array.Copy(Data, data, Data.Length);
-            var vector = new DenseVector(data);
+            var vector = Vector<double>.Build.Dense(data);
 
             for (var i = 0; i < data.Length; i++)
             {
@@ -92,8 +92,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateDenseVectorFromAnotherDenseVector()
         {
-            var vector = new DenseVector(Data);
-            var other = DenseVector.OfVector(vector);
+            var vector = Vector<double>.Build.Dense(Data);
+            var other = Vector<double>.Build.DenseOfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -108,8 +108,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateDenseVectorFromAnotherVector()
         {
-            var vector = (Vector<double>)new DenseVector(Data);
-            var other = DenseVector.OfVector(vector);
+            var vector = Vector<double>.Build.Dense(Data);
+            var other = Vector<double>.Build.DenseOfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateDenseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = DenseVector.OfVector(vector);
+            var other = Vector<double>.Build.DenseOfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -139,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateDenseVectorWithConstantValues()
         {
-            var vector = DenseVector.Create(5, i => 5);
+            var vector = Vector<double>.Build.Dense(5, 5);
             foreach (var t in vector)
             {
                 Assert.AreEqual(t, 5);
diff --git a/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs
index 7bf5b72a..6201beab 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/DiagonalMatrixTests.cs
@@ -74,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given dimensions.</returns>
         protected override Matrix<double> CreateMatrix(int rows, int columns)
         {
-            return new DiagonalMatrix(rows, columns);
+            return Matrix<double>.Build.Diagonal(rows, columns);
         }
 
         /// <summary>
@@ -95,7 +95,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector<double> CreateVector(int size)
         {
-            return new DenseVector(size);
+            return Vector<double>.Build.Dense(size);
         }
 
         /// <summary>
@@ -105,7 +105,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector<double> CreateVector(double[] data)
         {
-            return new DenseVector(data);
+            return Vector<double>.Build.Dense(data);
         }
 
         /// <summary>
@@ -182,7 +182,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateIdentity()
         {
-            var matrix = DiagonalMatrix.CreateIdentity(5);
+            var matrix = Matrix<double>.Build.DiagonalIdentity(5);
+            Assert.That(matrix, Is.TypeOf<DiagonalMatrix>());
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)
@@ -200,7 +201,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase(-1)]
         public void IdentityWithWrongOrderThrowsArgumentOutOfRangeException(int order)
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => DiagonalMatrix.CreateIdentity(order));
+            Assert.Throws<ArgumentOutOfRangeException>(() => Matrix<double>.Build.DiagonalIdentity(order));
         }
 
         /// <summary>
@@ -212,7 +213,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             var matrixA = TestMatrices[nameA];
             var matrixB = TestMatrices[nameB];
-            var matrixC = new SparseMatrix(matrixA.RowCount, matrixB.ColumnCount);
+            var matrixC = Matrix<double>.Build.Sparse(matrixA.RowCount, matrixB.ColumnCount);
             matrixA.Multiply(matrixB, matrixC);
 
             Assert.AreEqual(matrixC.RowCount, matrixA.RowCount);
@@ -279,15 +280,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public override void CanComputeFrobeniusNorm()
         {
             var matrix = TestMatrices["Square3x3"];
-            var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]);
+            var denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Square3x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14);
 
             matrix = TestMatrices["Wide2x3"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Wide2x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14);
 
             matrix = TestMatrices["Tall3x2"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Tall3x2"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.FrobeniusNorm(), matrix.FrobeniusNorm(), 14);
         }
 
@@ -297,15 +298,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public override void CanComputeInfinityNorm()
         {
             var matrix = TestMatrices["Square3x3"];
-            var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]);
+            var denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Square3x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14);
 
             matrix = TestMatrices["Wide2x3"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Wide2x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14);
 
             matrix = TestMatrices["Tall3x2"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Tall3x2"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.InfinityNorm(), matrix.InfinityNorm(), 14);
         }
 
@@ -315,15 +316,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public override void CanComputeL1Norm()
         {
             var matrix = TestMatrices["Square3x3"];
-            var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]);
+            var denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Square3x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14);
 
             matrix = TestMatrices["Wide2x3"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Wide2x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14);
 
             matrix = TestMatrices["Tall3x2"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Tall3x2"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.L1Norm(), matrix.L1Norm(), 14);
         }
 
@@ -333,15 +334,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public override void CanComputeL2Norm()
         {
             var matrix = TestMatrices["Square3x3"];
-            var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]);
+            var denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Square3x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14);
 
             matrix = TestMatrices["Wide2x3"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Wide2x3"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Wide2x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14);
 
             matrix = TestMatrices["Tall3x2"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Tall3x2"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Tall3x2"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.L2Norm(), matrix.L2Norm(), 14);
         }
 
@@ -352,11 +353,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanComputeDeterminant()
         {
             var matrix = TestMatrices["Square3x3"];
-            var denseMatrix = DenseMatrix.OfArray(TestData2D["Square3x3"]);
+            var denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Square3x3"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14);
 
             matrix = TestMatrices["Square4x4"];
-            denseMatrix = DenseMatrix.OfArray(TestData2D["Square4x4"]);
+            denseMatrix = Matrix<double>.Build.DenseOfArray(TestData2D["Square4x4"]);
             AssertHelpers.AlmostEqualRelative(denseMatrix.Determinant(), matrix.Determinant(), 14);
         }
 
@@ -407,8 +408,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void DiagonalDenseMatrixMultiplication_IssueCP5706()
         {
-            Matrix<double> diagonal = DiagonalMatrix.CreateIdentity(3);
-            Matrix<double> dense = DenseMatrix.OfArray(new double[,] {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}});
+            Matrix<double> diagonal = Matrix<double>.Build.DiagonalIdentity(3);
+            Matrix<double> dense = Matrix<double>.Build.DenseOfArray(new double[,] { { 1, 2, 3 }, { 1, 2, 3 }, { 1, 2, 3 } });
             var test = diagonal*dense;
             var test2 = dense*diagonal;
         }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs
index 58548e08..c73105d3 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/CholeskyTests.cs
@@ -24,12 +24,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
+using MathNet.Numerics.LinearAlgebra.Double;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
 {
-    using System;
-    using LinearAlgebra.Double;
-    using NUnit.Framework;
-
     /// <summary>
     /// Cholesky factorization tests for a dense matrix.
     /// </summary>
@@ -44,7 +45,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentity(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorC = matrixI.Cholesky().Factor;
 
             Assert.AreEqual(matrixI.RowCount, factorC.RowCount);
@@ -65,7 +66,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [Test]
         public void CholeskyFailsWithDiagonalNonPositiveDefiniteMatrix()
         {
-            var matrixI = DenseMatrix.CreateIdentity(10);
+            var matrixI = Matrix<double>.Build.DenseIdentity(10);
             matrixI[3, 3] = -4.0;
             Assert.Throws<ArgumentException>(() => matrixI.Cholesky());
         }
@@ -89,7 +90,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void IdentityDeterminantIsOne(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorC = matrixI.Cholesky();
             Assert.AreEqual(1.0, factorC.Determinant);
             Assert.AreEqual(0.0, factorC.DeterminantLn);
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs
index fc00fac7..d2d7990e 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/EvdTests.cs
@@ -24,6 +24,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using NUnit.Framework;
 
@@ -49,7 +50,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentity(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorEvd = matrixI.Evd();
             var eigenValues = factorEvd.EigenValues;
             var eigenVectors = factorEvd.EigenVectors;
@@ -189,7 +190,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void IdentityDeterminantIsOne(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorEvd = matrixI.Evd();
             Assert.AreEqual(1.0, factorEvd.Determinant);
         }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs
index 51cb712d..3f134cb4 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/GramSchmidtTests.cs
@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Factorization;
 using NUnit.Framework;
@@ -54,7 +55,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentity(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorGramSchmidt = matrixI.GramSchmidt();
             var q = factorGramSchmidt.Q;
             var r = factorGramSchmidt.R;
@@ -102,7 +103,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void IdentityDeterminantIsOne(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorGramSchmidt = matrixI.GramSchmidt();
             Assert.AreEqual(1.0, factorGramSchmidt.Determinant);
         }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/LUTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/LUTests.cs
index ff92bd92..fffc3e36 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/LUTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/LUTests.cs
@@ -24,9 +24,10 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
 {
@@ -44,7 +45,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentity(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorLU = matrixI.LU();
 
             // Check lower triangular part.
@@ -91,7 +92,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void IdentityDeterminantIsOne(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var lu = matrixI.LU();
             Assert.AreEqual(1.0, lu.Determinant);
         }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs
index 2f3f905c..b7250367 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/QRTests.cs
@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Factorization;
 using MathNet.Numerics.LinearAlgebra.Factorization;
@@ -55,8 +56,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentity(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
-            var factorQR = matrixI.QR();
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
+            var factorQR = matrixI.QR(QRMethod.Full);
             var r = factorQR.R;
 
             Assert.AreEqual(matrixI.RowCount, r.RowCount);
@@ -87,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentityUsingThinQR(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorQR = matrixI.QR(QRMethod.Thin);
             var r = factorQR.R;
 
@@ -119,7 +120,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void IdentityDeterminantIsOne(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorQR = matrixI.QR();
             Assert.AreEqual(1.0, factorQR.Determinant);
         }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs b/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs
index 189a5c1b..e6b327d6 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Factorization/SvdTests.cs
@@ -25,6 +25,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using NUnit.Framework;
 
@@ -44,7 +45,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Factorization
         [TestCase(100)]
         public void CanFactorizeIdentity(int order)
         {
-            var matrixI = DenseMatrix.CreateIdentity(order);
+            var matrixI = Matrix<double>.Build.DenseIdentity(order);
             var factorSvd = matrixI.Svd();
             var u = factorSvd.U;
             var vt = factorSvd.VT;
diff --git a/src/UnitTests/LinearAlgebraTests/Double/MatrixLoader.cs b/src/UnitTests/LinearAlgebraTests/Double/MatrixLoader.cs
index 43ee6568..8bca0ab7 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/MatrixLoader.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/MatrixLoader.cs
@@ -29,10 +29,7 @@
 // </copyright>
 
 using System.Collections.Generic;
-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
@@ -89,15 +86,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public virtual void SetupMatrices()
         {
             TestData2D = new Dictionary<string, double[,]>
-                {
-                    {"Singular3x3", new[,] {{1.0, 1.0, 2.0}, {1.0, 1.0, 2.0}, {1.0, 1.0, 2.0}}},
-                    {"Square3x3", new[,] {{-1.1, -2.2, -3.3}, {0.0, 1.1, 2.2}, {-4.4, 5.5, 6.6}}},
-                    {"Square4x4", new[,] {{-1.1, -2.2, -3.3, -4.4}, {0.0, 1.1, 2.2, 3.3}, {1.0, 2.1, 6.2, 4.3}, {-4.4, 5.5, 6.6, -7.7}}},
-                    {"Singular4x4", new[,] {{-1.1, -2.2, -3.3, -4.4}, {-1.1, -2.2, -3.3, -4.4}, {-1.1, -2.2, -3.3, -4.4}, {-1.1, -2.2, -3.3, -4.4}}},
-                    {"Tall3x2", new[,] {{-1.1, -2.2}, {0.0, 1.1}, {-4.4, 5.5}}},
-                    {"Wide2x3", new[,] {{-1.1, -2.2, -3.3}, {0.0, 1.1, 2.2}}},
-                    {"Symmetric3x3", new[,] {{1.0, 2.0, 3.0}, {2.0, 2.0, 0.0}, {3.0, 0.0, 3.0}}}
-                };
+            {
+                { "Singular3x3", new[,] { { 1.0, 1.0, 2.0 }, { 1.0, 1.0, 2.0 }, { 1.0, 1.0, 2.0 } } },
+                { "Square3x3", new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 }, { -4.4, 5.5, 6.6 } } },
+                { "Square4x4", new[,] { { -1.1, -2.2, -3.3, -4.4 }, { 0.0, 1.1, 2.2, 3.3 }, { 1.0, 2.1, 6.2, 4.3 }, { -4.4, 5.5, 6.6, -7.7 } } },
+                { "Singular4x4", new[,] { { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 }, { -1.1, -2.2, -3.3, -4.4 } } },
+                { "Tall3x2", new[,] { { -1.1, -2.2 }, { 0.0, 1.1 }, { -4.4, 5.5 } } },
+                { "Wide2x3", new[,] { { -1.1, -2.2, -3.3 }, { 0.0, 1.1, 2.2 } } },
+                { "Symmetric3x3", new[,] { { 1.0, 2.0, 3.0 }, { 2.0, 2.0, 0.0 }, { 3.0, 0.0, 3.0 } } }
+            };
 
             TestMatrices = new Dictionary<string, Matrix<double>>();
             foreach (var name in TestData2D.Keys)
@@ -108,18 +105,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
 
         public static Matrix<double> GenerateRandomDenseMatrix(int row, int col)
         {
-            return DenseMatrix.CreateRandom(row, col, new Normal(new MersenneTwister(1)));
+            return Matrix<double>.Build.Random(row, col, 1);
         }
 
         public static Matrix<double> GenerateRandomPositiveDefiniteDenseMatrix(int order)
         {
-            var a = DenseMatrix.CreateRandom(order, order, new Normal(new MersenneTwister(1)));
-            return a.TransposeThisAndMultiply(a);
+            return Matrix<double>.Build.RandomPositiveDefinite(order, 1);
         }
 
         public static Vector<double> GenerateRandomDenseVector(int order)
         {
-            return DenseVector.CreateRandom(order, new Normal(new MersenneTwister(1)));
+            return Vector<double>.Build.Random(order, 1);
         }
 
         public static Matrix<double> GenerateRandomUserDefinedMatrix(int row, int col)
diff --git a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs
index 39e8b59f..3937de25 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/MatrixTests.Arithmetic.cs
@@ -985,7 +985,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase(-2)]
         public void RandomWithNonPositiveNumberOfRowsThrowsArgumentException(int numberOfRows)
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => DenseMatrix.CreateRandom(numberOfRows, 4, new ContinuousUniform()));
+            Assert.Throws<ArgumentOutOfRangeException>(() => Matrix<double>.Build.Random(numberOfRows, 4, new ContinuousUniform()));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs
index 0475dd63..edcdd56d 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -85,10 +86,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1.0d);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -126,13 +127,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveScaledUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Scale it with a funny number
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -170,7 +171,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolvePoissonMatrixAndBackMultiply()
         {
             // Create the matrix
-            var matrix = new SparseMatrix(100);
+            var matrix = Matrix<double>.Build.Sparse(100, 100);
 
             // Assemble the matrix. We assume we're solving the Poisson equation
             // on a rectangular 10 x 10 grid
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs
index 5cfd718c..95baf807 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -85,10 +86,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -126,13 +127,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveScaledUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Scale it with a funny number
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -170,7 +171,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolvePoissonMatrixAndBackMultiply()
         {
             // Create the matrix
-            var matrix = new SparseMatrix(100);
+            var matrix = Matrix<double>.Build.Sparse(100, 100);
 
             // Assemble the matrix. We assume we're solving the Poisson equation
             // on a rectangular 10 x 10 grid
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs
index 2e454009..40d453aa 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -85,10 +86,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -126,13 +127,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveScaledUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Scale it with a funny number
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -170,7 +171,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolvePoissonMatrixAndBackMultiply()
         {
             // Create the matrix
-            var matrix = new SparseMatrix(100);
+            var matrix = Matrix<double>.Build.Sparse(100, 100);
 
             // Assemble the matrix. We assume we're solving the Poisson equation
             // on a rectangular 10 x 10 grid
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs
index c551df08..c43a9cd8 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -85,10 +86,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -126,13 +127,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolveScaledUnitMatrixAndBackMultiply()
         {
             // Create the identity matrix
-            var matrix = SparseMatrix.CreateIdentity(100);
+            var matrix = Matrix<double>.Build.SparseIdentity(100);
 
             // Scale it with a funny number
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
@@ -170,7 +171,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         public void SolvePoissonMatrixAndBackMultiply()
         {
             // Create the matrix
-            var matrix = new SparseMatrix(100);
+            var matrix = Matrix<double>.Build.Sparse(100, 100);
 
             // Assemble the matrix. We assume we're solving the Poisson equation
             // on a rectangular 10 x 10 grid
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<double>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<double>(
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs
index 4237f32e..a226df48 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs
@@ -30,6 +30,7 @@
 
 using System;
 using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -51,9 +52,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
             var iterator = new Iterator<double>();
             Assert.DoesNotThrow(() => iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 5),
+                Vector<double>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -73,9 +74,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 5),
+                Vector<double>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -96,17 +97,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, iterator.Status, "Incorrect status");
         }
 
@@ -128,9 +129,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             iterator.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 9f05e24f..d0aa6143 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -82,9 +83,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium<double>(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 5),
+                Vector<double>.Build.Dense(3, 6)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 4fbf30e9..cb8f2f2e 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -60,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium<double>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<double>.Build.Dense(3, 4), Vector<double>.Build.Dense(3, 5), Vector<double>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -72,7 +73,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium<double>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, Vector<double>.Build.Dense(3, 4), Vector<double>.Build.Dense(3, 6), Vector<double>.Build.Dense(4, 4)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index daad3e1e..b1654a96 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -84,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<double>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<double>.Build.Dense(3, 1), Vector<double>.Build.Dense(3, 2), Vector<double>.Build.Dense(3, 3)));
         }
 
         /// <summary>
@@ -96,10 +97,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<double>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<double>.Build.Dense(3, 1), Vector<double>.Build.Dense(3, 2), Vector<double>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
-            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status2 = criterium.DetermineStatus(10, Vector<double>.Build.Dense(3, 1), Vector<double>.Build.Dense(3, 2), Vector<double>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, status2, "Should be finished");
         }
 
@@ -112,7 +113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<double>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<double>.Build.Dense(3, 1), Vector<double>.Build.Dense(3, 2), Vector<double>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
             criterium.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 53f0451d..8e9e01a6 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -29,8 +29,7 @@
 // </copyright>
 
 using System;
-using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -82,9 +81,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 5),
+                Vector<double>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -97,9 +96,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<double>.Build.Dense(4, 4),
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -112,9 +111,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(4, 4),
+                Vector<double>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -127,9 +126,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4)));
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(3, 4),
+                Vector<double>.Build.Dense(4, 4)));
         }
 
         /// <summary>
@@ -139,9 +138,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
         public void DetermineStatusWithSourceNaN()
         {
             var criterium = new ResidualStopCriterium<double>(1e-3, 10);
-            var solution = new DenseVector(new[] {1.0, 1.0, 2.0});
-            var source = new DenseVector(new[] {1.0, 1.0, double.NaN});
-            var residual = new DenseVector(new[] {1000.0, 1000.0, 2001.0});
+            var solution = Vector<double>.Build.Dense(new[] { 1.0, 1.0, 2.0 });
+            var source = Vector<double>.Build.Dense(new[] { 1.0, 1.0, double.NaN });
+            var residual = Vector<double>.Build.Dense(new[] { 1000.0, 1000.0, 2001.0 });
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
@@ -154,9 +153,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
         public void DetermineStatusWithResidualNaN()
         {
             var criterium = new ResidualStopCriterium<double>(1e-3, 10);
-            var solution = new DenseVector(new[] {1.0, 1.0, 2.0});
-            var source = new DenseVector(new[] {1.0, 1.0, 2.0});
-            var residual = new DenseVector(new[] {1000.0, double.NaN, 2001.0});
+            var solution = Vector<double>.Build.Dense(new[] { 1.0, 1.0, 2.0 });
+            var source = Vector<double>.Build.Dense(new[] { 1.0, 1.0, 2.0 });
+            var residual = Vector<double>.Build.Dense(new[] { 1000.0, double.NaN, 2001.0 });
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
@@ -169,9 +168,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
         public void DetermineStatusWithConvergenceAtFirstIteration()
         {
             var criterium = new ResidualStopCriterium<double>(1e-12);
-            var solution = new DenseVector(new[] {1.0, 1.0, 1.0});
-            var source = new DenseVector(new[] {1.0, 1.0, 1.0});
-            var residual = new DenseVector(new[] {0.0, 0.0, 0.0});
+            var solution = Vector<double>.Build.Dense(new[] { 1.0, 1.0, 1.0 });
+            var source = Vector<double>.Build.Dense(new[] { 1.0, 1.0, 1.0 });
+            var residual = Vector<double>.Build.Dense(new[] { 0.0, 0.0, 0.0 });
 
             var status = criterium.DetermineStatus(0, solution, source, residual);
             Assert.AreEqual(IterationStatus.Converged, status, "Should be done");
@@ -186,13 +185,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new ResidualStopCriterium<double>(1e-3, 10);
 
             // the solution vector isn't actually being used so ...
-            var solution = new DenseVector(new[] {double.NaN, double.NaN, double.NaN});
+            var solution = Vector<double>.Build.Dense(new[] { double.NaN, double.NaN, double.NaN });
 
             // Set the source values
-            var source = new DenseVector(new[] {1.000, 1.000, 2.001});
+            var source = Vector<double>.Build.Dense(new[] { 1.000, 1.000, 2.001 });
 
             // Set the residual values
-            var residual = new DenseVector(new[] {0.001, 0.001, 0.002});
+            var residual = Vector<double>.Build.Dense(new[] { 0.001, 0.001, 0.002 });
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Continue, status, "Should still be running");
@@ -209,9 +208,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
         {
             var criterium = new ResidualStopCriterium<double>(1e-3, 10);
 
-            var solution = new DenseVector(new[] {0.001, 0.001, 0.002});
-            var source = new DenseVector(new[] {0.001, 0.001, 0.002});
-            var residual = new DenseVector(new[] {1.000, 1.000, 2.001});
+            var solution = Vector<double>.Build.Dense(new[] { 0.001, 0.001, 0.002 });
+            var source = Vector<double>.Build.Dense(new[] { 0.001, 0.001, 0.002 });
+            var residual = Vector<double>.Build.Dense(new[] { 1.000, 1.000, 2.001 });
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
diff --git a/src/UnitTests/LinearAlgebraTests/Double/SparseMatrixTests.cs b/src/UnitTests/LinearAlgebraTests/Double/SparseMatrixTests.cs
index 078e8e3b..2f028585 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/SparseMatrixTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/SparseMatrixTests.cs
@@ -49,7 +49,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given dimensions.</returns>
         protected override Matrix<double> CreateMatrix(int rows, int columns)
         {
-            return new SparseMatrix(rows, columns);
+            return Matrix<double>.Build.Sparse(rows, columns);
         }
 
         /// <summary>
@@ -59,7 +59,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>A matrix with the given values.</returns>
         protected override Matrix<double> CreateMatrix(double[,] data)
         {
-            return SparseMatrix.OfArray(data);
+            return Matrix<double>.Build.SparseOfArray(data);
         }
 
         /// <summary>
@@ -70,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector<double> CreateVector(int size)
         {
-            return new SparseVector(size);
+            return Vector<double>.Build.Sparse(size);
         }
 
         /// <summary>
@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector<double> CreateVector(double[] data)
         {
-            return SparseVector.OfEnumerable(data);
+            return Vector<double>.Build.SparseOfEnumerable(data);
         }
 
         /// <summary>
@@ -91,11 +91,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             var testData = new Dictionary<string, Matrix<double>>
                 {
-                    {"Singular3x3", SparseMatrix.OfColumnMajor(3, 3, new double[] {1, 1, 1, 1, 1, 1, 2, 2, 2})},
-                    {"Square3x3", SparseMatrix.OfColumnMajor(3, 3, new[] {-1.1, 0.0, -4.4, -2.2, 1.1, 5.5, -3.3, 2.2, 6.6})},
-                    {"Square4x4", SparseMatrix.OfColumnMajor(4, 4, new[] {-1.1, 0.0, 1.0, -4.4, -2.2, 1.1, 2.1, 5.5, -3.3, 2.2, 6.2, 6.6, -4.4, 3.3, 4.3, -7.7})},
-                    {"Tall3x2", SparseMatrix.OfColumnMajor(3, 2, new[] {-1.1, 0.0, -4.4, -2.2, 1.1, 5.5})},
-                    {"Wide2x3", SparseMatrix.OfColumnMajor(2, 3, new[] {-1.1, 0.0, -2.2, 1.1, -3.3, 2.2})}
+                    {"Singular3x3", Matrix<double>.Build.SparseOfColumnMajor(3, 3, new double[] {1, 1, 1, 1, 1, 1, 2, 2, 2})},
+                    {"Square3x3", Matrix<double>.Build.SparseOfColumnMajor(3, 3, new[] {-1.1, 0.0, -4.4, -2.2, 1.1, 5.5, -3.3, 2.2, 6.6})},
+                    {"Square4x4", Matrix<double>.Build.SparseOfColumnMajor(4, 4, new[] {-1.1, 0.0, 1.0, -4.4, -2.2, 1.1, 2.1, 5.5, -3.3, 2.2, 6.2, 6.6, -4.4, 3.3, 4.3, -7.7})},
+                    {"Tall3x2", Matrix<double>.Build.SparseOfColumnMajor(3, 2, new[] {-1.1, 0.0, -4.4, -2.2, 1.1, 5.5})},
+                    {"Wide2x3", Matrix<double>.Build.SparseOfColumnMajor(2, 3, new[] {-1.1, 0.0, -2.2, 1.1, -3.3, 2.2})}
                 };
 
             foreach (var name in testData.Keys)
@@ -112,7 +112,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             // Sparse Matrix copies values from double[], but no remember reference. 
             var data = new double[] {1, 1, 1, 1, 1, 1, 2, 2, 2};
-            var matrix = SparseMatrix.OfColumnMajor(3, 3, data);
+            var matrix = Matrix<double>.Build.SparseOfColumnMajor(3, 3, data);
             matrix[0, 0] = 10.0;
             Assert.AreNotEqual(10.0, data[0]);
         }
@@ -123,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void MatrixFrom2DArrayIsCopy()
         {
-            var matrix = SparseMatrix.OfArray(TestData2D["Singular3x3"]);
+            var matrix = Matrix<double>.Build.SparseOfArray(TestData2D["Singular3x3"]);
             matrix[0, 0] = 10.0;
             Assert.AreEqual(1.0, TestData2D["Singular3x3"][0, 0]);
         }
@@ -140,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase("Wide2x3")]
         public void CanCreateMatrixFrom2DArray(string name)
         {
-            var matrix = SparseMatrix.OfArray(TestData2D[name]);
+            var matrix = Matrix<double>.Build.SparseOfArray(TestData2D[name]);
             for (var i = 0; i < TestData2D[name].GetLength(0); i++)
             {
                 for (var j = 0; j < TestData2D[name].GetLength(1); j++)
@@ -156,7 +156,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateIdentity()
         {
-            var matrix = SparseMatrix.CreateIdentity(5);
+            var matrix = Matrix<double>.Build.SparseIdentity(5);
+            Assert.That(matrix, Is.TypeOf<SparseMatrix>());
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)
@@ -174,7 +175,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [TestCase(-1)]
         public void IdentityWithWrongOrderThrowsArgumentOutOfRangeException(int order)
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => SparseMatrix.CreateIdentity(order));
+            Assert.Throws<ArgumentOutOfRangeException>(() => Matrix<double>.Build.SparseIdentity(order));
         }
 
         /// <summary>
@@ -211,37 +212,37 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanAddSparseMatricesBothWays()
         {
             var m1 = new SparseMatrix(1, 3);
-            var m2 = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            var m2 = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             var sum1 = m1 + m2;
             var sum2 = m2 + m1;
             Assert.IsTrue(sum1.Equals(m2));
             Assert.IsTrue(sum1.Equals(sum2));
 
-            var sparseResult = new SparseMatrix(1, 3);
+            Matrix<double> sparseResult = new SparseMatrix(1, 3);
             sparseResult.Add(m2, sparseResult);
             Assert.IsTrue(sparseResult.Equals(sum1));
 
-            sparseResult = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            sparseResult = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             sparseResult.Add(m1, sparseResult);
             Assert.IsTrue(sparseResult.Equals(sum1));
 
-            sparseResult = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            sparseResult = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             m1.Add(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(sum1));
 
-            sparseResult = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            sparseResult = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             sparseResult.Add(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(2*sum1));
 
-            var denseResult = new DenseMatrix(1, 3);
+            Matrix<double> denseResult = new DenseMatrix(1, 3);
             denseResult.Add(m2, denseResult);
             Assert.IsTrue(denseResult.Equals(sum1));
 
-            denseResult = DenseMatrix.OfArray(new double[,] {{0, 1, 1}});
+            denseResult = Matrix<double>.Build.DenseOfArray(new double[,] { { 0, 1, 1 } });
             denseResult.Add(m1, denseResult);
             Assert.IsTrue(denseResult.Equals(sum1));
 
-            var m3 = DenseMatrix.OfArray(new double[,] {{0, 1, 1}});
+            var m3 = Matrix<double>.Build.DenseOfArray(new double[,] { { 0, 1, 1 } });
             var sum3 = m1 + m3;
             var sum4 = m3 + m1;
             Assert.IsTrue(sum3.Equals(m3));
@@ -255,37 +256,37 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanSubtractSparseMatricesBothWays()
         {
             var m1 = new SparseMatrix(1, 3);
-            var m2 = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            var m2 = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             var diff1 = m1 - m2;
             var diff2 = m2 - m1;
             Assert.IsTrue(diff1.Equals(m2.Negate()));
             Assert.IsTrue(diff1.Equals(diff2.Negate()));
 
-            var sparseResult = new SparseMatrix(1, 3);
+            Matrix<double> sparseResult = new SparseMatrix(1, 3);
             sparseResult.Subtract(m2, sparseResult);
             Assert.IsTrue(sparseResult.Equals(diff1));
 
-            sparseResult = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            sparseResult = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             sparseResult.Subtract(m1, sparseResult);
             Assert.IsTrue(sparseResult.Equals(diff2));
 
-            sparseResult = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            sparseResult = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             m1.Subtract(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(diff1));
 
-            sparseResult = SparseMatrix.OfArray(new double[,] { { 0, 1, 1 } });
+            sparseResult = Matrix<double>.Build.SparseOfArray(new double[,] { { 0, 1, 1 } });
             sparseResult.Subtract(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(0*diff1));
 
-            var denseResult = new DenseMatrix(1, 3);
+            Matrix<double> denseResult = new DenseMatrix(1, 3);
             denseResult.Subtract(m2, denseResult);
             Assert.IsTrue(denseResult.Equals(diff1));
 
-            denseResult = DenseMatrix.OfArray(new double[,] {{0, 1, 1}});
+            denseResult = Matrix<double>.Build.DenseOfArray(new double[,] { { 0, 1, 1 } });
             denseResult.Subtract(m1, denseResult);
             Assert.IsTrue(denseResult.Equals(diff2));
 
-            var m3 = DenseMatrix.OfArray(new double[,] {{0, 1, 1}});
+            var m3 = Matrix<double>.Build.DenseOfArray(new double[,] { { 0, 1, 1 } });
             var diff3 = m1 - m3;
             var diff4 = m3 - m1;
             Assert.IsTrue(diff3.Equals(m3.Negate()));
@@ -299,7 +300,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateLargeMatrix()
         {
             const int Order = 1000000;
-            var matrix = new SparseMatrix(Order);
+            var matrix = Matrix<double>.Build.Sparse(Order, Order);
             Assert.AreEqual(Order, matrix.RowCount);
             Assert.AreEqual(Order, matrix.ColumnCount);
             Assert.DoesNotThrow(() => matrix[0, 0] = 1);
diff --git a/src/UnitTests/LinearAlgebraTests/Double/SparseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Double/SparseVectorArithmeticTheory.cs
index b4da1c61..94cc3aaa 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/SparseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/SparseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Double;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
@@ -38,16 +37,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
     public class SparseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<double>[] denseVectors = new Vector<double>[]
-            {
-                SparseVector.OfEnumerable(new double[] {1, 2, 3, 4, 5}),
-                SparseVector.OfEnumerable(new double[] {2, 0, 0, -5, 0}),
-                new SparseVector(5),
-                new SparseVector(int.MaxValue)
-            };
+        Vector<double>[] denseVectors =
+        {
+            Vector<double>.Build.SparseOfEnumerable(new double[] { 1, 2, 3, 4, 5 }),
+            Vector<double>.Build.SparseOfEnumerable(new double[] { 2, 0, 0, -5, 0 }),
+            Vector<double>.Build.Sparse(5),
+            Vector<double>.Build.Sparse(int.MaxValue)
+        };
 
         [Datapoints]
-        double[] scalars = new[] {2d};
-
+        double[] scalars = { 2d };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.cs b/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.cs
index 65d2383d..5cfdf537 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.cs
@@ -49,7 +49,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new <c>Vector</c>.</returns>
         protected override Vector<double> CreateVector(int size)
         {
-            return new SparseVector(size);
+            return Vector<double>.Build.Sparse(size);
         }
 
         /// <summary>
@@ -59,7 +59,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new <c>Vector</c>.</returns>
         protected override Vector<double> CreateVector(IList<double> data)
         {
-            var vector = new SparseVector(data.Count);
+            var vector = Vector<double>.Build.Sparse(data.Count);
             for (var index = 0; index < data.Count; index++)
             {
                 vector[index] = data[index];
@@ -76,7 +76,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             var data = new double[Data.Length];
             Array.Copy(Data, data, Data.Length);
-            var vector = SparseVector.OfEnumerable(data);
+            var vector = Vector<double>.Build.SparseOfEnumerable(data);
 
             for (var i = 0; i < data.Length; i++)
             {
@@ -90,8 +90,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateSparseVectorFromAnotherSparseVector()
         {
-            var vector = SparseVector.OfEnumerable(Data);
-            var other = SparseVector.OfVector(vector);
+            var vector = Vector<double>.Build.SparseOfEnumerable(Data);
+            var other = Vector<double>.Build.SparseOfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -106,8 +106,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateSparseVectorFromAnotherVector()
         {
-            var vector = (Vector<double>)SparseVector.OfEnumerable(Data);
-            var other = SparseVector.OfVector(vector);
+            var vector = Vector<double>.Build.SparseOfEnumerable(Data);
+            var other = Vector<double>.Build.SparseOfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -123,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateSparseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = SparseVector.OfVector(vector);
+            var other = Vector<double>.Build.SparseOfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -137,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateSparseMatrix()
         {
-            var vector = new SparseVector(3);
+            var vector = Vector<double>.Build.Sparse(3);
             var matrix = Matrix<double>.Build.SameAs(vector, 2, 3);
             Assert.IsInstanceOf<SparseMatrix>(matrix);
             Assert.AreEqual(2, matrix.RowCount);
@@ -150,7 +150,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanConvertSparseVectorToArray()
         {
-            var vector = SparseVector.OfEnumerable(Data);
+            var vector = Vector<double>.Build.SparseOfEnumerable(Data);
             var array = vector.ToArray();
             Assert.IsInstanceOf(typeof (double[]), array);
             CollectionAssert.AreEqual(vector, array);
@@ -163,7 +163,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanConvertArrayToSparseVector()
         {
             var array = new[] {0.0, 1.0, 2.0, 3.0, 4.0};
-            var vector = SparseVector.OfEnumerable(array);
+            var vector = Vector<double>.Build.SparseOfEnumerable(array);
             Assert.IsInstanceOf(typeof (SparseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
@@ -174,7 +174,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanMultiplySparseVectorByScalarUsingOperators()
         {
-            var vector = SparseVector.OfEnumerable(Data);
+            var vector = Vector<double>.Build.SparseOfEnumerable(Data);
             vector = vector*2.0;
 
             for (var i = 0; i < Data.Length; i++)
@@ -188,7 +188,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
                 Assert.AreEqual(Data[i]*2.0, vector[i]);
             }
 
-            vector = SparseVector.OfEnumerable(Data);
+            vector = Vector<double>.Build.SparseOfEnumerable(Data);
             vector = 2.0*vector;
 
             for (var i = 0; i < Data.Length; i++)
@@ -209,7 +209,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanDivideSparseVectorByScalarUsingOperators()
         {
-            var vector = SparseVector.OfEnumerable(Data);
+            var vector = Vector<double>.Build.SparseOfEnumerable(Data);
             vector = vector/2.0;
 
             for (var i = 0; i < Data.Length; i++)
@@ -248,7 +248,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CheckSparseMechanismBySettingValues()
         {
-            var vector = new SparseVector(10000);
+            var vector = Vector<double>.Build.Sparse(10000);
             var storage = (SparseVectorStorage<double>) vector.Storage;
 
             // Add non-zero elements
@@ -292,7 +292,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CheckSparseMechanismByZeroMultiply()
         {
-            var vector = new SparseVector(10000);
+            var vector = Vector<double>.Build.Sparse(10000);
 
             // Add non-zero elements
             vector[200] = 1.5;
@@ -317,14 +317,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanDotProductOfTwoSparseVectors()
         {
-            var vectorA = new SparseVector(10000);
+            var vectorA = Vector<double>.Build.Sparse(10000);
             vectorA[200] = 1;
             vectorA[500] = 3;
             vectorA[800] = 5;
             vectorA[100] = 7;
             vectorA[900] = 9;
 
-            var vectorB = new SparseVector(10000);
+            var vectorB = Vector<double>.Build.Sparse(10000);
             vectorB[300] = 3;
             vectorB[500] = 5;
             vectorB[800] = 7;
@@ -339,9 +339,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanPointwiseMultiplySparseVector()
         {
             var zeroArray = new[] {0.0, 1.0, 0.0, 1.0, 0.0};
-            var vector1 = SparseVector.OfEnumerable(Data);
-            var vector2 = SparseVector.OfEnumerable(zeroArray);
-            var result = new SparseVector(vector1.Count);
+            var vector1 = Vector<double>.Build.SparseOfEnumerable(Data);
+            var vector2 = Vector<double>.Build.SparseOfEnumerable(zeroArray);
+            var result = Vector<double>.Build.Sparse(vector1.Count);
 
             vector1.PointwiseMultiply(vector2, result);
 
@@ -360,8 +360,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanOuterMultiplySparseVectors()
         {
-            var vector1 = SparseVector.OfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
-            var vector2 = SparseVector.OfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
+            var vector1 = Vector<double>.Build.SparseOfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
+            var vector2 = Vector<double>.Build.SparseOfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
             var result = vector1.OuterProduct(vector2);
 
             Assert.AreEqual(4.0, result[0, 0]);
@@ -389,12 +389,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanScaleAVectorWhenSettingPreviousNonzeroElementsToZero()
         {
-            var vector = new SparseVector(20);
+            var vector = Vector<double>.Build.Sparse(20);
             vector[10] = 1.0;
             vector[11] = 2.0;
             vector[11] = 0.0;
 
-            var scaled = new SparseVector(20);
+            var scaled = Vector<double>.Build.Sparse(20);
             vector.Multiply(3.0, scaled);
 
             Assert.AreEqual(3.0, scaled[10]);
diff --git a/src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs b/src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs
index 716960b3..3363bdaa 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs
@@ -508,7 +508,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void RandomWithNumberOfElementsLessThanZeroThrowsArgumentException()
         {
-            Assert.Throws<ArgumentOutOfRangeException>(() => DenseVector.CreateRandom(-2, new ContinuousUniform()));
+            Assert.Throws<ArgumentOutOfRangeException>(() => Vector<double>.Build.Random(-2, new ContinuousUniform()));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Single/DenseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Single/DenseVectorArithmeticTheory.cs
index e6990db4..35ffa312 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/DenseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/DenseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Single;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
@@ -38,13 +37,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
     public class DenseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<float>[] denseVectors = new Vector<float>[]
-            {
-                new DenseVector(new float[] { 1, 2, 3, 4, 5 }),
-                new DenseVector(new float[] { 2, 0, 0, -5, 0 }),
-            };
+        Vector<float>[] denseVectors =
+        {
+            Vector<float>.Build.Dense(new float[] { 1, 2, 3, 4, 5 }),
+            Vector<float>.Build.Dense(new float[] { 2, 0, 0, -5, 0 }),
+        };
 
         [Datapoints]
-        private float[] scalars = new[] { 2f };
+        float[] scalars = { 2f };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Single/MatrixLoader.cs b/src/UnitTests/LinearAlgebraTests/Single/MatrixLoader.cs
index 6bc72ae9..f7b24ac0 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/MatrixLoader.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/MatrixLoader.cs
@@ -29,10 +29,7 @@
 // </copyright>
 
 using System.Collections.Generic;
-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
@@ -89,15 +86,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public virtual void SetupMatrices()
         {
             TestData2D = new Dictionary<string, float[,]>
-                {
-                    {"Singular3x3", new[,] {{1.0f, 1.0f, 2.0f}, {1.0f, 1.0f, 2.0f}, {1.0f, 1.0f, 2.0f}}},
-                    {"Square3x3", new[,] {{-1.1f, -2.2f, -3.3f}, {0.0f, 1.1f, 2.2f}, {-4.4f, 5.5f, 6.6f}}},
-                    {"Square4x4", new[,] {{-1.1f, -2.2f, -3.3f, -4.4f}, {0.0f, 1.1f, 2.2f, 3.3f}, {1.0f, 2.1f, 6.2f, 4.3f}, {-4.4f, 5.5f, 6.6f, -7.7f}}},
-                    {"Singular4x4", 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}}},
-                    {"Tall3x2", new[,] {{-1.1f, -2.2f}, {0.0f, 1.1f}, {-4.4f, 5.5f}}},
-                    {"Wide2x3", new[,] {{-1.1f, -2.2f, -3.3f}, {0.0f, 1.1f, 2.2f}}},
-                    {"Symmetric3x3", new[,] {{1.0f, 2.0f, 3.0f}, {2.0f, 2.0f, 0.0f}, {3.0f, 0.0f, 3.0f}}}
-                };
+            {
+                { "Singular3x3", new[,] { { 1.0f, 1.0f, 2.0f }, { 1.0f, 1.0f, 2.0f }, { 1.0f, 1.0f, 2.0f } } },
+                { "Square3x3", new[,] { { -1.1f, -2.2f, -3.3f }, { 0.0f, 1.1f, 2.2f }, { -4.4f, 5.5f, 6.6f } } },
+                { "Square4x4", new[,] { { -1.1f, -2.2f, -3.3f, -4.4f }, { 0.0f, 1.1f, 2.2f, 3.3f }, { 1.0f, 2.1f, 6.2f, 4.3f }, { -4.4f, 5.5f, 6.6f, -7.7f } } },
+                { "Singular4x4", 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 } } },
+                { "Tall3x2", new[,] { { -1.1f, -2.2f }, { 0.0f, 1.1f }, { -4.4f, 5.5f } } },
+                { "Wide2x3", new[,] { { -1.1f, -2.2f, -3.3f }, { 0.0f, 1.1f, 2.2f } } },
+                { "Symmetric3x3", new[,] { { 1.0f, 2.0f, 3.0f }, { 2.0f, 2.0f, 0.0f }, { 3.0f, 0.0f, 3.0f } } }
+            };
 
             TestMatrices = new Dictionary<string, Matrix<float>>();
             foreach (var name in TestData2D.Keys)
@@ -108,18 +105,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
 
         public static Matrix<float> GenerateRandomDenseMatrix(int row, int col)
         {
-            return DenseMatrix.CreateRandom(row, col, new Normal(new MersenneTwister(1)));
+            return Matrix<float>.Build.Random(row, col, 1);
         }
 
         public static Matrix<float> GenerateRandomPositiveDefiniteDenseMatrix(int order)
         {
-            var a = DenseMatrix.CreateRandom(order, order, new Normal(new MersenneTwister(1)));
-            return a.TransposeThisAndMultiply(a);
+            return Matrix<float>.Build.RandomPositiveDefinite(order, 1);
         }
 
         public static Vector<float> GenerateRandomDenseVector(int order)
         {
-            return DenseVector.CreateRandom(order, new Normal(new MersenneTwister(1)));
+            return Vector<float>.Build.Random(order, 1);
         }
 
         public static Matrix<float> GenerateRandomUserDefinedMatrix(int row, int col)
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs
index 0682bee5..9e66330a 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -88,7 +89,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -132,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs
index a7f010a2..ab0336eb 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -88,7 +89,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -132,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs
index 6fcf9957..b89b9517 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs
@@ -89,7 +89,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -133,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -210,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Due to datatype "float" it can happen that solution will not converge for specific random starting vectors
             // That's why we will do 3 tries
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs
index 4ab698ab..813b7e62 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -88,7 +89,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             var matrix = SparseMatrix.CreateIdentity(100);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -132,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
@@ -209,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            var y = DenseVector.Create(matrix.RowCount, i => 1);
+            var y = Vector<float>.Build.Dense(matrix.RowCount, 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator<float>(
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs
index e6042def..1372b337 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs
@@ -30,6 +30,7 @@
 
 using System;
 using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -51,9 +52,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
             var iterator = new Iterator<float>();
             Assert.DoesNotThrow(() => iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 5),
+                Vector<float>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -73,9 +74,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 5),
+                Vector<float>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -96,17 +97,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, iterator.Status, "Incorrect status");
         }
 
@@ -128,9 +129,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4));
             Assert.AreEqual(IterationStatus.Continue, iterator.Status, "Incorrect status");
 
             iterator.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index dd9dc046..657868aa 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
@@ -82,9 +83,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium<float>(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 5),
+                Vector<float>.Build.Dense(3, 6)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 20722e4a..34babd3d 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -60,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium<float>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<float>.Build.Dense(3, 4), Vector<float>.Build.Dense(3, 5), Vector<float>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -72,7 +73,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium<float>();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, Vector<float>.Build.Dense(3, 4), Vector<float>.Build.Dense(3, 6), Vector<float>.Build.Dense(4, 4)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index 3fd7a712..d876785c 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -29,6 +29,7 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
@@ -84,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<float>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, Vector<float>.Build.Dense(3, 1), Vector<float>.Build.Dense(3, 2), Vector<float>.Build.Dense(3, 3)));
         }
 
         /// <summary>
@@ -96,10 +97,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<float>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<float>.Build.Dense(3, 1), Vector<float>.Build.Dense(3, 2), Vector<float>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
-            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status2 = criterium.DetermineStatus(10, Vector<float>.Build.Dense(3, 1), Vector<float>.Build.Dense(3, 2), Vector<float>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.StoppedWithoutConvergence, status2, "Should be finished");
         }
 
@@ -112,7 +113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<float>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            var status = criterium.DetermineStatus(5, Vector<float>.Build.Dense(3, 1), Vector<float>.Build.Dense(3, 2), Vector<float>.Build.Dense(3, 3));
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
 
             criterium.Reset();
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index d9e3c22c..4f3fa950 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -29,8 +29,8 @@
 // </copyright>
 
 using System;
+using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -82,9 +82,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 5),
-                DenseVector.Create(3, i => 6)));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 5),
+                Vector<float>.Build.Dense(3, 6)));
         }
 
         /// <summary>
@@ -97,9 +97,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<float>.Build.Dense(4, 4),
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -112,9 +112,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4),
-                DenseVector.Create(3, i => 4)));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(4, 4),
+                Vector<float>.Build.Dense(3, 4)));
         }
 
         /// <summary>
@@ -127,9 +127,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(3, i => 4),
-                DenseVector.Create(4, i => 4)));
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(3, 4),
+                Vector<float>.Build.Dense(4, 4)));
         }
 
         /// <summary>
diff --git a/src/UnitTests/LinearAlgebraTests/Single/SparseVectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/Single/SparseVectorArithmeticTheory.cs
index 27929392..bae4ae42 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/SparseVectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/SparseVectorArithmeticTheory.cs
@@ -29,7 +29,6 @@
 // </copyright>
 
 using MathNet.Numerics.LinearAlgebra;
-using MathNet.Numerics.LinearAlgebra.Single;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
@@ -38,15 +37,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
     public class SparseVectorArithmeticTheory : VectorArithmeticTheory
     {
         [Datapoints]
-        Vector<float>[] denseVectors = new Vector<float>[]
-            {
-                SparseVector.OfEnumerable(new float[] {1, 2, 3, 4, 5}),
-                SparseVector.OfEnumerable(new float[] {2, 0, 0, -5, 0}),
-                new SparseVector(5),
-                new SparseVector(int.MaxValue)
-            };
+        Vector<float>[] denseVectors =
+        {
+            Vector<float>.Build.SparseOfEnumerable(new float[] { 1, 2, 3, 4, 5 }),
+            Vector<float>.Build.SparseOfEnumerable(new float[] { 2, 0, 0, -5, 0 }),
+            Vector<float>.Build.Sparse(5),
+            Vector<float>.Build.Sparse(int.MaxValue)
+        };
 
         [Datapoints]
-        float[] scalars = new[] {2f};
+        float[] scalars = { 2f };
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs b/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs
index 0516af38..daa0aab8 100644
--- a/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs
+++ b/src/UnitTests/LinearAlgebraTests/VectorArithmeticTheory.cs
@@ -174,7 +174,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests
             Assert.That(result3, Is.Not.SameAs(a));
             Assert.That(result3, Is.Not.SameAs(b));
             Assert.That(result1.Equals(result2));
-            // Assert.That(result1.Equals(result3)); BUG GH-21
+            Assert.That(result1.Equals(result3));
 
             for (var i = 0; i < Math.Min(a.Count, 20); i++)
             {