LA: Further clean up and extend matrix/vector enumeration

src/Examples/LinearAlgebra/VectorDataAccessor.cs

@@ -158,7 +158,7 @@ namespace Examples.LinearAlgebraExamples
 
             // 12. Indexed non-zero enumerator usage
             Console.WriteLine(@"11. Non-Zero Enumerator usage");
-            foreach (var value in vectorA.EnumerateNonZero())
+            foreach (var value in vectorA.EnumerateNonZeroIndexed())
             {
                 Console.WriteLine(@"Index = {0}; Value = {1}", value.Item1, value.Item2.ToString("#0.00\t", formatProvider));
             }

src/FSharp/LinearAlgebra.Matrix.fs

@@ -94,9 +94,36 @@ module MatrixExtensions =
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module Matrix =
 
-    /// Transform a vector into a 2D array.
+    /// Transform a matrix into a 2D array.
     let inline toArray2 (A: #Matrix<_>) = A.ToArray()
 
+
+    /// Transform a matrix into a sequence.
+    let inline toSeq (v: #Matrix<_>) = v.Enumerate()
+
+    /// Transform a matrix into an indexed sequence.
+    let inline toSeqi (v: #Matrix<_>) = v.EnumerateIndexed()
+
+    /// Transform a matrix into a sequence where zero-values are skipped.
+    let inline toSeqnz (v: #Matrix<_>) = v.EnumerateNonZero()
+
+    /// Transform a matrix into an indexed sequence where zero-values are skipped.
+    let inline toSeqinz (v: #Matrix<_>) = v.EnumerateNonZeroIndexed()
+
+
+    /// Transform a matrix into a column sequence.
+    let inline toColSeq (v: #Matrix<_>) = v.EnumerateColumns()
+
+    /// Transform a matrix into an indexed column sequence.
+    let inline toColSeqi (v: #Matrix<_>) = v.EnumerateColumnsIndexed()
+
+    /// Transform a matrix into a row sequence.
+    let inline toRowSeq (v: #Matrix<_>) = v.EnumerateRows()
+
+    /// Transform a matrix into an indexed row sequence.
+    let inline toRowSeqi (v: #Matrix<_>) = v.EnumerateRowsIndexed()
+
+
     /// In-place map of every matrix element using a function.
     let inline mapInPlace f (A: #Matrix<_>) =
         A.MapInplace((fun x -> f x), true)
@@ -115,6 +142,7 @@ module Matrix =
     let inline mapinzInPlace f (A: #Matrix<_>) =
         A.MapIndexedInplace((fun i j x -> f i j x), false)
 
+
     /// In-place map every matrix column using the given position dependent function.
     let inline mapColsInPlace (f: int -> Vector<'a> -> Vector<'a>) (A: #Matrix<_>) =
         for j = 0 to A.ColumnCount-1 do

src/FSharp/LinearAlgebra.Vector.fs

@@ -68,14 +68,19 @@ module Vector =
     /// Transform a vector into a list.
     let inline toList (v: #Vector<_>) = List.init v.Count v.At
 
+
     /// Transform a vector into a sequence.
     let inline toSeq (v: #Vector<_>) = v.Enumerate()
 
     /// Transform a vector into an indexed sequence.
     let inline toSeqi (v: #Vector<_>) = v.EnumerateIndexed()
 
-    /// Transform a vector into an indexed sequence where zero-values may be skipped.
+    /// Transform a vector into a sequence where zero-values are skipped.
-    let inline toSeqinz (v: #Vector<_>) = v.EnumerateNonZero()
+    let inline toSeqnz (v: #Vector<_>) = v.EnumerateNonZero()
+
+    /// Transform a vector into an indexed sequence where zero-values are skipped.
+    let inline toSeqinz (v: #Vector<_>) = v.EnumerateNonZeroIndexed()
+
 
     /// In-place mutation by applying a function to every element of the vector.
     let inline mapInPlace f (v: #Vector<_>) =
@@ -95,6 +100,7 @@ module Vector =
     let inline mapinzInPlace (f: int -> float -> float) (v: #Vector<float>) =
         v.MapIndexedInplace((fun i x -> f i x), false)
 
+
     /// Maps a vector to a new vector by applying a function to every element.
     let inline map f (v: #Vector<_>) =
         let w = v.Clone()
@@ -121,35 +127,39 @@ module Vector =
         w.MapIndexedInplace((fun i x -> f i x), false)
         w
 
+
     /// In-place vector addition.
     let inline addInPlace (v: #Vector<_>) (w: #Vector<_>) = v.Add(w, v)
 
     /// In place vector subtraction.
     let inline subInPlace (v: #Vector<_>) (w: #Vector<_>) = v.Subtract(w, v)
 
+
     /// Applies a function to all elements of the vector.
-    let inline iter f (v: #Vector<_>) = Seq.iter f (v.Enumerate())
+    let inline iter f (v: #Vector<_>) = v.Enumerate() |> Seq.iter f
 
     /// Applies a function to all indexed elements of the vector.
-    let inline iteri f (v: #Vector<_>) = Seq.iteri f (v.Enumerate())
+    let inline iteri f (v: #Vector<_>) = v.Enumerate() |> Seq.iteri f
 
     /// Applies a function to all non-zero elements of the vector.
-    let inline iternz f (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.iter (fun (_,v) -> f v)
+    let inline iternz f (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.iter f
 
     /// Applies a function to all non-zero indexed elements of the vector.
-    let inline iterinz f (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.iter (fun (i,v) -> f i v)
+    let inline iterinz f (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.iter (fun (i,v) -> f i v)
+
 
     /// Fold all entries of a vector.
-    let inline fold f state (v: #Vector<_>) = Seq.fold f state (v.Enumerate())
+    let inline fold f state (v: #Vector<_>) = v.Enumerate() |> Seq.fold f state
 
     /// Fold all entries of a vector using a position dependent folding function.
-    let inline foldi f acc0 (v: #Vector<_>) = v.EnumerateIndexed() |> Seq.fold (fun s (i,x) -> f i s x) acc0
+    let inline foldi f state (v: #Vector<_>) = v.EnumerateIndexed() |> Seq.fold (fun s (i,x) -> f i s x) state
 
     /// Fold all non-zero entries of a vector.
-    let inline foldnz f acc0 (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.fold (fun s (_,x) -> f s x) acc0
+    let inline foldnz f state (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.fold f state
 
     /// Fold all non-zero entries of a vector using a position dependent folding function.
-    let inline foldinz f acc0 (v: #Vector<_>) = v.EnumerateNonZero() |> Seq.fold (fun s (i,x) -> f i s x) acc0
+    let inline foldinz f state (v: #Vector<_>) = v.EnumerateNonZeroIndexed() |> Seq.fold (fun s (i,x) -> f i s x) state
+
 
     /// Fold all entries of a vector in reverse order.
     let inline foldBack f acc0 (v: #Vector<_>) =

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/BiCgStab.cs

@@ -532,7 +532,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/CompositeSolver.cs

@@ -623,7 +623,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/GpBiCg.cs

@@ -632,7 +632,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/MlkBiCgStab.cs

@@ -797,7 +797,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/TFQMR.cs

@@ -531,7 +531,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/BiCgStab.cs

@@ -526,7 +526,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/CompositeSolver.cs

@@ -623,7 +623,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/GpBiCg.cs

@@ -631,7 +631,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/MlkBiCgStab.cs

@@ -796,7 +796,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/TFQMR.cs

@@ -530,7 +530,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/BiCgStab.cs

@@ -524,7 +524,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/CompositeSolver.cs

@@ -620,7 +620,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/GpBiCg.cs

@@ -635,7 +635,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/MlkBiCgStab.cs

@@ -794,7 +794,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/TFQMR.cs

@@ -528,7 +528,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Matrix.cs

@@ -1253,13 +1253,56 @@ namespace MathNet.Numerics.LinearAlgebra
             }
         }
 
+        /// <summary>
+        /// Returns this matrix as a multidimensional array.
+        /// </summary>
+        /// <returns>A multidimensional containing the values of this matrix.</returns>
+        public T[,] ToArray()
+        {
+            return Storage.ToArray();
+        }
+
+        /// <summary>
+        /// Returns the matrix's elements as an array with the data laid out column-wise.
+        /// </summary>
+        /// <example><pre>
+        /// 1, 2, 3
+        /// 4, 5, 6  will be returned as  1, 4, 7, 2, 5, 8, 3, 6, 9
+        /// 7, 8, 9
+        /// </pre></example>
+        /// <returns>An array containing the matrix's elements.</returns>
+        /// <seealso cref="ToRowWiseArray"/>
+        /// <seealso cref="Enumerate"/>
+        public T[] ToColumnWiseArray()
+        {
+            return Storage.ToColumnMajorArray();
+        }
+
+        /// <summary>
+        /// Returns the matrix's elements as an array with the data laid row-wise.
+        /// </summary>
+        /// <example><pre>
+        /// 1, 2, 3
+        /// 4, 5, 6  will be returned as  1, 2, 3, 4, 5, 6, 7, 8, 9
+        /// 7, 8, 9
+        /// </pre></example>
+        /// <returns>An array containing the matrix's elements.</returns>
+        /// <seealso cref="ToColumnWiseArray"/>
+        /// <seealso cref="Enumerate"/>
+        public T[] ToRowWiseArray()
+        {
+            return Storage.ToRowMajorArray();
+        }
+
         /// <summary>
         /// Returns an IEnumerable that can be used to iterate through all values of the matrix.
         /// </summary>
         /// <remarks>
         /// The enumerator will include all values, even if they are zero.
-        /// The ordering of the values is unspecified (not necessarily column by column or row by row).
+        /// The ordering of the values is unspecified (not necessarily column-wise or row-wise).
         /// </remarks>
+        /// <seealso cref="ToColumnWiseArray"/>
+        /// <seealso cref="ToRowWiseArray"/>
         public IEnumerable<T> Enumerate()
         {
             return Storage.Enumerate();
@@ -1278,6 +1321,17 @@ namespace MathNet.Numerics.LinearAlgebra
             return Storage.EnumerateIndexed();
         }
 
+        /// <summary>
+        /// Returns an IEnumerable that can be used to iterate through all non-zero values of the matrix.
+        /// </summary>
+        /// <remarks>
+        /// The enumerator will skip all elements with a zero value.
+        /// </remarks>
+        public IEnumerable<T> EnumerateNonZero()
+        {
+            return Storage.EnumerateNonZero();
+        }
+
         /// <summary>
         /// Returns an IEnumerable that can be used to iterate through all non-zero values of the matrix and their index.
         /// </summary>
@@ -1286,9 +1340,9 @@ namespace MathNet.Numerics.LinearAlgebra
         /// and the third value being the value of the element at that index.
         /// The enumerator will skip all elements with a zero value.
         /// </remarks>
-        public IEnumerable<Tuple<int, int, T>> EnumerateNonZero()
+        public IEnumerable<Tuple<int, int, T>> EnumerateNonZeroIndexed()
         {
-            return Storage.EnumerateNonZero();
+            return Storage.EnumerateNonZeroIndexed();
         }
 
         /// <summary>
@@ -1407,43 +1461,6 @@ namespace MathNet.Numerics.LinearAlgebra
             }
         }
 
-        /// <summary>
-        /// Returns this matrix as a multidimensional array.
-        /// </summary>
-        /// <returns>A multidimensional containing the values of this matrix.</returns>
-        public T[,] ToArray()
-        {
-            return Storage.ToArray();
-        }
-
-        /// <summary>
-        /// Returns the matrix's elements as an array with the data laid out column-wise.
-        /// </summary>
-        /// <example><pre>
-        /// 1, 2, 3
-        /// 4, 5, 6  will be returned as  1, 4, 7, 2, 5, 8, 3, 6, 9
-        /// 7, 8, 9
-        /// </pre></example>
-        /// <returns>An array containing the matrix's elements.</returns>
-        public T[] ToColumnWiseArray()
-        {
-            return Storage.ToColumnMajorArray();
-        }
-
-        /// <summary>
-        /// Returns the matrix's elements as an array with the data laid row-wise.
-        /// </summary>
-        /// <example><pre>
-        /// 1, 2, 3
-        /// 4, 5, 6  will be returned as  1, 2, 3, 4, 5, 6, 7, 8, 9
-        /// 7, 8, 9
-        /// </pre></example>
-        /// <returns>An array containing the matrix's elements.</returns>
-        public T[] ToRowWiseArray()
-        {
-            return Storage.ToRowMajorArray();
-        }
-
         /// <summary>
         /// Applies a function to each value of this matrix and replaces the value with its result.
         /// If forceMapZero is not set to true, zero values may or may not be skipped depending

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/BiCgStab.cs

@@ -524,7 +524,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/CompositeSolver.cs

@@ -623,7 +623,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/GpBiCg.cs

@@ -629,7 +629,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/MlkBiCgStab.cs

@@ -797,7 +797,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector)input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/TFQMR.cs

@@ -528,7 +528,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             for (var column = 0; column < input.ColumnCount; column++)
             {
                 var solution = Solve(matrix, (Vector) input.Column(column));
-                foreach (var element in solution.EnumerateNonZero())
+                foreach (var element in solution.EnumerateNonZeroIndexed())
                 {
                     result.At(element.Item1, column, element.Item2);
                 }

src/Numerics/LinearAlgebra/Storage/DenseColumnMajorMatrixStorage.cs

@@ -277,43 +277,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return new DenseColumnMajorMatrixStorage<T>(rows, columns, array);
         }
 
-        // ENUMERATION
-
-        public override IEnumerable<T> Enumerate()
-        {
-            return Data;
-        }
-
-        public override IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
-        {
-            int index = 0;
-            for (int j = 0; j < ColumnCount; j++)
-            {
-                for (int i = 0; i < RowCount; i++)
-                {
-                    yield return new Tuple<int, int, T>(i, j, Data[index]);
-                    index++;
-                }
-            }
-        }
-
-        public override IEnumerable<Tuple<int, int, T>> EnumerateNonZero()
-        {
-            int index = 0;
-            for (int j = 0; j < ColumnCount; j++)
-            {
-                for (int i = 0; i < RowCount; i++)
-                {
-                    var x = Data[index];
-                    if (!Zero.Equals(x))
-                    {
-                        yield return new Tuple<int, int, T>(i, j, x);
-                    }
-                    index++;
-                }
-            }
-        }
-
         // MATRIX COPY
 
         internal override void CopyToUnchecked(MatrixStorage<T> target, bool skipClearing = false)
@@ -448,6 +411,48 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return ret;
         }
 
+        // ENUMERATION
+
+        public override IEnumerable<T> Enumerate()
+        {
+            return Data;
+        }
+
+        public override IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
+        {
+            int index = 0;
+            for (int j = 0; j < ColumnCount; j++)
+            {
+                for (int i = 0; i < RowCount; i++)
+                {
+                    yield return new Tuple<int, int, T>(i, j, Data[index]);
+                    index++;
+                }
+            }
+        }
+
+        public override IEnumerable<T> EnumerateNonZero()
+        {
+            return Data.Where(x => !Zero.Equals(x));
+        }
+
+        public override IEnumerable<Tuple<int, int, T>> EnumerateNonZeroIndexed()
+        {
+            int index = 0;
+            for (int j = 0; j < ColumnCount; j++)
+            {
+                for (int i = 0; i < RowCount; i++)
+                {
+                    var x = Data[index];
+                    if (!Zero.Equals(x))
+                    {
+                        yield return new Tuple<int, int, T>(i, j, x);
+                    }
+                    index++;
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public override void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Storage/DenseVectorStorage.cs

@@ -153,29 +153,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return new DenseVectorStorage<T>(array.Length, array);
         }
 
-        // ENUMERATION
-
-        public override IEnumerable<T> Enumerate()
-        {
-            return Data;
-        }
-
-        public override IEnumerable<Tuple<int, T>> EnumerateIndexed()
-        {
-            return Data.Select((t, i) => new Tuple<int, T>(i, t));
-        }
-
-        public override IEnumerable<Tuple<int, T>> EnumerateNonZero()
-        {
-            for (var i = 0; i < Data.Length; i++)
-            {
-                if (!Zero.Equals(Data[i]))
-                {
-                    yield return new Tuple<int, T>(i, Data[i]);
-                }
-            }
-        }
-
         // VECTOR COPY
 
         internal override void CopyToUnchecked(VectorStorage<T> target, bool skipClearing = false)
@@ -302,6 +279,34 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        // ENUMERATION
+
+        public override IEnumerable<T> Enumerate()
+        {
+            return Data;
+        }
+
+        public override IEnumerable<Tuple<int, T>> EnumerateIndexed()
+        {
+            return Data.Select((t, i) => new Tuple<int, T>(i, t));
+        }
+
+        public override IEnumerable<T> EnumerateNonZero()
+        {
+            return Data.Where(x => !Zero.Equals(x));
+        }
+
+        public override IEnumerable<Tuple<int, T>> EnumerateNonZeroIndexed()
+        {
+            for (var i = 0; i < Data.Length; i++)
+            {
+                if (!Zero.Equals(Data[i]))
+                {
+                    yield return new Tuple<int, T>(i, Data[i]);
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public override void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Storage/DiagonalMatrixStorage.cs

@@ -244,45 +244,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return storage;
         }
 
-        // ENUMERATION
-
-        public override IEnumerable<T> Enumerate()
-        {
-            for (int j = 0; j < ColumnCount; j++)
-            {
-                for (int i = 0; i < RowCount; i++)
-                {
-                    // PERF: consider to break up loop to avoid branching
-                    yield return i == j ? Data[i] : Zero;
-                }
-            }
-        }
-
-        public override IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
-        {
-            for (int j = 0; j < ColumnCount; j++)
-            {
-                for (int i = 0; i < RowCount; i++)
-                {
-                    // PERF: consider to break up loop to avoid branching
-                    yield return i == j
-                        ? new Tuple<int, int, T>(i, i, Data[i])
-                        : new Tuple<int, int, T>(i, j, Zero);
-                }
-            }
-        }
-
-        public override IEnumerable<Tuple<int, int, T>> EnumerateNonZero()
-        {
-            for (int i = 0; i < Data.Length; i++)
-            {
-                if (!Zero.Equals(Data[i]))
-                {
-                    yield return new Tuple<int, int, T>(i, i, Data[i]);
-                }
-            }
-        }
-
         // MATRIX COPY
 
         internal override void CopyToUnchecked(MatrixStorage<T> target, bool skipClearing = false)
@@ -566,6 +527,50 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return ret;
         }
 
+        // ENUMERATION
+
+        public override IEnumerable<T> Enumerate()
+        {
+            for (int j = 0; j < ColumnCount; j++)
+            {
+                for (int i = 0; i < RowCount; i++)
+                {
+                    // PERF: consider to break up loop to avoid branching
+                    yield return i == j ? Data[i] : Zero;
+                }
+            }
+        }
+
+        public override IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
+        {
+            for (int j = 0; j < ColumnCount; j++)
+            {
+                for (int i = 0; i < RowCount; i++)
+                {
+                    // PERF: consider to break up loop to avoid branching
+                    yield return i == j
+                        ? new Tuple<int, int, T>(i, i, Data[i])
+                        : new Tuple<int, int, T>(i, j, Zero);
+                }
+            }
+        }
+
+        public override IEnumerable<T> EnumerateNonZero()
+        {
+            return Data.Where(x => !Zero.Equals(x));
+        }
+
+        public override IEnumerable<Tuple<int, int, T>> EnumerateNonZeroIndexed()
+        {
+            for (int i = 0; i < Data.Length; i++)
+            {
+                if (!Zero.Equals(Data[i]))
+                {
+                    yield return new Tuple<int, int, T>(i, i, Data[i]);
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public override void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Storage/MatrixStorage.cs

@@ -227,45 +227,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return hash;
         }
 
-        // ENUMERATION
-
-        public virtual IEnumerable<T> Enumerate()
-        {
-            for (int i = 0; i < RowCount; i++)
-            {
-                for (int j = 0; j < ColumnCount; j++)
-                {
-                    yield return At(i, j);
-                }
-            }
-        }
-
-        public virtual IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
-        {
-            for (int i = 0; i < RowCount; i++)
-            {
-                for (int j = 0; j < ColumnCount; j++)
-                {
-                    yield return new Tuple<int, int, T>(i, j, At(i, j));
-                }
-            }
-        }
-
-        public virtual IEnumerable<Tuple<int, int, T>> EnumerateNonZero()
-        {
-            for (int i = 0; i < RowCount; i++)
-            {
-                for (int j = 0; j < ColumnCount; j++)
-                {
-                    var x = At(i, j);
-                    if (!Zero.Equals(x))
-                    {
-                        yield return new Tuple<int, int, T>(i, j, x);
-                    }
-                }
-            }
-        }
-
         // MATRIX COPY
 
         public void CopyTo(MatrixStorage<T> target, bool skipClearing = false)
@@ -452,6 +413,60 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return ret;
         }
 
+        // ENUMERATION
+
+        public virtual IEnumerable<T> Enumerate()
+        {
+            for (int i = 0; i < RowCount; i++)
+            {
+                for (int j = 0; j < ColumnCount; j++)
+                {
+                    yield return At(i, j);
+                }
+            }
+        }
+
+        public virtual IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
+        {
+            for (int i = 0; i < RowCount; i++)
+            {
+                for (int j = 0; j < ColumnCount; j++)
+                {
+                    yield return new Tuple<int, int, T>(i, j, At(i, j));
+                }
+            }
+        }
+
+        public virtual IEnumerable<T> EnumerateNonZero()
+        {
+            for (int i = 0; i < RowCount; i++)
+            {
+                for (int j = 0; j < ColumnCount; j++)
+                {
+                    var x = At(i, j);
+                    if (!Zero.Equals(x))
+                    {
+                        yield return x;
+                    }
+                }
+            }
+        }
+
+        public virtual IEnumerable<Tuple<int, int, T>> EnumerateNonZeroIndexed()
+        {
+            for (int i = 0; i < RowCount; i++)
+            {
+                for (int j = 0; j < ColumnCount; j++)
+                {
+                    var x = At(i, j);
+                    if (!Zero.Equals(x))
+                    {
+                        yield return new Tuple<int, int, T>(i, j, x);
+                    }
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public virtual void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Storage/SparseCompressedRowMatrixStorage.cs

@@ -30,6 +30,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using MathNet.Numerics.Properties;
 
 namespace MathNet.Numerics.LinearAlgebra.Storage
@@ -638,52 +639,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return storage;
         }
 
-        // ENUMERATION
-
-        public override IEnumerable<T> Enumerate()
-        {
-            int k = 0;
-            for (int row = 0; row < RowCount; row++)
-            {
-                for (int col = 0; col < ColumnCount; col++)
-                {
-                    yield return k < (row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount) && (ColumnIndices[k]) == col
-                        ? Values[k++]
-                        : Zero;
-                }
-            }
-        }
-
-        public override IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
-        {
-            int k = 0;
-            for (int row = 0; row < RowCount; row++)
-            {
-                for (int col = 0; col < ColumnCount; col++)
-                {
-                    yield return k < (row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount) && (ColumnIndices[k]) == col
-                        ? new Tuple<int, int, T>(row, col, Values[k++])
-                        : new Tuple<int, int, T>(row, col, Zero);
-                }
-            }
-        }
-
-        public override IEnumerable<Tuple<int, int, T>> EnumerateNonZero()
-        {
-            for (int row = 0; row < RowCount; row++)
-            {
-                var startIndex = RowPointers[row];
-                var endIndex = row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount;
-                for (var j = startIndex; j < endIndex; j++)
-                {
-                    if (!Zero.Equals(Values[j]))
-                    {
-                        yield return new Tuple<int, int, T>(row, ColumnIndices[j], Values[j]);
-                    }
-                }
-            }
-        }
-
         // MATRIX COPY
 
         internal override void CopyToUnchecked(MatrixStorage<T> target, bool skipClearing = false)
@@ -958,6 +913,57 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return ret;
         }
 
+        // ENUMERATION
+
+        public override IEnumerable<T> Enumerate()
+        {
+            int k = 0;
+            for (int row = 0; row < RowCount; row++)
+            {
+                for (int col = 0; col < ColumnCount; col++)
+                {
+                    yield return k < (row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount) && (ColumnIndices[k]) == col
+                        ? Values[k++]
+                        : Zero;
+                }
+            }
+        }
+
+        public override IEnumerable<Tuple<int, int, T>> EnumerateIndexed()
+        {
+            int k = 0;
+            for (int row = 0; row < RowCount; row++)
+            {
+                for (int col = 0; col < ColumnCount; col++)
+                {
+                    yield return k < (row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount) && (ColumnIndices[k]) == col
+                        ? new Tuple<int, int, T>(row, col, Values[k++])
+                        : new Tuple<int, int, T>(row, col, Zero);
+                }
+            }
+        }
+
+        public override IEnumerable<T> EnumerateNonZero()
+        {
+            return Values.Take(ValueCount).Where(x => !Zero.Equals(x));
+        }
+
+        public override IEnumerable<Tuple<int, int, T>> EnumerateNonZeroIndexed()
+        {
+            for (int row = 0; row < RowCount; row++)
+            {
+                var startIndex = RowPointers[row];
+                var endIndex = row < RowPointers.Length - 1 ? RowPointers[row + 1] : ValueCount;
+                for (var j = startIndex; j < endIndex; j++)
+                {
+                    if (!Zero.Equals(Values[j]))
+                    {
+                        yield return new Tuple<int, int, T>(row, ColumnIndices[j], Values[j]);
+                    }
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public override void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Storage/SparseVectorStorage.cs

@@ -30,6 +30,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using MathNet.Numerics.Properties;
 
 namespace MathNet.Numerics.LinearAlgebra.Storage
@@ -376,41 +377,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
                 };
         }
 
-        // ENUMERATION
-
-        public override IEnumerable<T> Enumerate()
-        {
-            int k = 0;
-            for (int i = 0; i < Length; i++)
-            {
-                yield return k < ValueCount && Indices[k] == i
-                    ? Values[k++]
-                    : Zero;
-            }
-        }
-
-        public override IEnumerable<Tuple<int, T>> EnumerateIndexed()
-        {
-            int k = 0;
-            for (int i = 0; i < Length; i++)
-            {
-                yield return k < ValueCount && Indices[k] == i
-                    ? new Tuple<int, T>(i, Values[k++])
-                    : new Tuple<int, T>(i, Zero);
-            }
-        }
-
-        public override IEnumerable<Tuple<int, T>> EnumerateNonZero()
-        {
-            for (var i = 0; i < ValueCount; i++)
-            {
-                if (!Zero.Equals(Values[i]))
-                {
-                    yield return new Tuple<int, T>(Indices[i], Values[i]);
-                }
-            }
-        }
-
         // VECTOR COPY
 
         internal override void CopyToUnchecked(VectorStorage<T> target, bool skipClearing = false)
@@ -602,6 +568,46 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        // ENUMERATION
+
+        public override IEnumerable<T> Enumerate()
+        {
+            int k = 0;
+            for (int i = 0; i < Length; i++)
+            {
+                yield return k < ValueCount && Indices[k] == i
+                    ? Values[k++]
+                    : Zero;
+            }
+        }
+
+        public override IEnumerable<Tuple<int, T>> EnumerateIndexed()
+        {
+            int k = 0;
+            for (int i = 0; i < Length; i++)
+            {
+                yield return k < ValueCount && Indices[k] == i
+                    ? new Tuple<int, T>(i, Values[k++])
+                    : new Tuple<int, T>(i, Zero);
+            }
+        }
+
+        public override IEnumerable<T> EnumerateNonZero()
+        {
+            return Values.Take(ValueCount).Where(x => !Zero.Equals(x));
+        }
+
+        public override IEnumerable<Tuple<int, T>> EnumerateNonZeroIndexed()
+        {
+            for (var i = 0; i < ValueCount; i++)
+            {
+                if (!Zero.Equals(Values[i]))
+                {
+                    yield return new Tuple<int, T>(Indices[i], Values[i]);
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public override void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Storage/VectorStorage.cs

@@ -198,36 +198,6 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             return hash;
         }
 
-        // ENUMERATION
-
-        public virtual IEnumerable<T> Enumerate()
-        {
-            for (var i = 0; i < Length; i++)
-            {
-                yield return At(i);
-            }
-        }
-
-        public virtual IEnumerable<Tuple<int, T>> EnumerateIndexed()
-        {
-            for (var i = 0; i < Length; i++)
-            {
-                yield return new Tuple<int, T>(i, At(i));
-            }
-        }
-
-        public virtual IEnumerable<Tuple<int, T>> EnumerateNonZero()
-        {
-            for (var i = 0; i < Length; i++)
-            {
-                var x = At(i);
-                if (!Zero.Equals(x))
-                {
-                    yield return new Tuple<int, T>(i, x);
-                }
-            }
-        }
-
         // VECTOR COPY
 
         public void CopyTo(VectorStorage<T> target, bool skipClearing = false)
@@ -400,6 +370,48 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
             }
         }
 
+        // ENUMERATION
+
+        public virtual IEnumerable<T> Enumerate()
+        {
+            for (var i = 0; i < Length; i++)
+            {
+                yield return At(i);
+            }
+        }
+
+        public virtual IEnumerable<Tuple<int, T>> EnumerateIndexed()
+        {
+            for (var i = 0; i < Length; i++)
+            {
+                yield return new Tuple<int, T>(i, At(i));
+            }
+        }
+
+        public virtual IEnumerable<T> EnumerateNonZero()
+        {
+            for (var i = 0; i < Length; i++)
+            {
+                var x = At(i);
+                if (!Zero.Equals(x))
+                {
+                    yield return x;
+                }
+            }
+        }
+
+        public virtual IEnumerable<Tuple<int, T>> EnumerateNonZeroIndexed()
+        {
+            for (var i = 0; i < Length; i++)
+            {
+                var x = At(i);
+                if (!Zero.Equals(x))
+                {
+                    yield return new Tuple<int, T>(i, x);
+                }
+            }
+        }
+
         // FUNCTIONAL COMBINATORS
 
         public virtual void MapInplace(Func<T, T> f, bool forceMapZeros = false)

src/Numerics/LinearAlgebra/Vector.cs

@@ -312,6 +312,17 @@ namespace MathNet.Numerics.LinearAlgebra
             return Storage.EnumerateIndexed();
         }
 
+        /// <summary>
+        /// Returns an IEnumerable that can be used to iterate through all non-zero values of the vector.
+        /// </summary>
+        /// <remarks>
+        /// The enumerator will skip all elements with a zero value.
+        /// </remarks>
+        public IEnumerable<T> EnumerateNonZero()
+        {
+            return Storage.EnumerateNonZero();
+        }
+
         /// <summary>
         /// Returns an IEnumerable that can be used to iterate through all non-zero values of the vector and their index.
         /// </summary>
@@ -320,9 +331,9 @@ namespace MathNet.Numerics.LinearAlgebra
         /// and the second value being the value of the element at that index.
         /// The enumerator will skip all elements with a zero value.
         /// </remarks>
-        public IEnumerable<Tuple<int, T>> EnumerateNonZero()
+        public IEnumerable<Tuple<int, T>> EnumerateNonZeroIndexed()
         {
-            return Storage.EnumerateNonZero();
+            return Storage.EnumerateNonZeroIndexed();
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Complex/VectorTests.cs

@@ -258,7 +258,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanEnumerateOverVectorUsingNonZeroEnumerator()
         {
             var vector = CreateVector(Data);
-            foreach (var pair in vector.EnumerateNonZero())
+            foreach (var pair in vector.EnumerateNonZeroIndexed())
             {
                 Assert.AreEqual(Data[pair.Item1], pair.Item2);
                 Assert.AreNotEqual(Complex.Zero, pair.Item2);

src/UnitTests/LinearAlgebraTests/Complex32/VectorTests.cs

@@ -258,7 +258,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanEnumerateOverVectorUsingNonZeroEnumerator()
         {
             var vector = CreateVector(Data);
-            foreach (var pair in vector.EnumerateNonZero())
+            foreach (var pair in vector.EnumerateNonZeroIndexed())
             {
                 Assert.AreEqual(Data[pair.Item1], pair.Item2);
                 Assert.AreNotEqual(Complex32.Zero, pair.Item2);

src/UnitTests/LinearAlgebraTests/Double/VectorTests.cs

@@ -255,7 +255,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanEnumerateOverVectorUsingNonZeroEnumerator()
         {
             var vector = CreateVector(Data);
-            foreach (var pair in vector.EnumerateNonZero())
+            foreach (var pair in vector.EnumerateNonZeroIndexed())
             {
                 Assert.AreEqual(Data[pair.Item1], pair.Item2);
                 Assert.AreNotEqual(0d, pair.Item2);

src/UnitTests/LinearAlgebraTests/Single/VectorTests.cs

@@ -255,7 +255,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanEnumerateOverVectorUsingNonZeroEnumerator()
         {
             var vector = CreateVector(Data);
-            foreach (var pair in vector.EnumerateNonZero())
+            foreach (var pair in vector.EnumerateNonZeroIndexed())
             {
                 Assert.AreEqual(Data[pair.Item1], pair.Item2);
                 Assert.AreNotEqual(0f, pair.Item2);