Misc cleanup, docs, optional params

src/Numerics/Complex32.cs

@@ -824,22 +824,6 @@ namespace MathNet.Numerics
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a complex number based on a string. The string can be in the
-        /// following formats (without the quotes): 'n', 'ni', 'n +/- ni',
-        /// 'ni +/- n', 'n,n', 'n,ni,' '(n,n)', or '(n,ni)', where n is a float.
-        /// </summary>
-        /// <returns>
-        /// A complex number containing the value specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static Complex32 Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a complex number based on a string. The string can be in the
         /// following formats (without the quotes): 'n', 'ni', 'n +/- ni',
@@ -855,7 +839,7 @@ namespace MathNet.Numerics
         /// An <see cref="IFormatProvider"/> that supplies culture-specific
         /// formatting information.
         /// </param>
-        public static Complex32 Parse(string value, IFormatProvider formatProvider)
+        public static Complex32 Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

src/Numerics/Fit.cs

@@ -31,7 +31,6 @@
 using System;
 using System.Linq;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Factorization;
 using MathNet.Numerics.Properties;
 
 namespace MathNet.Numerics
@@ -102,7 +101,7 @@ namespace MathNet.Numerics
         {
             return DenseMatrix
                 .OfColumns(x.Length, order + 1, Enumerable.Range(0, order + 1).Select(j => DenseVector.Create(x.Length, i => Math.Pow(x[i], j))))
-                .QR(QRMethod.Thin).Solve(new DenseVector(y))
+                .QR().Solve(new DenseVector(y))
                 .ToArray();
         }
 
@@ -124,7 +123,7 @@ namespace MathNet.Numerics
         {
             return DenseMatrix
                 .OfColumns(x.Length, functions.Length, functions.Select(f => DenseVector.Create(x.Length, i => f(x[i]))))
-                .QR(QRMethod.Thin).Solve(new DenseVector(y))
+                .QR().Solve(new DenseVector(y))
                 .ToArray();
         }
 
@@ -146,7 +145,7 @@ namespace MathNet.Numerics
         {
             return DenseMatrix
                 .OfRows(x.Length, functions.Length, x.Select(xi => functions.Select(f => f(xi))))
-                .QR(QRMethod.Thin).Solve(new DenseVector(y))
+                .QR().Solve(new DenseVector(y))
                 .ToArray();
         }
 
@@ -168,7 +167,7 @@ namespace MathNet.Numerics
         {
             return DenseMatrix
                 .OfRows(x.Length, functions.Length, x.Select(xi => functions.Select(f => f(xi))))
-                .QR(QRMethod.Thin).Solve(new DenseVector(y))
+                .QR().Solve(new DenseVector(y))
                 .ToArray();
         }
 

src/Numerics/LinearAlgebra/Complex/DenseVector.cs

@@ -692,21 +692,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a Complex dense vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a Complex.
-        /// </summary>
-        /// <returns>
-        /// A Complex dense vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static DenseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a Complex dense vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a double.
@@ -720,7 +705,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static DenseVector Parse(string value, IFormatProvider formatProvider)
+        public static DenseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

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

@@ -247,6 +247,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         /// <summary>
         /// Symmetric tridiagonal QL algorithm.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <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>
@@ -393,6 +394,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         /// <summary>
         /// Determines eigenvectors by undoing the symmetric tridiagonalize transformation
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixA">Previously tridiagonalized matrix by <see cref="SymmetricTridiagonalize"/>.</param>
         /// <param name="tau">Contains further information about the transformations</param>
         /// <param name="order">Input matrix order</param>
@@ -438,6 +440,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         /// <summary>
         /// Nonsymmetric reduction to Hessenberg form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <param name="order">Order of initial matrix</param>
         /// <remarks>This is derived from the Algol procedures orthes and ortran,
@@ -583,6 +586,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         /// <summary>
         /// Nonsymmetric reduction from Hessenberg to real Schur form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
+        /// <param name="eigenValues">The eigen values to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <param name="order">Order of initial matrix</param>
         /// <remarks>This is derived from the Algol procedure hqr2,

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

@@ -98,6 +98,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
         /// <param name="input">The solution <see cref="Vector"/>, <c>b</c>.</param>
         /// <param name="result">The result <see cref="Vector"/>, <c>x</c>.</param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Complex> matrix, Vector<Complex> input, Vector<Complex> result, Iterator<Complex> iterator, IPreconditioner<Complex> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -77,6 +77,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Complex> matrix, Vector<Complex> input, Vector<Complex> result, Iterator<Complex> iterator, IPreconditioner<Complex> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -161,6 +161,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Complex> matrix, Vector<Complex> input, Vector<Complex> result, Iterator<Complex> iterator, IPreconditioner<Complex> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -247,6 +247,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Complex> matrix, Vector<Complex> input, Vector<Complex> result, Iterator<Complex> iterator, IPreconditioner<Complex> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -89,39 +89,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        public DivergenceStopCriterium() : this(DefaultMaximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease) : this(maximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the specified minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued. </param>
-        public DivergenceStopCriterium(int minimumIterations) : this(DefaultMinimumNumberOfIterations, minimumIterations)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
         /// relative increase and the specified minimum number of tracking iterations.
         /// </summary>
         /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued. </param>
         /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease, int minimumIterations)
+        public DivergenceStopCriterium(double maximumRelativeIncrease = DefaultMaximumRelativeIncrease, int minimumIterations = DefaultMinimumNumberOfIterations)
         {
             if (maximumRelativeIncrease <= 0)
             {

src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -88,35 +88,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum 
-        /// residual and the default minimum number of iterations.
-        /// </summary>
-        public ResidualStopCriterium() : this(DefaultMaximumResidual, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
-        /// maximum residual and the default minimum number of iterations.
-        /// </summary>
-        /// <param name="maximum">The maximum value for the residual below which the calculation is considered converged.</param>
-        public ResidualStopCriterium(double maximum) : this(maximum, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum residual
-        /// and specified minimum number of iterations.
-        /// </summary>
-        /// <param name="minimumIterationsBelowMaximum">
-        /// The minimum number of iterations for which the residual has to be below the maximum before
-        /// the calculation is considered converged.
-        /// </param>
-        public ResidualStopCriterium(int minimumIterationsBelowMaximum) : this(DefaultMaximumResidual, minimumIterationsBelowMaximum)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
         /// maximum residual and minimum number of iterations.
@@ -128,7 +99,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         /// The minimum number of iterations for which the residual has to be below the maximum before
         /// the calculation is considered converged.
         /// </param>
-        public ResidualStopCriterium(double maximum, int minimumIterationsBelowMaximum)
+        public ResidualStopCriterium(double maximum = DefaultMaximumResidual, int minimumIterationsBelowMaximum = DefaultMinimumIterationsBelowMaximum)
         {
             if (maximum < 0)
             {

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

@@ -95,6 +95,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Complex> matrix, Vector<Complex> input, Vector<Complex> result, Iterator<Complex> iterator, IPreconditioner<Complex> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Complex/SparseVector.cs

@@ -853,21 +853,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a double sparse vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a Complex.
-        /// </summary>
-        /// <returns>
-        /// A double sparse vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static SparseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a double sparse vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a Complex.
@@ -881,7 +866,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static SparseVector Parse(string value, IFormatProvider formatProvider)
+        public static SparseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

src/Numerics/LinearAlgebra/Complex32/DenseVector.cs

@@ -687,21 +687,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a Complex32 dense vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a Complex32.
-        /// </summary>
-        /// <returns>
-        /// A Complex32 dense vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static DenseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a Complex32 dense vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a double.
@@ -715,7 +700,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static DenseVector Parse(string value, IFormatProvider formatProvider)
+        public static DenseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

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

@@ -111,10 +111,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// 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(Numerics.Complex32[] matrixA, float[] d, float[] e, Numerics.Complex32[] tau, int order)
+        internal static void SymmetricTridiagonalize(Complex32[] matrixA, float[] d, float[] e, Complex32[] tau, int order)
         {
             float hh;
-            tau[order - 1] = Numerics.Complex32.One;
+            tau[order - 1] = Complex32.One;
 
             for (var i = 0; i < order; i++)
             {
@@ -135,7 +135,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                 if (scale == 0.0f)
                 {
-                    tau[i - 1] = Numerics.Complex32.One;
+                    tau[i - 1] = Complex32.One;
                     e[i] = 0.0f;
                 }
                 else
@@ -146,10 +146,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                         h += matrixA[k*order + i].MagnitudeSquared;
                     }
 
-                    Numerics.Complex32 g = (float) Math.Sqrt(h);
+                    Complex32 g = (float) Math.Sqrt(h);
                     e[i] = scale*g.Real;
 
-                    Numerics.Complex32 temp;
+                    Complex32 temp;
                     var im1Oi = (i - 1)*order + i;
                     var f = matrixA[im1Oi];
                     if (f.Magnitude != 0.0f)
@@ -167,10 +167,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                     if ((f.Magnitude == 0.0f) || (i != 1))
                     {
-                        f = Numerics.Complex32.Zero;
+                        f = Complex32.Zero;
                         for (var j = 0; j < i; j++)
                         {
-                            var tmp = Numerics.Complex32.Zero;
+                            var tmp = Complex32.Zero;
                             var jO = j*order;
                             // Form element of A*U.
                             for (var k = 0; k <= j; k++)
@@ -214,7 +214,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                 hh = d[i];
                 d[i] = matrixA[i*order + i].Real;
-                matrixA[i*order + i] = new Numerics.Complex32(hh, scale*(float) Math.Sqrt(h));
+                matrixA[i*order + i] = new Complex32(hh, scale*(float) Math.Sqrt(h));
             }
 
             hh = d[0];
@@ -235,7 +235,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// Auto. Comp., Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
         /// <exception cref="NonConvergenceException"></exception>
-        internal static void SymmetricDiagonalize(Numerics.Complex32[] dataEv, float[] d, float[] e, int order)
+        internal static void SymmetricDiagonalize(Complex32[] dataEv, float[] d, float[] e, int order)
         {
             const int maxiter = 1000;
 
@@ -381,7 +381,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// 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 SymmetricUntridiagonalize(Numerics.Complex32[] dataEv, Numerics.Complex32[] matrixA, Numerics.Complex32[] tau, int order)
+        internal static void SymmetricUntridiagonalize(Complex32[] dataEv, Complex32[] matrixA, Complex32[] tau, int order)
         {
             for (var i = 0; i < order; i++)
             {
@@ -399,7 +399,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 {
                     for (var j = 0; j < order; j++)
                     {
-                        var s = Numerics.Complex32.Zero;
+                        var s = Complex32.Zero;
                         for (var k = 0; k < i; k++)
                         {
                             s += dataEv[(j*order) + k]*matrixA[k*order + i];
@@ -426,9 +426,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// by Martin and Wilkinson, Handbook for Auto. Comp.,
         /// Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutines in EISPACK.</remarks>
-        internal static void NonsymmetricReduceToHessenberg(Numerics.Complex32[] dataEv, Numerics.Complex32[] matrixH, int order)
+        internal static void NonsymmetricReduceToHessenberg(Complex32[] dataEv, Complex32[] matrixH, int order)
         {
-            var ort = new Numerics.Complex32[order];
+            var ort = new Complex32[order];
 
             for (var m = 1; m < order - 1; m++)
             {
@@ -467,7 +467,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                     // H = (I-u*u'/h)*H*(I-u*u')/h)
                     for (var j = m; j < order; j++)
                     {
-                        var f = Numerics.Complex32.Zero;
+                        var f = Complex32.Zero;
                         var jO = j*order;
                         for (var i = order - 1; i >= m; i--)
                         {
@@ -483,7 +483,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                     for (var i = 0; i < order; i++)
                     {
-                        var f = Numerics.Complex32.Zero;
+                        var f = Complex32.Zero;
                         for (var j = order - 1; j >= m; j--)
                         {
                             f += ort[j]*matrixH[j*order + i];
@@ -506,7 +506,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             {
                 for (var j = 0; j < order; j++)
                 {
-                    dataEv[(j*order) + i] = i == j ? Numerics.Complex32.One : Numerics.Complex32.Zero;
+                    dataEv[(j*order) + i] = i == j ? Complex32.One : Complex32.Zero;
                 }
             }
 
@@ -514,7 +514,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             {
                 var mm1O = (m - 1)*order;
                 var mm1Om = mm1O + m;
-                if (matrixH[mm1Om] != Numerics.Complex32.Zero && ort[m] != Numerics.Complex32.Zero)
+                if (matrixH[mm1Om] != Complex32.Zero && ort[m] != Complex32.Zero)
                 {
                     var norm = (matrixH[mm1Om].Real*ort[m].Real) + (matrixH[mm1Om].Imaginary*ort[m].Imaginary);
 
@@ -525,7 +525,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                     for (var j = m; j < order; j++)
                     {
-                        var g = Numerics.Complex32.Zero;
+                        var g = Complex32.Zero;
                         for (var i = m; i < order; i++)
                         {
                             g += ort[i].Conjugate()*dataEv[(j*order) + i];
@@ -581,14 +581,14 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// by Martin and Wilkinson, Handbook for Auto. Comp.,
         /// Vol.ii-Linear Algebra, and the corresponding
         /// Fortran subroutine in EISPACK.</remarks>
-        internal static void NonsymmetricReduceHessenberToRealSchur(Numerics.Complex32[] vectorV, Numerics.Complex32[] dataEv, Numerics.Complex32[] matrixH, int order)
+        internal static void NonsymmetricReduceHessenberToRealSchur(Complex32[] vectorV, Complex32[] dataEv, Complex32[] matrixH, int order)
         {
             // Initialize
             var n = order - 1;
             var eps = (float) Precision.SingleMachinePrecision;
 
             float norm;
-            Numerics.Complex32 x, y, z, exshift = Numerics.Complex32.Zero;
+            Complex32 x, y, z, exshift = Complex32.Zero;
 
             // Outer loop over eigenvalue index
             var iter = 0;
@@ -626,7 +626,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 else
                 {
                     // Form shift
-                    Numerics.Complex32 s;
+                    Complex32 s;
                     if (iter != 10 && iter != 20)
                     {
                         s = matrixH[nOn];
@@ -670,7 +670,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                         x = matrixH[im1Oim1]/norm;
                         vectorV[i - 1] = x;
                         matrixH[im1Oim1] = norm;
-                        matrixH[im1O + i] = new Numerics.Complex32(0.0f, s.Real/norm);
+                        matrixH[im1O + i] = new Complex32(0.0f, s.Real/norm);
 
                         for (var j = i; j < order; j++)
                         {
@@ -714,7 +714,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                             else
                             {
                                 y = matrixH[jm1Oi].Real;
-                                matrixH[jm1Oi] = new Numerics.Complex32((x.Real*y.Real) - (x.Imaginary*y.Imaginary) + (matrixH[jm1O + j].Imaginary*z.Real), matrixH[jm1Oi].Imaginary);
+                                matrixH[jm1Oi] = new Complex32((x.Real*y.Real) - (x.Imaginary*y.Imaginary) + (matrixH[jm1O + j].Imaginary*z.Real), matrixH[jm1Oi].Imaginary);
                             }
 
                             matrixH[jO + i] = (x.Conjugate()*z) - (matrixH[jm1O + j].Imaginary*y);
@@ -806,7 +806,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 var jO = j*order;
                 for (var i = 0; i < order; i++)
                 {
-                    z = Numerics.Complex32.Zero;
+                    z = Complex32.Zero;
                     for (var k = 0; k <= j; k++)
                     {
                         z += dataEv[(k*order) + i]*matrixH[jO + k];
@@ -822,7 +822,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// </summary>
         /// <param name="input">The right hand side <see cref="Matrix{T}"/>, <b>B</b>.</param>
         /// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>X</b>.</param>
-        public override void Solve(Matrix<Numerics.Complex32> input, Matrix<Numerics.Complex32> result)
+        public override void Solve(Matrix<Complex32> input, Matrix<Complex32> result)
         {
             // The solution X should have the same number of columns as B
             if (input.ColumnCount != result.ColumnCount)
@@ -845,13 +845,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             if (IsSymmetric)
             {
                 var order = EigenValues.Count;
-                var tmp = new Numerics.Complex32[order];
+                var tmp = new Complex32[order];
 
                 for (var k = 0; k < order; k++)
                 {
                     for (var j = 0; j < order; j++)
                     {
-                        Numerics.Complex32 value = 0.0f;
+                        Complex32 value = 0.0f;
                         if (j < order)
                         {
                             for (var i = 0; i < order; i++)
@@ -867,7 +867,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                     for (var j = 0; j < order; j++)
                     {
-                        Numerics.Complex32 value = 0.0f;
+                        Complex32 value = 0.0f;
                         for (var i = 0; i < order; i++)
                         {
                             value += ((DenseMatrix) EigenVectors).Values[(i*order) + j]*tmp[i];
@@ -888,7 +888,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// </summary>
         /// <param name="input">The right hand side vector, <b>b</b>.</param>
         /// <param name="result">The left hand side <see cref="Matrix{T}"/>, <b>x</b>.</param>
-        public override void Solve(Vector<Numerics.Complex32> input, Vector<Numerics.Complex32> result)
+        public override void Solve(Vector<Complex32> input, Vector<Complex32> result)
         {
             // Ax=b where A is an m x m matrix
             // Check that b is a column vector with m entries
@@ -907,8 +907,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
             {
                 // Symmetric case -> x = V * inv(λ) * VH * b;
                 var order = EigenValues.Count;
-                var tmp = new Numerics.Complex32[order];
-                Numerics.Complex32 value;
+                var tmp = new Complex32[order];
+                Complex32 value;
 
                 for (var j = 0; j < order; j++)
                 {

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

@@ -249,6 +249,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// <summary>
         /// Symmetric tridiagonal QL algorithm.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <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>
@@ -395,6 +396,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// <summary>
         /// Determines eigenvectors by undoing the symmetric tridiagonalize transformation
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixA">Previously tridiagonalized matrix by <see cref="SymmetricTridiagonalize"/>.</param>
         /// <param name="tau">Contains further information about the transformations</param>
         /// <param name="order">Input matrix order</param>
@@ -440,6 +442,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// <summary>
         /// Nonsymmetric reduction to Hessenberg form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <param name="order">Order of initial matrix</param>
         /// <remarks>This is derived from the Algol procedures orthes and ortran,
@@ -585,6 +588,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         /// <summary>
         /// Nonsymmetric reduction from Hessenberg to real Schur form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
+        /// <param name="eigenValues">The eigen values to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <param name="order">Order of initial matrix</param>
         /// <remarks>This is derived from the Algol procedure hqr2,

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

@@ -91,6 +91,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
         /// <param name="input">The solution <see cref="Vector"/>, <c>b</c>.</param>
         /// <param name="result">The result <see cref="Vector"/>, <c>x</c>.</param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Numerics.Complex32> matrix, Vector<Numerics.Complex32> input, Vector<Numerics.Complex32> result, Iterator<Numerics.Complex32> iterator, IPreconditioner<Numerics.Complex32> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -70,6 +70,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Numerics.Complex32> matrix, Vector<Numerics.Complex32> input, Vector<Numerics.Complex32> result, Iterator<Numerics.Complex32> iterator, IPreconditioner<Numerics.Complex32> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -154,6 +154,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Numerics.Complex32> matrix, Vector<Numerics.Complex32> input, Vector<Numerics.Complex32> result, Iterator<Numerics.Complex32> iterator, IPreconditioner<Numerics.Complex32> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -240,6 +240,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Numerics.Complex32> matrix, Vector<Numerics.Complex32> input, Vector<Numerics.Complex32> result, Iterator<Numerics.Complex32> iterator, IPreconditioner<Numerics.Complex32> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -84,39 +84,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        public DivergenceStopCriterium() : this(DefaultMaximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease) : this(maximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the specified minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued. </param>
-        public DivergenceStopCriterium(int minimumIterations) : this(DefaultMinimumNumberOfIterations, minimumIterations)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
         /// relative increase and the specified minimum number of tracking iterations.
         /// </summary>
         /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued. </param>
         /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease, int minimumIterations)
+        public DivergenceStopCriterium(double maximumRelativeIncrease = DefaultMaximumRelativeIncrease, int minimumIterations = DefaultMinimumNumberOfIterations)
         {
             if (maximumRelativeIncrease <= 0)
             {

src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -83,35 +83,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum 
-        /// residual and the default minimum number of iterations.
-        /// </summary>
-        public ResidualStopCriterium() : this(DefaultMaximumResidual, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
-        /// maximum residual and the default minimum number of iterations.
-        /// </summary>
-        /// <param name="maximum">The maximum value for the residual below which the calculation is considered converged.</param>
-        public ResidualStopCriterium(float maximum) : this(maximum, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum residual
-        /// and specified minimum number of iterations.
-        /// </summary>
-        /// <param name="minimumIterationsBelowMaximum">
-        /// The minimum number of iterations for which the residual has to be below the maximum before
-        /// the calculation is considered converged.
-        /// </param>
-        public ResidualStopCriterium(int minimumIterationsBelowMaximum) : this(DefaultMaximumResidual, minimumIterationsBelowMaximum)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
         /// maximum residual and minimum number of iterations.
@@ -123,7 +94,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         /// The minimum number of iterations for which the residual has to be below the maximum before
         /// the calculation is considered converged.
         /// </param>
-        public ResidualStopCriterium(float maximum, int minimumIterationsBelowMaximum)
+        public ResidualStopCriterium(float maximum = DefaultMaximumResidual, int minimumIterationsBelowMaximum = DefaultMinimumIterationsBelowMaximum)
         {
             if (maximum < 0)
             {

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

@@ -87,6 +87,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<Numerics.Complex32> matrix, Vector<Numerics.Complex32> input, Vector<Numerics.Complex32> result, Iterator<Numerics.Complex32> iterator, IPreconditioner<Numerics.Complex32> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Complex32/SparseVector.cs

@@ -848,21 +848,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a double sparse vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a Complex32.
-        /// </summary>
-        /// <returns>
-        /// A double sparse vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static SparseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a double sparse vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n;n;..', '(n;n;..)', '[n;n;...]', where n is a Complex32.
@@ -876,7 +861,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static SparseVector Parse(string value, IFormatProvider formatProvider)
+        public static SparseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -759,21 +759,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a double dense vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a double.
-        /// </summary>
-        /// <returns>
-        /// A double dense vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static DenseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a double dense vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a double.
@@ -787,7 +772,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static DenseVector Parse(string value, IFormatProvider formatProvider)
+        public static DenseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

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

@@ -137,6 +137,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         /// <summary>
         /// Symmetric Householder reduction to tridiagonal form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <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>
@@ -289,6 +290,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         /// <summary>
         /// Symmetric tridiagonal QL algorithm.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <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>
@@ -435,6 +437,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         /// <summary>
         /// Nonsymmetric reduction to Hessenberg form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <param name="order">Order of initial matrix</param>
         /// <remarks>This is derived from the Algol procedures orthes and ortran,
@@ -550,6 +553,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         /// <summary>
         /// Nonsymmetric reduction from Hessenberg to real Schur form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <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>

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

@@ -91,6 +91,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
         /// <param name="input">The solution <see cref="Vector"/>, <c>b</c>.</param>
         /// <param name="result">The result <see cref="Vector"/>, <c>x</c>.</param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<double> matrix, Vector<double> input, Vector<double> result, Iterator<double> iterator, IPreconditioner<double> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -70,6 +70,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<double> matrix, Vector<double> input, Vector<double> result, Iterator<double> iterator, IPreconditioner<double> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -160,6 +160,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<double> matrix, Vector<double> input, Vector<double> result, Iterator<double> iterator, IPreconditioner<double> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -240,6 +240,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<double> matrix, Vector<double> input, Vector<double> result, Iterator<double> iterator, IPreconditioner<double> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -82,39 +82,13 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        public DivergenceStopCriterium() : this(DefaultMaximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease) : this(maximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the specified minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued. </param>
-        public DivergenceStopCriterium(int minimumIterations) : this(DefaultMinimumNumberOfIterations, minimumIterations)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
         /// relative increase and the specified minimum number of tracking iterations.
         /// </summary>
         /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued. </param>
         /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease, int minimumIterations)
+        public DivergenceStopCriterium(double maximumRelativeIncrease = DefaultMaximumRelativeIncrease, int minimumIterations = DefaultMinimumNumberOfIterations)
         {
             if (maximumRelativeIncrease <= 0)
             {

src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -81,35 +81,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum 
-        /// residual and the default minimum number of iterations.
-        /// </summary>
-        public ResidualStopCriterium() : this(DefaultMaximumResidual, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
-        /// maximum residual and the default minimum number of iterations.
-        /// </summary>
-        /// <param name="maximum">The maximum value for the residual below which the calculation is considered converged.</param>
-        public ResidualStopCriterium(double maximum) : this(maximum, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum residual
-        /// and specified minimum number of iterations.
-        /// </summary>
-        /// <param name="minimumIterationsBelowMaximum">
-        /// The minimum number of iterations for which the residual has to be below the maximum before
-        /// the calculation is considered converged.
-        /// </param>
-        public ResidualStopCriterium(int minimumIterationsBelowMaximum) : this(DefaultMaximumResidual, minimumIterationsBelowMaximum)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
         /// maximum residual and minimum number of iterations.
@@ -121,7 +92,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         /// The minimum number of iterations for which the residual has to be below the maximum before
         /// the calculation is considered converged.
         /// </param>
-        public ResidualStopCriterium(double maximum, int minimumIterationsBelowMaximum)
+        public ResidualStopCriterium(double maximum = DefaultMaximumResidual, int minimumIterationsBelowMaximum = DefaultMinimumIterationsBelowMaximum)
         {
             if (maximum < 0)
             {

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

@@ -87,6 +87,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<double> matrix, Vector<double> input, Vector<double> result, Iterator<double> iterator, IPreconditioner<double> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Double/SparseVector.cs

@@ -856,21 +856,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a double sparse vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a double.
-        /// </summary>
-        /// <returns>
-        /// A double sparse vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static SparseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a double sparse vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a double.
@@ -884,7 +869,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static SparseVector Parse(string value, IFormatProvider formatProvider)
+        public static SparseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

src/Numerics/LinearAlgebra/Matrix.Arithmetic.cs

@@ -87,7 +87,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// </summary>
         /// <param name="scalar">The scalar to subtract from.</param>
         /// <param name="result">The matrix to store the result of the subtraction.</param>
-        protected virtual void DoSubtractFrom(T scalar, Matrix<T> result)
+        protected void DoSubtractFrom(T scalar, Matrix<T> result)
         {
             DoNegate(result);
             result.DoAdd(scalar, result);
@@ -1072,7 +1072,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// </summary>
         /// <param name="other">The other matrix.</param>
         /// <returns>The kronecker product of the two matrices.</returns>
-        public virtual Matrix<T> KroneckerProduct(Matrix<T> other)
+        public Matrix<T> KroneckerProduct(Matrix<T> other)
         {
             var result = CreateMatrix(RowCount*other.RowCount, ColumnCount*other.ColumnCount);
             KroneckerProduct(other, result);
@@ -1108,14 +1108,14 @@ namespace MathNet.Numerics.LinearAlgebra
         /// <param name="p">The norm under which to normalize the columns under.</param>
         /// <returns>A normalized version of the matrix.</returns>
         /// <exception cref="ArgumentOutOfRangeException">If the parameter p is not positive.</exception>
-        public virtual Matrix<T> NormalizeColumns(int p)
+        public Matrix<T> NormalizeColumns(int p)
         {
             if (p < 1)
             {
                 throw new ArgumentOutOfRangeException("p", Resources.ArgumentMustBePositive);
             }
 
-            var ret = Clone();
+            var ret = CreateMatrix(RowCount, ColumnCount);
 
             for (var index = 0; index < ColumnCount; index++)
             {
@@ -1131,14 +1131,14 @@ namespace MathNet.Numerics.LinearAlgebra
         /// <param name="p">The norm under which to normalize the rows under.</param>
         /// <returns>A normalized version of the matrix.</returns>
         /// <exception cref="ArgumentOutOfRangeException">If the parameter p is not positive.</exception>
-        public virtual Matrix<T> NormalizeRows(int p)
+        public Matrix<T> NormalizeRows(int p)
         {
             if (p < 1)
             {
                 throw new ArgumentOutOfRangeException("p", Resources.ArgumentMustBePositive);
             }
 
-            var ret = Clone();
+            var ret = CreateMatrix(RowCount, ColumnCount);
 
             for (var index = 0; index < RowCount; index++)
             {
@@ -1150,46 +1150,46 @@ namespace MathNet.Numerics.LinearAlgebra
 
         #region Exceptions - possibly move elsewhere?
 
-        public static Exception DimensionsDontMatch<TException>(Matrix<T> left, Matrix<T> right, Matrix<T> result, string paramName = null)
+        internal static Exception DimensionsDontMatch<TException>(Matrix<T> left, Matrix<T> right, Matrix<T> result, string paramName = null)
             where TException : Exception
         {
             var message = string.Format(Resources.ArgumentMatrixDimensions3, left.RowCount + "x" + left.ColumnCount, right.RowCount + "x" + right.ColumnCount, result.RowCount + "x" + result.ColumnCount);
             return CreateException<TException>(message, paramName);
         }
 
-        public static Exception DimensionsDontMatch<TException>(Matrix<T> left, Matrix<T> right, string paramName = null)
+        internal static Exception DimensionsDontMatch<TException>(Matrix<T> left, Matrix<T> right, string paramName = null)
             where TException : Exception
         {
             var message = string.Format(Resources.ArgumentMatrixDimensions2, left.RowCount + "x" + left.ColumnCount, right.RowCount + "x" + right.ColumnCount);
             return CreateException<TException>(message, paramName);
         }
 
-        public static Exception DimensionsDontMatch<TException>(Matrix<T> matrix)
+        internal static Exception DimensionsDontMatch<TException>(Matrix<T> matrix)
             where TException : Exception
         {
             var message = string.Format(Resources.ArgumentMatrixDimensions1, matrix.RowCount + "x" + matrix.ColumnCount);
             return CreateException<TException>(message);
         }
 
-        public static Exception DimensionsDontMatch<TException>(Matrix<T> left, Vector<T> right, Vector<T> result, string paramName = null)
+        internal static Exception DimensionsDontMatch<TException>(Matrix<T> left, Vector<T> right, Vector<T> result, string paramName = null)
             where TException : Exception
         {
             return DimensionsDontMatch<TException>(left, right.ToColumnMatrix(), result.ToColumnMatrix(), paramName);
         }
 
-        public static Exception DimensionsDontMatch<TException>(Matrix<T> left, Vector<T> right, string paramName = null)
+        internal static Exception DimensionsDontMatch<TException>(Matrix<T> left, Vector<T> right, string paramName = null)
             where TException : Exception
         {
             return DimensionsDontMatch<TException>(left, right.ToColumnMatrix(), paramName);
         }
 
-        public static Exception DimensionsDontMatch<TException>(Vector<T> left, Matrix<T> right, string paramName = null)
+        internal static Exception DimensionsDontMatch<TException>(Vector<T> left, Matrix<T> right, string paramName = null)
             where TException : Exception
         {
             return DimensionsDontMatch<TException>(left.ToColumnMatrix(), right, paramName);
         }
 
-        public static Exception DimensionsDontMatch<TException>(Vector<T> left, Vector<T> right, string paramName = null)
+        internal static Exception DimensionsDontMatch<TException>(Vector<T> left, Vector<T> right, string paramName = null)
             where TException : Exception
         {
             return DimensionsDontMatch<TException>(left.ToColumnMatrix(), right.ToColumnMatrix(), paramName);

src/Numerics/LinearAlgebra/Matrix.Solve.cs

@@ -155,7 +155,9 @@ namespace MathNet.Numerics.LinearAlgebra
         /// <param name="input">The solution vector <c>b</c>.</param>
         /// <param name="result">The result vector <c>x</c>.</param>
         /// <param name="solver">The iterative solver to use.</param>
-        public IterationStatus TrySolveIterative(Vector<T> input, Vector<T> result, IIterativeSolver<T> solver, IPreconditioner<T> preconditioner, Iterator<T> iterator = null)
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
+        public IterationStatus TrySolveIterative(Vector<T> input, Vector<T> result, IIterativeSolver<T> solver, Iterator<T> iterator = null, IPreconditioner<T> preconditioner = null)
         {
             if (iterator == null)
             {
@@ -178,7 +180,9 @@ namespace MathNet.Numerics.LinearAlgebra
         /// <param name="input">The solution matrix <c>B</c>.</param>
         /// <param name="result">The result matrix <c>X</c></param>
         /// <param name="solver">The iterative solver to use.</param>
-        public IterationStatus TrySolveIterative(Matrix<T> input, Matrix<T> result, IIterativeSolver<T> solver, IPreconditioner<T> preconditioner, Iterator<T> iterator = null)
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
+        public IterationStatus TrySolveIterative(Matrix<T> input, Matrix<T> result, IIterativeSolver<T> solver, Iterator<T> iterator = null, IPreconditioner<T> preconditioner = null)
         {
             if (RowCount != input.RowCount || input.RowCount != result.RowCount || input.ColumnCount != result.ColumnCount)
             {
@@ -210,100 +214,46 @@ namespace MathNet.Numerics.LinearAlgebra
             return iterator.Status;
         }
 
-        public IterationStatus TrySolveIterative(Vector<T> input, Vector<T> result, IIterativeSolver<T> solver, Iterator<T> iterator)
-        {
-            var preconditioner = new UnitPreconditioner<T>();
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
-        }
-
-        public IterationStatus TrySolveIterative(Matrix<T> input, Matrix<T> result, IIterativeSolver<T> solver, Iterator<T> iterator)
-        {
-            var preconditioner = new UnitPreconditioner<T>();
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
-        }
-
-        public IterationStatus TrySolveIterative(Vector<T> input, Vector<T> result, IIterativeSolver<T> solver)
-        {
-            var preconditioner = new UnitPreconditioner<T>();
-            var iterator = new Iterator<T>(Builder.IterativeSolverStopCriteria());
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
-        }
-
-        public IterationStatus TrySolveIterative(Matrix<T> input, Matrix<T> result, IIterativeSolver<T> solver)
-        {
-            var preconditioner = new UnitPreconditioner<T>();
-            var iterator = new Iterator<T>(Builder.IterativeSolverStopCriteria());
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
-        }
-
         public IterationStatus TrySolveIterative(Vector<T> input, Vector<T> result, IIterativeSolver<T> solver, IPreconditioner<T> preconditioner, params IIterationStopCriterium<T>[] stopCriteria)
         {
             var iterator = new Iterator<T>(stopCriteria.Length == 0 ? Builder.IterativeSolverStopCriteria() : stopCriteria);
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
+            return TrySolveIterative(input, result, solver, iterator, preconditioner);
         }
 
         public IterationStatus TrySolveIterative(Matrix<T> input, Matrix<T> result, IIterativeSolver<T> solver, IPreconditioner<T> preconditioner, params IIterationStopCriterium<T>[] stopCriteria)
         {
             var iterator = new Iterator<T>(stopCriteria.Length == 0 ? Builder.IterativeSolverStopCriteria() : stopCriteria);
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
+            return TrySolveIterative(input, result, solver, iterator, preconditioner);
         }
 
         public IterationStatus TrySolveIterative(Vector<T> input, Vector<T> result, IIterativeSolver<T> solver, params IIterationStopCriterium<T>[] stopCriteria)
         {
-            var preconditioner = new UnitPreconditioner<T>();
             var iterator = new Iterator<T>(stopCriteria.Length == 0 ? Builder.IterativeSolverStopCriteria() : stopCriteria);
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
+            return TrySolveIterative(input, result, solver, iterator);
         }
 
         public IterationStatus TrySolveIterative(Matrix<T> input, Matrix<T> result, IIterativeSolver<T> solver, params IIterationStopCriterium<T>[] stopCriteria)
         {
-            var preconditioner = new UnitPreconditioner<T>();
             var iterator = new Iterator<T>(stopCriteria.Length == 0 ? Builder.IterativeSolverStopCriteria() : stopCriteria);
-            return TrySolveIterative(input, result, solver, preconditioner, iterator);
+            return TrySolveIterative(input, result, solver, iterator);
         }
 
 
 
         // Iterative Solvers: Simple
 
-        public Vector<T> SolveIterative(Vector<T> input, IIterativeSolver<T> solver, IPreconditioner<T> preconditioner, Iterator<T> iterator)
-        {
-            var result = Builder.DenseVector(RowCount);
-            TrySolveIterative(input, result, solver, preconditioner, iterator);
-            return result;
-        }
-
-        public Matrix<T> SolveIterative(Matrix<T> input, IIterativeSolver<T> solver, IPreconditioner<T> preconditioner, Iterator<T> iterator)
-        {
-            var result = Builder.DenseMatrix(input.RowCount, input.ColumnCount);
-            TrySolveIterative(input, result, solver, preconditioner, iterator);
-            return result;
-        }
-
-        public Vector<T> SolveIterative(Vector<T> input, IIterativeSolver<T> solver, Iterator<T> iterator)
-        {
-            var result = Builder.DenseVector(RowCount);
-            TrySolveIterative(input, result, solver, iterator);
-            return result;
-        }
-
-        public Matrix<T> SolveIterative(Matrix<T> input, IIterativeSolver<T> solver, Iterator<T> iterator)
-        {
-            var result = Builder.DenseMatrix(input.RowCount, input.ColumnCount);
-            TrySolveIterative(input, result, solver, iterator);
-            return result;
-        }
-
         /// <summary>
         /// Solves the matrix equation Ax = b, where A is the coefficient matrix (this matrix), b is the solution vector and x is the unknown vector.
         /// </summary>
         /// <param name="input">The solution vector <c>b</c>.</param>
         /// <param name="solver">The iterative solver to use.</param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         /// <returns>The result vector <c>x</c>.</returns>
-        public Vector<T> SolveIterative(Vector<T> input, IIterativeSolver<T> solver)
+        public Vector<T> SolveIterative(Vector<T> input, IIterativeSolver<T> solver, Iterator<T> iterator = null, IPreconditioner<T> preconditioner = null)
         {
             var result = Builder.DenseVector(RowCount);
-            TrySolveIterative(input, result, solver);
+            TrySolveIterative(input, result, solver, iterator, preconditioner);
             return result;
         }
 
@@ -312,11 +262,13 @@ namespace MathNet.Numerics.LinearAlgebra
         /// </summary>
         /// <param name="input">The solution matrix <c>B</c>.</param>
         /// <param name="solver">The iterative solver to use.</param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         /// <returns>The result matrix <c>X</c>.</returns>
-        public Matrix<T> SolveIterative(Matrix<T> input, IIterativeSolver<T> solver)
+        public Matrix<T> SolveIterative(Matrix<T> input, IIterativeSolver<T> solver, Iterator<T> iterator = null, IPreconditioner<T> preconditioner = null)
         {
             var result = Builder.DenseMatrix(input.RowCount, input.ColumnCount);
-            TrySolveIterative(input, result, solver);
+            TrySolveIterative(input, result, solver, iterator, preconditioner);
             return result;
         }
 

src/Numerics/LinearAlgebra/Single/DenseVector.cs

@@ -748,21 +748,6 @@ namespace MathNet.Numerics.LinearAlgebra.Single
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a float dense vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a float.
-        /// </summary>
-        /// <returns>
-        /// A float dense vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static DenseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a float dense vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a float.
@@ -776,7 +761,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static DenseVector Parse(string value, IFormatProvider formatProvider)
+        public static DenseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

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

@@ -136,6 +136,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         /// <summary>
         /// Symmetric Householder reduction to tridiagonal form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <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>
@@ -288,6 +289,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         /// <summary>
         /// Symmetric tridiagonal QL algorithm.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <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>
@@ -434,6 +436,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         /// <summary>
         /// Nonsymmetric reduction to Hessenberg form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <param name="order">Order of initial matrix</param>
         /// <remarks>This is derived from the Algol procedures orthes and ortran,
@@ -549,6 +552,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         /// <summary>
         /// Nonsymmetric reduction from Hessenberg to real Schur form.
         /// </summary>
+        /// <param name="eigenVectors">The eigen vectors to work on.</param>
         /// <param name="matrixH">Array for internal storage of nonsymmetric Hessenberg form.</param>
         /// <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>

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

@@ -91,6 +91,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <param name="matrix">The coefficient <see cref="Matrix"/>, <c>A</c>.</param>
         /// <param name="input">The solution <see cref="Vector"/>, <c>b</c>.</param>
         /// <param name="result">The result <see cref="Vector"/>, <c>x</c>.</param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<float> matrix, Vector<float> input, Vector<float> result, Iterator<float> iterator, IPreconditioner<float> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -70,6 +70,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<float> matrix, Vector<float> input, Vector<float> result, Iterator<float> iterator, IPreconditioner<float> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -154,6 +154,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<float> matrix, Vector<float> input, Vector<float> result, Iterator<float> iterator, IPreconditioner<float> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

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

@@ -243,6 +243,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<float> matrix, Vector<float> input, Vector<float> result, Iterator<float> iterator, IPreconditioner<float> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -82,39 +82,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        public DivergenceStopCriterium() : this(DefaultMaximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
-        /// relative increase and the default minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease) : this(maximumRelativeIncrease, DefaultMinimumNumberOfIterations)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the default maximum 
-        /// relative increase and the specified minimum number of tracking iterations.
-        /// </summary>
-        /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued. </param>
-        public DivergenceStopCriterium(int minimumIterations) : this(DefaultMinimumNumberOfIterations, minimumIterations)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="DivergenceStopCriterium"/> class with the specified maximum 
         /// relative increase and the specified minimum number of tracking iterations.
         /// </summary>
         /// <param name="maximumRelativeIncrease">The maximum relative increase that the residual may experience before a divergence warning is issued. </param>
         /// <param name="minimumIterations">The minimum number of iterations over which the residual must grow before a divergence warning is issued.</param>
-        public DivergenceStopCriterium(double maximumRelativeIncrease, int minimumIterations)
+        public DivergenceStopCriterium(double maximumRelativeIncrease = DefaultMaximumRelativeIncrease, int minimumIterations = DefaultMinimumNumberOfIterations)
         {
             if (maximumRelativeIncrease <= 0)
             {

src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -81,35 +81,6 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         /// </summary>
         int _lastIteration = DefaultLastIterationNumber;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum 
-        /// residual and the default minimum number of iterations.
-        /// </summary>
-        public ResidualStopCriterium() : this(DefaultMaximumResidual, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
-        /// maximum residual and the default minimum number of iterations.
-        /// </summary>
-        /// <param name="maximum">The maximum value for the residual below which the calculation is considered converged.</param>
-        public ResidualStopCriterium(float maximum) : this(maximum, DefaultMinimumIterationsBelowMaximum)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the default maximum residual
-        /// and specified minimum number of iterations.
-        /// </summary>
-        /// <param name="minimumIterationsBelowMaximum">
-        /// The minimum number of iterations for which the residual has to be below the maximum before
-        /// the calculation is considered converged.
-        /// </param>
-        public ResidualStopCriterium(int minimumIterationsBelowMaximum) : this(DefaultMaximumResidual, minimumIterationsBelowMaximum)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ResidualStopCriterium"/> class with the specified 
         /// maximum residual and minimum number of iterations.
@@ -121,7 +92,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         /// The minimum number of iterations for which the residual has to be below the maximum before
         /// the calculation is considered converged.
         /// </param>
-        public ResidualStopCriterium(float maximum, int minimumIterationsBelowMaximum)
+        public ResidualStopCriterium(float maximum = DefaultMaximumResidual, int minimumIterationsBelowMaximum = DefaultMinimumIterationsBelowMaximum)
         {
             if (maximum < 0)
             {

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

@@ -87,6 +87,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         public void Solve(Matrix<float> matrix, Vector<float> input, Vector<float> result, Iterator<float> iterator, IPreconditioner<float> preconditioner)
         {
             if (matrix.RowCount != matrix.ColumnCount)

src/Numerics/LinearAlgebra/Single/SparseVector.cs

@@ -860,21 +860,6 @@ namespace MathNet.Numerics.LinearAlgebra.Single
 
         #region Parse Functions
 
-        /// <summary>
-        /// Creates a float sparse vector based on a string. The string can be in the following formats (without the
-        /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a float.
-        /// </summary>
-        /// <returns>
-        /// A float sparse vector containing the values specified by the given string.
-        /// </returns>
-        /// <param name="value">
-        /// The string to parse.
-        /// </param>
-        public static SparseVector Parse(string value)
-        {
-            return Parse(value, null);
-        }
-
         /// <summary>
         /// Creates a float sparse vector based on a string. The string can be in the following formats (without the
         /// quotes): 'n', 'n,n,..', '(n,n,..)', '[n,n,...]', where n is a float.
@@ -888,7 +873,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// <param name="formatProvider">
         /// An <see cref="IFormatProvider"/> that supplies culture-specific formatting information.
         /// </param>
-        public static SparseVector Parse(string value, IFormatProvider formatProvider)
+        public static SparseVector Parse(string value, IFormatProvider formatProvider = null)
         {
             if (value == null)
             {

src/Numerics/LinearAlgebra/Solvers/IIterativeSolver.cs

@@ -45,6 +45,8 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <param name="matrix">The coefficient matrix, <c>A</c>.</param>
         /// <param name="input">The solution vector, <c>b</c></param>
         /// <param name="result">The result vector, <c>x</c></param>
+        /// <param name="iterator">The iterator to use to control when to stop iterating.</param>
+        /// <param name="preconditioner">The preconditioner to use for approximations.</param>
         void Solve(Matrix<T> matrix, Vector<T> input, Vector<T> result, Iterator<T> iterator, IPreconditioner<T> preconditioner);
     }
 }

src/Numerics/LinearAlgebra/Solvers/SolverSetup.cs

@@ -41,8 +41,9 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
+        /// <param name="ignoreFailed">If true, types that fail to load are simply ignored. Otherwise the exception is rethrown.</param>
         /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
-        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(Assembly assembly, bool ignoreFailed, params Type[] typesToExclude)
+        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(Assembly assembly, bool ignoreFailed = true, params Type[] typesToExclude)
         {
             var excludedTypes = new List<Type>(typesToExclude);
             var setupInterfaceType = typeof (IIterativeSolverSetup<T>);
@@ -71,53 +72,28 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
                 .OrderBy(s => s.SolutionSpeed/s.Reliability);
         }
 
-        /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
-        /// </summary>
-        /// <param name="assembly">The assembly which will be searched for setup objects.</param>
-        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(Assembly assembly)
-        {
-            return LoadFromAssembly(assembly, true);
-        }
-
         /// <summary>
         /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
+        /// <param name="ignoreFailed">If true, types that fail to load are simply ignored. Otherwise the exception is rethrown.</param>
         /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
-        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(Type typeInAssembly, bool ignoreFailed, params Type[] typesToExclude)
+        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(Type typeInAssembly, bool ignoreFailed = true, params Type[] typesToExclude)
         {
             return LoadFromAssembly(typeInAssembly.Assembly, ignoreFailed, typesToExclude);
         }
 
-        /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
-        /// </summary>
-        /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
-        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(Type typeInAssembly)
-        {
-            return LoadFromAssembly(typeInAssembly.Assembly, true);
-        }
-
         /// <summary>
         /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
+        /// <param name="ignoreFailed">If true, types that fail to load are simply ignored. Otherwise the exception is rethrown.</param>
         /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
-        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(AssemblyName assemblyName, bool ignoreFailed, params Type[] typesToExclude)
+        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(AssemblyName assemblyName, bool ignoreFailed = true, params Type[] typesToExclude)
         {
             return LoadFromAssembly(Assembly.Load(assemblyName.FullName), ignoreFailed, typesToExclude);
         }
 
-        /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
-        /// </summary>
-        /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
-        public static IEnumerable<IIterativeSolverSetup<T>> LoadFromAssembly(AssemblyName assemblyName)
-        {
-            return LoadFromAssembly(Assembly.Load(assemblyName.FullName), true);
-        }
-
         /// <summary>
         /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the Math.NET Numerics assembly.
         /// </summary>

src/Numerics/LinearAlgebra/Storage/DenseVectorStorage.cs

@@ -142,7 +142,7 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
                 return new DenseVectorStorage<T>(copy.Length, copy);
             }
 
-            var array = Enumerable.ToArray(data);
+            var array = data.ToArray();
             return new DenseVectorStorage<T>(array.Length, array);
         }
 

src/Numerics/LinearAlgebra/Vector.Arithmetic.cs

@@ -83,7 +83,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// </summary>
         /// <param name="scalar">The scalar to subtract from.</param>
         /// <param name="result">The vector to store the result of the subtraction.</param>
-        protected virtual void DoSubtractFrom(T scalar, Vector<T> result)
+        protected void DoSubtractFrom(T scalar, Vector<T> result)
         {
             DoNegate(result);
             result.DoAdd(scalar, result);

src/Numerics/LinearAlgebra/Vector.BCL.cs

@@ -129,7 +129,7 @@ namespace MathNet.Numerics.LinearAlgebra
 
         bool ICollection<T>.Contains(T item)
         {
-            // Do NOT convert this loop to LINQ (since LINQ would redirect to this very method)!
+            // ReSharper disable once LoopCanBeConvertedToQuery
             foreach (var x in this)
             {
                 if (x.Equals(item))
@@ -211,7 +211,7 @@ namespace MathNet.Numerics.LinearAlgebra
 
         object ICollection.SyncRoot
         {
-            get { return null; }
+            get { return Storage; }
         }
 
         void ICollection.CopyTo(Array array, int index)

src/Numerics/LinearAlgebra/Vector.cs

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra
     /// <typeparam name="T">Supported data types are double, single, <see cref="Complex"/>, and <see cref="Complex32"/>.</typeparam>
     [Serializable]
     public abstract partial class Vector<T> :
-        IFormattable, IEnumerable<T>, IEquatable<Vector<T>>, IList, IList<T>
+        IFormattable, IEquatable<Vector<T>>, IList, IList<T>
 #if !PORTABLE
         , ICloneable
 #endif

src/Numerics/Precision.cs

@@ -338,20 +338,6 @@ namespace MathNet.Numerics
             return (result >= 0) ? result : (int.MinValue - result);
         }
 
-        /// <summary>
-        /// Increments a floating point number to the next bigger number representable by the data type.
-        /// </summary>
-        /// <param name="value">The value which needs to be incremented.</param>
-        /// <remarks>
-        /// The incrementation step length depends on the provided value.
-        /// Increment(double.MaxValue) will return positive infinity.
-        /// </remarks>
-        /// <returns>The next larger floating point value.</returns>
-        public static double Increment(this double value)
-        {
-            return Increment(value, 1);
-        }
-
         /// <summary>
         /// Increments a floating point number to the next bigger number representable by the data type.
         /// </summary>
@@ -362,7 +348,7 @@ namespace MathNet.Numerics
         /// Increment(double.MaxValue) will return positive infinity.
         /// </remarks>
         /// <returns>The next larger floating point value.</returns>
-        public static double Increment(this double value, int count)
+        public static double Increment(this double value, int count = 1)
         {
             if (double.IsInfinity(value) || double.IsNaN(value) || count == 0)
             {
@@ -405,20 +391,6 @@ namespace MathNet.Numerics
 #endif        
         }
 
-        /// <summary>
-        /// Decrements a floating point number to the next smaller number representable by the data type.
-        /// </summary>
-        /// <param name="value">The value which should be decremented.</param>
-        /// <remarks>
-        /// The decrementation step length depends on the provided value.
-        /// Decrement(double.MinValue) will return negative infinity.
-        /// </remarks>
-        /// <returns>The next smaller floating point value.</returns>
-        public static double Decrement(this double value)
-        {
-            return Decrement(value, 1);
-        }
-
         /// <summary>
         /// Decrements a floating point number to the next smaller number representable by the data type.
         /// </summary>
@@ -429,7 +401,7 @@ namespace MathNet.Numerics
         /// Decrement(double.MinValue) will return negative infinity.
         /// </remarks>
         /// <returns>The next smaller floating point value.</returns>
-        public static double Decrement(this double value, int count)
+        public static double Decrement(this double value, int count = 1)
         {
             if (double.IsInfinity(value) || double.IsNaN(value) || count == 0)
             {

src/Numerics/SpecialFunctions/ModifiedBessel.cs

@@ -65,14 +65,14 @@ namespace MathNet.Numerics
         /// 
         /// lim(x->0){ exp(-x) I0(x) } = 1.
         /// </summary>
-        private static readonly double[] BesselI0A = new[] { -4.41534164647933937950e-18, 3.33079451882223809783e-17, -2.43127984654795469359e-16, 1.71539128555513303061e-15, -1.16853328779934516808e-14, 7.67618549860493561688e-14, -4.85644678311192946090e-13, 2.95505266312963983461e-12, -1.72682629144155570723e-11, 9.67580903537323691224e-11, -5.18979560163526290666e-10, 2.65982372468238665035e-9, -1.30002500998624804212e-8, 6.04699502254191894932e-8, -2.67079385394061173391e-7, 1.11738753912010371815e-6, -4.41673835845875056359e-6, 1.64484480707288970893e-5, -5.75419501008210370398e-5, 1.88502885095841655729e-4, -5.76375574538582365885e-4, 1.63947561694133579842e-3, -4.32430999505057594430e-3, 1.05464603945949983183e-2, -2.37374148058994688156e-2, 4.93052842396707084878e-2, -9.49010970480476444210e-2, 1.71620901522208775349e-1, -3.04682672343198398683e-1, 6.76795274409476084995e-1 };
+        private static readonly double[] BesselI0A = { -4.41534164647933937950e-18, 3.33079451882223809783e-17, -2.43127984654795469359e-16, 1.71539128555513303061e-15, -1.16853328779934516808e-14, 7.67618549860493561688e-14, -4.85644678311192946090e-13, 2.95505266312963983461e-12, -1.72682629144155570723e-11, 9.67580903537323691224e-11, -5.18979560163526290666e-10, 2.65982372468238665035e-9, -1.30002500998624804212e-8, 6.04699502254191894932e-8, -2.67079385394061173391e-7, 1.11738753912010371815e-6, -4.41673835845875056359e-6, 1.64484480707288970893e-5, -5.75419501008210370398e-5, 1.88502885095841655729e-4, -5.76375574538582365885e-4, 1.63947561694133579842e-3, -4.32430999505057594430e-3, 1.05464603945949983183e-2, -2.37374148058994688156e-2, 4.93052842396707084878e-2, -9.49010970480476444210e-2, 1.71620901522208775349e-1, -3.04682672343198398683e-1, 6.76795274409476084995e-1 };
 
         /// <summary> Chebyshev coefficients for exp(-x) sqrt(x) I0(x)
         /// in the inverted interval [8, infinity].
         /// 
         /// lim(x->inf){ exp(-x) sqrt(x) I0(x) } = 1/sqrt(2pi).
         /// </summary>
-        private static readonly double[] BesselI0B = new[] { -7.23318048787475395456e-18, -4.83050448594418207126e-18, 4.46562142029675999901e-17, 3.46122286769746109310e-17, -2.82762398051658348494e-16, -3.42548561967721913462e-16, 1.77256013305652638360e-15, 3.81168066935262242075e-15, -9.55484669882830764870e-15, -4.15056934728722208663e-14, 1.54008621752140982691e-14, 3.85277838274214270114e-13, 7.18012445138366623367e-13, -1.79417853150680611778e-12, -1.32158118404477131188e-11, -3.14991652796324136454e-11, 1.18891471078464383424e-11, 4.94060238822496958910e-10, 3.39623202570838634515e-9, 2.26666899049817806459e-8, 2.04891858946906374183e-7, 2.89137052083475648297e-6, 6.88975834691682398426e-5, 3.36911647825569408990e-3, 8.04490411014108831608e-1 };
+        private static readonly double[] BesselI0B = { -7.23318048787475395456e-18, -4.83050448594418207126e-18, 4.46562142029675999901e-17, 3.46122286769746109310e-17, -2.82762398051658348494e-16, -3.42548561967721913462e-16, 1.77256013305652638360e-15, 3.81168066935262242075e-15, -9.55484669882830764870e-15, -4.15056934728722208663e-14, 1.54008621752140982691e-14, 3.85277838274214270114e-13, 7.18012445138366623367e-13, -1.79417853150680611778e-12, -1.32158118404477131188e-11, -3.14991652796324136454e-11, 1.18891471078464383424e-11, 4.94060238822496958910e-10, 3.39623202570838634515e-9, 2.26666899049817806459e-8, 2.04891858946906374183e-7, 2.89137052083475648297e-6, 6.88975834691682398426e-5, 3.36911647825569408990e-3, 8.04490411014108831608e-1 };
 
         /// <summary>
         /// **************************************
@@ -84,14 +84,14 @@ namespace MathNet.Numerics
         /// 
         /// lim(x->0){ exp(-x) I1(x) / x } = 1/2.
         /// </summary>
-        private static readonly double[] BesselI1A = new[] { 2.77791411276104639959e-18, -2.11142121435816608115e-17, 1.55363195773620046921e-16, -1.10559694773538630805e-15, 7.60068429473540693410e-15, -5.04218550472791168711e-14, 3.22379336594557470981e-13, -1.98397439776494371520e-12, 1.17361862988909016308e-11, -6.66348972350202774223e-11, 3.62559028155211703701e-10, -1.88724975172282928790e-9, 9.38153738649577178388e-9, -4.44505912879632808065e-8, 2.00329475355213526229e-7, -8.56872026469545474066e-7, 3.47025130813767847674e-6, -1.32731636560394358279e-5, 4.78156510755005422638e-5, -1.61760815825896745588e-4, 5.12285956168575772895e-4, -1.51357245063125314899e-3, 4.15642294431288815669e-3, -1.05640848946261981558e-2, 2.47264490306265168283e-2, -5.29459812080949914269e-2, 1.02643658689847095384e-1, -1.76416518357834055153e-1, 2.52587186443633654823e-1 };
+        private static readonly double[] BesselI1A = { 2.77791411276104639959e-18, -2.11142121435816608115e-17, 1.55363195773620046921e-16, -1.10559694773538630805e-15, 7.60068429473540693410e-15, -5.04218550472791168711e-14, 3.22379336594557470981e-13, -1.98397439776494371520e-12, 1.17361862988909016308e-11, -6.66348972350202774223e-11, 3.62559028155211703701e-10, -1.88724975172282928790e-9, 9.38153738649577178388e-9, -4.44505912879632808065e-8, 2.00329475355213526229e-7, -8.56872026469545474066e-7, 3.47025130813767847674e-6, -1.32731636560394358279e-5, 4.78156510755005422638e-5, -1.61760815825896745588e-4, 5.12285956168575772895e-4, -1.51357245063125314899e-3, 4.15642294431288815669e-3, -1.05640848946261981558e-2, 2.47264490306265168283e-2, -5.29459812080949914269e-2, 1.02643658689847095384e-1, -1.76416518357834055153e-1, 2.52587186443633654823e-1 };
 
         /// <summary> Chebyshev coefficients for exp(-x) sqrt(x) I1(x)
         /// in the inverted interval [8, infinity].
         ///
         /// lim(x->inf){ exp(-x) sqrt(x) I1(x) } = 1/sqrt(2pi).
         /// </summary>
-        private static readonly double[] BesselI1B = new[] { 7.51729631084210481353e-18, 4.41434832307170791151e-18, -4.65030536848935832153e-17, -3.20952592199342395980e-17, 2.96262899764595013876e-16, 3.30820231092092828324e-16, -1.88035477551078244854e-15, -3.81440307243700780478e-15, 1.04202769841288027642e-14, 4.27244001671195135429e-14, -2.10154184277266431302e-14, -4.08355111109219731823e-13, -7.19855177624590851209e-13, 2.03562854414708950722e-12, 1.41258074366137813316e-11, 3.25260358301548823856e-11, -1.89749581235054123450e-11, -5.58974346219658380687e-10, -3.83538038596423702205e-9, -2.63146884688951950684e-8, -2.51223623787020892529e-7, -3.88256480887769039346e-6, -1.10588938762623716291e-4, -9.76109749136146840777e-3, 7.78576235018280120474e-1 };
+        private static readonly double[] BesselI1B = { 7.51729631084210481353e-18, 4.41434832307170791151e-18, -4.65030536848935832153e-17, -3.20952592199342395980e-17, 2.96262899764595013876e-16, 3.30820231092092828324e-16, -1.88035477551078244854e-15, -3.81440307243700780478e-15, 1.04202769841288027642e-14, 4.27244001671195135429e-14, -2.10154184277266431302e-14, -4.08355111109219731823e-13, -7.19855177624590851209e-13, 2.03562854414708950722e-12, 1.41258074366137813316e-11, 3.25260358301548823856e-11, -1.89749581235054123450e-11, -5.58974346219658380687e-10, -3.83538038596423702205e-9, -2.63146884688951950684e-8, -2.51223623787020892529e-7, -3.88256480887769039346e-6, -1.10588938762623716291e-4, -9.76109749136146840777e-3, 7.78576235018280120474e-1 };
 
         /// <summary>
         /// **************************************
@@ -104,14 +104,14 @@ namespace MathNet.Numerics
         /// 
         /// lim(x->0){ K0(x) + log(x/2) I0(x) } = -EUL.
         /// </summary>
-        private static readonly double[] BesselK0A = new[] { 1.37446543561352307156e-16, 4.25981614279661018399e-14, 1.03496952576338420167e-11, 1.90451637722020886025e-9, 2.53479107902614945675e-7, 2.28621210311945178607e-5, 1.26461541144692592338e-3, 3.59799365153615016266e-2, 3.44289899924628486886e-1, -5.35327393233902768720e-1 };
+        private static readonly double[] BesselK0A = { 1.37446543561352307156e-16, 4.25981614279661018399e-14, 1.03496952576338420167e-11, 1.90451637722020886025e-9, 2.53479107902614945675e-7, 2.28621210311945178607e-5, 1.26461541144692592338e-3, 3.59799365153615016266e-2, 3.44289899924628486886e-1, -5.35327393233902768720e-1 };
 
         /// <summary> Chebyshev coefficients for exp(x) sqrt(x) K0(x)
         /// in the inverted interval [2, infinity].
         /// 
         /// lim(x->inf){ exp(x) sqrt(x) K0(x) } = sqrt(pi/2).
         /// </summary>
-        private static readonly double[] BesselK0B = new[] { 5.30043377268626276149e-18, -1.64758043015242134646e-17, 5.21039150503902756861e-17, -1.67823109680541210385e-16, 5.51205597852431940784e-16, -1.84859337734377901440e-15, 6.34007647740507060557e-15, -2.22751332699166985548e-14, 8.03289077536357521100e-14, -2.98009692317273043925e-13, 1.14034058820847496303e-12, -4.51459788337394416547e-12, 1.85594911495471785253e-11, -7.95748924447710747776e-11, 3.57739728140030116597e-10, -1.69753450938905987466e-9, 8.57403401741422608519e-9, -4.66048989768794782956e-8, 2.76681363944501510342e-7, -1.83175552271911948767e-6, 1.39498137188764993662e-5, -1.28495495816278026384e-4, 1.56988388573005337491e-3, -3.14481013119645005427e-2, 2.44030308206595545468e0 };
+        private static readonly double[] BesselK0B = { 5.30043377268626276149e-18, -1.64758043015242134646e-17, 5.21039150503902756861e-17, -1.67823109680541210385e-16, 5.51205597852431940784e-16, -1.84859337734377901440e-15, 6.34007647740507060557e-15, -2.22751332699166985548e-14, 8.03289077536357521100e-14, -2.98009692317273043925e-13, 1.14034058820847496303e-12, -4.51459788337394416547e-12, 1.85594911495471785253e-11, -7.95748924447710747776e-11, 3.57739728140030116597e-10, -1.69753450938905987466e-9, 8.57403401741422608519e-9, -4.66048989768794782956e-8, 2.76681363944501510342e-7, -1.83175552271911948767e-6, 1.39498137188764993662e-5, -1.28495495816278026384e-4, 1.56988388573005337491e-3, -3.14481013119645005427e-2, 2.44030308206595545468e0 };
 
         /// <summary>
         /// **************************************
@@ -123,14 +123,14 @@ namespace MathNet.Numerics
         /// 
         /// lim(x->0){ x(K1(x) - log(x/2) I1(x)) } = 1.
         /// </summary>
-        private static readonly double[] BesselK1A = new[] { -7.02386347938628759343e-18, -2.42744985051936593393e-15, -6.66690169419932900609e-13, -1.41148839263352776110e-10, -2.21338763073472585583e-8, -2.43340614156596823496e-6, -1.73028895751305206302e-4, -6.97572385963986435018e-3, -1.22611180822657148235e-1, -3.53155960776544875667e-1, 1.52530022733894777053e0 };
+        private static readonly double[] BesselK1A = { -7.02386347938628759343e-18, -2.42744985051936593393e-15, -6.66690169419932900609e-13, -1.41148839263352776110e-10, -2.21338763073472585583e-8, -2.43340614156596823496e-6, -1.73028895751305206302e-4, -6.97572385963986435018e-3, -1.22611180822657148235e-1, -3.53155960776544875667e-1, 1.52530022733894777053e0 };
 
         /// <summary> Chebyshev coefficients for exp(x) sqrt(x) K1(x)
         /// in the interval [2, infinity].
         ///
         /// lim(x->inf){ exp(x) sqrt(x) K1(x) } = sqrt(pi/2).
         /// </summary>
-        private static readonly double[] BesselK1B = new[] { -5.75674448366501715755e-18, 1.79405087314755922667e-17, -5.68946255844285935196e-17, 1.83809354436663880070e-16, -6.05704724837331885336e-16, 2.03870316562433424052e-15, -7.01983709041831346144e-15, 2.47715442448130437068e-14, -8.97670518232499435011e-14, 3.34841966607842919884e-13, -1.28917396095102890680e-12, 5.13963967348173025100e-12, -2.12996783842756842877e-11, 9.21831518760500529508e-11, -4.19035475934189648750e-10, 2.01504975519703286596e-9, -1.03457624656780970260e-8, 5.74108412545004946722e-8, -3.50196060308781257119e-7, 2.40648494783721712015e-6, -1.93619797416608296024e-5, 1.95215518471351631108e-4, -2.85781685962277938680e-3, 1.03923736576817238437e-1, 2.72062619048444266945e0 };
+        private static readonly double[] BesselK1B = { -5.75674448366501715755e-18, 1.79405087314755922667e-17, -5.68946255844285935196e-17, 1.83809354436663880070e-16, -6.05704724837331885336e-16, 2.03870316562433424052e-15, -7.01983709041831346144e-15, 2.47715442448130437068e-14, -8.97670518232499435011e-14, 3.34841966607842919884e-13, -1.28917396095102890680e-12, 5.13963967348173025100e-12, -2.12996783842756842877e-11, 9.21831518760500529508e-11, -4.19035475934189648750e-10, 2.01504975519703286596e-9, -1.03457624656780970260e-8, 5.74108412545004946722e-8, -3.50196060308781257119e-7, 2.40648494783721712015e-6, -1.93619797416608296024e-5, 1.95215518471351631108e-4, -2.85781685962277938680e-3, 1.03923736576817238437e-1, 2.72062619048444266945e0 };
 
         /// <summary>Returns the modified Bessel function of first kind, order 0 of the argument.
         /// <p/>

src/Numerics/Statistics/DescriptiveStatistics.cs

@@ -41,24 +41,6 @@ namespace MathNet.Numerics.Statistics
     /// </summary>
     public class DescriptiveStatistics
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DescriptiveStatistics"/> class.
-        /// </summary>
-        /// <param name="data">The sample data.</param>
-        public DescriptiveStatistics(IEnumerable<double> data)
-            : this(data, false)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DescriptiveStatistics"/> class.
-        /// </summary>
-        /// <param name="data">The sample data.</param>
-        public DescriptiveStatistics(IEnumerable<double?> data)
-            : this(data, false)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="DescriptiveStatistics"/> class. 
         /// </summary>
@@ -71,7 +53,7 @@ namespace MathNet.Numerics.Statistics
         /// Don't use increased accuracy for data sets containing large values (in absolute value).
         /// This may cause the calculations to overflow.
         /// </remarks>
-        public DescriptiveStatistics(IEnumerable<double> data, bool increasedAccuracy)
+        public DescriptiveStatistics(IEnumerable<double> data, bool increasedAccuracy = false)
         {
             if (data == null)
             {
@@ -100,7 +82,7 @@ namespace MathNet.Numerics.Statistics
         /// Don't use increased accuracy for data sets containing large values (in absolute value).
         /// This may cause the calculations to overflow.
         /// </remarks>
-        public DescriptiveStatistics(IEnumerable<double?> data, bool increasedAccuracy)
+        public DescriptiveStatistics(IEnumerable<double?> data, bool increasedAccuracy = false)
         {
             if (data == null)
             {

src/Numerics/Statistics/Histogram.cs

@@ -86,14 +86,7 @@ namespace MathNet.Numerics.Statistics
         /// <summary>
         /// Initializes a new instance of the Bucket class.
         /// </summary>
-        public Bucket(double lowerBound, double upperBound) : this(lowerBound, upperBound, 0.0)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the Bucket class.
-        /// </summary>
-        public Bucket(double lowerBound, double upperBound, double count)
+        public Bucket(double lowerBound, double upperBound, double count = 0.0)
         {
             if (lowerBound > upperBound)
             {

src/Numerics/Statistics/MCMC/HybridMC.cs

@@ -72,22 +72,6 @@ namespace MathNet.Numerics.Statistics.Mcmc
             }
         }
 
-        /// <summary>
-        /// Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution.
-        /// The burn interval will be set to 0.
-        /// The components of the momentum will be sampled from a normal distribution with standard deviation
-        /// 1 using the default <see cref="System.Random"/> random
-        /// number generator. A three point estimation will be used for differentiation.
-        /// </summary>
-        /// <param name="x0">The initial sample.</param>
-        /// <param name="pdfLnP">The log density of the distribution we want to sample from.</param>
-        /// <param name="frogLeapSteps">Number frogleap simulation steps.</param>
-        /// <param name="stepSize">Size of the frogleap simulation steps.</param>
-        public HybridMC(double[] x0, DensityLn<double[]> pdfLnP, int frogLeapSteps, double stepSize)
-            : this(x0, pdfLnP, frogLeapSteps, stepSize, 0)
-        {
-        }
-
         /// <summary>
         /// Constructs a new Hybrid Monte Carlo sampler for a multivariate probability distribution.
         /// The components of the momentum will be sampled from a normal distribution with standard deviation
@@ -101,7 +85,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// <param name="stepSize">Size of the frogleap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <exception cref="ArgumentOutOfRangeException">When the number of burnInterval iteration is negative.</exception>
-        public HybridMC(double[] x0, DensityLn<double[]> pdfLnP, int frogLeapSteps, double stepSize, int burnInterval)
+        public HybridMC(double[] x0, DensityLn<double[]> pdfLnP, int frogLeapSteps, double stepSize, int burnInterval = 0)
             : this(x0, pdfLnP, frogLeapSteps, stepSize, burnInterval, new double[x0.Count()], new Random(), Grad)
         {
             for (int i = 0; i < _length; i++)

src/Numerics/Statistics/MCMC/MetropolisHastingsSampler.cs

@@ -76,19 +76,6 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </summary>
         private int _burnInterval;
 
-        /// <summary>
-        /// Constructs a new Metropolis-Hastings sampler using the default <see cref="System.Random"/> random
-        /// number generator. The burn interval will be set to 0.
-        /// </summary>
-        /// <param name="x0">The initial sample.</param>
-        /// <param name="pdfLnP">The log density of the distribution we want to sample from.</param>
-        /// <param name="krnlQ">The log transition probability for the proposal distribution.</param>
-        /// <param name="proposal">A method that samples from the proposal distribution.</param>
-        public MetropolisHastingsSampler(T x0, DensityLn<T> pdfLnP, TransitionKernelLn<T> krnlQ, LocalProposalSampler<T> proposal)
-            : this(x0, pdfLnP, krnlQ, proposal, 0)
-        {
-        }
-
         /// <summary>
         /// Constructs a new Metropolis-Hastings sampler using the default <see cref="System.Random"/> random number generator. This
         /// constructor will set the burn interval.
@@ -99,7 +86,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// <param name="proposal">A method that samples from the proposal distribution.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <exception cref="ArgumentOutOfRangeException">When the number of burnInterval iteration is negative.</exception>
-        public MetropolisHastingsSampler(T x0, DensityLn<T> pdfLnP, TransitionKernelLn<T> krnlQ, LocalProposalSampler<T> proposal, int burnInterval)
+        public MetropolisHastingsSampler(T x0, DensityLn<T> pdfLnP, TransitionKernelLn<T> krnlQ, LocalProposalSampler<T> proposal, int burnInterval = 0)
         {
             _current = x0;
             _currentDensityLn = pdfLnP(x0);

src/Numerics/Statistics/MCMC/MetropolisSampler.cs

@@ -70,18 +70,6 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </summary>
         private int _burnInterval;
 
-        /// <summary>
-        /// Constructs a new Metropolis sampler using the default <see cref="System.Random"/> random
-        /// number generator. The burnInterval interval will be set to 0.
-        /// </summary>
-        /// <param name="x0">The initial sample.</param>
-        /// <param name="pdfLnP">The log density of the distribution we want to sample from.</param>
-        /// <param name="proposal">A method that samples from the symmetric proposal distribution.</param>
-        public MetropolisSampler(T x0, DensityLn<T> pdfLnP, LocalProposalSampler<T> proposal)
-            : this(x0, pdfLnP, proposal, 0)
-        {
-        }
-
         /// <summary>
         /// Constructs a new Metropolis sampler using the default <see cref="System.Random"/> random number generator.
         /// </summary>
@@ -90,7 +78,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// <param name="proposal">A method that samples from the symmetric proposal distribution.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <exception cref="ArgumentOutOfRangeException">When the number of burnInterval iteration is negative.</exception>
-        public MetropolisSampler(T x0, DensityLn<T> pdfLnP, LocalProposalSampler<T> proposal, int burnInterval)
+        public MetropolisSampler(T x0, DensityLn<T> pdfLnP, LocalProposalSampler<T> proposal, int burnInterval = 0)
         {
             _current = x0;
             _currentDensityLn = pdfLnP(x0);

src/Numerics/Statistics/MCMC/UnivariateHybridMC.cs

@@ -68,40 +68,6 @@ namespace MathNet.Numerics.Statistics.Mcmc
             }
         }
 
-        /// <summary>
-        /// Constructs a new Hybrid Monte Carlo sampler for a univariate probability distribution.
-        /// The burn interval will be set to 0.
-        /// The momentum will be sampled from a normal distribution with standard deviation
-        /// 1 using the default <see cref="System.Random"/> random
-        /// number generator. A three point estimation will be used for differentiation.
-        /// </summary>
-        /// <param name="x0">The initial sample.</param>
-        /// <param name="pdfLnP">The log density of the distribution we want to sample from.</param>
-        /// <param name="frogLeapSteps">Number frogleap simulation steps.</param>
-        /// <param name="stepSize">Size of the frogleap simulation steps.</param>
-        public UnivariateHybridMC(double x0, DensityLn<double> pdfLnP, int frogLeapSteps, double stepSize)
-            : this(x0, pdfLnP, frogLeapSteps, stepSize, 0)
-        {
-        }
-
-        /// <summary>
-        /// Constructs a new Hybrid Monte Carlo sampler for a univariate probability distribution.
-        /// The momentum will be sampled from a normal distribution with standard deviation
-        /// 1 using the default <see cref="System.Random"/> random
-        /// number generator. A three point estimation will be used for differentiation.
-        /// This constructor will set the burn interval.
-        /// </summary>
-        /// <param name="x0">The initial sample.</param>
-        /// <param name="pdfLnP">The log density of the distribution we want to sample from.</param>
-        /// <param name="frogLeapSteps">Number frogleap simulation steps.</param>
-        /// <param name="stepSize">Size of the frogleap simulation steps.</param>
-        /// <param name="burnInterval">The number of iterations in between returning samples.</param>
-        /// <exception cref="ArgumentOutOfRangeException">When the number of burnInterval iteration is negative.</exception>
-        public UnivariateHybridMC(double x0, DensityLn<double> pdfLnP, int frogLeapSteps, double stepSize, int burnInterval)
-            : this(x0, pdfLnP, frogLeapSteps, stepSize, burnInterval, 1)
-        {
-        }
-
         /// <summary>
         /// Constructs a new Hybrid Monte Carlo sampler for a univariate probability distribution.
         /// The momentum will be sampled from a normal distribution with standard deviation
@@ -117,7 +83,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// <param name="pSdv">The standard deviation of the normal distribution that is used to sample
         /// the momentum.</param>
         /// <exception cref="ArgumentOutOfRangeException">When the number of burnInterval iteration is negative.</exception>
-        public UnivariateHybridMC(double x0, DensityLn<double> pdfLnP, int frogLeapSteps, double stepSize, int burnInterval, double pSdv)
+        public UnivariateHybridMC(double x0, DensityLn<double> pdfLnP, int frogLeapSteps, double stepSize, int burnInterval = 0, double pSdv = 1)
             : this(x0, pdfLnP, frogLeapSteps, stepSize, burnInterval, pSdv, new Random())
         {
         }