Fix typos

src/Numerics/Complex32.cs

@@ -1167,9 +1167,9 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Implicit conversion of a unsgined real short to a <c>Complex32</c>.
+        /// Implicit conversion of a unsigned real short to a <c>Complex32</c>.
         /// </summary>
-        /// <param name="value">The unsgined short value to convert.</param>
+        /// <param name="value">The unsigned short value to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [CLSCompliant(false)]
         public static implicit operator Complex32(ushort value)

src/Numerics/Complex64.cs

@@ -838,9 +838,9 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Implicit conversion of a unsgined real short to a <c>Complex</c>.
+        /// Implicit conversion of a unsigned real short to a <c>Complex</c>.
         /// </summary>
-        /// <param name="value">The unsgined short value to convert.</param>
+        /// <param name="value">The unsigned short value to convert.</param>
         /// <returns>The result of the conversion.</returns>
         [CLSCompliant(false)]
         public static implicit operator Complex(ushort value)

src/Numerics/ComplexExtensions.cs

@@ -48,7 +48,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets the squared magnitude of the <c>Complex</c> number.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex32"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex32"/> number to perform this operation on.</param>
         /// <returns>The squared magnitude of the <c>Complex</c> number.</returns>
         public static double MagnitudeSquared(this Complex32 complex)
         {
@@ -58,7 +58,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets the squared magnitude of the <c>Complex</c> number.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>The squared magnitude of the <c>Complex</c> number.</returns>
         public static double MagnitudeSquared(this Complex complex)
         {
@@ -104,7 +104,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets the conjugate of the <c>Complex</c> number.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <remarks>
         /// The semantic of <i>setting the conjugate</i> is such that
         /// <code>
@@ -136,7 +136,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Exponential of this <c>Complex</c> (exp(x), E^x).
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         /// The exponential of this complex number.
         /// </returns>
@@ -149,7 +149,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Natural Logarithm of this <c>Complex</c> (Base E).
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         /// The natural logarithm of this complex number.
         /// </returns>
@@ -182,7 +182,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Raise this <c>Complex</c> to the given value.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <param name="exponent">
         /// The exponent.
         /// </param>
@@ -219,7 +219,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Raise this <c>Complex</c> to the inverse of the given value.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <param name="rootExponent">
         /// The root exponent.
         /// </param>
@@ -234,7 +234,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// The Square (power 2) of this <c>Complex</c>
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         /// The square of this complex number.
         /// </returns>
@@ -251,7 +251,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// The Square Root (power 1/2) of this <c>Complex</c>
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         /// The square root of this complex number.
         /// </returns>
@@ -324,7 +324,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets a value indicating whether the <c>Complex32</c> is zero.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns><c>true</c> if this instance is zero; otherwise, <c>false</c>.</returns>
         public static bool IsZero(this Complex complex)
         {
@@ -334,7 +334,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets a value indicating whether the <c>Complex32</c> is one.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns><c>true</c> if this instance is one; otherwise, <c>false</c>.</returns>
         public static bool IsOne(this Complex complex)
         {
@@ -345,7 +345,7 @@ namespace MathNet.Numerics
         /// Gets a value indicating whether the <c>Complex32</c> is the imaginary unit.
         /// </summary>
         /// <returns><c>true</c> if this instance is ImaginaryOne; otherwise, <c>false</c>.</returns>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         public static bool IsImaginaryOne(this Complex complex)
         {
             return complex.Real == 0.0 && complex.Imaginary == 1.0;
@@ -355,7 +355,7 @@ namespace MathNet.Numerics
         /// Gets a value indicating whether the provided <c>Complex32</c>evaluates
         /// to a value that is not a number.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         /// <c>true</c> if this instance is <c>NaN</c>; otherwise,
         /// <c>false</c>.
@@ -369,7 +369,7 @@ namespace MathNet.Numerics
         /// Gets a value indicating whether the provided <c>Complex32</c> evaluates to an
         /// infinite value.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         ///     <c>true</c> if this instance is infinite; otherwise, <c>false</c>.
         /// </returns>
@@ -385,7 +385,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets a value indicating whether the provided <c>Complex32</c> is real.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns><c>true</c> if this instance is a real number; otherwise, <c>false</c>.</returns>
         public static bool IsReal(this Complex complex)
         {
@@ -395,7 +395,7 @@ namespace MathNet.Numerics
         /// <summary>
         /// Gets a value indicating whether the provided <c>Complex32</c> is real and not negative, that is &gt;= 0.
         /// </summary>
-        /// <param name="complex">The <see cref="Complex"/> number to perfom this operation on.</param>
+        /// <param name="complex">The <see cref="Complex"/> number to perform this operation on.</param>
         /// <returns>
         ///     <c>true</c> if this instance is real nonnegative number; otherwise, <c>false</c>.
         /// </returns>

src/Numerics/Constants.cs

@@ -287,7 +287,7 @@ namespace MathNet.Numerics
         /// <summary>Classical Electron Radius: [m] (2007 CODATA)</summary>
         public const double ClassicalElectronRadius = 2.8179402894e-15;
 
-        /// <summary>Tomson Cross Section: [m^2] (2002 CODATA)</summary>
+        /// <summary>Thomson Cross Section: [m^2] (2002 CODATA)</summary>
         public const double ThomsonCrossSection = 0.6652458558e-28;
 
         /// <summary>Electron Magnetic Moment: [J T^-1] (2007 CODATA)</summary>
@@ -462,4 +462,4 @@ namespace MathNet.Numerics
         public const double Yocto = 1e-24;
         #endregion
     }
-}
+}

src/Numerics/Control.cs

@@ -260,7 +260,7 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Gets or sets the fourier transform provider. Consider to use UseNativeMKL or UseManaged instead.
+        /// Gets or sets the Fourier transform provider. Consider to use UseNativeMKL or UseManaged instead.
         /// </summary>
         /// <value>The linear algebra provider.</value>
         public static IFourierTransformProvider FourierTransformProvider
@@ -313,7 +313,7 @@ namespace MathNet.Numerics
         public static TaskScheduler TaskScheduler { get; set; }
 
         /// <summary>
-        /// Gets or sets the the block size to use for
+        /// Gets or sets the block size to use for
         /// the native linear algebra provider.
         /// </summary>
         /// <value>The block size. Default 512, must be at least 32.</value>

src/Numerics/Differentiation/FiniteDifferenceCoefficients.cs

@@ -95,7 +95,7 @@ namespace MathNet.Numerics.Differentiation
         /// Gets the finite difference coefficients for all orders at a specified center.
         /// </summary>
         /// <param name="center">Current function position with respect to coefficients. Must be within point range.</param>
-        /// <returns>Rectangular array of coefficients, with columns specifing order.</returns>
+        /// <returns>Rectangular array of coefficients, with columns specifying order.</returns>
         public double[,] GetCoefficientsForAllOrders(int center)
         {
             if (center >= _coefficients.Length)

src/Numerics/Differentiation/NumericalDerivative.cs

@@ -53,7 +53,7 @@ namespace MathNet.Numerics.Differentiation
         /// <summary>
         /// A base step size value, eps (typically machine precision), is scaled according to the finite difference coefficient order
         /// and function input parameter. The initial scaling according to finite different coefficient order can be thought of as producing a
-        /// base step size, h, that is equivalent to <see cref="RelativeX"/> scaling. This stepsize is then scaled according to the function
+        /// base step size, h, that is equivalent to <see cref="RelativeX"/> scaling. This step size is then scaled according to the function
         /// input parameter. Although implementation may vary, an example of second order accurate scaling may be (eps)^(1/3)*(1+abs(x)).
         /// </summary>
         Relative
@@ -101,7 +101,7 @@ namespace MathNet.Numerics.Differentiation
         }
 
         /// <summary>
-        /// Sets and gets the finite difference step size. This value is for each function evaluation if relative stepsize types are used.
+        /// Sets and gets the finite difference step size. This value is for each function evaluation if relative step size types are used.
         /// If the base step size used in scaling is desired, see <see cref="Epsilon"/>.
         /// </summary>
         /// <remarks>
@@ -120,7 +120,7 @@ namespace MathNet.Numerics.Differentiation
         }
 
         /// <summary>
-        /// Sets and gets the base fininte difference step size. This assigned value to this parameter is only used if <see cref="StepType"/> is set to RelativeX.
+        /// Sets and gets the base finite difference step size. This assigned value to this parameter is only used if <see cref="StepType"/> is set to RelativeX.
         /// However, if the StepType is Relative, it will contain the base step size computed from <see cref="Epsilon"/> based on the finite difference order.
         /// </summary>
         public double BaseStepSize

src/Numerics/Differentiation/NumericalHessian.cs

@@ -77,7 +77,7 @@ namespace MathNet.Numerics.Differentiation
         /// Evaluates the Hessian of a multivariate function f at points x.
         /// </summary>
         /// <remarks>
-        /// This method of computing the Hessian is only vaid for Lipschitz continuous functions.
+        /// This method of computing the Hessian is only valid for Lipschitz continuous functions.
         /// The function mirrors the Hessian along the diagonal since d2f/dxdy = d2f/dydx for continuously differentiable functions.
         /// </remarks>
         /// <param name="f">Multivariate function handle.></param>

src/Numerics/Distributions/Erlang.cs

@@ -36,7 +36,7 @@ namespace MathNet.Numerics.Distributions
 {
     /// <summary>
     /// Continuous Univariate Erlang distribution.
-    /// This distribution is is a continuous probability distribution with wide applicability primarily due to its
+    /// This distribution is a continuous probability distribution with wide applicability primarily due to its
     /// relation to the exponential and Gamma distributions.
     /// <a href="http://en.wikipedia.org/wiki/Erlang_distribution">Wikipedia - Erlang distribution</a>.
     /// </summary>

src/Numerics/Exceptions.cs

@@ -57,7 +57,7 @@ namespace MathNet.Numerics
     }
 
     /// <summary>
-    /// An error occured calling native provider function.
+    /// An error occurred calling native provider function.
     /// </summary>
     [Serializable]
     public abstract class NativeInterfaceException : Exception
@@ -84,7 +84,7 @@ namespace MathNet.Numerics
     }
 
     /// <summary>
-    /// An error occured calling native provider function.
+    /// An error occurred calling native provider function.
     /// </summary>
     [Serializable]
     public class InvalidParameterException : NativeInterfaceException
@@ -112,7 +112,7 @@ namespace MathNet.Numerics
     }
 
     /// <summary>
-    /// Native provider was unable to allocate sufficent memory.
+    /// Native provider was unable to allocate sufficient memory.
     /// </summary>
     [Serializable]
     public class MemoryAllocationException : NativeInterfaceException

src/Numerics/Integrate.cs

@@ -70,7 +70,7 @@ namespace MathNet.Numerics
         /// <param name="invervalEndA">Where the interval ends for the first (inside) integral, exclusive and finite.</param>
         /// <param name="invervalBeginB">Where the interval starts for the second (outside) integral, exclusive and finite.</param>
         /// /// <param name="invervalEndB">Where the interval ends for the second (outside) integral, exclusive and finite.</param>
-        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.</param>
+        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.</param>
         /// <returns>Approximation of the finite integral in the given interval.</returns>
         public static double OnRectangle(Func<double, double, double> f, double invervalBeginA, double invervalEndA, double invervalBeginB, double invervalEndB, int order)
         {

src/Numerics/Integration/DoubleExponentialTransformation.cs

@@ -115,7 +115,7 @@ namespace MathNet.Numerics.Integration
                 double arg = offset + t;
                 t += step;
 
-                // TODO: reuse abcissas as computed in EvaluateAbcissas
+                // TODO: reuse abscissas as computed in EvaluateAbcissas
                 double abcissa = Math.Tanh(Constants.PiOver2*Math.Sinh(arg));
                 weights[i] = Constants.PiOver2*(1 - (abcissa*abcissa))*Math.Cosh(arg);
             }
@@ -123,7 +123,7 @@ namespace MathNet.Numerics.Integration
             return weights;
         }
 
-        #region Precomputed Abcissas and Weights
+        #region Precomputed Abscissas and Weights
 
         /// <summary>
         /// Precomputed abscissa vector per level.

src/Numerics/Integration/GaussLegendreRule.cs

@@ -33,7 +33,7 @@ using MathNet.Numerics.Integration.GaussRule;
 namespace MathNet.Numerics.Integration
 {
     /// <summary>
-    /// Approximates a definite integral using an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.
+    /// Approximates a definite integral using an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.
     /// </summary>
     public class GaussLegendreRule
     {
@@ -44,7 +44,7 @@ namespace MathNet.Numerics.Integration
         /// </summary>
         /// <param name="intervalBegin">Where the interval starts, inclusive and finite.</param>
         /// <param name="intervalEnd">Where the interval stops, inclusive and finite.</param>
-        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.</param>
+        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.</param>
         public GaussLegendreRule(double intervalBegin, double intervalEnd, int order)
         {
             _gaussLegendrePoint = GaussLegendrePointFactory.GetGaussPoint(intervalBegin, intervalEnd, order);
@@ -131,7 +131,7 @@ namespace MathNet.Numerics.Integration
         /// <param name="f">The analytic smooth function to integrate.</param>
         /// <param name="invervalBegin">Where the interval starts, exclusive and finite.</param>
         /// <param name="invervalEnd">Where the interval ends, exclusive and finite.</param>
-        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.</param>
+        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.</param>
         /// <returns>Approximation of the finite integral in the given interval.</returns>
         public static double Integrate(Func<double, double> f, double invervalBegin, double invervalEnd, int order)
         {
@@ -174,7 +174,7 @@ namespace MathNet.Numerics.Integration
         /// <param name="invervalEndA">Where the interval ends for the first (inside) integral, exclusive and finite.</param>
         /// <param name="invervalBeginB">Where the interval starts for the second (outside) integral, exclusive and finite.</param>
         /// /// <param name="invervalEndB">Where the interval ends for the second (outside) integral, exclusive and finite.</param>
-        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.</param>
+        /// <param name="order">Defines an Nth order Gauss-Legendre rule. The order also defines the number of abscissas and weights for the rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.</param>
         /// <returns>Approximation of the finite integral in the given interval.</returns>
         public static double Integrate(Func<double, double, double> f, double invervalBeginA, double invervalEndA, double invervalBeginB, double invervalEndB, int order)
         {

src/Numerics/Integration/GaussRule/GaussLegendrePointFactory.cs

@@ -42,7 +42,7 @@ namespace MathNet.Numerics.Integration.GaussRule
         /// <summary>
         /// Getter for the GaussPoint.
         /// </summary>
-        /// <param name="order">Defines an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.</param>
+        /// <param name="order">Defines an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.</param>
         /// <returns>Object containing the non-negative abscissas/weights, order, and intervalBegin/intervalEnd. The non-negative abscissas/weights are generated over the interval [-1,1] for the given order.</returns>
         public static GaussPoint GetGaussPoint(int order)
         {
@@ -65,7 +65,7 @@ namespace MathNet.Numerics.Integration.GaussRule
         /// </summary>
         /// <param name="intervalBegin">Where the interval starts, inclusive and finite.</param>
         /// <param name="intervalEnd">Where the interval stops, inclusive and finite.</param>
-        /// <param name="order">Defines an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calulcated on the fly.</param>
+        /// <param name="order">Defines an Nth order Gauss-Legendre rule. Precomputed Gauss-Legendre abscissas/weights for orders 2-20, 32, 64, 96, 100, 128, 256, 512, 1024 are used, otherwise they're calculated on the fly.</param>
         /// <returns>Object containing the abscissas/weights, order, and intervalBegin/intervalEnd.</returns>
         public static GaussPoint GetGaussPoint(double intervalBegin, double intervalEnd, int order)
         {

src/Numerics/Interpolate.cs

@@ -59,7 +59,7 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Create a floater hormann rational pole-free interpolation based on arbitrary points.
+        /// Create a Floater-Hormann rational pole-free interpolation based on arbitrary points.
         /// </summary>
         /// <param name="points">The sample points t.</param>
         /// <param name="values">The sample point values x(t).</param>

src/Numerics/Interpolation/CubicSpline.cs

@@ -73,7 +73,7 @@ namespace MathNet.Numerics.Interpolation
         }
 
         /// <summary>
-        /// Create a hermite cubic spline interpolation from a set of (x,y) value pairs and their slope (first derivative), sorted ascendingly by x.
+        /// Create a Hermite cubic spline interpolation from a set of (x,y) value pairs and their slope (first derivative), sorted ascendingly by x.
         /// </summary>
         public static CubicSpline InterpolateHermiteSorted(double[] x, double[] y, double[] firstDerivatives)
         {
@@ -105,7 +105,7 @@ namespace MathNet.Numerics.Interpolation
         }
 
         /// <summary>
-        /// Create a hermite cubic spline interpolation from an unsorted set of (x,y) value pairs and their slope (first derivative).
+        /// Create a Hermite cubic spline interpolation from an unsorted set of (x,y) value pairs and their slope (first derivative).
         /// WARNING: Works in-place and can thus causes the data array to be reordered.
         /// </summary>
         public static CubicSpline InterpolateHermiteInplace(double[] x, double[] y, double[] firstDerivatives)
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.Interpolation
         }
 
         /// <summary>
-        /// Create a hermite cubic spline interpolation from an unsorted set of (x,y) value pairs and their slope (first derivative).
+        /// Create a Hermite cubic spline interpolation from an unsorted set of (x,y) value pairs and their slope (first derivative).
         /// </summary>
         public static CubicSpline InterpolateHermite(IEnumerable<double> x, IEnumerable<double> y, IEnumerable<double> firstDerivatives)
         {

src/Numerics/LinearAlgebra/Complex/DenseMatrix.cs

@@ -1264,7 +1264,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public override bool IsHermitian()
         {

src/Numerics/LinearAlgebra/Complex/DiagonalMatrix.cs

@@ -1012,7 +1012,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public sealed override bool IsHermitian()
         {

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

@@ -43,8 +43,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     /// Eigenvalues and eigenvectors of a complex matrix.
     /// </summary>
     /// <remarks>
-    /// If A is hermitan, then A = V*D*V' where the eigenvalue matrix D is
-    /// diagonal and the eigenvector matrix V is hermitan.
+    /// If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is
+    /// diagonal and the eigenvector matrix V is Hermitian.
     /// I.e. A = V*D*V' and V*VH=I.
     /// If A is not symmetric, then the eigenvalue matrix D is block diagonal
     /// with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
@@ -103,7 +103,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         }
 
         /// <summary>
-        /// Reduces a complex hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
+        /// Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
         /// </summary>
         /// <param name="matrixA">Source matrix to reduce</param>
         /// <param name="d">Output: Arrays for internal storage of real parts of eigenvalues</param>

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

@@ -48,7 +48,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix
+    /// If a <seealso cref="QRMethod.Full"/> factorization is performed, the resulting Q matrix is an m x m matrix
     /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
     /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>

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

@@ -43,8 +43,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
     /// Eigenvalues and eigenvectors of a complex matrix.
     /// </summary>
     /// <remarks>
-    /// If A is hermitan, then A = V*D*V' where the eigenvalue matrix D is
-    /// diagonal and the eigenvector matrix V is hermitan.
+    /// If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is
+    /// diagonal and the eigenvector matrix V is Hermitian.
     /// I.e. A = V*D*V' and V*VH=I.
     /// If A is not symmetric, then the eigenvalue matrix D is block diagonal
     /// with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
@@ -73,7 +73,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
             var order = matrix.RowCount;
 
-            // Initialize matricies for eigenvalues and eigenvectors
+            // Initialize matrices for eigenvalues and eigenvectors
             var eigenVectors = DenseMatrix.CreateIdentity(order);
             var blockDiagonal = Matrix<Complex>.Build.SameAs(matrix, order, order);
             var eigenValues = new DenseVector(order);
@@ -126,7 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         }
 
         /// <summary>
-        /// Reduces a complex hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
+        /// Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
         /// </summary>
         /// <param name="matrixA">Source matrix to reduce</param>
         /// <param name="d">Output: Arrays for internal storage of real parts of eigenvalues</param>

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

@@ -357,11 +357,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays. On
-                // completion the variables kase and l are set as follows.
-                // Kase = 1     if VectorS[m] and e[l-1] are negligible and l < m
-                // Kase = 2     if VectorS[l] is negligible and l < m
-                // Kase = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
-                // Лase = 4     if e[m-1] is negligible (convergence).
+                // completion the variables case and l are set as follows.
+                // Case = 1     if VectorS[m] and e[l-1] are negligible and l < m
+                // Case = 2     if VectorS[l] is negligible and l < m
+                // Case = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
+                // Case = 4     if e[m-1] is negligible (convergence).
                 double ztest;
                 double test;
                 for (l = m - 2; l >= 0; l--)
@@ -421,7 +421,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 double f;
                 double cs;
@@ -667,7 +667,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
+        /// Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>

src/Numerics/LinearAlgebra/Complex/Matrix.cs

@@ -797,7 +797,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public override bool IsHermitian()
         {

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

@@ -588,11 +588,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Sort vector descending, not changing vector but placing sorted indicies to <paramref name="sortedIndices"/>
+        /// Sort vector descending, not changing vector but placing sorted indices to <paramref name="sortedIndices"/>
         /// </summary>
         /// <param name="lowerBound">Start sort form</param>
         /// <param name="upperBound">Sort till upper bound</param>
-        /// <param name="sortedIndices">Array with sorted vector indicies</param>
+        /// <param name="sortedIndices">Array with sorted vector indices</param>
         /// <param name="values">Source <see cref="Vector"/></param>
         static void FindLargestItems(int lowerBound, int upperBound, int[] sortedIndices, Vector<Complex> values)
         {
@@ -742,11 +742,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Build heap for double indicies
+        /// Build heap for double indices
         /// </summary>
         /// <param name="start">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector{T}"/></param>
         private static void BuildDoubleIndexHeap(int start, int count, int[] sortedIndices, Vector<Complex> values)
         {
@@ -758,9 +758,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Sift double indicies
+        /// Sift double indices
         /// </summary>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector{T}"/></param>
         /// <param name="begin">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>

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

@@ -45,7 +45,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
     /// A simple milu(0) preconditioner.
     /// </summary>
     /// <remarks>
-    /// Original Fortran code by Youcef Saad (07 January 2004)
+    /// Original Fortran code by Yousef Saad (07 January 2004)
     /// </remarks>
     public sealed class MILU0Preconditioner : IPreconditioner<Complex>
     {

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

@@ -56,7 +56,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
     /// The algorithm was taken from: <br/>
     /// ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors
     /// <br/>
-    /// Man-chung Yeung and Tony F. Chan
+    /// Man-Chung Yeung and Tony F. Chan
     /// <br/>
     /// SIAM Journal of Scientific Computing
     /// <br/>
@@ -206,7 +206,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Create random vecrors array
+        /// Create random vectors array
         /// </summary>
         /// <param name="arraySize">Number of vectors</param>
         /// <param name="vectorSize">Size of each vector</param>

src/Numerics/LinearAlgebra/Complex/SparseMatrix.cs

@@ -1274,7 +1274,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public override bool IsHermitian()
         {

src/Numerics/LinearAlgebra/Complex/SparseVector.cs

@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
                     vnonZeroValues[indices[j]] = values[j] + scalar;
                 }
 
-                //assign this vectors arrary to the new arrays.
+                //assign this vectors array to the new arrays.
                 _storage.Values = vnonZeroValues;
                 _storage.Indices = vnonZeroIndices;
                 _storage.ValueCount = Count;

src/Numerics/LinearAlgebra/Complex32/DenseMatrix.cs

@@ -1261,7 +1261,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public override bool IsHermitian()
         {

src/Numerics/LinearAlgebra/Complex32/DiagonalMatrix.cs

@@ -1006,7 +1006,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public sealed override bool IsHermitian()
         {

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

@@ -44,8 +44,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     /// Eigenvalues and eigenvectors of a complex matrix.
     /// </summary>
     /// <remarks>
-    /// If A is hermitan, then A = V*D*V' where the eigenvalue matrix D is
-    /// diagonal and the eigenvector matrix V is hermitan.
+    /// If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is
+    /// diagonal and the eigenvector matrix V is Hermitian.
     /// I.e. A = V*D*V' and V*VH=I.
     /// If A is not symmetric, then the eigenvalue matrix D is block diagonal
     /// with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
@@ -104,7 +104,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         }
 
         /// <summary>
-        /// Reduces a complex hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
+        /// Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
         /// </summary>
         /// <param name="matrixA">Source matrix to reduce</param>
         /// <param name="d">Output: Arrays for internal storage of real parts of eigenvalues</param>

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

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix
+    /// If a <seealso cref="QRMethod.Full"/> factorization is performed, the resulting Q matrix is an m x m matrix
     /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
     /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>

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

@@ -42,8 +42,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
     /// Eigenvalues and eigenvectors of a complex matrix.
     /// </summary>
     /// <remarks>
-    /// If A is hermitan, then A = V*D*V' where the eigenvalue matrix D is
-    /// diagonal and the eigenvector matrix V is hermitan.
+    /// If A is Hermitian, then A = V*D*V' where the eigenvalue matrix D is
+    /// diagonal and the eigenvector matrix V is Hermitian.
     /// I.e. A = V*D*V' and V*VH=I.
     /// If A is not symmetric, then the eigenvalue matrix D is block diagonal
     /// with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues,
@@ -72,7 +72,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
             var order = matrix.RowCount;
 
-            // Initialize matricies for eigenvalues and eigenvectors
+            // Initialize matrices for eigenvalues and eigenvectors
             var eigenVectors = DenseMatrix.CreateIdentity(order);
             var blockDiagonal = Matrix<Complex32>.Build.SameAs(matrix, order, order);
             var eigenValues = new LinearAlgebra.Complex.DenseVector(order);
@@ -128,7 +128,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         }
 
         /// <summary>
-        /// Reduces a complex hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
+        /// Reduces a complex Hermitian matrix to a real symmetric tridiagonal matrix using unitary similarity transformations.
         /// </summary>
         /// <param name="matrixA">Source matrix to reduce</param>
         /// <param name="d">Output: Arrays for internal storage of real parts of eigenvalues</param>

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

@@ -352,11 +352,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays. On
-                // completion the variables kase and l are set as follows.
-                // Kase = 1     if VectorS[m] and e[l-1] are negligible and l < m
-                // Kase = 2     if VectorS[l] is negligible and l < m
-                // Kase = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
-                // Лase = 4     if e[m-1] is negligible (convergence).
+                // completion the variables case and l are set as follows.
+                // Case = 1     if VectorS[m] and e[l-1] are negligible and l < m
+                // Case = 2     if VectorS[l] is negligible and l < m
+                // Case = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
+                // Case = 4     if e[m-1] is negligible (convergence).
                 float ztest;
                 float test;
                 for (l = m - 2; l >= 0; l--)
@@ -416,7 +416,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 float f;
                 float sn;
@@ -662,7 +662,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
+        /// Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>

src/Numerics/LinearAlgebra/Complex32/Matrix.cs

@@ -792,7 +792,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public override bool IsHermitian()
         {

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

@@ -583,11 +583,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Sort vector descending, not changing vector but placing sorted indicies to <paramref name="sortedIndices"/>
+        /// Sort vector descending, not changing vector but placing sorted indices to <paramref name="sortedIndices"/>
         /// </summary>
         /// <param name="lowerBound">Start sort form</param>
         /// <param name="upperBound">Sort till upper bound</param>
-        /// <param name="sortedIndices">Array with sorted vector indicies</param>
+        /// <param name="sortedIndices">Array with sorted vector indices</param>
         /// <param name="values">Source <see cref="Vector"/></param>
         static void FindLargestItems(int lowerBound, int upperBound, int[] sortedIndices, Vector<Complex32> values)
         {
@@ -737,11 +737,11 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Build heap for double indicies
+        /// Build heap for double indices
         /// </summary>
         /// <param name="start">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector"/></param>
         private static void BuildDoubleIndexHeap(int start, int count, int[] sortedIndices, Vector<Complex32> values)
         {
@@ -753,9 +753,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Sift double indicies
+        /// Sift double indices
         /// </summary>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector"/></param>
         /// <param name="begin">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>

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

@@ -40,7 +40,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
     /// A simple milu(0) preconditioner.
     /// </summary>
     /// <remarks>
-    /// Original Fortran code by Youcef Saad (07 January 2004)
+    /// Original Fortran code by Yousef Saad (07 January 2004)
     /// </remarks>
     public sealed class MILU0Preconditioner : IPreconditioner<Complex32>
     {

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

@@ -49,7 +49,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
     /// The algorithm was taken from: <br/>
     /// ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors
     /// <br/>
-    /// Man-chung Yeung and Tony F. Chan
+    /// Man-Chung Yeung and Tony F. Chan
     /// <br/>
     /// SIAM Journal of Scientific Computing
     /// <br/>

src/Numerics/LinearAlgebra/Complex32/SparseMatrix.cs

@@ -1268,7 +1268,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public override bool IsHermitian()
         {

src/Numerics/LinearAlgebra/Complex32/SparseVector.cs

@@ -168,7 +168,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
                     vnonZeroValues[indices[j]] = values[j] + scalar;
                 }
 
-                //assign this vectors arrary to the new arrays.
+                //assign this vectors array to the new arrays.
                 _storage.Values = vnonZeroValues;
                 _storage.Indices = vnonZeroIndices;
                 _storage.ValueCount = Count;

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

@@ -73,7 +73,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
             var order = matrix.RowCount;
 
-            // Initialize matricies for eigenvalues and eigenvectors
+            // Initialize matrices for eigenvalues and eigenvectors
             var eigenVectors = Matrix<double>.Build.SameAs(matrix, order, order, fullyMutable: true);
             var blockDiagonal = Matrix<double>.Build.SameAs(matrix, order, order);
             var eigenValues = new LinearAlgebra.Complex.DenseVector(order);

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

@@ -336,11 +336,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays. On
-                // completion the variables kase and l are set as follows.
-                // Kase = 1     if VectorS[m] and e[l-1] are negligible and l < m
-                // Kase = 2     if VectorS[l] is negligible and l < m
-                // Kase = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
-                // Лase = 4     if e[m-1] is negligible (convergence).
+                // completion the variables case and l are set as follows.
+                // Case = 1     if VectorS[m] and e[l-1] are negligible and l < m
+                // Case = 2     if VectorS[l] is negligible and l < m
+                // Case = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
+                // Case = 4     if e[m-1] is negligible (convergence).
                 double ztest;
                 double test;
                 for (l = m - 2; l >= 0; l--)
@@ -400,7 +400,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 double f;
                 double sn;
@@ -645,7 +645,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
+        /// Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>

src/Numerics/LinearAlgebra/Double/Matrix.cs

@@ -762,7 +762,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public sealed override bool IsHermitian()
         {

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

@@ -581,11 +581,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Sort vector descending, not changing vector but placing sorted indicies to <paramref name="sortedIndices"/>
+        /// Sort vector descending, not changing vector but placing sorted indices to <paramref name="sortedIndices"/>
         /// </summary>
         /// <param name="lowerBound">Start sort form</param>
         /// <param name="upperBound">Sort till upper bound</param>
-        /// <param name="sortedIndices">Array with sorted vector indicies</param>
+        /// <param name="sortedIndices">Array with sorted vector indices</param>
         /// <param name="values">Source <see cref="Vector"/></param>
         static void FindLargestItems(int lowerBound, int upperBound, int[] sortedIndices, Vector<double> values)
         {
@@ -735,11 +735,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Build heap for double indicies
+        /// Build heap for double indices
         /// </summary>
         /// <param name="start">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector"/></param>
         private static void BuildDoubleIndexHeap(int start, int count, int[] sortedIndices, Vector<double> values)
         {
@@ -751,9 +751,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Sift double indicies
+        /// Sift double indices
         /// </summary>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector"/></param>
         /// <param name="begin">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>

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

@@ -38,7 +38,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
     /// A simple milu(0) preconditioner.
     /// </summary>
     /// <remarks>
-    /// Original Fortran code by Youcef Saad (07 January 2004)
+    /// Original Fortran code by Yousef Saad (07 January 2004)
     /// </remarks>
     public sealed class MILU0Preconditioner : IPreconditioner<double>
     {

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

@@ -49,7 +49,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
     /// The algorithm was taken from: <br/>
     /// ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors
     /// <br/>
-    /// Man-chung Yeung and Tony F. Chan
+    /// Man-Chung Yeung and Tony F. Chan
     /// <br/>
     /// SIAM Journal of Scientific Computing
     /// <br/>
@@ -199,7 +199,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Create random vecrors array
+        /// Create random vectors array
         /// </summary>
         /// <param name="arraySize">Number of vectors</param>
         /// <param name="vectorSize">Size of each vector</param>

src/Numerics/LinearAlgebra/Matrix.Arithmetic.cs

@@ -1568,7 +1568,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// <param name="f">Function which takes two matrices, modifies the second in place and returns void</param>
         /// <param name="other">The other matrix to be passed to the function as argument. It is not modified</param>
         /// <returns>The resulting matrix</returns>
-        /// <exception cref="ArgumentException">If this amtrix and <paramref name="other"/> are not the same dimension.</exception>
+        /// <exception cref="ArgumentException">If this matrix and <paramref name="other"/> are not the same dimension.</exception>
         protected Matrix<T> PointwiseBinary(Action<Matrix<T>, Matrix<T>> f, Matrix<T> other)
         {
             if (ColumnCount != other.ColumnCount || RowCount != other.RowCount)

src/Numerics/LinearAlgebra/Matrix.Operators.cs

@@ -135,7 +135,7 @@ namespace MathNet.Numerics.LinearAlgebra
         }
 
         /// <summary>
-        /// Substracts each element of a matrix from a scalar.
+        /// Subtracts each element of a matrix from a scalar.
         /// </summary>
         /// <remarks>This operator will allocate new memory for the result. It will
         /// choose the representation of the provided matrix.</remarks>

src/Numerics/LinearAlgebra/Matrix.cs

@@ -1278,7 +1278,7 @@ namespace MathNet.Numerics.LinearAlgebra
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public abstract bool IsHermitian();
 

src/Numerics/LinearAlgebra/Options.cs

@@ -73,7 +73,7 @@ namespace MathNet.Numerics.LinearAlgebra
         Symmetric = 1,
 
         /// <summary>
-        /// A matrix is hermitian (conjugate symmetric).
+        /// A matrix is Hermitian (conjugate symmetric).
         /// </summary>
         Hermitian = 2,
 

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

@@ -41,7 +41,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
     /// </summary>
     /// <remarks>
     /// The computation of the QR decomposition is done at construction time by Householder transformation.
-    /// If a <seealso cref="QRMethod.Full"/> factorization is peformed, the resulting Q matrix is an m x m matrix
+    /// If a <seealso cref="QRMethod.Full"/> factorization is performed, the resulting Q matrix is an m x m matrix
     /// and the R matrix is an m x n matrix. If a <seealso cref="QRMethod.Thin"/> factorization is performed, the
     /// resulting Q matrix is an m x n matrix and the R matrix is an n x n matrix.
     /// </remarks>

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

@@ -72,7 +72,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
             var order = matrix.RowCount;
 
-            // Initialize matricies for eigenvalues and eigenvectors
+            // Initialize matrices for eigenvalues and eigenvectors
             var eigenVectors = Matrix<float>.Build.SameAs(matrix, order, order, fullyMutable: true);
             var blockDiagonal = Matrix<float>.Build.SameAs(matrix, order, order);
             var eigenValues = new LinearAlgebra.Complex.DenseVector(order);

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

@@ -336,11 +336,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays. On
-                // completion the variables kase and l are set as follows.
-                // Kase = 1     if VectorS[m] and e[l-1] are negligible and l < m
-                // Kase = 2     if VectorS[l] is negligible and l < m
-                // Kase = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
-                // Лase = 4     if e[m-1] is negligible (convergence).
+                // completion the variables case and l are set as follows.
+                // Case = 1     if VectorS[m] and e[l-1] are negligible and l < m
+                // Case = 2     if VectorS[l] is negligible and l < m
+                // Case = 3     if e[l-1] is negligible, l < m, and VectorS[l, ..., VectorS[m] are not negligible (qr step).
+                // Case = 4     if e[m-1] is negligible (convergence).
                 float ztest;
                 float test;
                 for (l = m - 2; l >= 0; l--)
@@ -400,7 +400,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 float f;
                 float sn;
@@ -645,7 +645,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Factorization
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s
+        /// Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>

src/Numerics/LinearAlgebra/Single/Matrix.cs

@@ -763,7 +763,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         }
 
         /// <summary>
-        /// Evaluates whether this matrix is hermitian (conjugate symmetric).
+        /// Evaluates whether this matrix is Hermitian (conjugate symmetric).
         /// </summary>
         public sealed override bool IsHermitian()
         {

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

@@ -581,11 +581,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         }
 
         /// <summary>
-        /// Sort vector descending, not changing vector but placing sorted indicies to <paramref name="sortedIndices"/>
+        /// Sort vector descending, not changing vector but placing sorted indices to <paramref name="sortedIndices"/>
         /// </summary>
         /// <param name="lowerBound">Start sort form</param>
         /// <param name="upperBound">Sort till upper bound</param>
-        /// <param name="sortedIndices">Array with sorted vector indicies</param>
+        /// <param name="sortedIndices">Array with sorted vector indices</param>
         /// <param name="values">Source <see cref="Vector"/></param>
         static void FindLargestItems(int lowerBound, int upperBound, int[] sortedIndices, Vector<float> values)
         {
@@ -735,11 +735,11 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         }
 
         /// <summary>
-        /// Build heap for double indicies
+        /// Build heap for double indices
         /// </summary>
         /// <param name="start">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector"/></param>
         private static void BuildDoubleIndexHeap(int start, int count, int[] sortedIndices, Vector<float> values)
         {
@@ -751,9 +751,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         }
 
         /// <summary>
-        /// Sift double indicies
+        /// Sift double indices
         /// </summary>
-        /// <param name="sortedIndices">Indicies of <paramref name="values"/></param>
+        /// <param name="sortedIndices">Indices of <paramref name="values"/></param>
         /// <param name="values">Target <see cref="Vector"/></param>
         /// <param name="begin">Root position</param>
         /// <param name="count">Length of <paramref name="values"/></param>

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

@@ -38,7 +38,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
     /// A simple milu(0) preconditioner.
     /// </summary>
     /// <remarks>
-    /// Original Fortran code by Youcef Saad (07 January 2004)
+    /// Original Fortran code by Yousef Saad (07 January 2004)
     /// </remarks>
     public sealed class MILU0Preconditioner : IPreconditioner<float>
     {

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

@@ -48,7 +48,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
     /// The algorithm was taken from: <br/>
     /// ML(k)BiCGSTAB: A BiCGSTAB variant based on multiple Lanczos starting vectors
     /// <br/>
-    /// Man-chung Yeung and Tony F. Chan
+    /// Man-Chung Yeung and Tony F. Chan
     /// <br/>
     /// SIAM Journal of Scientific Computing
     /// <br/>

src/Numerics/LinearAlgebra/Single/SparseVector.cs

@@ -168,7 +168,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
                     vnonZeroValues[indices[j]] = values[j] + scalar;
                 }
 
-                //assign this vectors arrary to the new arrays.
+                //assign this vectors array to the new arrays.
                 _storage.Values = vnonZeroValues;
                 _storage.Indices = vnonZeroIndices;
                 _storage.ValueCount = Count;

src/Numerics/LinearAlgebra/Storage/SparseVectorStorage.cs

@@ -83,7 +83,7 @@ namespace MathNet.Numerics.LinearAlgebra.Storage
         /// </summary>
         public override T At(int index)
         {
-            // Search if item idex exists in NonZeroIndices array in range "0 - nonzero values count"
+            // Search if item index exists in NonZeroIndices array in range "0 - nonzero values count"
             var itemIndex = Array.BinarySearch(Indices, 0, ValueCount, index);
             return itemIndex >= 0 ? Values[itemIndex] : Zero;
         }

src/Numerics/LinearAlgebra/Vector.Arithmetic.cs

@@ -431,7 +431,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// Subtracts another vector from this vector.
         /// </summary>
         /// <param name="other">The vector to subtract from this one.</param>
-        /// <returns>A new vector containing the subtraction of the the two vectors.</returns>
+        /// <returns>A new vector containing the subtraction of the two vectors.</returns>
         /// <exception cref="ArgumentException">If this vector and <paramref name="other"/> are not the same size.</exception>
         public Vector<T> Subtract(Vector<T> other)
         {

src/Numerics/LinearAlgebra/Vector.BCL.cs

@@ -353,9 +353,9 @@ namespace MathNet.Numerics.LinearAlgebra
         /// Returns a string that represents the content of this vector, column by column.
         /// </summary>
         /// <param name="maxPerColumn">Maximum number of entries and thus lines per column. Typical value: 12; Minimum: 3.</param>
-        /// <param name="maxCharactersWidth">Maximum number of chatacters per line over all columns. Typical value: 80; Minimum: 16.</param>
+        /// <param name="maxCharactersWidth">Maximum number of characters per line over all columns. Typical value: 80; Minimum: 16.</param>
         /// <param name="ellipsis">Character to use to print if there is not enough space to print all entries. Typical value: "..".</param>
-        /// <param name="columnSeparator">Character to use to separate two coluns on a line. Typical value: "  " (2 spaces).</param>
+        /// <param name="columnSeparator">Character to use to separate two columns on a line. Typical value: "  " (2 spaces).</param>
         /// <param name="rowSeparator">Character to use to separate two rows/lines. Typical value: Environment.NewLine.</param>
         /// <param name="formatValue">Function to provide a string for any given entry value.</param>
         public string ToVectorString(int maxPerColumn, int maxCharactersWidth, string ellipsis, string columnSeparator, string rowSeparator, Func<T, string> formatValue)
@@ -369,7 +369,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// Returns a string that represents the content of this vector, column by column.
         /// </summary>
         /// <param name="maxPerColumn">Maximum number of entries and thus lines per column. Typical value: 12; Minimum: 3.</param>
-        /// <param name="maxCharactersWidth">Maximum number of chatacters per line over all columns. Typical value: 80; Minimum: 16.</param>
+        /// <param name="maxCharactersWidth">Maximum number of characters per line over all columns. Typical value: 80; Minimum: 16.</param>
         /// <param name="format">Floating point format string. Can be null. Default value: G6.</param>
         /// <param name="provider">Format provider or culture. Can be null.</param>
         public string ToVectorString(int maxPerColumn, int maxCharactersWidth, string format = null, IFormatProvider provider = null)
@@ -401,7 +401,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// Returns a string that summarizes this vector, column by column and with a type header.
         /// </summary>
         /// <param name="maxPerColumn">Maximum number of entries and thus lines per column. Typical value: 12; Minimum: 3.</param>
-        /// <param name="maxCharactersWidth">Maximum number of chatacters per line over all columns. Typical value: 80; Minimum: 16.</param>
+        /// <param name="maxCharactersWidth">Maximum number of characters per line over all columns. Typical value: 80; Minimum: 16.</param>
         /// <param name="format">Floating point format string. Can be null. Default value: G6.</param>
         /// <param name="provider">Format provider or culture. Can be null.</param>
         public string ToString(int maxPerColumn, int maxCharactersWidth, string format = null, IFormatProvider provider = null)

src/Numerics/LinearAlgebra/Vector.Operators.cs

@@ -120,7 +120,7 @@ namespace MathNet.Numerics.LinearAlgebra
         }
 
         /// <summary>
-        /// Substracts each element of a vector from a scalar.
+        /// Subtracts each element of a vector from a scalar.
         /// </summary>
         /// <param name="leftSide">The scalar value to subtract from.</param>
         /// <param name="rightSide">The vector to subtract.</param>

src/Numerics/LinearAlgebra/Vector.cs

@@ -205,7 +205,7 @@ namespace MathNet.Numerics.LinearAlgebra
         /// Copies the values of a given vector into a region in this vector.
         /// </summary>
         /// <param name="index">The field to start copying to</param>
-        /// <param name="count">The number of fields to cpy. Must be positive.</param>
+        /// <param name="count">The number of fields to copy. Must be positive.</param>
         /// <param name="subVector">The sub-vector to copy from.</param>
         /// <exception cref="ArgumentNullException">If <paramref name="subVector"/> is <see langword="null" /></exception>
         public void SetSubVector(int index, int count, Vector<T> subVector)

src/Numerics/Optimization/BfgsMinimizer.cs

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.Optimization
         /// </summary>
         /// <param name="gradientTolerance">The gradient tolerance</param>
         /// <param name="parameterTolerance">The parameter tolerance</param>
-        /// <param name="functionProgressTolerance">The funciton progress tolerance</param>
+        /// <param name="functionProgressTolerance">The function progress tolerance</param>
         /// <param name="maximumIterations">The maximum number of iterations</param>
         public BfgsMinimizer(double gradientTolerance, double parameterTolerance, double functionProgressTolerance, int maximumIterations=1000)
             :base(gradientTolerance,parameterTolerance,functionProgressTolerance,maximumIterations)

src/Numerics/Optimization/LineSearch/WeakWolfeLineSearch.cs

@@ -33,7 +33,7 @@ using MathNet.Numerics.LinearAlgebra;
 namespace MathNet.Numerics.Optimization.LineSearch
 {
     /// <summary>
-    /// Search for a step size alpha that satisfies the weak wolfe conditions. The weak Wolfe
+    /// Search for a step size alpha that satisfies the weak Wolfe conditions. The weak Wolfe
     /// Conditions are
     /// i)  Armijo Rule:         f(x_k + alpha_k p_k) &lt;= f(x_k) + c1 alpha_k p_k^T g(x_k)
     /// ii) Curvature Condition: p_k^T g(x_k + alpha_k p_k) &gt;= c2 p_k^T g(x_k)

src/Numerics/Optimization/MinimizerBase.cs

@@ -48,7 +48,7 @@ namespace MathNet.Numerics.Optimization
         /// </summary>
         /// <param name="gradientTolerance">The gradient tolerance</param>
         /// <param name="parameterTolerance">The parameter tolerance</param>
-        /// <param name="functionProgressTolerance">The funciton progress tolerance</param>
+        /// <param name="functionProgressTolerance">The function progress tolerance</param>
         /// <param name="maximumIterations">The maximum number of iterations</param>
         protected MinimizerBase(double gradientTolerance, double parameterTolerance, double functionProgressTolerance, int maximumIterations)
         {

src/Numerics/Optimization/NelderMeadSimplex.cs

@@ -27,7 +27,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
-// Converted from code relased with a MIT liscense available at https://code.google.com/p/nelder-mead-simplex/
+// Converted from code released with a MIT license available at https://code.google.com/p/nelder-mead-simplex/
 
 using MathNet.Numerics.LinearAlgebra;
 using System;
@@ -55,12 +55,12 @@ namespace MathNet.Numerics.Optimization
         }
 
         /// <summary>
-        /// Finds the minimum of the objective function without an intial pertubation, the default values used
+        /// Finds the minimum of the objective function without an initial perturbation, the default values used
         /// by fminsearch() in Matlab are used instead
         /// http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11
         /// </summary>
         /// <param name="objectiveFunction">The objective function, no gradient or hessian needed</param>
-        /// <param name="initialGuess">The intial guess</param>
+        /// <param name="initialGuess">The initial guess</param>
         /// <returns>The minimum point</returns>
         public MinimizationResult FindMinimum(IObjectiveFunction objectiveFunction, Vector<double> initialGuess)
         {
@@ -68,11 +68,11 @@ namespace MathNet.Numerics.Optimization
         }
 
         /// <summary>
-        /// Finds the minimum of the objective function with an intial pertubation
+        /// Finds the minimum of the objective function with an initial perturbation
         /// </summary>
         /// <param name="objectiveFunction">The objective function, no gradient or hessian needed</param>
-        /// <param name="initialGuess">The intial guess</param>
-        /// <param name="initalPertubation">The inital pertubation</param>
+        /// <param name="initialGuess">The initial guess</param>
+        /// <param name="initalPertubation">The initial perturbation</param>
         /// <returns>The minimum point</returns>
         public MinimizationResult FindMinimum(IObjectiveFunction objectiveFunction, Vector<double> initialGuess, Vector<double> initalPertubation)
         {
@@ -80,12 +80,12 @@ namespace MathNet.Numerics.Optimization
         }
 
         /// <summary>
-        /// Finds the minimum of the objective function without an intial pertubation, the default values used
+        /// Finds the minimum of the objective function without an initial perturbation, the default values used
         /// by fminsearch() in Matlab are used instead
         /// http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11
         /// </summary>
         /// <param name="objectiveFunction">The objective function, no gradient or hessian needed</param>
-        /// <param name="initialGuess">The intial guess</param>
+        /// <param name="initialGuess">The initial guess</param>
         /// <returns>The minimum point</returns>
         public static MinimizationResult Minimum(IObjectiveFunction objectiveFunction, Vector<double> initialGuess, double convergenceTolerance=1e-8, int maximumIterations=1000)
         {
@@ -98,11 +98,11 @@ namespace MathNet.Numerics.Optimization
         }
 
         /// <summary>
-        /// Finds the minimum of the objective function with an intial pertubation
+        /// Finds the minimum of the objective function with an initial perturbation
         /// </summary>
         /// <param name="objectiveFunction">The objective function, no gradient or hessian needed</param>
-        /// <param name="initialGuess">The intial guess</param>
-        /// <param name="initalPertubation">The inital pertubation</param>
+        /// <param name="initialGuess">The initial guess</param>
+        /// <param name="initalPertubation">The initial perturbation</param>
         /// <returns>The minimum point</returns>
         public static MinimizationResult Minimum(IObjectiveFunction objectiveFunction, Vector<double> initialGuess, Vector<double> initalPertubation, double convergenceTolerance=1e-8, int maximumIterations=1000)
         {

src/Numerics/Precision.Equality.cs

@@ -258,7 +258,7 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Checks whether two Compex numbers are almost equal.
+        /// Checks whether two Complex numbers are almost equal.
         /// </summary>
         /// <param name="a">The first number</param>
         /// <param name="b">The second number</param>
@@ -269,7 +269,7 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Checks whether two Compex numbers are almost equal.
+        /// Checks whether two Complex numbers are almost equal.
         /// </summary>
         /// <param name="a">The first number</param>
         /// <param name="b">The second number</param>
@@ -302,7 +302,7 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Checks whether two Compex numbers are almost equal.
+        /// Checks whether two Complex numbers are almost equal.
         /// </summary>
         /// <param name="a">The first number</param>
         /// <param name="b">The second number</param>
@@ -313,7 +313,7 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Checks whether two Compex numbers are almost equal.
+        /// Checks whether two Complex numbers are almost equal.
         /// </summary>
         /// <param name="a">The first number</param>
         /// <param name="b">The second number</param>

src/Numerics/Providers/FourierTransform/Mkl/MklFourierTransformProvider.cs

@@ -72,7 +72,7 @@ namespace MathNet.Numerics.Providers.FourierTransform.Mkl
             int fftMinor = SafeNativeMethods.query_capability((int) ProviderCapability.FourierTransformMinor);
             if (!(fftMajor == 1 && fftMinor >= 0))
             {
-                throw new NotSupportedException(string.Format("MKL Native Provider not compatible. Expecting fourier transform v1 but provider implements v{0}.", fftMajor));
+                throw new NotSupportedException(string.Format("MKL Native Provider not compatible. Expecting Fourier transform v1 but provider implements v{0}.", fftMajor));
             }
         }
 

src/Numerics/Providers/LinearAlgebra/Cuda/CudaLinearAlgebraProvider.cs

@@ -88,7 +88,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Cuda
                     throw new ArgumentException("Invalid value");
 
                 case 8:  // CUBLAS_STATUS_ARCH_MISMATCH
-                    throw new NotSupportedException("The device does not support this opeation.");
+                    throw new NotSupportedException("The device does not support this operation.");
 
                 case 11: // CUBLAS_STATUS_MAPPING_ERROR
                     throw new Exception("Mapping error.");

src/Numerics/Providers/LinearAlgebra/ILinearAlgebraProvider.cs

@@ -438,10 +438,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         void EigenDecomp(bool isSymmetric, int order, T[] matrix, T[] matrixEv, Complex[] vectorEv, T[] matrixD);
     }
 }

src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs

@@ -2400,11 +2400,11 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays,
-                // on completion the variables kase and l are set as follows:
-                // kase = 1: if mS[m] and e[l-1] are negligible and l < m
-                // kase = 2: if mS[l] is negligible and l < m
-                // kase = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
-                // kase = 4: if e[m-1] is negligible (convergence).
+                // on completion the variables case and l are set as follows:
+                // case = 1: if mS[m] and e[l-1] are negligible and l < m
+                // case = 2: if mS[l] is negligible and l < m
+                // case = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
+                // case = 4: if e[m-1] is negligible (convergence).
                 double ztest;
                 double test;
                 for (l = m - 2; l >= 0; l--)
@@ -2464,7 +2464,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 double f;
                 double cs;
@@ -2827,10 +2827,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public virtual void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs

@@ -2400,11 +2400,11 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays,
-                // on completion the variables kase and l are set as follows:
-                // kase = 1: if mS[m] and e[l-1] are negligible and l < m
-                // kase = 2: if mS[l] is negligible and l < m
-                // kase = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
-                // kase = 4: if e[m-1] is negligible (convergence).
+                // on completion the variables case and l are set as follows:
+                // case = 1: if mS[m] and e[l-1] are negligible and l < m
+                // case = 2: if mS[l] is negligible and l < m
+                // case = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
+                // case = 4: if e[m-1] is negligible (convergence).
                 float ztest;
                 float test;
                 for (l = m - 2; l >= 0; l--)
@@ -2464,7 +2464,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 float f;
                 float sn;
@@ -2827,10 +2827,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public virtual void EigenDecomp(bool isSymmetric, int order, Complex32[] matrix, Complex32[] matrixEv, Complex[] vectorEv, Complex32[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs

@@ -2287,11 +2287,11 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays,
-                // on completion the variables kase and l are set as follows:
-                // kase = 1: if mS[m] and e[l-1] are negligible and l < m
-                // kase = 2: if mS[l] is negligible and l < m
-                // kase = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
-                // kase = 4: if e[m-1] is negligible (convergence).
+                // on completion the variables case and l are set as follows:
+                // case = 1: if mS[m] and e[l-1] are negligible and l < m
+                // case = 2: if mS[l] is negligible and l < m
+                // case = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
+                // case = 4: if e[m-1] is negligible (convergence).
                 double ztest;
                 double test;
                 for (l = m - 2; l >= 0; l--)
@@ -2351,7 +2351,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 double f;
                 double cs;
@@ -2772,10 +2772,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public virtual void EigenDecomp(bool isSymmetric, int order, double[] matrix, double[] matrixEv, Complex[] vectorEv, double[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs

@@ -2292,11 +2292,11 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
                 }
 
                 // This section of the program inspects for negligible elements in the s and e arrays,
-                // on completion the variables kase and l are set as follows:
-                // kase = 1: if mS[m] and e[l-1] are negligible and l < m
-                // kase = 2: if mS[l] is negligible and l < m
-                // kase = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
-                // kase = 4: if e[m-1] is negligible (convergence).
+                // on completion the variables case and l are set as follows:
+                // case = 1: if mS[m] and e[l-1] are negligible and l < m
+                // case = 2: if mS[l] is negligible and l < m
+                // case = 3: if e[l-1] is negligible, l < m, and mS[l, ..., mS[m] are not negligible (qr step).
+                // case = 4: if e[m-1] is negligible (convergence).
                 double ztest;
                 double test;
                 for (l = m - 2; l >= 0; l--)
@@ -2356,7 +2356,7 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
 
                 l = l + 1;
 
-                // Perform the task indicated by kase.
+                // Perform the task indicated by case.
                 int k;
                 float f;
                 float cs;
@@ -2778,10 +2778,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public virtual void EigenDecomp(bool isSymmetric, int order, float[] matrix, float[] matrixEv, Complex[] vectorEv, float[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/Mkl/MklLinearAlgebraProvider.Complex.cs

@@ -1139,10 +1139,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Mkl
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/Mkl/MklLinearAlgebraProvider.Complex32.cs

@@ -1134,10 +1134,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Mkl
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, Complex32[] matrix, Complex32[] matrixEv, Complex[] vectorEv, Complex32[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/Mkl/MklLinearAlgebraProvider.Double.cs

@@ -1139,10 +1139,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Mkl
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, double[] matrix, double[] matrixEv, Complex[] vectorEv, double[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/Mkl/MklLinearAlgebraProvider.Single.cs

@@ -1134,10 +1134,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.Mkl
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, float[] matrix, float[] matrixEv, Complex[] vectorEv, float[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/OpenBlas/OpenBlasLinearAlgebraProvider.Complex.cs

@@ -959,10 +959,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.OpenBlas
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/OpenBlas/OpenBlasLinearAlgebraProvider.Complex32.cs

@@ -954,10 +954,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.OpenBlas
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, Complex32[] matrix, Complex32[] matrixEv, Complex[] vectorEv, Complex32[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/OpenBlas/OpenBlasLinearAlgebraProvider.Double.cs

@@ -959,10 +959,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.OpenBlas
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, double[] matrix, double[] matrixEv, Complex[] vectorEv, double[] matrixD)
         {
             if (matrix == null)

src/Numerics/Providers/LinearAlgebra/OpenBlas/OpenBlasLinearAlgebraProvider.Single.cs

@@ -954,10 +954,10 @@ namespace MathNet.Numerics.Providers.LinearAlgebra.OpenBlas
         /// </summary>
         /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param>
         /// <param name="order">The order of the matrix.</param>
-        /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param>
-        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param>
-        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param>
-        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param>
+        /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param>
+        /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param>
+        /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param>
+        /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param>
         public override void EigenDecomp(bool isSymmetric, int order, float[] matrix, float[] matrixEv, Complex[] vectorEv, float[] matrixD)
         {
             if (matrix == null)

src/Numerics/Random/RandomSource.cs

@@ -531,7 +531,7 @@ namespace MathNet.Numerics.Random
             // every bit with independent uniform distribution
             uint uint32 = BitConverter.ToUInt32(bytes, 0);
 
-            // the least significant N bits with independend uniform distribution and the remaining bits zero
+            // the least significant N bits with independent uniform distribution and the remaining bits zero
             uint uintN = uint32 >> (32 - bitCount);
             return (int)uintN;
         }
@@ -555,7 +555,7 @@ namespace MathNet.Numerics.Random
             // every bit with independent uniform distribution
             ulong uint64 = BitConverter.ToUInt64(bytes, 0);
 
-            // the least significant N bits with independend uniform distribution and the remaining bits zero
+            // the least significant N bits with independent uniform distribution and the remaining bits zero
             ulong uintN = uint64 >> (64 - bitCount);
             return (long)uintN;
         }

src/Numerics/RootFinding/Brent.cs

@@ -33,7 +33,7 @@ using MathNet.Numerics.Properties;
 namespace MathNet.Numerics.RootFinding
 {
     /// <summary>
-    /// Algorithm by by Brent, Van Wijngaarden, Dekker et al.
+    /// Algorithm by Brent, Van Wijngaarden, Dekker et al.
     /// Implementation inspired by Press, Teukolsky, Vetterling, and Flannery, "Numerical Recipes in C", 2nd edition, Cambridge University Press
     /// </summary>
     public static class Brent

src/Numerics/SpecialFunctions/Erf.cs

@@ -57,7 +57,7 @@ namespace MathNet.Numerics
         /// </summary>
         private static readonly double[] ErfImpAn = { 0.00337916709551257388990745, -0.00073695653048167948530905, -0.374732337392919607868241, 0.0817442448733587196071743, -0.0421089319936548595203468, 0.0070165709512095756344528, -0.00495091255982435110337458, 0.000871646599037922480317225 };
 
-        /// <summary> Polynomial coefficients for  adenominator of ErfImp
+        /// <summary> Polynomial coefficients for  a denominator of ErfImp
         /// calculation for Erf(x) in the interval [1e-10, 0.5].
         /// </summary>
         private static readonly double[] ErfImpAd = { 1, -0.218088218087924645390535, 0.412542972725442099083918, -0.0841891147873106755410271, 0.0655338856400241519690695, -0.0120019604454941768171266, 0.00408165558926174048329689, -0.000615900721557769691924509 };

src/Numerics/SpecialFunctions/ModifiedBessel.cs

@@ -50,7 +50,7 @@ namespace MathNet.Numerics
 // ReSharper restore CheckNamespace
 {
     /// <summary>
-    /// This partial implementation of the SpecialFunctions class contains all methods related to the modified bessel function.
+    /// This partial implementation of the SpecialFunctions class contains all methods related to the modified Bessel function.
     /// </summary>
     public static partial class SpecialFunctions
     {
@@ -139,7 +139,7 @@ namespace MathNet.Numerics
         /// (8, infinity). Chebyshev polynomial expansions are employed
         /// in each interval.
         /// </summary>
-        /// <param name="x">The value to compute the bessel function of.
+        /// <param name="x">The value to compute the Bessel function of.
         /// </param>
         public static double BesselI0(double x)
         {
@@ -167,7 +167,7 @@ namespace MathNet.Numerics
         /// (8, infinity). Chebyshev polynomial expansions are employed
         /// in each interval.
         /// </summary>
-        /// <param name="x">The value to compute the bessel function of.
+        /// <param name="x">The value to compute the Bessel function of.
         /// </param>
         public static double BesselI1(double x)
         {
@@ -198,7 +198,7 @@ namespace MathNet.Numerics
         /// (8, infinity). Chebyshev polynomial expansions are employed
         /// in each interval.
         /// </summary>
-        /// <param name="x">The value to compute the bessel function of.
+        /// <param name="x">The value to compute the Bessel function of.
         /// </param>
         public static double BesselK0(double x)
         {
@@ -220,7 +220,7 @@ namespace MathNet.Numerics
         /// <summary>Returns the exponentially scaled modified Bessel function
         /// of the second kind of order 0 of the argument.
         /// </summary>
-        /// <param name="x">The value to compute the bessel function of.
+        /// <param name="x">The value to compute the Bessel function of.
         /// </param>
         public static double BesselK0e(double x)
         {
@@ -246,7 +246,7 @@ namespace MathNet.Numerics
         /// (2, infinity). Chebyshev polynomial expansions are employed
         /// in each interval.
         /// </summary>
-        /// <param name="x">The value to compute the bessel function of.
+        /// <param name="x">The value to compute the Bessel function of.
         /// </param>
         public static double BesselK1(double x)
         {
@@ -271,7 +271,7 @@ namespace MathNet.Numerics
         /// <p/>
         /// <tt>k1e(x) = exp(x) * k1(x)</tt>.
         /// </summary>
-        /// <param name="x">The value to compute the bessel function of.
+        /// <param name="x">The value to compute the Bessel function of.
         /// </param>
         public static double BesselK1e(double x)
         {

src/Numerics/SpecialFunctions/ModifiedStruve.cs

@@ -50,7 +50,7 @@ namespace MathNet.Numerics
 // ReSharper restore CheckNamespace
 {
     /// <summary>
-    /// This partial implementation of the SpecialFunctions class contains all methods related to the modified bessel function.
+    /// This partial implementation of the SpecialFunctions class contains all methods related to the modified Bessel function.
     /// </summary>
     public static partial class SpecialFunctions
     {

src/Numerics/Statistics/ArrayStatistics.Single.cs

@@ -514,7 +514,7 @@ namespace MathNet.Numerics.Statistics
         /// <summary>
         /// Estimates the tau-th quantile from the unsorted data array.
         /// The tau-th quantile is the data value where the cumulative distribution
-        /// function crosses tau. The quantile defintion can be specified
+        /// function crosses tau. The quantile definition can be specified
         /// by 4 parameters a, b, c and d, consistent with Mathematica.
         /// WARNING: Works inplace and can thus causes the data array to be reordered.
         /// </summary>

src/Numerics/Statistics/ArrayStatistics.cs

@@ -524,7 +524,7 @@ namespace MathNet.Numerics.Statistics
         /// <summary>
         /// Estimates the tau-th quantile from the unsorted data array.
         /// The tau-th quantile is the data value where the cumulative distribution
-        /// function crosses tau. The quantile defintion can be specified
+        /// function crosses tau. The quantile definition can be specified
         /// by 4 parameters a, b, c and d, consistent with Mathematica.
         /// WARNING: Works inplace and can thus causes the data array to be reordered.
         /// </summary>

src/Numerics/Statistics/DescriptiveStatistics.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.Statistics
     /// This type declares a DataContract for out of the box ephemeral serialization
     /// with engines like DataContractSerializer, Protocol Buffers and FsPickler,
     /// but does not guarantee any compatibility between versions.
-    /// It is not recommended to rely on this mechanism for durable persistance.
+    /// It is not recommended to rely on this mechanism for durable persistence.
     /// </remarks>
     [DataContract(Namespace = "urn:MathNet/Numerics")]
     public class DescriptiveStatistics

src/Numerics/Statistics/Histogram.cs

@@ -43,7 +43,7 @@ namespace MathNet.Numerics.Statistics
     /// This type declares a DataContract for out of the box ephemeral serialization
     /// with engines like DataContractSerializer, Protocol Buffers and FsPickler,
     /// but does not guarantee any compatibility between versions.
-    /// It is not recommended to rely on this mechanism for durable persistance.
+    /// It is not recommended to rely on this mechanism for durable persistence.
     /// </remarks>
     [Serializable]
     [DataContract(Namespace = "urn:MathNet/Numerics")]
@@ -281,7 +281,7 @@ namespace MathNet.Numerics.Statistics
         /// Constructs a Histogram with a specific number of equally sized buckets. The upper and lower bound of the histogram
         /// will be set to the smallest and largest datapoint.
         /// </summary>
-        /// <param name="data">The datasequence to build a histogram on.</param>
+        /// <param name="data">The data sequence to build a histogram on.</param>
         /// <param name="nbuckets">The number of buckets to use.</param>
         public Histogram(IEnumerable<double> data, int nbuckets)
             : this()
@@ -317,7 +317,7 @@ namespace MathNet.Numerics.Statistics
         /// <summary>
         /// Constructs a Histogram with a specific number of equally sized buckets.
         /// </summary>
-        /// <param name="data">The datasequence to build a histogram on.</param>
+        /// <param name="data">The data sequence to build a histogram on.</param>
         /// <param name="nbuckets">The number of buckets to use.</param>
         /// <param name="lower">The histogram lower bound.</param>
         /// <param name="upper">The histogram upper bound.</param>

src/Numerics/Statistics/MCMC/HybridMC.cs

@@ -79,8 +79,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap 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 = 0)
@@ -101,8 +101,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="pSdv">The standard deviations of the normal distributions that are used to sample
         /// the components of the momentum.</param>
@@ -121,8 +121,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="pSdv">The standard deviations of the normal distributions that are used to sample
         /// the components of the momentum.</param>
@@ -141,8 +141,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="pSdv">The standard deviations of the normal distributions that are used to sample
         /// the components of the momentum.</param>

src/Numerics/Statistics/MCMC/HybridMCGeneric.cs

@@ -96,7 +96,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// <summary>
         /// Gets or sets the number of iterations in the Hamiltonian equation.
         /// </summary>
-        /// <exception cref="ArgumentOutOfRangeException">When frogleap steps is negative or zero.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">When frog leap steps is negative or zero.</exception>
         public int FrogLeapSteps
         {
             get { return _frogLeapSteps; }
@@ -124,8 +124,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="randomSource">Random number generator used for sampling the momentum.</param>
         /// <param name="diff">The method used for differentiation.</param>

src/Numerics/Statistics/MCMC/MetropolisHastingsSampler.cs

@@ -34,7 +34,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
     using Distributions;
 
     /// <summary>
-    /// Metropolis-Hastings sampling produces samples from distribition P by sampling from a proposal distribution Q
+    /// Metropolis-Hastings sampling produces samples from distribution P by sampling from a proposal distribution Q
     /// and accepting/rejecting based on the density of P. Metropolis-Hastings sampling doesn't require that the
     /// proposal distribution Q is symmetric in comparison to <seealso cref="MetropolisSampler{T}"/>. It does need to
     /// be able to evaluate the proposal sampler's log density though. All densities are required to be in log space.
@@ -158,4 +158,4 @@ namespace MathNet.Numerics.Statistics.Mcmc
             return _current;
         }
     }
-}
+}

src/Numerics/Statistics/MCMC/MetropolisSampler.cs

@@ -34,7 +34,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
     using Distributions;
 
     /// <summary>
-    /// Metropolis sampling produces samples from distribition P by sampling from a proposal distribution Q
+    /// Metropolis sampling produces samples from distribution P by sampling from a proposal distribution Q
     /// and accepting/rejecting based on the density of P. Metropolis sampling requires that the proposal
     /// distribution Q is symmetric. All densities are required to be in log space.
     ///
@@ -145,4 +145,4 @@ namespace MathNet.Numerics.Statistics.Mcmc
             return _current;
         }
     }
-}
+}

src/Numerics/Statistics/MCMC/RejectionSampler.cs

@@ -33,7 +33,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
     using Properties;
 
     /// <summary>
-    /// Rejection sampling produces samples from distribition P by sampling from a proposal distribution Q
+    /// Rejection sampling produces samples from distribution P by sampling from a proposal distribution Q
     /// and accepting/rejecting based on the density of P and Q. The density of P and Q don't need to
     /// to be normalized, but we do need that for each x, P(x) &lt; Q(x).
     /// </summary>
@@ -100,4 +100,4 @@ namespace MathNet.Numerics.Statistics.Mcmc
             }
         }
     }
-}
+}

src/Numerics/Statistics/MCMC/UnivariateHybridMC.cs

@@ -75,8 +75,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="pSdv">The standard deviation of the normal distribution that is used to sample
         /// the momentum.</param>
@@ -95,8 +95,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="pSdv">The standard deviation of the normal distribution that is used to sample
         /// the momentum.</param>
@@ -116,8 +116,8 @@ namespace MathNet.Numerics.Statistics.Mcmc
         /// </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="frogLeapSteps">Number frog leap simulation steps.</param>
+        /// <param name="stepSize">Size of the frog leap simulation steps.</param>
         /// <param name="burnInterval">The number of iterations in between returning samples.</param>
         /// <param name="pSdv">The standard deviation of the normal distribution that is used to sample
         /// the momentum.</param>

src/Numerics/Statistics/MCMC/UnivariateSliceSampler.cs

@@ -33,7 +33,7 @@ namespace MathNet.Numerics.Statistics.Mcmc
     using Properties;
 
     /// <summary>
-    /// Slice sampling produces samples from distribition P by uniformly sampling from under the pdf of P using
+    /// Slice sampling produces samples from distribution P by uniformly sampling from under the pdf of P using
     /// a technique described in "Slice Sampling", R. Neal, 2003. All densities are required to be in log space.
     ///
     /// The slice sampler is a stateful sampler. It keeps track of where it currently is in the domain

src/Numerics/Statistics/RunningStatistics.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.Statistics
     /// This type declares a DataContract for out of the box ephemeral serialization
     /// with engines like DataContractSerializer, Protocol Buffers and FsPickler,
     /// but does not guarantee any compatibility between versions.
-    /// It is not recommended to rely on this mechanism for durable persistance.
+    /// It is not recommended to rely on this mechanism for durable persistence.
     /// </remarks>
     [DataContract(Namespace = "urn:MathNet/Numerics")]
     public class RunningStatistics