LA: push some of the manual F# matrix create routines up to storage for perf and C# support

src/FSharp/LinearAlgebra.Double.Matrix.fs

@@ -76,13 +76,10 @@ module DenseMatrix =
     let inline randomCreate (rows: int) (cols: int) dist = DenseMatrix.CreateRandom(rows, cols, dist) :> _ Matrix
 
     /// Create a matrix with the given dimension and set all values to x.
-    let inline create (rows: int) (cols: int) x = DenseMatrix.Create(rows, cols, fun i j -> x) :> _ Matrix
+    let inline create (rows: int) (cols: int) (x: float) = DenseMatrix.Create(rows, cols, x) :> _ Matrix
 
     /// Create a matrix with the given dimension and set all diagonal values to x. All other values are zero.
-    let createDiag (rows: int) (cols: int) x =
-        let A = DenseMatrix(rows,cols)
-        for i=0 to min (rows-1) (cols-1) do A.At(i,i,x)
-        A :> _ Matrix
+    let inline createDiag (rows: int) (cols: int) (x: float) = DenseMatrix.CreateDiagonal(rows, cols, x) :> _ Matrix
 
     /// Initialize a matrix by calling a construction function for every element.
     let inline init (rows: int) (cols: int) (f: int -> int -> float) = DenseMatrix.Create(rows, cols, fun i j -> f i j) :> _ Matrix
@@ -94,10 +91,7 @@ module DenseMatrix =
     let inline initColumns (cols: int) (f: int -> Vector<float>) = DenseMatrix.OfColumnVectors(Array.init cols f) :> _ Matrix
 
     /// Initialize a matrix by calling a construction function for every diagonal element. All other values are zero.
-    let initDiag (rows: int) (cols: int) (f: int -> float) =
-        let A = DenseMatrix(rows,cols)
-        for i=0 to min (rows-1) (cols-1) do A.At(i,i,f i)
-        A :> _ Matrix
+    let inline initDiag (rows: int) (cols: int) (f: int -> float) = DenseMatrix.CreateDiagonal(rows, cols, f) :> _ Matrix
 
     /// Create an identity matrix with the given dimension.
     let inline identity (rows: int) (cols: int) = createDiag rows cols 1.0
@@ -158,11 +152,11 @@ module SparseMatrix =
     /// Create an all-zero matrix with the given dimension.
     let inline zeroCreate (rows: int) (cols: int) = SparseMatrix(rows, cols) :> _ Matrix
 
+    /// Create a matrix with the given dimension and set all values to x. Note that a dense matrix would likely be more appropriate.
+    let inline create (rows: int) (cols: int) (x: float) = SparseMatrix.Create(rows, cols, x) :> _ Matrix
+
     /// Create a matrix with the given dimension and set all diagonal values to x. All other values are zero.
-    let createDiag (rows: int) (cols: int) x =
-        let A = SparseMatrix(rows,cols)
-        for i=0 to min (rows-1) (cols-1) do A.At(i,i,x)
-        A :> _ Matrix
+    let inline createDiag (rows: int) (cols: int) (x: float) = SparseMatrix.CreateDiagonal(rows, cols, x) :> _ Matrix
 
     /// Initialize a matrix by calling a construction function for every element.
     let inline init (rows: int) (cols: int) (f: int -> int -> float) = SparseMatrix.Create(rows, cols, fun n m -> f n m) :> _ Matrix
@@ -174,10 +168,7 @@ module SparseMatrix =
     let inline initColumns (cols: int) (f: int -> Vector<float>) = SparseMatrix.OfColumnVectors(Array.init cols f) :> _ Matrix
 
     /// Initialize a matrix by calling a construction function for every diagonal element. All other values are zero.
-    let initDiag (rows: int) (cols: int) (f: int -> float) =
-        let A = SparseMatrix(rows,cols)
-        for i=0 to min (rows-1) (cols-1) do A.At(i,i,f i)
-        A :> _ Matrix
+    let inline initDiag (rows: int) (cols: int) (f: int -> float) = SparseMatrix.CreateDiagonal(rows, cols, f) :> _ Matrix
 
     /// Create an identity matrix with the given dimension.
     let inline identity (rows: int) (cols: int) = createDiag rows cols 1.0

src/FSharp/LinearAlgebra.Double.Vector.fs

@@ -62,10 +62,13 @@ module DenseVector =
     let inline randomCreate (n: int) dist = DenseVector.CreateRandom(n, dist) :> _ Vector
 
     /// Initialize an x-valued vector with the given dimension.
-    let inline create (n: int) x = DenseVector.Create(n, fun i -> x) :> _ Vector
+    let inline create (n: int) (x: float) = DenseVector.Create(n, x) :> _ Vector
 
     /// Initialize a vector by calling a construction function for every element.
-    let inline init (n: int) (f: int -> float) = DenseVector.Create(n, fun i -> f i) :> _ Vector
+    let inline init (n: int) (f: int -> float) = DenseVector.Create(n, f) :> _ Vector
+
+    /// Create a vector from a float array (by copying - use raw instead if no copy is needed).
+    let inline ofArray (fl: float array) = DenseVector(Array.copy fl) :> _ Vector
 
     /// Create a vector from a float list.
     let inline ofList (fl: float list) = DenseVector(Array.ofList fl) :> _ Vector
@@ -93,8 +96,14 @@ module SparseVector =
     /// Initialize an all-zero vector with the given dimension.
     let inline zeroCreate (n: int) = SparseVector(n) :> _ Vector
 
+    /// Initialize an x-valued vector with the given dimension.
+    let inline create (n: int) (x: float) = SparseVector.Create(n, x) :> _ Vector
+
     /// Initialize a vector by calling a construction function for every element.
-    let inline init (n: int) (f: int -> float) = SparseVector.Create(n, fun i -> f i) :> _ Vector
+    let inline init (n: int) (f: int -> float) = SparseVector.Create(n, f) :> _ Vector
+
+    /// Create a sparse vector from a float array.
+    let inline ofArray (fl: float array) = SparseVector.OfEnumerable(Seq.ofArray fl) :> _ Vector
 
     /// Create a sparse vector from a float list.
     let inline ofList (fl: float list) = SparseVector.OfEnumerable(Seq.ofList fl) :> _ Vector

src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs

@@ -234,6 +234,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new dense matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static DenseMatrix Create(int rows, int columns, Complex value)
+        {
+            if (value == Complex.Zero) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new dense matrix and initialize each value using the provided init function.
         /// </summary>
@@ -242,6 +251,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, Complex value)
+        {
+            if (value == Complex.Zero) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, Func<int, Complex> init)
+        {
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Create a new dense matrix with values sampled from the provided random distribution.
         /// </summary>

src/Numerics/LinearAlgebra/Complex/DenseVector.cs

@@ -127,6 +127,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new DenseVector(DenseVectorStorage<Complex>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense vector and initialize each value using the provided value.
+        /// </summary>
+        public static DenseVector Create(int length, Complex value)
+        {
+            if (value == Complex.Zero) return new DenseVector(length);
+            return new DenseVector(DenseVectorStorage<Complex>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new dense vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs

@@ -223,6 +223,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new sparse matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static SparseMatrix Create(int rows, int columns, Complex value)
+        {
+            if (value == Complex.Zero) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new sparse matrix and initialize each value using the provided init function.
         /// </summary>
@@ -231,6 +240,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, Complex value)
+        {
+            if (value == Complex.Zero) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, Func<int, Complex> init)
+        {
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Creates a <c>SparseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Complex/SparseVector.cs

@@ -116,6 +116,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             return new SparseVector(SparseVectorStorage<Complex>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided value.
+        /// </summary>
+        public static SparseVector Create(int length, Complex value)
+        {
+            if (value == Complex.Zero) return new SparseVector(length);
+            return new SparseVector(SparseVectorStorage<Complex>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new sparse vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs

@@ -229,6 +229,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex32>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new dense matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static DenseMatrix Create(int rows, int columns, Complex32 value)
+        {
+            if (value == Complex32.Zero) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex32>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new dense matrix and initialize each value using the provided init function.
         /// </summary>
@@ -237,6 +246,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex32>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, Complex32 value)
+        {
+            if (value == Complex32.Zero) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex32>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, Func<int, Complex32> init)
+        {
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<Complex32>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Create a new dense matrix with values sampled from the provided random distribution.
         /// </summary>

src/Numerics/LinearAlgebra/Complex32/DenseVector.cs

@@ -122,6 +122,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new DenseVector(DenseVectorStorage<Complex32>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense vector and initialize each value using the provided value.
+        /// </summary>
+        public static DenseVector Create(int length, Complex32 value)
+        {
+            if (value == Complex32.Zero) return new DenseVector(length);
+            return new DenseVector(DenseVectorStorage<Complex32>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new dense vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs

@@ -218,6 +218,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex32>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new sparse matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static SparseMatrix Create(int rows, int columns, Complex32 value)
+        {
+            if (value == Complex32.Zero) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex32>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new sparse matrix and initialize each value using the provided init function.
         /// </summary>
@@ -226,6 +235,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex32>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, Complex32 value)
+        {
+            if (value == Complex32.Zero) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex32>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, Func<int, Complex32> init)
+        {
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<Complex32>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Creates a <c>SparseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Complex32/SparseVector.cs

@@ -111,6 +111,15 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             return new SparseVector(SparseVectorStorage<Complex32>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided value.
+        /// </summary>
+        public static SparseVector Create(int length, Complex32 value)
+        {
+            if (value == Complex32.Zero) return new SparseVector(length);
+            return new SparseVector(SparseVectorStorage<Complex32>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new sparse vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Double/DenseMatrix.cs

@@ -227,6 +227,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new dense matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static DenseMatrix Create(int rows, int columns, double value)
+        {
+            if (value == 0d) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new dense matrix and initialize each value using the provided init function.
         /// </summary>
@@ -235,13 +244,29 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, double value)
+        {
+            if (value == 0d) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, Func<int, double> init)
+        {
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Create a new dense matrix with values sampled from the provided random distribution.
         /// </summary>
         public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution)
         {
-            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfInit(rows, columns,
-                (i, j) => distribution.Sample()));
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<double>.OfInit(rows, columns, (i, j) => distribution.Sample()));
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -122,6 +122,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new DenseVector(DenseVectorStorage<double>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense vector and initialize each value using the provided value.
+        /// </summary>
+        public static DenseVector Create(int length, double value)
+        {
+            if (value == 0d) return new DenseVector(length);
+            return new DenseVector(DenseVectorStorage<double>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new dense vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Double/SparseMatrix.cs

@@ -216,6 +216,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new SparseMatrix(SparseCompressedRowMatrixStorage<double>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new sparse matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static SparseMatrix Create(int rows, int columns, double value)
+        {
+            if (value == 0d) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<double>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new sparse matrix and initialize each value using the provided init function.
         /// </summary>
@@ -224,6 +233,23 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new SparseMatrix(SparseCompressedRowMatrixStorage<double>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, double value)
+        {
+            if (value == 0d) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<double>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, Func<int, double> init)
+        {
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<double>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Creates a <c>SparseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Double/SparseVector.cs

@@ -111,6 +111,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return new SparseVector(SparseVectorStorage<double>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided value.
+        /// </summary>
+        public static SparseVector Create(int length, double value)
+        {
+            if (value == 0d) return new SparseVector(length);
+            return new SparseVector(SparseVectorStorage<double>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new sparse vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Single/DenseMatrix.cs

@@ -227,6 +227,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new dense matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static DenseMatrix Create(int rows, int columns, float value)
+        {
+            if (value == 0f) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new dense matrix and initialize each value using the provided init function.
         /// </summary>
@@ -235,13 +244,29 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, float value)
+        {
+            if (value == 0f) return new DenseMatrix(rows, columns);
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal dense matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static DenseMatrix CreateDiagonal(int rows, int columns, Func<int, float> init)
+        {
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Create a new dense matrix with values sampled from the provided random distribution.
         /// </summary>
         public static DenseMatrix CreateRandom(int rows, int columns, IContinuousDistribution distribution)
         {
-            return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfInit(rows, columns,
-                (i, j) => (float) distribution.Sample()));
+            return new DenseMatrix(DenseColumnMajorMatrixStorage<float>.OfInit(rows, columns, (i, j) => (float) distribution.Sample()));
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Single/DenseVector.cs

@@ -121,6 +121,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new DenseVector(DenseVectorStorage<float>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new dense vector and initialize each value using the provided value.
+        /// </summary>
+        public static DenseVector Create(int length, float value)
+        {
+            if (value == 0f) return new DenseVector(length);
+            return new DenseVector(DenseVectorStorage<float>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new dense vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Single/SparseMatrix.cs

@@ -216,6 +216,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new SparseMatrix(SparseCompressedRowMatrixStorage<float>.OfRowVectors(storage));
         }
 
+        /// <summary>
+        /// Create a new sparse matrix and initialize each value to the same provided value.
+        /// </summary>
+        public static SparseMatrix Create(int rows, int columns, float value)
+        {
+            if (value == 0f) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<float>.OfInit(rows, columns, (i, j) => value));
+        }
+
         /// <summary>
         /// Create a new sparse matrix and initialize each value using the provided init function.
         /// </summary>
@@ -224,6 +233,23 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new SparseMatrix(SparseCompressedRowMatrixStorage<float>.OfInit(rows, columns, init));
         }
 
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value to the same provided value.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, float value)
+        {
+            if (value == 0f) return new SparseMatrix(rows, columns);
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<float>.OfDiagonalInit(rows, columns, i => value));
+        }
+
+        /// <summary>
+        /// Create a new diagonal sparse matrix and initialize each diagonal value using the provided init function.
+        /// </summary>
+        public static SparseMatrix CreateDiagonal(int rows, int columns, Func<int, float> init)
+        {
+            return new SparseMatrix(SparseCompressedRowMatrixStorage<float>.OfDiagonalInit(rows, columns, init));
+        }
+
         /// <summary>
         /// Creates a <c>SparseMatrix</c> for the given number of rows and columns.
         /// </summary>

src/Numerics/LinearAlgebra/Single/SparseVector.cs

@@ -111,6 +111,15 @@ namespace MathNet.Numerics.LinearAlgebra.Single
             return new SparseVector(SparseVectorStorage<float>.OfIndexedEnumerable(length, enumerable));
         }
 
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided value.
+        /// </summary>
+        public static SparseVector Create(int length, float value)
+        {
+            if (value == 0f) return new SparseVector(length);
+            return new SparseVector(SparseVectorStorage<float>.OfInit(length, i => value));
+        }
+
         /// <summary>
         /// Create a new sparse vector and initialize each value using the provided init function.
         /// </summary>

src/Numerics/LinearAlgebra/Storage/DenseColumnMajorMatrixStorage.cs

@@ -114,9 +114,9 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
         {
             var storage = new DenseColumnMajorMatrixStorage<T>(rows, columns);
             int index = 0;
-            for (var j = 0; j < storage.ColumnCount; j++)
+            for (var j = 0; j < columns; j++)
             {
-                for (var i = 0; i < storage.RowCount; i++)
+                for (var i = 0; i < rows; i++)
                 {
                     storage.Data[index++] = init(i, j);
                 }
@@ -124,6 +124,19 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return storage;
         }
 
+        public static DenseColumnMajorMatrixStorage<T> OfDiagonalInit(int rows, int columns, Func<int, T> init)
+        {
+            var storage = new DenseColumnMajorMatrixStorage<T>(rows, columns);
+            int index = 0;
+            int stride = rows + 1;
+            for (var i = 0; i < Math.Min(rows, columns); i++)
+            {
+                storage.Data[index] = init(i);
+                index += stride;
+            }
+            return storage;
+        }
+
         public static DenseColumnMajorMatrixStorage<T> OfArray(T[,] array)
         {
             var storage = new DenseColumnMajorMatrixStorage<T>(array.GetLength(0), array.GetLength(1));

src/Numerics/LinearAlgebra/Storage/SparseCompressedRowMatrixStorage.cs

@@ -384,10 +384,10 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
                 rowPointers[row] = values.Count;
                 for (int col = 0; col < columns; col++)
                 {
-                    var item = init(row, col);
-                    if (!Zero.Equals(item))
+                    var x = init(row, col);
+                    if (!Zero.Equals(x))
                     {
-                        values.Add(item);
+                        values.Add(x);
                         columnIndices.Add(col);
                     }
                 }
@@ -399,6 +399,30 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return storage;
         }
 
+        public static SparseCompressedRowMatrixStorage<T> OfDiagonalInit(int rows, int columns, Func<int, T> init)
+        {
+            var storage = new SparseCompressedRowMatrixStorage<T>(rows, columns);
+            var rowPointers = storage.RowPointers;
+            var columnIndices = new List<int>();
+            var values = new List<T>();
+
+            for (int i = 0; i < Math.Min(rows, columns); i++)
+            {
+                rowPointers[i] = values.Count;
+                var x = init(i);
+                if (!Zero.Equals(x))
+                {
+                    values.Add(x);
+                    columnIndices.Add(i);
+                }
+            }
+
+            storage.ColumnIndices = columnIndices.ToArray();
+            storage.Values = values.ToArray();
+            storage.ValueCount = values.Count;
+            return storage;
+        }
+
         public static SparseCompressedRowMatrixStorage<T> OfArray(T[,] array)
         {
             var storage = new SparseCompressedRowMatrixStorage<T>(array.GetLength(0), array.GetLength(1));

src/UnitTests/LinearAlgebraTests/Complex32/DenseMatrixTests.cs

@@ -155,7 +155,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanCreateMatrixWithUniformValues()
         {
-            var matrix = DenseMatrix.Create(10, 10, (i, j) => new Complex32(10.0f, 1));
+            var matrix = DenseMatrix.Create(10, 10, new Complex32(10.0f, 1));
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)

src/UnitTests/LinearAlgebraTests/Single/DenseMatrixTests.cs

@@ -154,7 +154,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanCreateMatrixWithUniformValues()
         {
-            var matrix = DenseMatrix.Create(10, 10, (i, j) => 10.0f);
+            var matrix = DenseMatrix.Create(10, 10, 10.0f);
             for (var i = 0; i < matrix.RowCount; i++)
             {
                 for (var j = 0; j < matrix.ColumnCount; j++)