Cosmetics: fix trailing whitespace

.editorconfig

@@ -8,3 +8,6 @@ indent_style = space
 indent_size = 4
 insert_final_newline = true
 trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

src/Numerics/LinearAlgebra/Complex/Factorization/DenseEvd.cs

@@ -110,9 +110,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         /// <param name="e">Output: Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="tau">Output: Arrays that contains further information about the transformations.</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures HTRIDI by 
-        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures HTRIDI by
+        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         internal static void SymmetricTridiagonalize(Complex[] matrixA, double[] d, double[] e, Complex[] tau, int order)
         {
@@ -332,7 +332,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {
@@ -747,7 +747,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 }
             }
 
-            // All roots found.  
+            // All roots found.
             // Backsubstitute to find vectors of upper triangular form
             norm = 0.0;
             for (var i = 0; i < order; i++)

src/Numerics/LinearAlgebra/Complex/Factorization/DenseGramSchmidt.cs

@@ -50,7 +50,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     internal sealed class DenseGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="DenseGramSchmidt"/> class. This object creates an unitary matrix 
+        /// Initializes a new instance of the <see cref="DenseGramSchmidt"/> class. This object creates an unitary matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -114,7 +114,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                     for (var index = 0; index < rowsQ; index++)
                     {
                         dot += q[(k1 * rowsQ) + index].Conjugate() * q[(j1 * rowsQ) + index];
-                    } 
+                    }
 
                     r[(j * columnsQ) + k] = dot;
                     for (var i = 0; i < rowsQ; i++)

src/Numerics/LinearAlgebra/Complex/Factorization/DenseQR.cs

@@ -42,8 +42,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex/Factorization/DenseSvd.cs

@@ -41,13 +41,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="DenseMatrix"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex/Factorization/LU.cs

@@ -42,7 +42,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     /// <para>A class which encapsulates the functionality of an LU factorization.</para>
     /// <para>For a matrix A, the LU factorization is a pair of lower triangular matrix L and
     /// upper triangular matrix U so that A = L*U.</para>
-    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased 
+    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased
     /// numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex/Factorization/QR.cs

@@ -43,14 +43,14 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
     /// <para>Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix 
-    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the 
-    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.     
+    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix
+    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
+    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>
     internal abstract class QR : QR<Complex>
     {

src/Numerics/LinearAlgebra/Complex/Factorization/UserEvd.cs

@@ -133,9 +133,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         /// <param name="e">Output: Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="tau">Output: Arrays that contains further information about the transformations.</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures HTRIDI by 
-        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures HTRIDI by
+        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         static void SymmetricTridiagonalize(Complex[,] matrixA, double[] d, double[] e, Complex[] tau, int order)
         {
@@ -354,7 +354,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {
@@ -745,7 +745,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 }
             }
 
-            // All roots found.  
+            // All roots found.
             // Backsubstitute to find vectors of upper triangular form
             norm = 0.0;
             for (var i = 0; i < order; i++)

src/Numerics/LinearAlgebra/Complex/Factorization/UserGramSchmidt.cs

@@ -49,7 +49,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     internal sealed class UserGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an unitary matrix 
+        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an unitary matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -87,7 +87,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                     {
                         dot += q.Column(k)[i].Conjugate() * q.Column(j)[i];
                     }
-                    
+
                     r.At(k, j, dot);
                     for (var i = 0; i < q.RowCount; i++)
                     {
@@ -131,7 +131,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
             }
 
             var inputCopy = input.Clone();
-            
+
             // Compute Y = transpose(Q)*B
             var column = new Complex[Q.RowCount];
             for (var j = 0; j < input.ColumnCount; j++)

src/Numerics/LinearAlgebra/Complex/Factorization/UserQR.cs

@@ -44,8 +44,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex/Factorization/UserSvd.cs

@@ -41,13 +41,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="Matrix{T}"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>
@@ -349,7 +349,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             while (m > 0)
             {
-                // Quit if all the singular values have been found. If too many iterations have been performed, 
+                // Quit if all the singular values have been found. If too many iterations have been performed,
                 // throw exception that Convergence Failed
                 if (iter >= maxiter)
                 {
@@ -667,7 +667,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s 
+        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>
@@ -780,7 +780,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         }
 
         /// <summary>
-        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>, 
+        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>,
         /// each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i)
         /// </summary>
         /// <param name="a">Source matrix</param>

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

@@ -203,7 +203,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
                 residuals.Add(temp, vecS);
 
                 // Check if we're converged. If so then stop. Otherwise continue;
-                // Calculate the temporary result. 
+                // Calculate the temporary result.
                 // Be careful not to change any of the temp vectors, except for
                 // temp. Others will be used in the calculation later on.
                 // x_i = x_(i-1) + alpha_i * p^_i + s^_i

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

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 
     /// <summary>
     /// A composite matrix solver. The actual solver is made by a sequence of
-    /// matrix solvers. 
+    /// matrix solvers.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -121,9 +121,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
                 }
                 catch (Exception)
                 {
-                    // The solver broke down. 
+                    // The solver broke down.
                     // Log a message about this
-                    // Switch to the next preconditioner. 
+                    // Switch to the next preconditioner.
                     // Reset the solution vector to the previous solution
                     input.CopyTo(internalInput);
                     continue;

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

@@ -45,16 +45,16 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an 
+    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an
     /// alternative version of the Bi-Conjugate Gradient stabilized (CG) solver.
-    /// Unlike the CG solver the GPBiCG solver can be used on 
+    /// Unlike the CG solver the GPBiCG solver can be used on
     /// non-symmetric matrices. <br/>
     /// Note that much of the success of the solver depends on the selection of the
     /// proper preconditioner.
     /// </para>
     /// <para>
     /// The GPBiCG algorithm was taken from: <br/>
-    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with 
+    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with
     /// efficiency and robustness
     /// <br/>
     /// S. Fujino
@@ -70,13 +70,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
     public sealed class GpBiCg : IIterativeSolver<Complex>
     {
         /// <summary>
-        /// Indicates the number of <c>BiCGStab</c> steps should be taken 
+        /// Indicates the number of <c>BiCGStab</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
-        /// Indicates the number of <c>GPBiCG</c> steps should be taken 
+        /// Indicates the number of <c>GPBiCG</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfGpbiCgSteps = 4;

src/Numerics/LinearAlgebra/Complex/Solvers/ILU0Preconditioner.cs

@@ -191,7 +191,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
             var rowValues = new DenseVector(_decompositionLU.RowCount);
             for (var i = 0; i < _decompositionLU.RowCount; i++)
             {
-                // Clear the rowValues 
+                // Clear the rowValues
                 rowValues.Clear();
                 _decompositionLU.Row(i, rowValues);
 

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

@@ -50,7 +50,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
     /// <remarks>
     /// <para>
     /// The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement'
-    /// of the standard BiCgStab solver. 
+    /// of the standard BiCgStab solver.
     /// </para>
     /// <para>
     /// The algorithm was taken from: <br/>
@@ -88,7 +88,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// Gets or sets the number of starting vectors.
         /// </summary>
         /// <remarks>
-        /// Must be larger than 1 and smaller than the number of variables in the matrix that 
+        /// Must be larger than 1 and smaller than the number of variables in the matrix that
         /// for which this solver will be used.
         /// </remarks>
         public int NumberOfStartingVectors
@@ -117,7 +117,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Gets or sets a series of orthonormal vectors which will be used as basis for the 
+        /// Gets or sets a series of orthonormal vectors which will be used as basis for the
         /// Krylov sub-space.
         /// </summary>
         public IList<Vector<Complex>> StartingVectors
@@ -159,7 +159,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <returns>
         ///  An array with starting vectors. The array will never be larger than the
         ///  <paramref name="maximumNumberOfStartingVectors"/> but it may be smaller if
-        ///  the <paramref name="numberOfVariables"/> is smaller than 
+        ///  the <paramref name="numberOfVariables"/> is smaller than
         ///  the <paramref name="maximumNumberOfStartingVectors"/>.
         /// </returns>
         static IList<Vector<Complex>> CreateStartingVectors(int maximumNumberOfStartingVectors, int numberOfVariables)
@@ -287,7 +287,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
                 // We don't accept collections with zero starting vectors so ...
                 if (_startingVectors.Count <= NumberOfStartingVectorsToCreate(_numberOfStartingVectors, input.Count))
                 {
-                    // Only check the first vector for sizing. If that matches we assume the 
+                    // Only check the first vector for sizing. If that matches we assume the
                     // other vectors match too. If they don't the process will crash
                     if (_startingVectors[0].Count == input.Count)
                     {

src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs

@@ -911,7 +911,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             }
 
             result.Clear();
-            
+
 
             var rowPointers = _storage.RowPointers;
             var columnIndices = _storage.ColumnIndices;

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseEvd.cs

@@ -111,9 +111,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// <param name="e">Output: Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="tau">Output: Arrays that contains further information about the transformations.</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures HTRIDI by 
-        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures HTRIDI by
+        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         internal static void SymmetricTridiagonalize(Complex32[] matrixA, float[] d, float[] e, Complex32[] tau, int order)
         {
@@ -333,7 +333,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {
@@ -748,7 +748,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 }
             }
 
-            // All roots found.  
+            // All roots found.
             // Backsubstitute to find vectors of upper triangular form
             norm = 0.0f;
             for (var i = 0; i < order; i++)

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseGramSchmidt.cs

@@ -45,7 +45,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     internal sealed class DenseGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="DenseGramSchmidt"/> class. This object creates an unitary matrix 
+        /// Initializes a new instance of the <see cref="DenseGramSchmidt"/> class. This object creates an unitary matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -110,7 +110,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                     {
                         dot += q[(k1 * rowsQ) + index].Conjugate() * q[(j1 * rowsQ) + index];
                     }
-                    
+
                     r[(j * columnsQ) + k] = dot;
                     for (var i = 0; i < rowsQ; i++)
                     {

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseQR.cs

@@ -37,8 +37,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex32/Factorization/DenseSvd.cs

@@ -36,13 +36,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="DenseMatrix"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex32/Factorization/LU.cs

@@ -37,7 +37,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     /// <para>A class which encapsulates the functionality of an LU factorization.</para>
     /// <para>For a matrix A, the LU factorization is a pair of lower triangular matrix L and
     /// upper triangular matrix U so that A = L*U.</para>
-    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased 
+    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased
     /// numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex32/Factorization/QR.cs

@@ -38,14 +38,14 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
     /// <para>Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix 
-    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the 
-    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.     
+    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix
+    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
+    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>
     internal abstract class QR : QR<Complex32>
     {

src/Numerics/LinearAlgebra/Complex32/Factorization/UserEvd.cs

@@ -135,9 +135,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// <param name="e">Output: Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="tau">Output: Arrays that contains further information about the transformations.</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures HTRIDI by 
-        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures HTRIDI by
+        /// Smith, Boyle, Dongarra, Garbow, Ikebe, Klema, Moler, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         static void SymmetricTridiagonalize(Complex32[,] matrixA, float[] d, float[] e, Complex32[] tau, int order)
         {
@@ -356,7 +356,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {
@@ -747,7 +747,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 }
             }
 
-            // All roots found.  
+            // All roots found.
             // Backsubstitute to find vectors of upper triangular form
             norm = 0.0f;
             for (var i = 0; i < order; i++)

src/Numerics/LinearAlgebra/Complex32/Factorization/UserGramSchmidt.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     internal sealed class UserGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an unitary matrix 
+        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an unitary matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -82,7 +82,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                     {
                         dot += q.Column(k)[i].Conjugate() * q.Column(j)[i];
                     }
-                    
+
                     r.At(k, j, dot);
                     for (var i = 0; i < q.RowCount; i++)
                     {
@@ -99,7 +99,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             : base(q, rFull)
         {
         }
-        
+
         /// <summary>
         /// Solves a system of linear equations, <b>AX = B</b>, with A QR factorized.
         /// </summary>
@@ -126,7 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             }
 
             var inputCopy = input.Clone();
-            
+
             // Compute Y = transpose(Q)*B
             var column = new Complex32[Q.RowCount];
             for (var j = 0; j < input.ColumnCount; j++)

src/Numerics/LinearAlgebra/Complex32/Factorization/UserQR.cs

@@ -39,8 +39,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Complex32/Factorization/UserSvd.cs

@@ -36,13 +36,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="Matrix{T}"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>
@@ -344,7 +344,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             while (m > 0)
             {
-                // Quit if all the singular values have been found. If too many iterations have been performed, 
+                // Quit if all the singular values have been found. If too many iterations have been performed,
                 // throw exception that Convergence Failed
                 if (iter >= maxiter)
                 {
@@ -662,7 +662,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s 
+        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>
@@ -775,7 +775,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         }
 
         /// <summary>
-        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>, 
+        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>,
         /// each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i)
         /// </summary>
         /// <param name="a">Source matrix</param>

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

@@ -196,7 +196,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
                 residuals.Add(temp, vecS);
 
                 // Check if we're converged. If so then stop. Otherwise continue;
-                // Calculate the temporary result. 
+                // Calculate the temporary result.
                 // Be careful not to change any of the temp vectors, except for
                 // temp. Others will be used in the calculation later on.
                 // x_i = x_(i-1) + alpha_i * p^_i + s^_i

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

@@ -37,7 +37,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     /// <summary>
     /// A composite matrix solver. The actual solver is made by a sequence of
-    /// matrix solvers. 
+    /// matrix solvers.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -114,9 +114,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
                 }
                 catch (Exception)
                 {
-                    // The solver broke down. 
+                    // The solver broke down.
                     // Log a message about this
-                    // Switch to the next preconditioner. 
+                    // Switch to the next preconditioner.
                     // Reset the solution vector to the previous solution
                     input.CopyTo(internalInput);
                     continue;

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

@@ -38,16 +38,16 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an 
+    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an
     /// alternative version of the Bi-Conjugate Gradient stabilized (CG) solver.
-    /// Unlike the CG solver the GPBiCG solver can be used on 
+    /// Unlike the CG solver the GPBiCG solver can be used on
     /// non-symmetric matrices. <br/>
     /// Note that much of the success of the solver depends on the selection of the
     /// proper preconditioner.
     /// </para>
     /// <para>
     /// The GPBiCG algorithm was taken from: <br/>
-    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with 
+    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with
     /// efficiency and robustness
     /// <br/>
     /// S. Fujino
@@ -63,13 +63,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
     public sealed class GpBiCg : IIterativeSolver<Numerics.Complex32>
     {
         /// <summary>
-        /// Indicates the number of <c>BiCGStab</c> steps should be taken 
+        /// Indicates the number of <c>BiCGStab</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
-        /// Indicates the number of <c>GPBiCG</c> steps should be taken 
+        /// Indicates the number of <c>GPBiCG</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfGpbiCgSteps = 4;

src/Numerics/LinearAlgebra/Complex32/Solvers/ILU0Preconditioner.cs

@@ -186,7 +186,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
             var rowValues = new DenseVector(_decompositionLU.RowCount);
             for (var i = 0; i < _decompositionLU.RowCount; i++)
             {
-                // Clear the rowValues 
+                // Clear the rowValues
                 rowValues.Clear();
                 _decompositionLU.Row(i, rowValues);
 

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

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
     /// <remarks>
     /// <para>
     /// The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement'
-    /// of the standard BiCgStab solver. 
+    /// of the standard BiCgStab solver.
     /// </para>
     /// <para>
     /// The algorithm was taken from: <br/>
@@ -81,7 +81,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// Gets or sets the number of starting vectors.
         /// </summary>
         /// <remarks>
-        /// Must be larger than 1 and smaller than the number of variables in the matrix that 
+        /// Must be larger than 1 and smaller than the number of variables in the matrix that
         /// for which this solver will be used.
         /// </remarks>
         public int NumberOfStartingVectors
@@ -110,7 +110,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Gets or sets a series of orthonormal vectors which will be used as basis for the 
+        /// Gets or sets a series of orthonormal vectors which will be used as basis for the
         /// Krylov sub-space.
         /// </summary>
         public IList<Vector<Numerics.Complex32>> StartingVectors
@@ -152,7 +152,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// <returns>
         ///  An array with starting vectors. The array will never be larger than the
         ///  <paramref name="maximumNumberOfStartingVectors"/> but it may be smaller if
-        ///  the <paramref name="numberOfVariables"/> is smaller than 
+        ///  the <paramref name="numberOfVariables"/> is smaller than
         ///  the <paramref name="maximumNumberOfStartingVectors"/>.
         /// </returns>
         static IList<Vector<Numerics.Complex32>> CreateStartingVectors(int maximumNumberOfStartingVectors, int numberOfVariables)
@@ -285,7 +285,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
                 // We don't accept collections with zero starting vectors so ...
                 if (_startingVectors.Count <= NumberOfStartingVectorsToCreate(_numberOfStartingVectors, input.Count))
                 {
-                    // Only check the first vector for sizing. If that matches we assume the 
+                    // Only check the first vector for sizing. If that matches we assume the
                     // other vectors match too. If they don't the process will crash
                     if (_startingVectors[0].Count == input.Count)
                     {

src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs

@@ -905,7 +905,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             }
 
             result.Clear();
-            
+
 
             var rowPointers = _storage.RowPointers;
             var columnIndices = _storage.ColumnIndices;

src/Numerics/LinearAlgebra/Double/Factorization/DenseEvd.cs

@@ -110,9 +110,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         /// <param name="d">Arrays for internal storage of real parts of eigenvalues</param>
         /// <param name="e">Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures tred2 by 
-        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures tred2 by
+        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         internal static void SymmetricTridiagonalize(double[] a, double[] d, double[] e, int order)
         {
@@ -362,7 +362,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {

src/Numerics/LinearAlgebra/Double/Factorization/DenseQR.cs

@@ -35,8 +35,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Double/Factorization/DenseSvd.cs

@@ -34,13 +34,13 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="DenseMatrix"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Double/Factorization/LU.cs

@@ -35,7 +35,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
     /// <para>A class which encapsulates the functionality of an LU factorization.</para>
     /// <para>For a matrix A, the LU factorization is a pair of lower triangular matrix L and
     /// upper triangular matrix U so that A = L*U.</para>
-    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased 
+    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased
     /// numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Double/Factorization/QR.cs

@@ -36,14 +36,14 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
     /// <para>Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is performed, the resulting Q matrix is an m x m matrix 
-    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the 
-    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.     
+    /// If a <seealso cref="QRMethod.Full"/> factorization is performed, the resulting Q matrix is an m x m matrix
+    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
+    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>
     internal abstract class QR : QR<double>
     {

src/Numerics/LinearAlgebra/Double/Factorization/UserEvd.cs

@@ -146,9 +146,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         /// <param name="d">Arrays for internal storage of real parts of eigenvalues</param>
         /// <param name="e">Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures tred2 by 
-        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures tred2 by
+        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         static void SymmetricTridiagonalize(Matrix<double> eigenVectors, double[] d, double[] e, int order)
         {
@@ -398,7 +398,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {

src/Numerics/LinearAlgebra/Double/Factorization/UserGramSchmidt.cs

@@ -42,7 +42,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
     internal sealed class UserGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an orthogonal matrix 
+        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an orthogonal matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -119,7 +119,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
             }
 
             var inputCopy = input.Clone();
-            
+
             // Compute Y = transpose(Q)*B
             var column = new double[Q.RowCount];
             for (var j = 0; j < input.ColumnCount; j++)

src/Numerics/LinearAlgebra/Double/Factorization/UserQR.cs

@@ -37,8 +37,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Double/Factorization/UserSvd.cs

@@ -34,13 +34,13 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="Matrix{T}"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>
@@ -328,7 +328,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             while (m > 0)
             {
-                // Quit if all the singular values have been found. If too many iterations have been performed, 
+                // Quit if all the singular values have been found. If too many iterations have been performed,
                 // throw exception that Convergence Failed
                 if (iter >= maxiter)
                 {
@@ -645,7 +645,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s 
+        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>
@@ -758,7 +758,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         }
 
         /// <summary>
-        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>, 
+        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>,
         /// each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i)
         /// </summary>
         /// <param name="a">Source matrix</param>

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

@@ -196,7 +196,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
                 residuals.Add(temp, vecS);
 
                 // Check if we're converged. If so then stop. Otherwise continue;
-                // Calculate the temporary result. 
+                // Calculate the temporary result.
                 // Be careful not to change any of the temp vectors, except for
                 // temp. Others will be used in the calculation later on.
                 // x_i = x_(i-1) + alpha_i * p^_i + s^_i

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

@@ -37,7 +37,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// A composite matrix solver. The actual solver is made by a sequence of
-    /// matrix solvers. 
+    /// matrix solvers.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -114,9 +114,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
                 }
                 catch (Exception)
                 {
-                    // The solver broke down. 
+                    // The solver broke down.
                     // Log a message about this
-                    // Switch to the next preconditioner. 
+                    // Switch to the next preconditioner.
                     // Reset the solution vector to the previous solution
                     input.CopyTo(internalInput);
                     continue;

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

@@ -38,16 +38,16 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an 
+    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an
     /// alternative version of the Bi-Conjugate Gradient stabilized (CG) solver.
-    /// Unlike the CG solver the GPBiCG solver can be used on 
+    /// Unlike the CG solver the GPBiCG solver can be used on
     /// non-symmetric matrices. <br/>
     /// Note that much of the success of the solver depends on the selection of the
     /// proper preconditioner.
     /// </para>
     /// <para>
     /// The GPBiCG algorithm was taken from: <br/>
-    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with 
+    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with
     /// efficiency and robustness
     /// <br/>
     /// S. Fujino
@@ -63,13 +63,13 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
     public sealed class GpBiCg : IIterativeSolver<double>
     {
         /// <summary>
-        /// Indicates the number of <c>BiCGStab</c> steps should be taken 
+        /// Indicates the number of <c>BiCGStab</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
-        /// Indicates the number of <c>GPBiCG</c> steps should be taken 
+        /// Indicates the number of <c>GPBiCG</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfGpbiCgSteps = 4;

src/Numerics/LinearAlgebra/Double/Solvers/ILU0Preconditioner.cs

@@ -184,7 +184,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
             var rowValues = new DenseVector(_decompositionLU.RowCount);
             for (var i = 0; i < _decompositionLU.RowCount; i++)
             {
-                // Clear the rowValues 
+                // Clear the rowValues
                 rowValues.Clear();
                 _decompositionLU.Row(i, rowValues);
 

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

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
     /// <remarks>
     /// <para>
     /// The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement'
-    /// of the standard BiCgStab solver. 
+    /// of the standard BiCgStab solver.
     /// </para>
     /// <para>
     /// The algorithm was taken from: <br/>
@@ -81,7 +81,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// Gets or sets the number of starting vectors.
         /// </summary>
         /// <remarks>
-        /// Must be larger than 1 and smaller than the number of variables in the matrix that 
+        /// Must be larger than 1 and smaller than the number of variables in the matrix that
         /// for which this solver will be used.
         /// </remarks>
         public int NumberOfStartingVectors
@@ -113,7 +113,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Gets or sets a series of orthonormal vectors which will be used as basis for the 
+        /// Gets or sets a series of orthonormal vectors which will be used as basis for the
         /// Krylov sub-space.
         /// </summary>
         public IList<Vector<double>> StartingVectors
@@ -158,7 +158,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <returns>
         ///  An array with starting vectors. The array will never be larger than the
         ///  <paramref name="maximumNumberOfStartingVectors"/> but it may be smaller if
-        ///  the <paramref name="numberOfVariables"/> is smaller than 
+        ///  the <paramref name="numberOfVariables"/> is smaller than
         ///  the <paramref name="maximumNumberOfStartingVectors"/>.
         /// </returns>
         static IList<Vector<double>> CreateStartingVectors(int maximumNumberOfStartingVectors, int numberOfVariables)
@@ -285,7 +285,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
                 // We don't accept collections with zero starting vectors so ...
                 if (_startingVectors.Count <= NumberOfStartingVectorsToCreate(_numberOfStartingVectors, input.Count))
                 {
-                    // Only check the first vector for sizing. If that matches we assume the 
+                    // Only check the first vector for sizing. If that matches we assume the
                     // other vectors match too. If they don't the process will crash
                     if (_startingVectors[0].Count == input.Count)
                     {

src/Numerics/LinearAlgebra/Factorization/Evd.cs

@@ -90,7 +90,7 @@ namespace MathNet.Numerics.LinearAlgebra.Factorization
         /// Gets or sets the eigen values (λ) of matrix in ascending value.
         /// </summary>
         public Vector<Complex> EigenValues { get; private set; }
-        
+
         /// <summary>
         /// Gets or sets eigenvectors.
         /// </summary>

src/Numerics/LinearAlgebra/Factorization/LU.cs

@@ -35,7 +35,7 @@ namespace MathNet.Numerics.LinearAlgebra.Factorization
     /// <para>A class which encapsulates the functionality of an LU factorization.</para>
     /// <para>For a matrix A, the LU factorization is a pair of lower triangular matrix L and
     /// upper triangular matrix U so that A = L*U.</para>
-    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased 
+    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased
     /// numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Matrix.Arithmetic.cs

@@ -1561,7 +1561,7 @@ namespace MathNet.Numerics.LinearAlgebra
 
         /// <summary>
         /// Helper function to apply a binary function which takes two matrices
-        /// and modifies the latter in place.  A copy of the "this" matrix is 
+        /// and modifies the latter in place.  A copy of the "this" matrix is
         /// first made and then passed to f together with the other matrix. The
         /// copy is then returned as the result
         /// </summary>

src/Numerics/LinearAlgebra/Single/Factorization/DenseEvd.cs

@@ -110,9 +110,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         /// <param name="d">Arrays for internal storage of real parts of eigenvalues</param>
         /// <param name="e">Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures tred2 by 
-        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures tred2 by
+        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         internal static void SymmetricTridiagonalize(float[] a, float[] d, float[] e, int order)
         {
@@ -362,7 +362,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {

src/Numerics/LinearAlgebra/Single/Factorization/DenseGramSchmidt.cs

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
     internal sealed class DenseGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="DenseGramSchmidt"/> class. This object creates an orthogonal matrix 
+        /// Initializes a new instance of the <see cref="DenseGramSchmidt"/> class. This object creates an orthogonal matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -102,7 +102,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 {
                     var k1 = k;
                     var j1 = j;
-                    
+
                     var dot = 0.0f;
                     for (var index = 0; index < rowsQ; index++)
                     {

src/Numerics/LinearAlgebra/Single/Factorization/DenseQR.cs

@@ -35,8 +35,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Single/Factorization/DenseSvd.cs

@@ -34,13 +34,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="DenseMatrix"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Single/Factorization/LU.cs

@@ -35,7 +35,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
     /// <para>A class which encapsulates the functionality of an LU factorization.</para>
     /// <para>For a matrix A, the LU factorization is a pair of lower triangular matrix L and
     /// upper triangular matrix U so that A = L*U.</para>
-    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased 
+    /// <para>In the Math.Net implementation we also store a set of pivot elements for increased
     /// numerical stability. The pivot elements encode a permutation matrix P such that P*A = L*U.</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Single/Factorization/QR.cs

@@ -36,14 +36,14 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
     /// <para>Any real square matrix A (m x n) may be decomposed as A = QR where Q is an orthogonal matrix
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix 
-    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the 
-    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.     
+    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix
+    /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
+    /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>
     internal abstract class QR : QR<float>
     {

src/Numerics/LinearAlgebra/Single/Factorization/UserEvd.cs

@@ -145,9 +145,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         /// <param name="d">Arrays for internal storage of real parts of eigenvalues</param>
         /// <param name="e">Arrays for internal storage of imaginary parts of eigenvalues</param>
         /// <param name="order">Order of initial matrix</param>
-        /// <remarks>This is derived from the Algol procedures tred2 by 
-        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for 
-        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding 
+        /// <remarks>This is derived from the Algol procedures tred2 by
+        /// Bowdler, Martin, Reinsch, and Wilkinson, Handbook for
+        /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         static void SymmetricTridiagonalize(Matrix<float> eigenVectors, float[] d, float[] e, int order)
         {
@@ -397,7 +397,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                         e[l] = s*p;
                         d[l] = c*p;
 
-                        // Check for convergence. If too many iterations have been performed, 
+                        // Check for convergence. If too many iterations have been performed,
                         // throw exception that Convergence Failed
                         if (iter >= maxiter)
                         {

src/Numerics/LinearAlgebra/Single/Factorization/UserGramSchmidt.cs

@@ -42,7 +42,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
     internal sealed class UserGramSchmidt : GramSchmidt
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an orthogonal matrix 
+        /// Initializes a new instance of the <see cref="UserGramSchmidt"/> class. This object creates an orthogonal matrix
         /// using the modified Gram-Schmidt method.
         /// </summary>
         /// <param name="matrix">The matrix to factor.</param>
@@ -119,7 +119,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
             }
 
             var inputCopy = input.Clone();
-            
+
             // Compute Y = transpose(Q)*B
             var column = new float[Q.RowCount];
             for (var j = 0; j < input.ColumnCount; j++)

src/Numerics/LinearAlgebra/Single/Factorization/UserQR.cs

@@ -37,8 +37,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the QR decomposition.</para>
-    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix 
-    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix 
+    /// <para>Any real square matrix A may be decomposed as A = QR where Q is an orthogonal matrix
+    /// (its columns are orthogonal unit vectors meaning QTQ = I) and R is an upper triangular matrix
     /// (also called right triangular matrix).</para>
     /// </summary>
     /// <remarks>

src/Numerics/LinearAlgebra/Single/Factorization/UserSvd.cs

@@ -34,13 +34,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 {
     /// <summary>
     /// <para>A class which encapsulates the functionality of the singular value decomposition (SVD) for <see cref="Matrix{T}"/>.</para>
-    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers. 
+    /// <para>Suppose M is an m-by-n matrix whose entries are real numbers.
     /// Then there exists a factorization of the form M = UΣVT where:
     /// - U is an m-by-m unitary matrix;
     /// - Σ is m-by-n diagonal matrix with nonnegative real numbers on the diagonal;
-    /// - VT denotes transpose of V, an n-by-n unitary matrix; 
-    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal 
-    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined 
+    /// - VT denotes transpose of V, an n-by-n unitary matrix;
+    /// Such a factorization is called a singular-value decomposition of M. A common convention is to order the diagonal
+    /// entries Σ(i,i) in descending order. In this case, the diagonal matrix Σ is uniquely determined
     /// by M (though the matrices U and V are not). The diagonal entries of Σ are known as the singular values of M.</para>
     /// </summary>
     /// <remarks>
@@ -328,7 +328,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             while (m > 0)
             {
-                // Quit if all the singular values have been found. If too many iterations have been performed, 
+                // Quit if all the singular values have been found. If too many iterations have been performed,
                 // throw exception that Convergence Failed
                 if (iter >= maxiter)
                 {
@@ -645,7 +645,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s 
+        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>
@@ -758,7 +758,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         }
 
         /// <summary>
-        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>, 
+        /// Performs rotation of points in the plane. Given two vectors x <paramref name="columnA"/> and y <paramref name="columnB"/>,
         /// each vector element of these vectors is replaced as follows: x(i) = c*x(i) + s*y(i); y(i) = c*y(i) - s*x(i)
         /// </summary>
         /// <param name="a">Source matrix</param>

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

@@ -196,7 +196,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
                 residuals.Add(temp, vecS);
 
                 // Check if we're converged. If so then stop. Otherwise continue;
-                // Calculate the temporary result. 
+                // Calculate the temporary result.
                 // Be careful not to change any of the temp vectors, except for
                 // temp. Others will be used in the calculation later on.
                 // x_i = x_(i-1) + alpha_i * p^_i + s^_i

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

@@ -37,7 +37,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// A composite matrix solver. The actual solver is made by a sequence of
-    /// matrix solvers. 
+    /// matrix solvers.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -114,9 +114,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
                 }
                 catch (Exception)
                 {
-                    // The solver broke down. 
+                    // The solver broke down.
                     // Log a message about this
-                    // Switch to the next preconditioner. 
+                    // Switch to the next preconditioner.
                     // Reset the solution vector to the previous solution
                     input.CopyTo(internalInput);
                     continue;

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

@@ -38,16 +38,16 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an 
+    /// The Generalized Product Bi-Conjugate Gradient (GPBiCG) solver is an
     /// alternative version of the Bi-Conjugate Gradient stabilized (CG) solver.
-    /// Unlike the CG solver the GPBiCG solver can be used on 
+    /// Unlike the CG solver the GPBiCG solver can be used on
     /// non-symmetric matrices. <br/>
     /// Note that much of the success of the solver depends on the selection of the
     /// proper preconditioner.
     /// </para>
     /// <para>
     /// The GPBiCG algorithm was taken from: <br/>
-    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with 
+    /// GPBiCG(m,l): A hybrid of BiCGSTAB and GPBiCG methods with
     /// efficiency and robustness
     /// <br/>
     /// S. Fujino
@@ -63,13 +63,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
     public sealed class GpBiCg : IIterativeSolver<float>
     {
         /// <summary>
-        /// Indicates the number of <c>BiCGStab</c> steps should be taken 
+        /// Indicates the number of <c>BiCGStab</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
-        /// Indicates the number of <c>GPBiCG</c> steps should be taken 
+        /// Indicates the number of <c>GPBiCG</c> steps should be taken
         /// before switching.
         /// </summary>
         int _numberOfGpbiCgSteps = 4;

src/Numerics/LinearAlgebra/Single/Solvers/ILU0Preconditioner.cs

@@ -184,7 +184,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
             var rowValues = new DenseVector(_decompositionLU.RowCount);
             for (var i = 0; i < _decompositionLU.RowCount; i++)
             {
-                // Clear the rowValues 
+                // Clear the rowValues
                 rowValues.Clear();
                 _decompositionLU.Row(i, rowValues);
 

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

@@ -42,7 +42,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
     /// <remarks>
     /// <para>
     /// The Multiple-Lanczos Bi-Conjugate Gradient stabilized (ML(k)-BiCGStab) solver is an 'improvement'
-    /// of the standard BiCgStab solver. 
+    /// of the standard BiCgStab solver.
     /// </para>
     /// <para>
     /// The algorithm was taken from: <br/>
@@ -80,7 +80,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// Gets or sets the number of starting vectors.
         /// </summary>
         /// <remarks>
-        /// Must be larger than 1 and smaller than the number of variables in the matrix that 
+        /// Must be larger than 1 and smaller than the number of variables in the matrix that
         /// for which this solver will be used.
         /// </remarks>
         public int NumberOfStartingVectors
@@ -112,7 +112,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         }
 
         /// <summary>
-        /// Gets or sets a series of orthonormal vectors which will be used as basis for the 
+        /// Gets or sets a series of orthonormal vectors which will be used as basis for the
         /// Krylov sub-space.
         /// </summary>
         public IList<Vector<float>> StartingVectors
@@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <returns>
         ///  An array with starting vectors. The array will never be larger than the
         ///  <paramref name="maximumNumberOfStartingVectors"/> but it may be smaller if
-        ///  the <paramref name="numberOfVariables"/> is smaller than 
+        ///  the <paramref name="numberOfVariables"/> is smaller than
         ///  the <paramref name="maximumNumberOfStartingVectors"/>.
         /// </returns>
         static IList<Vector<float>> CreateStartingVectors(int maximumNumberOfStartingVectors, int numberOfVariables)
@@ -288,7 +288,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
                 // We don't accept collections with zero starting vectors so ...
                 if (_startingVectors.Count <= NumberOfStartingVectorsToCreate(_numberOfStartingVectors, input.Count))
                 {
-                    // Only check the first vector for sizing. If that matches we assume the 
+                    // Only check the first vector for sizing. If that matches we assume the
                     // other vectors match too. If they don't the process will crash
                     if (_startingVectors[0].Count == input.Count)
                     {

src/Numerics/LinearAlgebra/Solvers/DelegateStopCriterion.cs

@@ -59,7 +59,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <param name="residualVector">The vector containing the current residual vectors.</param>
         /// <remarks>
         /// The individual stop criteria may internally track the progress of the calculation based
-        /// on the invocation of this method. Therefore this method should only be called if the 
+        /// on the invocation of this method. Therefore this method should only be called if the
         /// calculation has moved forwards at least one step.
         /// </remarks>
         public IterationStatus DetermineStatus(int iterationNumber, Vector<T> solutionVector, Vector<T> sourceVector, Vector<T> residualVector)

src/Numerics/LinearAlgebra/Solvers/IIterativeSolverSetup.cs

@@ -33,7 +33,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
 {
     /// <summary>
     /// Defines the interface for objects that can create an iterative solver with
-    /// specific settings. This interface is used to pass iterative solver creation 
+    /// specific settings. This interface is used to pass iterative solver creation
     /// setup information around.
     /// </summary>
     public interface IIterativeSolverSetup<T> where T : struct, IEquatable<T>, IFormattable
@@ -59,7 +59,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         IPreconditioner<T> CreatePreconditioner();
 
         /// <summary>
-        /// Gets the relative speed of the solver. 
+        /// Gets the relative speed of the solver.
         /// </summary>
         /// <value>Returns a value between 0 and 1, inclusive.</value>
         double SolutionSpeed { get; }

src/Numerics/LinearAlgebra/Solvers/IPreconditioner.cs

@@ -39,9 +39,9 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
     /// Preconditioners are used by iterative solvers to improve the convergence
     /// speed of the solving process. Increase in convergence speed
     /// is related to the number of iterations necessary to get a converged solution.
-    /// So while in general the use of a preconditioner means that the iterative 
+    /// So while in general the use of a preconditioner means that the iterative
     /// solver will perform fewer iterations it does not guarantee that the actual
-    /// solution time decreases given that some preconditioners can be expensive to 
+    /// solution time decreases given that some preconditioners can be expensive to
     /// setup and run.
     /// </para>
     /// <para>

src/Numerics/LinearAlgebra/Solvers/IterationCountStopCriterion.cs

@@ -33,7 +33,7 @@ using System.Diagnostics;
 namespace MathNet.Numerics.LinearAlgebra.Solvers
 {
     /// <summary>
-    /// Defines an <see cref="IIterationStopCriterion{T}"/> that monitors the numbers of iteration 
+    /// Defines an <see cref="IIterationStopCriterion{T}"/> that monitors the numbers of iteration
     /// steps as stop criterion.
     /// </summary>
     public sealed class IterationCountStopCriterion<T> : IIterationStopCriterion<T> where T : struct, IEquatable<T>, IFormattable
@@ -55,7 +55,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         IterationStatus _status = IterationStatus.Continue;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="IterationCountStopCriterion{T}"/> class with the default maximum 
+        /// Initializes a new instance of the <see cref="IterationCountStopCriterion{T}"/> class with the default maximum
         /// number of iterations.
         /// </summary>
         public IterationCountStopCriterion() : this(DefaultMaximumNumberOfIterations)
@@ -116,7 +116,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <param name="residualVector">The vector containing the current residual vectors.</param>
         /// <remarks>
         /// The individual stop criteria may internally track the progress of the calculation based
-        /// on the invocation of this method. Therefore this method should only be called if the 
+        /// on the invocation of this method. Therefore this method should only be called if the
         /// calculation has moved forwards at least one step.
         /// </remarks>
         public IterationStatus DetermineStatus(int iterationNumber, Vector<T> solutionVector, Vector<T> sourceVector, Vector<T> residualVector)

src/Numerics/LinearAlgebra/Vector.Arithmetic.cs

@@ -236,7 +236,7 @@ namespace MathNet.Numerics.LinearAlgebra
         protected abstract void DoPointwiseAbs(Vector<T> result);
         protected abstract void DoPointwiseAcos(Vector<T> result);
         protected abstract void DoPointwiseAsin(Vector<T> result);
-        protected abstract void DoPointwiseAtan(Vector<T> result);        
+        protected abstract void DoPointwiseAtan(Vector<T> result);
         protected abstract void DoPointwiseCeiling(Vector<T> result);
         protected abstract void DoPointwiseCos(Vector<T> result);
         protected abstract void DoPointwiseCosh(Vector<T> result);
@@ -1008,8 +1008,8 @@ namespace MathNet.Numerics.LinearAlgebra
 
         /// <summary>
         /// Helper function to apply a binary function which takes a scalar and
-        /// a vector and modifies the latter in place. A copy of the "this" 
-        /// vector is therefore first made and then passed to f together with 
+        /// a vector and modifies the latter in place. A copy of the "this"
+        /// vector is therefore first made and then passed to f together with
         /// the scalar argument.  The copy is then returned as the result
         /// </summary>
         /// <param name="f">Function which takes a scalar and a vector, modifies the vector in place and returns void</param>
@@ -1040,7 +1040,7 @@ namespace MathNet.Numerics.LinearAlgebra
 
         /// <summary>
         /// Helper function to apply a binary function which takes two vectors
-        /// and modifies the latter in place.  A copy of the "this" vector is 
+        /// and modifies the latter in place.  A copy of the "this" vector is
         /// first made and then passed to f together with the other vector. The
         /// copy is then returned as the result
         /// </summary>