LA: Vector construction consistent with matrix

src/Examples/LinearAlgebra/VectorInitialization.cs

@@ -66,13 +66,13 @@ namespace Examples.LinearAlgebraExamples
             var vector1 = new DenseVector(5);
 
             // 2. Initialize a new instance of the vector with a given size and each element set to the given value
-            var vector2 = new DenseVector(5, 3.0);
+            var vector2 = DenseVector.Create(5, i => 3.0);
 
             // 3. Initialize a new instance of the vector from an array.
             var vector3 = new DenseVector(new[] { 1.0, 2.0, 3.0, 4.0, 5.0 });
 
             // 4. Initialize a new instance of the vector by copying the values from another.
-            var vector4 = new DenseVector(vector3);
+            var vector4 = DenseVector.OfVector(vector3);
 
             // Format vector output to console
             var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();

src/Numerics/Distributions/Multivariate/MatrixNormal.cs

@@ -283,7 +283,7 @@ namespace MathNet.Numerics.Distributions
             var vki = v.KroneckerProduct(k.Inverse());
 
             // Sample a vector valued random variable with VKi as the covariance.
-            var vector = SampleVectorNormal(rnd, new DenseVector(n * p, 0.0), vki);
+            var vector = SampleVectorNormal(rnd, new DenseVector(n * p), vki);
 
             // Unstack the vector v and add the mean.
             var r = m.Clone();
@@ -323,7 +323,7 @@ namespace MathNet.Numerics.Distributions
             var count = mean.Count;
 
             // Sample a standard normal variable.
-            var v = new DenseVector(count, 0.0);
+            var v = new DenseVector(count);
             for (var d = 0; d < count; d += 2)
             {
                 var sample = Normal.SampleUncheckedBoxMuller(rnd);

src/Numerics/LinearAlgebra/Complex/DenseVector.cs

@@ -82,18 +82,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         }
 
         /// <summary>
-        /// Create a new dense vector with the given length.
-        /// All cells of the vector will be initialized with the provided value.
-        /// Zero-length vectors are not supported.
+        /// Create a new dense vector directly binding to a raw array.
+        /// The array is used directly without copying.
+        /// Very efficient, but changes to the array and the vector will affect each other.
         /// </summary>
-        /// <exception cref="ArgumentException">If length is less than one.</exception>
-        public DenseVector(int length, Complex value)
-            : this(length)
+        public DenseVector(Complex[] storage)
+            : this(new DenseVectorStorage<Complex>(storage.Length, storage))
         {
-            for (var index = 0; index < _values.Length; index++)
-            {
-                _values[index] = value;
-            }
         }
 
         /// <summary>
@@ -101,9 +96,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(Vector<Complex> other)
-            : this(DenseVectorStorage<Complex>.OfVector(other.Storage))
+        public static DenseVector OfVector(Vector<Complex> vector)
         {
+            return new DenseVector(DenseVectorStorage<Complex>.OfVector(vector.Storage));
         }
 
         /// <summary>
@@ -111,19 +106,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(IEnumerable<Complex> other)
-            : this(DenseVectorStorage<Complex>.OfEnumerable(other))
-        {
-        }
-
-        /// <summary>
-        /// Create a new dense vector directly binding to a raw array.
-        /// The array is used directly without copying.
-        /// Very efficient, but changes to the array and the vector will affect each other.
-        /// </summary>
-        public DenseVector(Complex[] storage)
-            : this(new DenseVectorStorage<Complex>(storage.Length, storage))
+        public static DenseVector OfEnumerable(IEnumerable<Complex> enumerable)
         {
+            return new DenseVector(DenseVectorStorage<Complex>.OfEnumerable(enumerable));
         }
 
         /// <summary>
@@ -143,6 +128,40 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
                 i => new Complex(distribution.Sample(), distribution.Sample())));
         }
 
+        /// <summary>
+        /// Create a new dense vector with the given length.
+        /// All cells of the vector will be initialized with the provided value.
+        /// Zero-length vectors are not supported.
+        /// </summary>
+        /// <exception cref="ArgumentException">If length is less than one.</exception>
+        [Obsolete("Use DenseVector.Create instead. Scheduled for removal in v3.0.")]
+        public DenseVector(int length, Complex value)
+            : this(DenseVectorStorage<Complex>.OfInit(length, i => value))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfVector instead. Scheduled for removal in v3.0.")]
+        public DenseVector(Vector<Complex> other)
+            : this(DenseVectorStorage<Complex>.OfVector(other.Storage))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
+        public DenseVector(IEnumerable<Complex> other)
+            : this(DenseVectorStorage<Complex>.OfEnumerable(other))
+        {
+        }
+
         /// <summary>
         /// Gets the vector's data.
         /// </summary>

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

@@ -69,35 +69,35 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// The status used if there is no status, i.e. the solver hasn't run yet and there is no
         /// iterator.
         /// </summary>
-        private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
+        static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        IPreConditioner _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
         /// </summary>
-        private IIterator _iterator;
+        IIterator _iterator;
 
         /// <summary>
         /// Indicates the number of <c>BiCGStab</c> steps should be taken 
         /// before switching.
         /// </summary>
-        private int _numberOfBiCgStabSteps = 1;
+        int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
         /// Indicates the number of <c>GPBiCG</c> steps should be taken 
         /// before switching.
         /// </summary>
-        private int _numberOfGpbiCgSteps = 4;
+        int _numberOfGpbiCgSteps = 4;
 
         /// <summary>
         /// Indicates if the user has stopped the solver.
         /// </summary>
-        private bool _hasBeenStopped;
+        bool _hasBeenStopped;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
@@ -106,7 +106,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// When using this constructor the solver will use the <see cref="IIterator"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
-        public GpBiCg() : this(null, null)
+        public GpBiCg()
+            : this(null, null)
         {
         }
 
@@ -129,7 +130,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </para>
         /// </remarks>
         /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IIterator iterator) : this(null, iterator)
+        public GpBiCg(IIterator iterator)
+            : this(null, iterator)
         {
         }
 
@@ -141,7 +143,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner) : this(preconditioner, null)
+        public GpBiCg(IPreConditioner preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -174,10 +177,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         public int NumberOfBiCgStabSteps
         {
-            get
-            {
-                return _numberOfBiCgStabSteps;
-            }
+            get { return _numberOfBiCgStabSteps; }
 
             set
             {
@@ -186,7 +186,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                     throw new ArgumentOutOfRangeException("value");
                 }
 
-                _numberOfBiCgStabSteps = value;     
+                _numberOfBiCgStabSteps = value;
             }
         }
 
@@ -196,10 +196,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         public int NumberOfGpBiCgSteps
         {
-            get
-            {
-                return _numberOfGpbiCgSteps;
-            }
+            get { return _numberOfGpbiCgSteps; }
 
             set
             {
@@ -235,10 +232,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         public ICalculationStatus IterationResult
         {
-            get 
-            {
-                return (_iterator != null) ? _iterator.Status : DefaultStatus;
-            }
+            get { return (_iterator != null) ? _iterator.Status : DefaultStatus; }
         }
 
         /// <summary>
@@ -323,7 +317,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             {
                 _preconditioner = new UnitPreconditioner();
             }
-         
+
             _preconditioner.Initialize(matrix);
 
             // x_0 is initial guess
@@ -340,7 +334,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
 
             // Define the temporary vectors
             // rDash_0 = r_0
-            Vector rdash = new DenseVector(residuals);
+            Vector rdash = DenseVector.OfVector(residuals);
 
             // t_-1 = 0
             Vector t = new DenseVector(residuals.Count);
@@ -378,7 +372,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                 matrix.Multiply(temp, s);
 
                 // alpha_k = (r*_0 * r_k) / (r*_0 * s_k)
-                var alpha = rdash.DotProduct(residuals) / rdash.DotProduct(s);
+                var alpha = rdash.DotProduct(residuals)/rdash.DotProduct(s);
 
                 // y_k = t_(k-1) - r_k - alpha_k * w_(k-1) + alpha_k s_k
                 s.Subtract(w, temp);
@@ -401,7 +395,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                 // c_k = A d_k
                 matrix.Multiply(temp, c);
                 var cdot = c.DotProduct(c);
-                
+
                 // cDot can only be zero if c is a zero vector
                 // We'll set cDot to 1 if it is zero to prevent NaN's
                 // Note that the calculation should continue fine because
@@ -421,7 +415,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                 if (((_numberOfBiCgStabSteps == 0) && (iterationNumber == 0)) || ShouldRunBiCgStabSteps(iterationNumber))
                 {
                     // sigma_k = (c_k * t_k) / (c_k * c_k)
-                    sigma = ctdot / cdot;
+                    sigma = ctdot/cdot;
 
                     // eta_k = 0
                     eta = 0;
@@ -442,13 +436,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                     var ytdot = y.DotProduct(t);
                     var cydot = c.DotProduct(y);
 
-                    var denom = (cdot * ydot) - (cydot * cydot);
+                    var denom = (cdot*ydot) - (cydot*cydot);
 
                     // sigma_k = ((y_k * y_k)(c_k * t_k) - (y_k * t_k)(c_k * y_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
-                    sigma = ((ydot * ctdot) - (ytdot * cydot)) / denom;
+                    sigma = ((ydot*ctdot) - (ytdot*cydot))/denom;
 
                     // eta_k = ((c_k * c_k)(y_k * t_k) - (y_k * c_k)(c_k * t_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
-                    eta = ((cdot * ytdot) - (cydot * ctdot)) / denom;
+                    eta = ((cdot*ytdot) - (cydot*ctdot))/denom;
                 }
 
                 // u_k = sigma_k s_k + eta_k (t_(k-1) - r_k + beta_(k-1) u_(k-1))
@@ -494,7 +488,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
 
                 // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k)
                 // But first we check if there is a possible NaN. If so just reset beta to zero.
-                beta = (!sigma.Real.AlmostEqual(0, 1) || !sigma.Imaginary.AlmostEqual(0, 1)) ? alpha / sigma * rdash.DotProduct(residuals) / rdash.DotProduct(t0) : 0;
+                beta = (!sigma.Real.AlmostEqual(0, 1) || !sigma.Imaginary.AlmostEqual(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0;
 
                 // w_k = c_k + beta_k s_k
                 s.Multiply(beta, temp2);
@@ -523,7 +517,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// <param name="residual">Residual values in <see cref="Vector"/>.</param>
         /// <param name="x">Instance of the <see cref="Vector"/> x.</param>
         /// <param name="b">Instance of the <see cref="Vector"/> b.</param>
-        private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
+        static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
         {
             // -Ax = residual
             matrix.Multiply(x, residual);
@@ -541,7 +535,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// <param name="source">Source <see cref="Vector"/>.</param>
         /// <param name="residuals">Residual <see cref="Vector"/>.</param>
         /// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
-        private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
+        bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
         {
             if (_hasBeenStopped)
             {
@@ -557,17 +551,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             // - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
             return (!status.TerminatesCalculation) && (!_hasBeenStopped);
         }
-        
+
         /// <summary>
         /// Decide if to do steps with BiCgStab
         /// </summary>
         /// <param name="iterationNumber">Number of iteration</param>
         /// <returns><c>true</c> if yes, otherwise <c>false</c></returns>
-        private bool ShouldRunBiCgStabSteps(int iterationNumber)
+        bool ShouldRunBiCgStabSteps(int iterationNumber)
         {
             // Run the first steps as BiCGStab
             // The number of steps past a whole iteration set
-            var difference = iterationNumber % (_numberOfBiCgStabSteps + _numberOfGpbiCgSteps);
+            var difference = iterationNumber%(_numberOfBiCgStabSteps + _numberOfGpbiCgSteps);
 
             // Do steps with BiCGStab if:
             // - The difference is zero or more (i.e. we have done zero or more complete cycles)
@@ -594,7 +588,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                 throw new ArgumentNullException("input");
             }
 
-            var result = (Matrix)matrix.CreateMatrix(input.RowCount, input.ColumnCount);
+            var result = (Matrix) matrix.CreateMatrix(input.RowCount, input.ColumnCount);
             Solve(matrix, input, result);
             return result;
         }
@@ -630,7 +624,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
 
             for (var column = 0; column < input.ColumnCount; column++)
             {
-                var solution = Solve(matrix, (Vector)input.Column(column));
+                var solution = Solve(matrix, (Vector) input.Column(column));
                 foreach (var element in solution.GetIndexedEnumerator())
                 {
                     result.At(element.Item1, column, element.Item2);

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

@@ -59,23 +59,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// The status used if there is no status, i.e. the solver hasn't run yet and there is no
         /// iterator.
         /// </summary>
-        private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
+        static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        IPreConditioner _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
         /// </summary>
-        private IIterator _iterator;
+        IIterator _iterator;
 
         /// <summary>
         /// Indicates if the user has stopped the solver.
         /// </summary>
-        private bool _hasBeenStopped;
+        bool _hasBeenStopped;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
@@ -84,7 +84,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// When using this constructor the solver will use the <see cref="IIterator"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
-        public TFQMR() : this(null, null)
+        public TFQMR()
+            : this(null, null)
         {
         }
 
@@ -107,7 +108,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </para>
         /// </remarks>
         /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IIterator iterator) : this(null, iterator)
+        public TFQMR(IIterator iterator)
+            : this(null, iterator)
         {
         }
 
@@ -119,7 +121,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner) : this(preconditioner, null)
+        public TFQMR(IPreConditioner preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -169,10 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         public ICalculationStatus IterationResult
         {
-            get 
-            { 
-                return (_iterator != null) ? _iterator.Status : DefaultStatus; 
-            }
+            get { return (_iterator != null) ? _iterator.Status : DefaultStatus; }
         }
 
         /// <summary>
@@ -260,17 +260,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             _preconditioner.Initialize(matrix);
 
             var d = new DenseVector(input.Count);
-            var r = new DenseVector(input);
+            var r = DenseVector.OfVector(input);
 
             var uodd = new DenseVector(input.Count);
             var ueven = new DenseVector(input.Count);
 
             var v = new DenseVector(input.Count);
-            var pseudoResiduals = new DenseVector(input);
+            var pseudoResiduals = DenseVector.OfVector(input);
 
             var x = new DenseVector(input.Count);
             var yodd = new DenseVector(input.Count);
-            var yeven = new DenseVector(input);
+            var yeven = DenseVector.OfVector(input);
 
             // Temp vectors
             var temp = new DenseVector(input.Count);
@@ -286,12 +286,12 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
             double theta = 0;
 
             var tau = startNorm.Real;
-            Complex rho = tau * tau;
+            Complex rho = tau*tau;
 
             // Calculate the initial values for v
             // M temp = yEven
             _preconditioner.Approximate(yeven, temp);
-            
+
             // v = A temp
             matrix.Multiply(temp, v);
 
@@ -315,7 +315,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                     }
 
                     // alpha = rho / sigma
-                    alpha = rho / sigma;
+                    alpha = rho/sigma;
 
                     // yOdd = yEven - alpha * v
                     v.Multiply(-alpha, temp1);
@@ -340,18 +340,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                 temp2.CopyTo(pseudoResiduals);
 
                 // d = yOdd + theta * theta * eta / alpha * d
-                d.Multiply(theta * theta * eta / alpha, temp);
+                d.Multiply(theta*theta*eta/alpha, temp);
                 yinternal.Add(temp, d);
 
                 // theta = ||pseudoResiduals||_2 / tau
-                theta = pseudoResiduals.Norm(2).Real / tau;
-                var c = 1 / Math.Sqrt(1 + (theta * theta));
+                theta = pseudoResiduals.Norm(2).Real/tau;
+                var c = 1/Math.Sqrt(1 + (theta*theta));
 
                 // tau = tau * theta * c
-                tau *= theta * c;
+                tau *= theta*c;
 
                 // eta = c^2 * alpha
-                eta = c * c * alpha;
+                eta = c*c*alpha;
 
                 // x = x + eta * d
                 d.Multiply(eta, temp1);
@@ -388,7 +388,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                     }
 
                     var rhoNew = pseudoResiduals.DotProduct(r.Conjugate());
-                    var beta = rhoNew / rho;
+                    var beta = rhoNew/rho;
 
                     // Update rho for the next loop
                     rho = rhoNew;
@@ -425,7 +425,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// <param name="residual">Residual values in <see cref="Vector"/>.</param>
         /// <param name="x">Instance of the <see cref="Vector"/> x.</param>
         /// <param name="b">Instance of the <see cref="Vector"/> b.</param>
-        private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
+        static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
         {
             // -Ax = residual
             matrix.Multiply(x, residual);
@@ -443,7 +443,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// <param name="source">Source <see cref="Vector"/>.</param>
         /// <param name="residuals">Residual <see cref="Vector"/>.</param>
         /// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
-        private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
+        bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
         {
             if (_hasBeenStopped)
             {
@@ -465,9 +465,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         /// <param name="number">Number to check</param>
         /// <returns><c>true</c> if <paramref name="number"/> even, otherwise <c>false</c></returns>
-        private static bool IsEven(int number)
+        static bool IsEven(int number)
         {
-            return number % 2 == 0;
+            return number%2 == 0;
         }
 
         /// <summary>
@@ -489,7 +489,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
                 throw new ArgumentNullException("input");
             }
 
-            var result = (Matrix)matrix.CreateMatrix(input.RowCount, input.ColumnCount);
+            var result = (Matrix) matrix.CreateMatrix(input.RowCount, input.ColumnCount);
             Solve(matrix, input, result);
             return result;
         }
@@ -525,7 +525,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
 
             for (var column = 0; column < input.ColumnCount; column++)
             {
-                var solution = Solve(matrix, (Vector)input.Column(column));
+                var solution = Solve(matrix, (Vector) input.Column(column));
                 foreach (var element in solution.GetIndexedEnumerator())
                 {
                     result.At(element.Item1, column, element.Item2);

src/Numerics/LinearAlgebra/Complex/SparseVector.cs

@@ -81,6 +81,34 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         {
         }
 
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfVector(Vector<Complex> vector)
+        {
+            return new SparseVector(SparseVectorStorage<Complex>.OfVector(vector.Storage));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfEnumerable(IEnumerable<Complex> enumerable)
+        {
+            return new SparseVector(SparseVectorStorage<Complex>.OfEnumerable(enumerable));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided init function.
+        /// </summary>
+        public static SparseVector Create(int length, Func<int, Complex> init)
+        {
+            return new SparseVector(SparseVectorStorage<Complex>.OfInit(length, init));
+        }
+
         /// <summary>
         /// Create a new sparse vector with the given length.
         /// All cells of the vector will be initialized with the provided value.
@@ -89,22 +117,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// <exception cref="ArgumentException">If length is less than one.</exception>
         [Obsolete("Use a dense vector instead. Scheduled for removal in v3.0.")]
         public SparseVector(int length, Complex value)
-            : this(new SparseVectorStorage<Complex>(length))
+            : this(SparseVectorStorage<Complex>.OfInit(length, i => value))
         {
-            if (value == Complex.Zero)
-            {
-                return;
-            }
-
-            var valueCount = _storage.ValueCount = length;
-            var indices = _storage.Indices = new int[valueCount];
-            var values = _storage.Values = new Complex[valueCount];
-
-            for (int i = 0; i < values.Length; i++)
-            {
-                values[i] = value;
-                indices[i] = i;
-            }
         }
 
         /// <summary>
@@ -112,6 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfVector instead. Scheduled for removal in v3.0.")]
         public SparseVector(Vector<Complex> other)
             : this(SparseVectorStorage<Complex>.OfVector(other.Storage))
         {
@@ -122,19 +137,12 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
         public SparseVector(IEnumerable<Complex> other)
             : this(SparseVectorStorage<Complex>.OfEnumerable(other))
         {
         }
 
-        /// <summary>
-        /// Create a new sparse vector and initialize each value using the provided init function.
-        /// </summary>
-        public static SparseVector Create(int length, Func<int, Complex> init)
-        {
-            return new SparseVector(SparseVectorStorage<Complex>.OfInit(length, init));
-        }
-
         /// <summary>
         /// Creates a matrix with the given dimensions using the same storage type
         /// as this vector.
@@ -965,7 +973,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
             {
                 throw new FormatException();
             }
-            return new SparseVector(data.ToArray());
+            return OfEnumerable(data);
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Complex32/DenseVector.cs

@@ -82,18 +82,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         }
 
         /// <summary>
-        /// Create a new dense vector with the given length.
-        /// All cells of the vector will be initialized with the provided value.
-        /// Zero-length vectors are not supported.
+        /// Create a new dense vector directly binding to a raw array.
+        /// The array is used directly without copying.
+        /// Very efficient, but changes to the array and the vector will affect each other.
         /// </summary>
-        /// <exception cref="ArgumentException">If length is less than one.</exception>
-        public DenseVector(int length, Complex32 value)
-            : this(length)
+        public DenseVector(Complex32[] storage)
+            : this(new DenseVectorStorage<Complex32>(storage.Length, storage))
         {
-            for (var index = 0; index < _values.Length; index++)
-            {
-                _values[index] = value;
-            }
         }
 
         /// <summary>
@@ -101,9 +96,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(Vector<Complex32> other)
-            : this(DenseVectorStorage<Complex32>.OfVector(other.Storage))
+        public static DenseVector OfVector(Vector<Complex32> vector)
         {
+            return new DenseVector(DenseVectorStorage<Complex32>.OfVector(vector.Storage));
         }
 
         /// <summary>
@@ -111,19 +106,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(IEnumerable<Complex32> other)
-            : this(DenseVectorStorage<Complex32>.OfEnumerable(other))
-        {
-        }
-
-        /// <summary>
-        /// Create a new dense vector directly binding to a raw array.
-        /// The array is used directly without copying.
-        /// Very efficient, but changes to the array and the vector will affect each other.
-        /// </summary>
-        public DenseVector(Complex32[] storage)
-            : this(new DenseVectorStorage<Complex32>(storage.Length, storage))
+        public static DenseVector OfEnumerable(IEnumerable<Complex32> enumerable)
         {
+            return new DenseVector(DenseVectorStorage<Complex32>.OfEnumerable(enumerable));
         }
 
         /// <summary>
@@ -140,7 +125,41 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         public static DenseVector CreateRandom(int length, IContinuousDistribution distribution)
         {
             return new DenseVector(DenseVectorStorage<Complex32>.OfInit(length,
-                i => new Complex32((float) distribution.Sample(), (float) distribution.Sample())));
+                i => new Complex32((float)distribution.Sample(), (float)distribution.Sample())));
+        }
+
+        /// <summary>
+        /// Create a new dense vector with the given length.
+        /// All cells of the vector will be initialized with the provided value.
+        /// Zero-length vectors are not supported.
+        /// </summary>
+        /// <exception cref="ArgumentException">If length is less than one.</exception>
+        [Obsolete("Use DenseVector.Create instead. Scheduled for removal in v3.0.")]
+        public DenseVector(int length, Complex32 value)
+            : this(DenseVectorStorage<Complex32>.OfInit(length, i => value))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfVector instead. Scheduled for removal in v3.0.")]
+        public DenseVector(Vector<Complex32> other)
+            : this(DenseVectorStorage<Complex32>.OfVector(other.Storage))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
+        public DenseVector(IEnumerable<Complex32> other)
+            : this(DenseVectorStorage<Complex32>.OfEnumerable(other))
+        {
         }
 
         /// <summary>

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

@@ -69,35 +69,35 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// The status used if there is no status, i.e. the solver hasn't run yet and there is no
         /// iterator.
         /// </summary>
-        private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
+        static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        IPreConditioner _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
         /// </summary>
-        private IIterator _iterator;
+        IIterator _iterator;
 
         /// <summary>
         /// Indicates the number of <c>BiCGStab</c> steps should be taken 
         /// before switching.
         /// </summary>
-        private int _numberOfBiCgStabSteps = 1;
+        int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
         /// Indicates the number of <c>GPBiCG</c> steps should be taken 
         /// before switching.
         /// </summary>
-        private int _numberOfGpbiCgSteps = 4;
+        int _numberOfGpbiCgSteps = 4;
 
         /// <summary>
         /// Indicates if the user has stopped the solver.
         /// </summary>
-        private bool _hasBeenStopped;
+        bool _hasBeenStopped;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
@@ -106,7 +106,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// When using this constructor the solver will use the <see cref="IIterator"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
-        public GpBiCg() : this(null, null)
+        public GpBiCg()
+            : this(null, null)
         {
         }
 
@@ -129,7 +130,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </para>
         /// </remarks>
         /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IIterator iterator) : this(null, iterator)
+        public GpBiCg(IIterator iterator)
+            : this(null, iterator)
         {
         }
 
@@ -141,7 +143,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner) : this(preconditioner, null)
+        public GpBiCg(IPreConditioner preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -174,10 +177,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         public int NumberOfBiCgStabSteps
         {
-            get
-            {
-                return _numberOfBiCgStabSteps;
-            }
+            get { return _numberOfBiCgStabSteps; }
 
             set
             {
@@ -186,7 +186,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                     throw new ArgumentOutOfRangeException("value");
                 }
 
-                _numberOfBiCgStabSteps = value;     
+                _numberOfBiCgStabSteps = value;
             }
         }
 
@@ -196,10 +196,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         public int NumberOfGpBiCgSteps
         {
-            get
-            {
-                return _numberOfGpbiCgSteps;
-            }
+            get { return _numberOfGpbiCgSteps; }
 
             set
             {
@@ -235,10 +232,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         public ICalculationStatus IterationResult
         {
-            get 
-            {
-                return (_iterator != null) ? _iterator.Status : DefaultStatus;
-            }
+            get { return (_iterator != null) ? _iterator.Status : DefaultStatus; }
         }
 
         /// <summary>
@@ -328,7 +322,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             {
                 _preconditioner = new UnitPreconditioner();
             }
-         
+
             _preconditioner.Initialize(matrix);
 
             // x_0 is initial guess
@@ -345,7 +339,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
 
             // Define the temporary vectors
             // rDash_0 = r_0
-            Vector rdash = new DenseVector(residuals);
+            Vector rdash = DenseVector.OfVector(residuals);
 
             // t_-1 = 0
             Vector t = new DenseVector(residuals.Count);
@@ -383,7 +377,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                 matrix.Multiply(temp, s);
 
                 // alpha_k = (r*_0 * r_k) / (r*_0 * s_k)
-                var alpha = rdash.DotProduct(residuals) / rdash.DotProduct(s);
+                var alpha = rdash.DotProduct(residuals)/rdash.DotProduct(s);
 
                 // y_k = t_(k-1) - r_k - alpha_k * w_(k-1) + alpha_k s_k
                 s.Subtract(w, temp);
@@ -406,7 +400,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                 // c_k = A d_k
                 matrix.Multiply(temp, c);
                 var cdot = c.DotProduct(c);
-                
+
                 // cDot can only be zero if c is a zero vector
                 // We'll set cDot to 1 if it is zero to prevent NaN's
                 // Note that the calculation should continue fine because
@@ -426,7 +420,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                 if (((_numberOfBiCgStabSteps == 0) && (iterationNumber == 0)) || ShouldRunBiCgStabSteps(iterationNumber))
                 {
                     // sigma_k = (c_k * t_k) / (c_k * c_k)
-                    sigma = ctdot / cdot;
+                    sigma = ctdot/cdot;
 
                     // eta_k = 0
                     eta = 0;
@@ -447,13 +441,13 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                     var ytdot = y.DotProduct(t);
                     var cydot = c.DotProduct(y);
 
-                    var denom = (cdot * ydot) - (cydot * cydot);
+                    var denom = (cdot*ydot) - (cydot*cydot);
 
                     // sigma_k = ((y_k * y_k)(c_k * t_k) - (y_k * t_k)(c_k * y_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
-                    sigma = ((ydot * ctdot) - (ytdot * cydot)) / denom;
+                    sigma = ((ydot*ctdot) - (ytdot*cydot))/denom;
 
                     // eta_k = ((c_k * c_k)(y_k * t_k) - (y_k * c_k)(c_k * t_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
-                    eta = ((cdot * ytdot) - (cydot * ctdot)) / denom;
+                    eta = ((cdot*ytdot) - (cydot*ctdot))/denom;
                 }
 
                 // u_k = sigma_k s_k + eta_k (t_(k-1) - r_k + beta_(k-1) u_(k-1))
@@ -499,7 +493,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
 
                 // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k)
                 // But first we check if there is a possible NaN. If so just reset beta to zero.
-                beta = (!sigma.Real.AlmostEqual(0, 1) || !sigma.Imaginary.AlmostEqual(0, 1)) ? alpha / sigma * rdash.DotProduct(residuals) / rdash.DotProduct(t0) : 0;
+                beta = (!sigma.Real.AlmostEqual(0, 1) || !sigma.Imaginary.AlmostEqual(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0;
 
                 // w_k = c_k + beta_k s_k
                 s.Multiply(beta, temp2);
@@ -528,7 +522,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// <param name="residual">Residual values in <see cref="Vector"/>.</param>
         /// <param name="x">Instance of the <see cref="Vector"/> x.</param>
         /// <param name="b">Instance of the <see cref="Vector"/> b.</param>
-        private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
+        static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
         {
             // -Ax = residual
             matrix.Multiply(x, residual);
@@ -546,7 +540,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// <param name="source">Source <see cref="Vector"/>.</param>
         /// <param name="residuals">Residual <see cref="Vector"/>.</param>
         /// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
-        private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
+        bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
         {
             if (_hasBeenStopped)
             {
@@ -562,17 +556,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             // - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
             return (!status.TerminatesCalculation) && (!_hasBeenStopped);
         }
-        
+
         /// <summary>
         /// Decide if to do steps with BiCgStab
         /// </summary>
         /// <param name="iterationNumber">Number of iteration</param>
         /// <returns><c>true</c> if yes, otherwise <c>false</c></returns>
-        private bool ShouldRunBiCgStabSteps(int iterationNumber)
+        bool ShouldRunBiCgStabSteps(int iterationNumber)
         {
             // Run the first steps as BiCGStab
             // The number of steps past a whole iteration set
-            var difference = iterationNumber % (_numberOfBiCgStabSteps + _numberOfGpbiCgSteps);
+            var difference = iterationNumber%(_numberOfBiCgStabSteps + _numberOfGpbiCgSteps);
 
             // Do steps with BiCGStab if:
             // - The difference is zero or more (i.e. we have done zero or more complete cycles)
@@ -599,7 +593,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                 throw new ArgumentNullException("input");
             }
 
-            var result = (Matrix)matrix.CreateMatrix(input.RowCount, input.ColumnCount);
+            var result = (Matrix) matrix.CreateMatrix(input.RowCount, input.ColumnCount);
             Solve(matrix, input, result);
             return result;
         }
@@ -635,7 +629,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
 
             for (var column = 0; column < input.ColumnCount; column++)
             {
-                var solution = Solve(matrix, (Vector)input.Column(column));
+                var solution = Solve(matrix, (Vector) input.Column(column));
                 foreach (var element in solution.GetIndexedEnumerator())
                 {
                     result.At(element.Item1, column, element.Item2);

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

@@ -59,23 +59,23 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// The status used if there is no status, i.e. the solver hasn't run yet and there is no
         /// iterator.
         /// </summary>
-        private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
+        static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        IPreConditioner _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
         /// </summary>
-        private IIterator _iterator;
+        IIterator _iterator;
 
         /// <summary>
         /// Indicates if the user has stopped the solver.
         /// </summary>
-        private bool _hasBeenStopped;
+        bool _hasBeenStopped;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
@@ -84,7 +84,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// When using this constructor the solver will use the <see cref="IIterator"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
-        public TFQMR() : this(null, null)
+        public TFQMR()
+            : this(null, null)
         {
         }
 
@@ -107,7 +108,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </para>
         /// </remarks>
         /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IIterator iterator) : this(null, iterator)
+        public TFQMR(IIterator iterator)
+            : this(null, iterator)
         {
         }
 
@@ -119,7 +121,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner) : this(preconditioner, null)
+        public TFQMR(IPreConditioner preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -169,10 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         public ICalculationStatus IterationResult
         {
-            get 
-            { 
-                return (_iterator != null) ? _iterator.Status : DefaultStatus; 
-            }
+            get { return (_iterator != null) ? _iterator.Status : DefaultStatus; }
         }
 
         /// <summary>
@@ -265,17 +265,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             _preconditioner.Initialize(matrix);
 
             var d = new DenseVector(input.Count);
-            var r = new DenseVector(input);
+            var r = DenseVector.OfVector(input);
 
             var uodd = new DenseVector(input.Count);
             var ueven = new DenseVector(input.Count);
 
             var v = new DenseVector(input.Count);
-            var pseudoResiduals = new DenseVector(input);
+            var pseudoResiduals = DenseVector.OfVector(input);
 
             var x = new DenseVector(input.Count);
             var yodd = new DenseVector(input.Count);
-            var yeven = new DenseVector(input);
+            var yeven = DenseVector.OfVector(input);
 
             // Temp vectors
             var temp = new DenseVector(input.Count);
@@ -291,12 +291,12 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
             float theta = 0;
 
             var tau = startNorm.Real;
-            Complex32 rho = tau * tau;
+            Complex32 rho = tau*tau;
 
             // Calculate the initial values for v
             // M temp = yEven
             _preconditioner.Approximate(yeven, temp);
-            
+
             // v = A temp
             matrix.Multiply(temp, v);
 
@@ -320,7 +320,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                     }
 
                     // alpha = rho / sigma
-                    alpha = rho / sigma;
+                    alpha = rho/sigma;
 
                     // yOdd = yEven - alpha * v
                     v.Multiply(-alpha, temp1);
@@ -345,18 +345,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                 temp2.CopyTo(pseudoResiduals);
 
                 // d = yOdd + theta * theta * eta / alpha * d
-                d.Multiply(theta * theta * eta / alpha, temp);
+                d.Multiply(theta*theta*eta/alpha, temp);
                 yinternal.Add(temp, d);
 
                 // theta = ||pseudoResiduals||_2 / tau
-                theta = pseudoResiduals.Norm(2).Real / tau;
-                var c = 1 / (float)Math.Sqrt(1 + (theta * theta));
+                theta = pseudoResiduals.Norm(2).Real/tau;
+                var c = 1/(float) Math.Sqrt(1 + (theta*theta));
 
                 // tau = tau * theta * c
-                tau *= theta * c;
+                tau *= theta*c;
 
                 // eta = c^2 * alpha
-                eta = c * c * alpha;
+                eta = c*c*alpha;
 
                 // x = x + eta * d
                 d.Multiply(eta, temp1);
@@ -393,7 +393,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                     }
 
                     var rhoNew = pseudoResiduals.DotProduct(r.Conjugate());
-                    var beta = rhoNew / rho;
+                    var beta = rhoNew/rho;
 
                     // Update rho for the next loop
                     rho = rhoNew;
@@ -430,7 +430,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// <param name="residual">Residual values in <see cref="Vector"/>.</param>
         /// <param name="x">Instance of the <see cref="Vector"/> x.</param>
         /// <param name="b">Instance of the <see cref="Vector"/> b.</param>
-        private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
+        static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
         {
             // -Ax = residual
             matrix.Multiply(x, residual);
@@ -448,7 +448,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// <param name="source">Source <see cref="Vector"/>.</param>
         /// <param name="residuals">Residual <see cref="Vector"/>.</param>
         /// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
-        private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
+        bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
         {
             if (_hasBeenStopped)
             {
@@ -470,9 +470,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         /// <param name="number">Number to check</param>
         /// <returns><c>true</c> if <paramref name="number"/> even, otherwise <c>false</c></returns>
-        private static bool IsEven(int number)
+        static bool IsEven(int number)
         {
-            return number % 2 == 0;
+            return number%2 == 0;
         }
 
         /// <summary>
@@ -494,7 +494,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
                 throw new ArgumentNullException("input");
             }
 
-            var result = (Matrix)matrix.CreateMatrix(input.RowCount, input.ColumnCount);
+            var result = (Matrix) matrix.CreateMatrix(input.RowCount, input.ColumnCount);
             Solve(matrix, input, result);
             return result;
         }
@@ -530,7 +530,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
 
             for (var column = 0; column < input.ColumnCount; column++)
             {
-                var solution = Solve(matrix, (Vector)input.Column(column));
+                var solution = Solve(matrix, (Vector) input.Column(column));
                 foreach (var element in solution.GetIndexedEnumerator())
                 {
                     result.At(element.Item1, column, element.Item2);

src/Numerics/LinearAlgebra/Complex32/SparseVector.cs

@@ -81,6 +81,34 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         {
         }
 
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfVector(Vector<Complex32> vector)
+        {
+            return new SparseVector(SparseVectorStorage<Complex32>.OfVector(vector.Storage));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfEnumerable(IEnumerable<Complex32> enumerable)
+        {
+            return new SparseVector(SparseVectorStorage<Complex32>.OfEnumerable(enumerable));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided init function.
+        /// </summary>
+        public static SparseVector Create(int length, Func<int, Complex32> init)
+        {
+            return new SparseVector(SparseVectorStorage<Complex32>.OfInit(length, init));
+        }
+
         /// <summary>
         /// Create a new sparse vector with the given length.
         /// All cells of the vector will be initialized with the provided value.
@@ -89,22 +117,8 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// <exception cref="ArgumentException">If length is less than one.</exception>
         [Obsolete("Use a dense vector instead. Scheduled for removal in v3.0.")]
         public SparseVector(int length, Complex32 value)
-            : this(new SparseVectorStorage<Complex32>(length))
+            : this(SparseVectorStorage<Complex32>.OfInit(length, i => value))
         {
-            if (value == Complex32.Zero)
-            {
-                return;
-            }
-
-            var valueCount = _storage.ValueCount = length;
-            var indices = _storage.Indices = new int[valueCount];
-            var values = _storage.Values = new Complex32[valueCount];
-
-            for (int i = 0; i < values.Length; i++)
-            {
-                values[i] = value;
-                indices[i] = i;
-            }
         }
 
         /// <summary>
@@ -112,6 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfVector instead. Scheduled for removal in v3.0.")]
         public SparseVector(Vector<Complex32> other)
             : this(SparseVectorStorage<Complex32>.OfVector(other.Storage))
         {
@@ -122,19 +137,12 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
         public SparseVector(IEnumerable<Complex32> other)
             : this(SparseVectorStorage<Complex32>.OfEnumerable(other))
         {
         }
 
-        /// <summary>
-        /// Create a new sparse vector and initialize each value using the provided init function.
-        /// </summary>
-        public static SparseVector Create(int length, Func<int, Complex32> init)
-        {
-            return new SparseVector(SparseVectorStorage<Complex32>.OfInit(length, init));
-        }
-
         /// <summary>
         /// Creates a matrix with the given dimensions using the same storage type
         /// as this vector.
@@ -965,7 +973,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32
             {
                 throw new FormatException();
             }
-            return new SparseVector(data.ToArray());
+            return OfEnumerable(data);
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -83,18 +83,13 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         }
 
         /// <summary>
-        /// Create a new dense vector with the given length.
-        /// All cells of the vector will be initialized with the provided value.
-        /// Zero-length vectors are not supported.
+        /// Create a new dense vector directly binding to a raw array.
+        /// The array is used directly without copying.
+        /// Very efficient, but changes to the array and the vector will affect each other.
         /// </summary>
-        /// <exception cref="ArgumentException">If length is less than one.</exception>
-        public DenseVector(int length, double value)
-            : this(length)
+        public DenseVector(double[] storage)
+            : this(new DenseVectorStorage<double>(storage.Length, storage))
         {
-            for (var index = 0; index < _values.Length; index++)
-            {
-                _values[index] = value;
-            }
         }
 
         /// <summary>
@@ -102,9 +97,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(Vector<double> other)
-            : this(DenseVectorStorage<double>.OfVector(other.Storage))
+        public static DenseVector OfVector(Vector<double> vector)
         {
+            return new DenseVector(DenseVectorStorage<double>.OfVector(vector.Storage));
         }
 
         /// <summary>
@@ -112,19 +107,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(IEnumerable<double> other)
-            : this(DenseVectorStorage<double>.OfEnumerable(other))
-        {
-        }
-
-        /// <summary>
-        /// Create a new dense vector directly binding to a raw array.
-        /// The array is used directly without copying.
-        /// Very efficient, but changes to the array and the vector will affect each other.
-        /// </summary>
-        public DenseVector(double[] storage)
-            : this(new DenseVectorStorage<double>(storage.Length, storage))
+        public static DenseVector OfEnumerable(IEnumerable<double> enumerable)
         {
+            return new DenseVector(DenseVectorStorage<double>.OfEnumerable(enumerable));
         }
 
         /// <summary>
@@ -144,6 +129,40 @@ namespace MathNet.Numerics.LinearAlgebra.Double
                 i => distribution.Sample()));
         }
 
+        /// <summary>
+        /// Create a new dense vector with the given length.
+        /// All cells of the vector will be initialized with the provided value.
+        /// Zero-length vectors are not supported.
+        /// </summary>
+        /// <exception cref="ArgumentException">If length is less than one.</exception>
+        [Obsolete("Use DenseVector.Create instead. Scheduled for removal in v3.0.")]
+        public DenseVector(int length, double value)
+            : this(DenseVectorStorage<double>.OfInit(length, i => value))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfVector instead. Scheduled for removal in v3.0.")]
+        public DenseVector(Vector<double> other)
+            : this(DenseVectorStorage<double>.OfVector(other.Storage))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
+        public DenseVector(IEnumerable<double> other)
+            : this(DenseVectorStorage<double>.OfEnumerable(other))
+        {
+        }
+
         /// <summary>
         /// Gets the vector's data.
         /// </summary>

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

@@ -344,7 +344,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
 
             // Define the temporary vectors
             // rDash_0 = r_0
-            Vector rdash = new DenseVector(residuals);
+            Vector rdash = DenseVector.OfVector(residuals);
 
             // t_-1 = 0
             Vector t = new DenseVector(residuals.Count);

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

@@ -264,17 +264,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
             _preconditioner.Initialize(matrix);
 
             var d = new DenseVector(input.Count);
-            var r = new DenseVector(input);
+            var r = DenseVector.OfVector(input);
 
             var uodd = new DenseVector(input.Count);
             var ueven = new DenseVector(input.Count);
 
             var v = new DenseVector(input.Count);
-            var pseudoResiduals = new DenseVector(input);
+            var pseudoResiduals = DenseVector.OfVector(input);
 
             var x = new DenseVector(input.Count);
             var yodd = new DenseVector(input.Count);
-            var yeven = new DenseVector(input);
+            var yeven = DenseVector.OfVector(input);
 
             // Temp vectors
             var temp = new DenseVector(input.Count);

src/Numerics/LinearAlgebra/Double/SparseVector.cs

@@ -81,6 +81,34 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         {
         }
 
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfVector(Vector<double> vector)
+        {
+            return new SparseVector(SparseVectorStorage<double>.OfVector(vector.Storage));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfEnumerable(IEnumerable<double> enumerable)
+        {
+            return new SparseVector(SparseVectorStorage<double>.OfEnumerable(enumerable));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided init function.
+        /// </summary>
+        public static SparseVector Create(int length, Func<int, double> init)
+        {
+            return new SparseVector(SparseVectorStorage<double>.OfInit(length, init));
+        }
+
         /// <summary>
         /// Create a new sparse vector with the given length.
         /// All cells of the vector will be initialized with the provided value.
@@ -89,22 +117,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// <exception cref="ArgumentException">If length is less than one.</exception>
         [Obsolete("Use a dense vector instead. Scheduled for removal in v3.0.")]
         public SparseVector(int length, double value)
-            : this(new SparseVectorStorage<double>(length))
+            : this(SparseVectorStorage<double>.OfInit(length, i => value))
         {
-            if (value == 0.0)
-            {
-                return;
-            }
-
-            var valueCount = _storage.ValueCount = length;
-            var indices = _storage.Indices = new int[valueCount];
-            var values = _storage.Values = new double[valueCount];
-
-            for (int i = 0; i < values.Length; i++)
-            {
-                values[i] = value;
-                indices[i] = i;
-            }
         }
 
         /// <summary>
@@ -112,6 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfVector instead. Scheduled for removal in v3.0.")]
         public SparseVector(Vector<double> other)
             : this(SparseVectorStorage<double>.OfVector(other.Storage))
         {
@@ -122,19 +137,12 @@ namespace MathNet.Numerics.LinearAlgebra.Double
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
         public SparseVector(IEnumerable<double> other)
             : this(SparseVectorStorage<double>.OfEnumerable(other))
         {
         }
 
-        /// <summary>
-        /// Create a new sparse vector and initialize each value using the provided init function.
-        /// </summary>
-        public static SparseVector Create(int length, Func<int, double> init)
-        {
-            return new SparseVector(SparseVectorStorage<double>.OfInit(length, init));
-        }
-
         /// <summary>
         /// Creates a matrix with the given dimensions using the same storage type
         /// as this vector.
@@ -969,9 +977,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double
 
             // parsing
             var tokens = value.Split(new[] { formatProvider.GetTextInfo().ListSeparator, " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
-            var data = tokens.Select(t => Double.Parse(t, NumberStyles.Any, formatProvider)).ToArray();
-            if (data.Length == 0) throw new FormatException();
-            return new SparseVector(data);
+            var data = tokens.Select(t => Double.Parse(t, NumberStyles.Any, formatProvider)).ToList();
+            if (data.Count == 0) throw new FormatException();
+            return OfEnumerable(data);
         }
 
         /// <summary>

src/Numerics/LinearAlgebra/Single/DenseVector.cs

@@ -82,18 +82,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         }
 
         /// <summary>
-        /// Create a new dense vector with the given length.
-        /// All cells of the vector will be initialized with the provided value.
-        /// Zero-length vectors are not supported.
+        /// Create a new dense vector directly binding to a raw array.
+        /// The array is used directly without copying.
+        /// Very efficient, but changes to the array and the vector will affect each other.
         /// </summary>
-        /// <exception cref="ArgumentException">If length is less than one.</exception>
-        public DenseVector(int length, float value)
-            : this(length)
+        public DenseVector(float[] storage)
+            : this(new DenseVectorStorage<float>(storage.Length, storage))
         {
-            for (var index = 0; index < _values.Length; index++)
-            {
-                _values[index] = value;
-            }
         }
 
         /// <summary>
@@ -101,9 +96,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(Vector<float> other)
-            : this(DenseVectorStorage<float>.OfVector(other.Storage))
+        public static DenseVector OfVector(Vector<float> vector)
         {
+            return new DenseVector(DenseVectorStorage<float>.OfVector(vector.Storage));
         }
 
         /// <summary>
@@ -111,19 +106,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
-        public DenseVector(IEnumerable<float> other)
-            : this(DenseVectorStorage<float>.OfEnumerable(other))
-        {
-        }
-
-        /// <summary>
-        /// Create a new dense vector directly binding to a raw array.
-        /// The array is used directly without copying.
-        /// Very efficient, but changes to the array and the vector will affect each other.
-        /// </summary>
-        public DenseVector(float[] storage)
-            : this(new DenseVectorStorage<float>(storage.Length, storage))
+        public static DenseVector OfEnumerable(IEnumerable<float> enumerable)
         {
+            return new DenseVector(DenseVectorStorage<float>.OfEnumerable(enumerable));
         }
 
         /// <summary>
@@ -140,7 +125,41 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         public static DenseVector CreateRandom(int length, IContinuousDistribution distribution)
         {
             return new DenseVector(DenseVectorStorage<float>.OfInit(length,
-                i => (float) distribution.Sample()));
+                i => (float)distribution.Sample()));
+        }
+
+        /// <summary>
+        /// Create a new dense vector with the given length.
+        /// All cells of the vector will be initialized with the provided value.
+        /// Zero-length vectors are not supported.
+        /// </summary>
+        /// <exception cref="ArgumentException">If length is less than one.</exception>
+        [Obsolete("Use DenseVector.Create instead. Scheduled for removal in v3.0.")]
+        public DenseVector(int length, float value)
+            : this(DenseVectorStorage<float>.OfInit(length, i => value))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfVector instead. Scheduled for removal in v3.0.")]
+        public DenseVector(Vector<float> other)
+            : this(DenseVectorStorage<float>.OfVector(other.Storage))
+        {
+        }
+
+        /// <summary>
+        /// Create a new dense vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        [Obsolete("Use DenseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
+        public DenseVector(IEnumerable<float> other)
+            : this(DenseVectorStorage<float>.OfEnumerable(other))
+        {
         }
 
         /// <summary>

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

@@ -68,35 +68,35 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// The status used if there is no status, i.e. the solver hasn't run yet and there is no
         /// iterator.
         /// </summary>
-        private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
+        static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        IPreConditioner _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
         /// </summary>
-        private IIterator _iterator;
+        IIterator _iterator;
 
         /// <summary>
         /// Indicates the number of <c>BiCGStab</c> steps should be taken 
         /// before switching.
         /// </summary>
-        private int _numberOfBiCgStabSteps = 1;
+        int _numberOfBiCgStabSteps = 1;
 
         /// <summary>
         /// Indicates the number of <c>GPBiCG</c> steps should be taken 
         /// before switching.
         /// </summary>
-        private int _numberOfGpbiCgSteps = 4;
+        int _numberOfGpbiCgSteps = 4;
 
         /// <summary>
         /// Indicates if the user has stopped the solver.
         /// </summary>
-        private bool _hasBeenStopped;
+        bool _hasBeenStopped;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
@@ -105,7 +105,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// When using this constructor the solver will use the <see cref="IIterator"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
-        public GpBiCg() : this(null, null)
+        public GpBiCg()
+            : this(null, null)
         {
         }
 
@@ -128,7 +129,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </para>
         /// </remarks>
         /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IIterator iterator) : this(null, iterator)
+        public GpBiCg(IIterator iterator)
+            : this(null, iterator)
         {
         }
 
@@ -140,7 +142,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner) : this(preconditioner, null)
+        public GpBiCg(IPreConditioner preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -173,10 +176,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         public int NumberOfBiCgStabSteps
         {
-            get
-            {
-                return _numberOfBiCgStabSteps;
-            }
+            get { return _numberOfBiCgStabSteps; }
 
             set
             {
@@ -185,7 +185,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                     throw new ArgumentOutOfRangeException("value");
                 }
 
-                _numberOfBiCgStabSteps = value;     
+                _numberOfBiCgStabSteps = value;
             }
         }
 
@@ -195,10 +195,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         public int NumberOfGpBiCgSteps
         {
-            get
-            {
-                return _numberOfGpbiCgSteps;
-            }
+            get { return _numberOfGpbiCgSteps; }
 
             set
             {
@@ -234,10 +231,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         public ICalculationStatus IterationResult
         {
-            get 
-            {
-                return (_iterator != null) ? _iterator.Status : DefaultStatus;
-            }
+            get { return (_iterator != null) ? _iterator.Status : DefaultStatus; }
         }
 
         /// <summary>
@@ -327,7 +321,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             {
                 _preconditioner = new UnitPreconditioner();
             }
-         
+
             _preconditioner.Initialize(matrix);
 
             // x_0 is initial guess
@@ -344,7 +338,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
 
             // Define the temporary vectors
             // rDash_0 = r_0
-            Vector rdash = new DenseVector(residuals);
+            Vector rdash = DenseVector.OfVector(residuals);
 
             // t_-1 = 0
             Vector t = new DenseVector(residuals.Count);
@@ -382,7 +376,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                 matrix.Multiply(temp, s);
 
                 // alpha_k = (r*_0 * r_k) / (r*_0 * s_k)
-                var alpha = rdash.DotProduct(residuals) / rdash.DotProduct(s);
+                var alpha = rdash.DotProduct(residuals)/rdash.DotProduct(s);
 
                 // y_k = t_(k-1) - r_k - alpha_k * w_(k-1) + alpha_k s_k
                 s.Subtract(w, temp);
@@ -405,7 +399,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                 // c_k = A d_k
                 matrix.Multiply(temp, c);
                 var cdot = c.DotProduct(c);
-                
+
                 // cDot can only be zero if c is a zero vector
                 // We'll set cDot to 1 if it is zero to prevent NaN's
                 // Note that the calculation should continue fine because
@@ -425,7 +419,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                 if (((_numberOfBiCgStabSteps == 0) && (iterationNumber == 0)) || ShouldRunBiCgStabSteps(iterationNumber))
                 {
                     // sigma_k = (c_k * t_k) / (c_k * c_k)
-                    sigma = ctdot / cdot;
+                    sigma = ctdot/cdot;
 
                     // eta_k = 0
                     eta = 0;
@@ -446,13 +440,13 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                     var ytdot = y.DotProduct(t);
                     var cydot = c.DotProduct(y);
 
-                    var denom = (cdot * ydot) - (cydot * cydot);
+                    var denom = (cdot*ydot) - (cydot*cydot);
 
                     // sigma_k = ((y_k * y_k)(c_k * t_k) - (y_k * t_k)(c_k * y_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
-                    sigma = ((ydot * ctdot) - (ytdot * cydot)) / denom;
+                    sigma = ((ydot*ctdot) - (ytdot*cydot))/denom;
 
                     // eta_k = ((c_k * c_k)(y_k * t_k) - (y_k * c_k)(c_k * t_k)) / ((c_k * c_k)(y_k * y_k) - (y_k * c_k)(c_k * y_k))
-                    eta = ((cdot * ytdot) - (cydot * ctdot)) / denom;
+                    eta = ((cdot*ytdot) - (cydot*ctdot))/denom;
                 }
 
                 // u_k = sigma_k s_k + eta_k (t_(k-1) - r_k + beta_(k-1) u_(k-1))
@@ -498,7 +492,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
 
                 // beta_k = alpha_k / sigma_k * (r*_0 * r_(k+1)) / (r*_0 * r_k)
                 // But first we check if there is a possible NaN. If so just reset beta to zero.
-                beta = (!sigma.AlmostEqual(0, 1)) ? alpha / sigma * rdash.DotProduct(residuals) / rdash.DotProduct(t0) : 0;
+                beta = (!sigma.AlmostEqual(0, 1)) ? alpha/sigma*rdash.DotProduct(residuals)/rdash.DotProduct(t0) : 0;
 
                 // w_k = c_k + beta_k s_k
                 s.Multiply(beta, temp2);
@@ -527,7 +521,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// <param name="residual">Residual values in <see cref="Vector"/>.</param>
         /// <param name="x">Instance of the <see cref="Vector"/> x.</param>
         /// <param name="b">Instance of the <see cref="Vector"/> b.</param>
-        private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
+        static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
         {
             // -Ax = residual
             matrix.Multiply(x, residual);
@@ -545,7 +539,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// <param name="source">Source <see cref="Vector"/>.</param>
         /// <param name="residuals">Residual <see cref="Vector"/>.</param>
         /// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
-        private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
+        bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
         {
             if (_hasBeenStopped)
             {
@@ -561,17 +555,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             // - the calculation needs to be stopped from a numerical point of view (divergence, convergence etc.)
             return (!status.TerminatesCalculation) && (!_hasBeenStopped);
         }
-        
+
         /// <summary>
         /// Decide if to do steps with BiCgStab
         /// </summary>
         /// <param name="iterationNumber">Number of iteration</param>
         /// <returns><c>true</c> if yes, otherwise <c>false</c></returns>
-        private bool ShouldRunBiCgStabSteps(int iterationNumber)
+        bool ShouldRunBiCgStabSteps(int iterationNumber)
         {
             // Run the first steps as BiCGStab
             // The number of steps past a whole iteration set
-            var difference = iterationNumber % (_numberOfBiCgStabSteps + _numberOfGpbiCgSteps);
+            var difference = iterationNumber%(_numberOfBiCgStabSteps + _numberOfGpbiCgSteps);
 
             // Do steps with BiCGStab if:
             // - The difference is zero or more (i.e. we have done zero or more complete cycles)
@@ -598,7 +592,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                 throw new ArgumentNullException("input");
             }
 
-            var result = (Matrix)matrix.CreateMatrix(input.RowCount, input.ColumnCount);
+            var result = (Matrix) matrix.CreateMatrix(input.RowCount, input.ColumnCount);
             Solve(matrix, input, result);
             return result;
         }
@@ -634,7 +628,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
 
             for (var column = 0; column < input.ColumnCount; column++)
             {
-                var solution = Solve(matrix, (Vector)input.Column(column));
+                var solution = Solve(matrix, (Vector) input.Column(column));
                 foreach (var element in solution.GetIndexedEnumerator())
                 {
                     result.At(element.Item1, column, element.Item2);

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

@@ -58,23 +58,23 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// The status used if there is no status, i.e. the solver hasn't run yet and there is no
         /// iterator.
         /// </summary>
-        private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
+        static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        IPreConditioner _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
         /// </summary>
-        private IIterator _iterator;
+        IIterator _iterator;
 
         /// <summary>
         /// Indicates if the user has stopped the solver.
         /// </summary>
-        private bool _hasBeenStopped;
+        bool _hasBeenStopped;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
@@ -83,7 +83,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// When using this constructor the solver will use the <see cref="IIterator"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
-        public TFQMR() : this(null, null)
+        public TFQMR()
+            : this(null, null)
         {
         }
 
@@ -106,7 +107,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </para>
         /// </remarks>
         /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IIterator iterator) : this(null, iterator)
+        public TFQMR(IIterator iterator)
+            : this(null, iterator)
         {
         }
 
@@ -118,7 +120,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner) : this(preconditioner, null)
+        public TFQMR(IPreConditioner preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -168,10 +171,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         public ICalculationStatus IterationResult
         {
-            get 
-            { 
-                return (_iterator != null) ? _iterator.Status : DefaultStatus; 
-            }
+            get { return (_iterator != null) ? _iterator.Status : DefaultStatus; }
         }
 
         /// <summary>
@@ -264,17 +264,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             _preconditioner.Initialize(matrix);
 
             var d = new DenseVector(input.Count);
-            var r = new DenseVector(input);
+            var r = DenseVector.OfVector(input);
 
             var uodd = new DenseVector(input.Count);
             var ueven = new DenseVector(input.Count);
 
             var v = new DenseVector(input.Count);
-            var pseudoResiduals = new DenseVector(input);
+            var pseudoResiduals = DenseVector.OfVector(input);
 
             var x = new DenseVector(input.Count);
             var yodd = new DenseVector(input.Count);
-            var yeven = new DenseVector(input);
+            var yeven = DenseVector.OfVector(input);
 
             // Temp vectors
             var temp = new DenseVector(input.Count);
@@ -290,12 +290,12 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
             float theta = 0;
 
             var tau = startNorm;
-            var rho = tau * tau;
+            var rho = tau*tau;
 
             // Calculate the initial values for v
             // M temp = yEven
             _preconditioner.Approximate(yeven, temp);
-            
+
             // v = A temp
             matrix.Multiply(temp, v);
 
@@ -319,7 +319,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                     }
 
                     // alpha = rho / sigma
-                    alpha = rho / sigma;
+                    alpha = rho/sigma;
 
                     // yOdd = yEven - alpha * v
                     v.Multiply(-alpha, temp1);
@@ -344,18 +344,18 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                 temp2.CopyTo(pseudoResiduals);
 
                 // d = yOdd + theta * theta * eta / alpha * d
-                d.Multiply(theta * theta * eta / alpha, temp);
+                d.Multiply(theta*theta*eta/alpha, temp);
                 yinternal.Add(temp, d);
 
                 // theta = ||pseudoResiduals||_2 / tau
-                theta = pseudoResiduals.Norm(2) / tau;
-                var c = 1 / (float)Math.Sqrt(1 + (theta * theta));
+                theta = pseudoResiduals.Norm(2)/tau;
+                var c = 1/(float) Math.Sqrt(1 + (theta*theta));
 
                 // tau = tau * theta * c
-                tau *= theta * c;
+                tau *= theta*c;
 
                 // eta = c^2 * alpha
-                eta = c * c * alpha;
+                eta = c*c*alpha;
 
                 // x = x + eta * d
                 d.Multiply(eta, temp1);
@@ -392,7 +392,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                     }
 
                     var rhoNew = pseudoResiduals.DotProduct(r);
-                    var beta = rhoNew / rho;
+                    var beta = rhoNew/rho;
 
                     // Update rho for the next loop
                     rho = rhoNew;
@@ -429,7 +429,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// <param name="residual">Residual values in <see cref="Vector"/>.</param>
         /// <param name="x">Instance of the <see cref="Vector"/> x.</param>
         /// <param name="b">Instance of the <see cref="Vector"/> b.</param>
-        private static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
+        static void CalculateTrueResidual(Matrix matrix, Vector residual, Vector x, Vector b)
         {
             // -Ax = residual
             matrix.Multiply(x, residual);
@@ -447,7 +447,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// <param name="source">Source <see cref="Vector"/>.</param>
         /// <param name="residuals">Residual <see cref="Vector"/>.</param>
         /// <returns><c>true</c> if continue, otherwise <c>false</c></returns>
-        private bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
+        bool ShouldContinue(int iterationNumber, Vector result, Vector source, Vector residuals)
         {
             if (_hasBeenStopped)
             {
@@ -469,9 +469,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         /// <param name="number">Number to check</param>
         /// <returns><c>true</c> if <paramref name="number"/> even, otherwise <c>false</c></returns>
-        private static bool IsEven(int number)
+        static bool IsEven(int number)
         {
-            return number % 2 == 0;
+            return number%2 == 0;
         }
 
         /// <summary>
@@ -493,7 +493,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
                 throw new ArgumentNullException("input");
             }
 
-            var result = (Matrix)matrix.CreateMatrix(input.RowCount, input.ColumnCount);
+            var result = (Matrix) matrix.CreateMatrix(input.RowCount, input.ColumnCount);
             Solve(matrix, input, result);
             return result;
         }
@@ -529,7 +529,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
 
             for (var column = 0; column < input.ColumnCount; column++)
             {
-                var solution = Solve(matrix, (Vector)input.Column(column));
+                var solution = Solve(matrix, (Vector) input.Column(column));
                 foreach (var element in solution.GetIndexedEnumerator())
                 {
                     result.At(element.Item1, column, element.Item2);

src/Numerics/LinearAlgebra/Single/SparseVector.cs

@@ -81,6 +81,34 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         {
         }
 
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given other vector.
+        /// This new vector will be independent from the other vector.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfVector(Vector<float> vector)
+        {
+            return new SparseVector(SparseVectorStorage<float>.OfVector(vector.Storage));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector as a copy of the given enumerable.
+        /// This new vector will be independent from the enumerable.
+        /// A new memory block will be allocated for storing the vector.
+        /// </summary>
+        public static SparseVector OfEnumerable(IEnumerable<float> enumerable)
+        {
+            return new SparseVector(SparseVectorStorage<float>.OfEnumerable(enumerable));
+        }
+
+        /// <summary>
+        /// Create a new sparse vector and initialize each value using the provided init function.
+        /// </summary>
+        public static SparseVector Create(int length, Func<int, float> init)
+        {
+            return new SparseVector(SparseVectorStorage<float>.OfInit(length, init));
+        }
+
         /// <summary>
         /// Create a new sparse vector with the given length.
         /// All cells of the vector will be initialized with the provided value.
@@ -89,22 +117,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// <exception cref="ArgumentException">If length is less than one.</exception>
         [Obsolete("Use a dense vector instead. Scheduled for removal in v3.0.")]
         public SparseVector(int length, float value)
-            : this(new SparseVectorStorage<float>(length))
+            : this(SparseVectorStorage<float>.OfInit(length, i => value))
         {
-            if (value == 0.0)
-            {
-                return;
-            }
-
-            var valueCount = _storage.ValueCount = length;
-            var indices = _storage.Indices = new int[valueCount];
-            var values = _storage.Values = new float[valueCount];
-
-            for (int i = 0; i < values.Length; i++)
-            {
-                values[i] = value;
-                indices[i] = i;
-            }
         }
 
         /// <summary>
@@ -112,6 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// This new vector will be independent from the other vector.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfVector instead. Scheduled for removal in v3.0.")]
         public SparseVector(Vector<float> other)
             : this(SparseVectorStorage<float>.OfVector(other.Storage))
         {
@@ -122,19 +137,12 @@ namespace MathNet.Numerics.LinearAlgebra.Single
         /// This new vector will be independent from the enumerable.
         /// A new memory block will be allocated for storing the vector.
         /// </summary>
+        [Obsolete("Use SparseVector.OfEnumerable instead. Scheduled for removal in v3.0.")]
         public SparseVector(IEnumerable<float> other)
             : this(SparseVectorStorage<float>.OfEnumerable(other))
         {
         }
 
-        /// <summary>
-        /// Create a new sparse vector and initialize each value using the provided init function.
-        /// </summary>
-        public static SparseVector Create(int length, Func<int, float> init)
-        {
-            return new SparseVector(SparseVectorStorage<float>.OfInit(length, init));
-        }
-
         /// <summary>
         /// Creates a matrix with the given dimensions using the same storage type
         /// as this vector.
@@ -973,9 +981,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single
 
             // parsing
             var tokens = value.Split(new[] { formatProvider.GetTextInfo().ListSeparator, " ", "\t" }, StringSplitOptions.RemoveEmptyEntries);
-            var data = tokens.Select(t => Single.Parse(t, NumberStyles.Any, formatProvider)).ToArray();
-            if (data.Length == 0) throw new FormatException();
-            return new SparseVector(data);
+            var data = tokens.Select(t => Single.Parse(t, NumberStyles.Any, formatProvider)).ToList();
+            if (data.Count == 0) throw new FormatException();
+            return OfEnumerable(data);
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Complex/DenseVectorTests.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -90,7 +94,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanCreateDenseVectorFromAnotherDenseVector()
         {
             var vector = new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -105,8 +109,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanCreateDenseVectorFromAnotherVector()
         {
-            var vector = (Vector<Complex>)new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var vector = (Vector<Complex>) new DenseVector(Data);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -122,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanCreateDenseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -136,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanCreateDenseVectorWithConstantValues()
         {
-            var vector = new DenseVector(5, 5);
+            var vector = DenseVector.Create(5, i => 5);
             foreach (var t in vector)
             {
                 Assert.AreEqual(t, new Complex(5.0, 0));
@@ -162,8 +166,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanConvertDenseVectorToArray()
         {
             var vector = new DenseVector(Data);
-            var array = (Complex[])vector;
-            Assert.IsInstanceOf(typeof(Complex[]), array);
+            var array = (Complex[]) vector;
+            Assert.IsInstanceOf(typeof (Complex[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -173,9 +177,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanConvertArrayToDenseVector()
         {
-            var array = new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1) };
-            var vector = (DenseVector)array;
-            Assert.IsInstanceOf(typeof(DenseVector), vector);
+            var array = new[] {new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1)};
+            var vector = (DenseVector) array;
+            Assert.IsInstanceOf(typeof (DenseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
 
@@ -207,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0, result[i]);
+                Assert.AreEqual(Data[i]*2.0, result[i]);
             }
         }
 
@@ -250,31 +254,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanMultiplyDenseVectorByScalarUsingOperators()
         {
             var vector = new DenseVector(Data);
-            vector = vector * new Complex(2.0, 1);
+            vector = vector*new Complex(2.0, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
 
-            vector = vector * 1.0;
+            vector = vector*1.0;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
 
             vector = new DenseVector(Data);
-            vector = new Complex(2.0, 1) * vector;
+            vector = new Complex(2.0, 1)*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
 
-            vector = 1.0 * vector;
+            vector = 1.0*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
         }
 
@@ -285,17 +289,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanDivideDenseVectorByComplexUsingOperators()
         {
             var vector = new DenseVector(Data);
-            vector = vector / new Complex(2.0, 1);
+            vector = vector/new Complex(2.0, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex(2.0, 1), vector[i], 14);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14);
             }
 
-            vector = vector / 1.0;
+            vector = vector/1.0;
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex(2.0, 1), vector[i], 14);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14);
             }
         }
 
@@ -312,7 +316,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }

src/UnitTests/LinearAlgebraTests/Complex/DiagonalMatrixTests.cs

@@ -103,7 +103,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         /// <returns>The new vector. </returns>
         protected override Vector CreateVector(Complex[] data)
         {
-            return new SparseVector(data);
+            return SparseVector.OfEnumerable(data);
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/BiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -44,12 +48,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -87,16 +91,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, Complex.One);
+            Vector y = DenseVector.Create(matrix.RowCount, i => Complex.One);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -132,16 +136,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(new Complex(Math.PI, Math.PI), matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, Complex.One);
+            Vector y = DenseVector.Create(matrix.RowCount, i => Complex.One);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, Complex.One);
+            Vector y = DenseVector.Create(matrix.RowCount, i => Complex.One);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -255,16 +259,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new BiCgStab(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -287,10 +291,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new BiCgStab(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -300,7 +304,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new GpBiCg(monitor);
 
             // Solve equation Ax = y
@@ -131,16 +135,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -256,16 +260,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new GpBiCg(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -288,10 +292,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new GpBiCg(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -301,7 +305,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterative
 {
     using System;
@@ -42,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -85,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new MlkBiCgStab(monitor);
 
@@ -131,16 +136,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -209,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -254,16 +259,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new MlkBiCgStab(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -286,10 +291,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new MlkBiCgStab(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -299,7 +304,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterative
 {
     using System;
@@ -42,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -85,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new TFQMR(monitor);
 
@@ -131,16 +136,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -209,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -254,16 +259,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new TFQMR(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -286,10 +291,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new TFQMR(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -299,7 +304,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Iterativ
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -57,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         [Test]
         public void CreateWithEmptyCollection()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { });
+            var iterator = new Iterator(new IIterationStopCriterium[] {});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -68,7 +72,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         [Test]
         public void CreateWithCollectionWithNulls()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { null, null });
+            var iterator = new Iterator(new IIterationStopCriterium[] {null, null});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -80,10 +84,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void CreateWithDuplicatesThrowsArgumentException()
         {
             Assert.Throws<ArgumentException>(() => new Iterator(new IIterationStopCriterium[]
-                                                                {
-                                                                    new FailureStopCriterium(),
-                                                                    new FailureStopCriterium()
-                                                                }));
+                {
+                    new FailureStopCriterium(),
+                    new FailureStopCriterium()
+                }));
         }
 
         /// <summary>
@@ -93,12 +97,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void CreateWithCollection()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.IsNotNull(iterator, "Should have an iterator");
 
@@ -140,12 +144,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void Add()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator();
             Assert.AreEqual(0, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -170,12 +174,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void RemoveWithNullStopCriteriumThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -189,11 +193,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void RemoveWithNonExistingStopCriterium()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -208,12 +212,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void Remove()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -233,9 +237,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
             var iterator = new Iterator();
             Assert.Throws<ArgumentException>(() => iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -245,19 +249,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -267,19 +271,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -289,19 +293,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatusWithNullSourceVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 5),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -311,18 +315,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatusWithNullResidualVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -333,29 +337,29 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
         }
 
         /// <summary>
@@ -365,27 +369,27 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             iterator.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), iterator.Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[0].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[1].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[2].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), iterator.Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[0].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[1].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[2].Status, "Incorrect status");
         }
 
         /// <summary>
@@ -395,17 +399,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void Clone()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
 
             var iterator = new Iterator(criteria);
 
             var clonedIterator = iterator.Clone();
-            Assert.IsInstanceOf(typeof(Iterator), clonedIterator, "Incorrect type");
+            Assert.IsInstanceOf(typeof (Iterator), clonedIterator, "Incorrect type");
 
             var clone = clonedIterator as Iterator;
             Assert.IsNotNull(clone);

src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -109,9 +113,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -123,8 +127,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -144,11 +148,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex((i + 1) * (Increase + 0.1), 0) }));
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex((i + 1)*(Increase + 0.1), 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -164,15 +168,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. We should not diverge because we won't have enough increase
-            for (var i = 0; i < Iterations * 2; i++)
+            for (var i = 0; i < Iterations*2; i++)
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex((i + 1) * (Increase - 0.01), 0) }));
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex((i + 1)*(Increase - 0.01), 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -192,21 +196,21 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex((i + 1) * (Increase - 0.01), 0) }));
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex((i + 1)*(Increase - 0.01), 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
             criterium.DetermineStatus(
                 Iterations,
-                new DenseVector(new[] { new Complex(1.0, 0) }),
-                new DenseVector(new[] { new Complex(1.0, 0) }),
-                new DenseVector(new[] { new Complex(double.NaN, 0) }));
+                new DenseVector(new[] {new Complex(1.0, 0)}),
+                new DenseVector(new[] {new Complex(1.0, 0)}),
+                new DenseVector(new[] {new Complex(double.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -227,22 +231,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
                 previous *= 1 + Increase + 0.01;
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex(1.0, 0) }),
-                    new DenseVector(new[] { new Complex(previous, 0) }));
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex(1.0, 0)}),
+                    new DenseVector(new[] {new Complex(previous, 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01;
             criterium.DetermineStatus(
                 Iterations - 1,
-                new DenseVector(new[] { new Complex(1.0, 0) }),
-                new DenseVector(new[] { new Complex(1.0, 0) }),
-                new DenseVector(new[] { new Complex(previous, 0) }));
+                new DenseVector(new[] {new Complex(1.0, 0)}),
+                new DenseVector(new[] {new Complex(1.0, 0)}),
+                new DenseVector(new[] {new Complex(previous, 0)}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -259,18 +263,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             // Add residuals. Blow it up instantly
             criterium.DetermineStatus(
                 1,
-                new DenseVector(new[] { new Complex(1.0, 0) }),
-                new DenseVector(new[] { new Complex(1.0, 0) }),
-                new DenseVector(new[] { new Complex(double.NaN, 0) }));
+                new DenseVector(new[] {new Complex(1.0, 0)}),
+                new DenseVector(new[] {new Complex(1.0, 0)}),
+                new DenseVector(new[] {new Complex(double.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
 
             Assert.AreEqual(Increase, criterium.MaximumRelativeIncrease, "Incorrect maximum");
             Assert.AreEqual(Iterations, criterium.MinimumNumberOfIterations, "Incorrect iteration count");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -286,7 +290,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(DivergenceStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (DivergenceStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as DivergenceStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -58,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 4), new DenseVector(3, 5), new DenseVector(3, 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -70,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -82,7 +86,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), null));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), null));
         }
 
         /// <summary>
@@ -94,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -106,12 +110,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(1.0, 0), new Complex(1.0, 0), new Complex(2.0, 0) });
-            var source = new DenseVector(new[] { new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0) });
-            var residual = new DenseVector(new[] { new Complex(1000, 0), new Complex(double.NaN, 0), new Complex(2001, 0) });
+            var solution = new DenseVector(new[] {new Complex(1.0, 0), new Complex(1.0, 0), new Complex(2.0, 0)});
+            var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
+            var residual = new DenseVector(new[] {new Complex(1000, 0), new Complex(double.NaN, 0), new Complex(2001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
         }
 
         /// <summary>
@@ -123,12 +127,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(1.0, 0), new Complex(1.0, 0), new Complex(double.NaN, 0) });
-            var source = new DenseVector(new[] { new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0) });
-            var residual = new DenseVector(new[] { new Complex(1000, 0), new Complex(1000, 0), new Complex(2001, 0) });
+            var solution = new DenseVector(new[] {new Complex(1.0, 0), new Complex(1.0, 0), new Complex(double.NaN, 0)});
+            var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
+            var residual = new DenseVector(new[] {new Complex(1000, 0), new Complex(1000, 0), new Complex(2001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
         }
 
         /// <summary>
@@ -140,12 +144,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(3.0, 0), new Complex(2.0, 0), new Complex(1, 0) });
-            var source = new DenseVector(new[] { new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0) });
-            var residual = new DenseVector(new[] { new Complex(1.0, 0), new Complex(2.0, 0), new Complex(3, 0) });
+            var solution = new DenseVector(new[] {new Complex(3.0, 0), new Complex(2.0, 0), new Complex(1, 0)});
+            var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
+            var residual = new DenseVector(new[] {new Complex(1.0, 0), new Complex(2.0, 0), new Complex(3, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
         }
 
         /// <summary>
@@ -157,15 +161,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(1.0, 0), new Complex(1.0, 0), new Complex(2, 0) });
-            var source = new DenseVector(new[] { new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0) });
-            var residual = new DenseVector(new[] { new Complex(1000, 0), new Complex(1000, 0), new Complex(2001, 0) });
+            var solution = new DenseVector(new[] {new Complex(1.0, 0), new Complex(1.0, 0), new Complex(2, 0)});
+            var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
+            var residual = new DenseVector(new[] {new Complex(1000, 0), new Complex(1000, 0), new Complex(2001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -177,7 +181,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(FailureStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (FailureStopCriterium), clone, "Wrong criterium type");
         }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -81,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
         }
 
         /// <summary>
@@ -93,11 +97,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
-            criterium.DetermineStatus(10, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
         }
 
         /// <summary>
@@ -109,11 +113,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -127,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             Assert.AreEqual(10, criterium.MaximumNumberOfIterations, "Incorrect maximum");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(IterationCountStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (IterationCountStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as IterationCountStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -107,9 +111,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -124,8 +128,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -139,9 +143,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
+                DenseVector.Create(3, i => 4),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -155,8 +159,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -171,9 +175,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(4, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -187,9 +191,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(4, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -203,9 +207,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(4, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -217,12 +221,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new ResidualStopCriterium(1e-3, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) });
-            var source = new DenseVector(new[] { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(double.NaN, 1) });
-            var residual = new DenseVector(new[] { new Complex(1000.0, 1), new Complex(1000.0, 1), new Complex(2001.0, 1) });
+            var solution = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)});
+            var source = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(double.NaN, 1)});
+            var residual = new DenseVector(new[] {new Complex(1000.0, 1), new Complex(1000.0, 1), new Complex(2001.0, 1)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -234,12 +238,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new ResidualStopCriterium(1e-3, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) });
-            var source = new DenseVector(new[] { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) });
-            var residual = new DenseVector(new[] { new Complex(1000.0, 1), new Complex(double.NaN, 1), new Complex(2001.0, 1) });
+            var solution = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)});
+            var source = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)});
+            var residual = new DenseVector(new[] {new Complex(1000.0, 1), new Complex(double.NaN, 1), new Complex(2001.0, 1)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -255,12 +259,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new ResidualStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { Complex.One, Complex.One, Complex.One });
-            var source = new DenseVector(new[] { Complex.One, Complex.One, Complex.One });
-            var residual = new DenseVector(new[] { Complex.Zero, Complex.Zero, Complex.Zero });
+            var solution = new DenseVector(new[] {Complex.One, Complex.One, Complex.One});
+            var source = new DenseVector(new[] {Complex.One, Complex.One, Complex.One});
+            var residual = new DenseVector(new[] {Complex.Zero, Complex.Zero, Complex.Zero});
 
             criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -273,19 +277,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             // the solution vector isn't actually being used so ...
-            var solution = new DenseVector(new[] { new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN) });
+            var solution = new DenseVector(new[] {new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN)});
 
             // Set the source values
-            var source = new DenseVector(new[] { new Complex(1.000, 1), new Complex(1.000, 1), new Complex(2.001, 1) });
+            var source = new DenseVector(new[] {new Complex(1.000, 1), new Complex(1.000, 1), new Complex(2.001, 1)});
 
             // Set the residual values
-            var residual = new DenseVector(new[] { new Complex(0.001, 0), new Complex(0.001, 0), new Complex(0.002, 0) });
+            var residual = new DenseVector(new[] {new Complex(0.001, 0), new Complex(0.001, 0), new Complex(0.002, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should still be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
 
             criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -297,15 +301,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new ResidualStopCriterium(1e-3, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1) });
-            var source = new DenseVector(new[] { new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1) });
-            var residual = new DenseVector(new[] { new Complex(1.000, 0), new Complex(1.000, 0), new Complex(2.001, 0) });
+            var solution = new DenseVector(new[] {new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1)});
+            var source = new DenseVector(new[] {new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1)});
+            var residual = new DenseVector(new[] {new Complex(1.000, 0), new Complex(1.000, 0), new Complex(2.001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -318,7 +322,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(ResidualStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (ResidualStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as ResidualStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Complex/SparseMatrixTests.cs

@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         /// <returns>The new vector. </returns>
         protected override Vector CreateVector(Complex[] data)
         {
-            return new SparseVector(data);
+            return SparseVector.OfEnumerable(data);
         }
 
         /// <summary>
@@ -211,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanAddSparseMatricesBothWays()
         {
             var m1 = new SparseMatrix(1, 3);
-            var m2 = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            var m2 = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             var sum1 = m1 + m2;
             var sum2 = m2 + m1;
             Assert.IsTrue(sum1.Equals(m2));
@@ -221,15 +221,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             sparseResult.Add(m2, sparseResult);
             Assert.IsTrue(sparseResult.Equals(sum1));
 
-            sparseResult = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            sparseResult = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             sparseResult.Add(m1, sparseResult);
             Assert.IsTrue(sparseResult.Equals(sum1));
 
-            sparseResult = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            sparseResult = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             m1.Add(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(sum1));
 
-            sparseResult = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            sparseResult = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             sparseResult.Add(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(2*sum1));
 
@@ -255,7 +255,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanSubtractSparseMatricesBothWays()
         {
             var m1 = new SparseMatrix(1, 3);
-            var m2 = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            var m2 = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             var diff1 = m1 - m2;
             var diff2 = m2 - m1;
             Assert.IsTrue(diff1.Equals(m2.Negate()));
@@ -265,15 +265,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             sparseResult.Subtract(m2, sparseResult);
             Assert.IsTrue(sparseResult.Equals(diff1));
 
-            sparseResult = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            sparseResult = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             sparseResult.Subtract(m1, sparseResult);
             Assert.IsTrue(sparseResult.Equals(diff2));
 
-            sparseResult = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            sparseResult = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             m1.Subtract(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(diff1));
 
-            sparseResult = SparseMatrix.OfArray(new Complex[,] { { 0, 1, 1 } });
+            sparseResult = SparseMatrix.OfArray(new Complex[,] {{0, 1, 1}});
             sparseResult.Subtract(sparseResult, sparseResult);
             Assert.IsTrue(sparseResult.Equals(0*diff1));
 

src/UnitTests/LinearAlgebraTests/Complex/SparseVectorArithmeticTheory.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -41,13 +41,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Datapoints]
         Vector<Complex>[] denseVectors = new Vector<Complex>[]
             {
-                new SparseVector(new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1) }),
-                new SparseVector(new[] { new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0) }),
+                SparseVector.OfEnumerable(new[] {new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1), new Complex(5, 1)}),
+                SparseVector.OfEnumerable(new[] {new Complex(2, -1), new Complex(0, 0), new Complex(0, 2), new Complex(-5, 1), new Complex(0, 0)}),
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
 
         [Datapoints]
-        private Complex[] scalars = new[] { new Complex(2d, -1d) };
+        Complex[] scalars = new[] {new Complex(2d, -1d)};
     }
 }

src/UnitTests/LinearAlgebraTests/Complex/SparseVectorTest.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         {
             var data = new Complex[Data.Length];
             Array.Copy(Data, data, Data.Length);
-            var vector = new SparseVector(data);
+            var vector = SparseVector.OfEnumerable(data);
 
             for (var i = 0; i < data.Length; i++)
             {
@@ -91,8 +91,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanCreateSparseVectorFromAnotherSparseVector()
         {
-            var vector = new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -107,8 +107,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanCreateSparseVectorFromAnotherVector()
         {
-            var vector = (Vector<Complex>)new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = (Vector<Complex>)SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -124,7 +124,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CanCreateSparseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new SparseVector(vector);
+            var other = SparseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -150,9 +150,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanConvertSparseVectorToArray()
         {
-            var vector = new SparseVector(Data);
+            var vector = SparseVector.OfEnumerable(Data);
             var array = vector.ToArray();
-            Assert.IsInstanceOf(typeof(Complex[]), array);
+            Assert.IsInstanceOf(typeof (Complex[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -162,9 +162,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanConvertArrayToSparseVector()
         {
-            var array = new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1) };
-            var vector = new SparseVector(array);
-            Assert.IsInstanceOf(typeof(SparseVector), vector);
+            var array = new[] {new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1)};
+            var vector = SparseVector.OfEnumerable(array);
+            Assert.IsInstanceOf(typeof (SparseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
 
@@ -174,32 +174,32 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanMultiplySparseVectorByScalarUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector * new Complex(2.0, 1);
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector*new Complex(2.0, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
 
-            vector = vector * 1.0;
+            vector = vector*1.0;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
 
-            vector = new SparseVector(Data);
-            vector = new Complex(2.0, 1) * vector;
+            vector = SparseVector.OfEnumerable(Data);
+            vector = new Complex(2.0, 1)*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
 
-            vector = 1.0 * vector;
+            vector = 1.0*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex(2.0, 1), vector[i]);
             }
         }
 
@@ -209,18 +209,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanDivideSparseVectorByScalarUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector / new Complex(2.0, 1);
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector/new Complex(2.0, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex(2.0, 1), vector[i], 14);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14);
             }
 
-            vector = vector / 1.0;
+            vector = vector/1.0;
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex(2.0, 1), vector[i], 14);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex(2.0, 1), vector[i], 14);
             }
         }
 
@@ -237,7 +237,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }
@@ -261,7 +261,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         public void CheckSparseMechanismBySettingValues()
         {
             var vector = new SparseVector(10000);
-            var storage = (SparseVectorStorage<Complex>)vector.Storage;
+            var storage = (SparseVectorStorage<Complex>) vector.Storage;
 
             // Add non-zero elements
             vector[200] = new Complex(1.5, 1);
@@ -315,7 +315,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
             // Multiply by 0
             vector *= 0;
 
-            var storage = (SparseVectorStorage<Complex>)vector.Storage;
+            var storage = (SparseVectorStorage<Complex>) vector.Storage;
             Assert.AreEqual(Complex.Zero, vector[200]);
             Assert.AreEqual(Complex.Zero, vector[500]);
             Assert.AreEqual(Complex.Zero, vector[800]);
@@ -350,19 +350,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex
         [Test]
         public void CanPointwiseMultiplySparseVector()
         {
-            var zeroArray = new[] { Complex.Zero, new Complex(1.0, 1), Complex.Zero, new Complex(1.0, 1), Complex.Zero };
-            var vector1 = new SparseVector(Data);
-            var vector2 = new SparseVector(zeroArray);
+            var zeroArray = new[] {Complex.Zero, new Complex(1.0, 1), Complex.Zero, new Complex(1.0, 1), Complex.Zero};
+            var vector1 = SparseVector.OfEnumerable(Data);
+            var vector2 = SparseVector.OfEnumerable(zeroArray);
             var result = new SparseVector(vector1.Count);
 
             vector1.PointwiseMultiply(vector2, result);
 
             for (var i = 0; i < vector1.Count; i++)
             {
-                Assert.AreEqual(Data[i] * zeroArray[i], result[i]);
+                Assert.AreEqual(Data[i]*zeroArray[i], result[i]);
             }
 
-            var resultStorage = (SparseVectorStorage<Complex>)result.Storage;
+            var resultStorage = (SparseVectorStorage<Complex>) result.Storage;
             Assert.AreEqual(2, resultStorage.ValueCount);
         }
 

src/UnitTests/LinearAlgebraTests/Complex32/DenseVectorTests.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -90,7 +94,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanCreateDenseVectorFromAnotherDenseVector()
         {
             var vector = new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -105,8 +109,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanCreateDenseVectorFromAnotherVector()
         {
-            var vector = (Vector<Complex32>)new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var vector = (Vector<Complex32>) new DenseVector(Data);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -122,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanCreateDenseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -136,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanCreateDenseVectorWithConstantValues()
         {
-            var vector = new DenseVector(5, 5);
+            var vector = DenseVector.Create(5, i => 5);
             foreach (var t in vector)
             {
                 Assert.AreEqual(t, new Complex32(5.0f, 0));
@@ -162,8 +166,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanConvertDenseVectorToArray()
         {
             var vector = new DenseVector(Data);
-            var array = (Complex32[])vector;
-            Assert.IsInstanceOf(typeof(Complex32[]), array);
+            var array = (Complex32[]) vector;
+            Assert.IsInstanceOf(typeof (Complex32[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -173,9 +177,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanConvertArrayToDenseVector()
         {
-            var array = new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1) };
-            var vector = (DenseVector)array;
-            Assert.IsInstanceOf(typeof(DenseVector), vector);
+            var array = new[] {new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1)};
+            var vector = (DenseVector) array;
+            Assert.IsInstanceOf(typeof (DenseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
 
@@ -207,7 +211,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, result[i]);
+                Assert.AreEqual(Data[i]*2.0f, result[i]);
             }
         }
 
@@ -250,31 +254,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanMultiplyDenseVectorByComplexUsingOperators()
         {
             var vector = new DenseVector(Data);
-            vector = vector * new Complex32(2.0f, 1);
+            vector = vector*new Complex32(2.0f, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
 
-            vector = vector * 1.0f;
+            vector = vector*1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
 
             vector = new DenseVector(Data);
-            vector = new Complex32(2.0f, 1) * vector;
+            vector = new Complex32(2.0f, 1)*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
 
-            vector = 1.0f * vector;
+            vector = 1.0f*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
         }
 
@@ -285,17 +289,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanDivideDenseVectorByComplexUsingOperators()
         {
             var vector = new DenseVector(Data);
-            vector = vector / new Complex32(2.0f, 1);
+            vector = vector/new Complex32(2.0f, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex32(2.0f, 1), vector[i], 7);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7);
             }
 
-            vector = vector / 1.0f;
+            vector = vector/1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex32(2.0f, 1), vector[i], 7);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7);
             }
         }
 
@@ -312,7 +316,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }

src/UnitTests/LinearAlgebraTests/Complex32/DiagonalMatrixTests.cs

@@ -103,7 +103,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         /// <returns>The new vector. </returns>
         protected override Vector CreateVector(Complex32[] data)
         {
-            return new SparseVector(data);
+            return SparseVector.OfEnumerable(data);
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/BiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterative
 {
     using System;
@@ -43,12 +48,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +91,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, Complex32.One);
+            Vector y = DenseVector.Create(matrix.RowCount, i => Complex32.One);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -128,19 +133,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply(new Complex32((float)Math.PI, (float)Math.PI), matrix);
+            matrix.Multiply(new Complex32((float) Math.PI, (float) Math.PI), matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, Complex32.One);
+            Vector y = DenseVector.Create(matrix.RowCount, i => Complex32.One);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -209,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, Complex32.One);
+            Vector y = DenseVector.Create(matrix.RowCount, i => Complex32.One);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -237,7 +242,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             // Now compare the vectors
             for (var i = 0; i < y.Count; i++)
             {
-#if !PORTABLE 
+#if !PORTABLE
                 Assert.IsTrue((y[i] - z[i]).Magnitude.IsSmaller(ConvergenceBoundary, 1), "#05-" + i);
 #else
                 Assert.IsTrue((y[i] - z[i]).Magnitude.IsSmaller(ConvergenceBoundary * 10.0f, 1), "#05-" + i);
@@ -258,10 +263,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new BiCgStab(monitor);
 
                 var resultx = solver.Solve(matrixA, vectorb);
@@ -273,13 +278,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -301,10 +306,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new BiCgStab(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -320,15 +325,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                        Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new GpBiCg(monitor);
 
             // Solve equation Ax = y
@@ -128,19 +132,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -256,10 +260,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new GpBiCg(monitor);
 
                 var resultx = solver.Solve(matrixA, vectorb);
@@ -271,13 +275,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new MlkBiCgStab(monitor);
 
@@ -129,19 +133,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -255,10 +259,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new MlkBiCgStab(monitor);
 
                 var resultx = solver.Solve(matrixA, vectorb);
@@ -270,13 +274,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -298,10 +302,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new MlkBiCgStab(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -317,15 +321,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                        Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new TFQMR(monitor);
 
@@ -129,19 +133,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -255,10 +259,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new TFQMR(monitor);
 
                 var resultx = solver.Solve(matrixA, vectorb);
@@ -270,13 +274,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Real, matrixBReconstruct[i].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i].Imaginary, matrixBReconstruct[i].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -298,10 +302,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(1000),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(1000),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new TFQMR(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -317,15 +321,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Iterat
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, (float)Math.Pow(1.0 / 10.0, iteration - 3));
-                        Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j].Real, matrixBReconstruct[i, j].Real, (float) Math.Pow(1.0/10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j].Imaginary, matrixBReconstruct[i, j].Imaginary, (float) Math.Pow(1.0/10.0, iteration - 3));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
 {
     using System;
@@ -56,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         [Test]
         public void CreateWithEmptyCollection()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { });
+            var iterator = new Iterator(new IIterationStopCriterium[] {});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -67,7 +72,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         [Test]
         public void CreateWithCollectionWithNulls()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { null, null });
+            var iterator = new Iterator(new IIterationStopCriterium[] {null, null});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -79,10 +84,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void CreateWithDuplicatesThrowsArgumentException()
         {
             Assert.Throws<ArgumentException>(() => new Iterator(new IIterationStopCriterium[]
-                                                                {
-                                                                    new FailureStopCriterium(),
-                                                                    new FailureStopCriterium()
-                                                                }));
+                {
+                    new FailureStopCriterium(),
+                    new FailureStopCriterium()
+                }));
         }
 
         /// <summary>
@@ -92,12 +97,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void CreateWithCollection()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.IsNotNull(iterator, "Should have an iterator");
 
@@ -139,12 +144,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void Add()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator();
             Assert.AreEqual(0, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -169,12 +174,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void RemoveWithNullStopCriteriumThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -188,11 +193,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void RemoveWithNonExistingStopCriterium()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -207,12 +212,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void Remove()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -232,9 +237,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
             var iterator = new Iterator();
             Assert.Throws<ArgumentException>(() => iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -244,19 +249,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -266,19 +271,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -288,19 +293,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatusWithNullSourceVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 5),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -310,18 +315,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatusWithNullResidualVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -332,29 +337,29 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
         }
 
         /// <summary>
@@ -364,27 +369,27 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             iterator.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), iterator.Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[0].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[1].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[2].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), iterator.Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[0].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[1].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[2].Status, "Incorrect status");
         }
 
         /// <summary>
@@ -394,17 +399,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void Clone()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
 
             var iterator = new Iterator(criteria);
 
             var clonedIterator = iterator.Clone();
-            Assert.IsInstanceOf(typeof(Iterator), clonedIterator, "Incorrect type");
+            Assert.IsInstanceOf(typeof (Iterator), clonedIterator, "Incorrect type");
 
             var clone = clonedIterator as Iterator;
             Assert.IsNotNull(clone);

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCriterium
 {
     using System;
@@ -108,9 +113,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -122,8 +127,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -143,10 +148,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32((i + 1) * (Increase + 0.1f), 0) }));
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32((i + 1)*(Increase + 0.1f), 0)}));
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -162,15 +167,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. We should not diverge because we won't have enough increase
-            for (var i = 0; i < Iterations * 2; i++)
+            for (var i = 0; i < Iterations*2; i++)
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32((i + 1) * (Increase - 0.01f), 0) }));
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32((i + 1)*(Increase - 0.01f), 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -190,21 +195,21 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32((i + 1) * (Increase - 0.01f), 0) }));
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32((i + 1)*(Increase - 0.01f), 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
             criterium.DetermineStatus(
                 Iterations,
-                new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                new DenseVector(new[] { new Complex32(float.NaN, 0) }));
+                new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                new DenseVector(new[] {new Complex32(float.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -225,22 +230,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
                 previous *= 1 + Increase + 0.01f;
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                    new DenseVector(new[] { new Complex32(previous, 0) }));
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                    new DenseVector(new[] {new Complex32(previous, 0)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01f;
             criterium.DetermineStatus(
                 Iterations - 1,
-                new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                new DenseVector(new[] { new Complex32(previous, 0) }));
+                new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                new DenseVector(new[] {new Complex32(previous, 0)}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -257,18 +262,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             // Add residuals. Blow it up instantly
             criterium.DetermineStatus(
                 1,
-                new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                new DenseVector(new[] { new Complex32(1.0f, 0) }),
-                new DenseVector(new[] { new Complex32(float.NaN, 0) }));
+                new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                new DenseVector(new[] {new Complex32(1.0f, 0)}),
+                new DenseVector(new[] {new Complex32(float.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
 
             Assert.AreEqual(Increase, criterium.MaximumRelativeIncrease, "Incorrect maximum");
             Assert.AreEqual(Iterations, criterium.MinimumNumberOfIterations, "Incorrect iteration count");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -284,7 +289,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(DivergenceStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (DivergenceStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as DivergenceStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCriterium
 {
     using System;
@@ -57,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 4), new DenseVector(3, 5), new DenseVector(3, 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -69,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -81,7 +86,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), null));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), null));
         }
 
         /// <summary>
@@ -93,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -105,12 +110,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(2.0f, 0) });
-            var source = new DenseVector(new[] { new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0) });
-            var residual = new DenseVector(new[] { new Complex32(1000, 0), new Complex32(float.NaN, 0), new Complex32(2001, 0) });
+            var solution = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(2.0f, 0)});
+            var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
+            var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(float.NaN, 0), new Complex32(2001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
         }
 
         /// <summary>
@@ -122,12 +127,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(float.NaN, 0) });
-            var source = new DenseVector(new[] { new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0) });
-            var residual = new DenseVector(new[] { new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0) });
+            var solution = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(float.NaN, 0)});
+            var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
+            var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
         }
 
         /// <summary>
@@ -139,12 +144,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(3.0f, 0), new Complex32(2.0f, 0), new Complex32(1, 0) });
-            var source = new DenseVector(new[] { new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0) });
-            var residual = new DenseVector(new[] { new Complex32(1.0f, 0), new Complex32(2.0f, 0), new Complex32(3, 0) });
+            var solution = new DenseVector(new[] {new Complex32(3.0f, 0), new Complex32(2.0f, 0), new Complex32(1, 0)});
+            var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
+            var residual = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(2.0f, 0), new Complex32(3, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
         }
 
         /// <summary>
@@ -156,15 +161,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(2, 0) });
-            var source = new DenseVector(new[] { new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0) });
-            var residual = new DenseVector(new[] { new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0) });
+            var solution = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(1.0f, 0), new Complex32(2, 0)});
+            var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
+            var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -177,7 +182,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(FailureStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (FailureStopCriterium), clone, "Wrong criterium type");
         }
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCriterium
 {
     using System;
@@ -80,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
         }
 
         /// <summary>
@@ -92,11 +97,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
-            criterium.DetermineStatus(10, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
         }
 
         /// <summary>
@@ -108,11 +113,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -126,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             Assert.AreEqual(10, criterium.MaximumNumberOfIterations, "Incorrect maximum");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(IterationCountStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (IterationCountStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as IterationCountStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -107,9 +111,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -124,8 +128,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -139,9 +143,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
+                DenseVector.Create(3, i => 4),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -155,8 +159,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -171,9 +175,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(4, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -187,9 +191,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(4, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -203,9 +207,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(4, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -217,12 +221,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new ResidualStopCriterium(1e-3f, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) });
-            var source = new DenseVector(new[] { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(float.NaN, 1) });
-            var residual = new DenseVector(new[] { new Complex32(1000.0f, 1), new Complex32(1000.0f, 1), new Complex32(2001.0f, 1) });
+            var solution = new DenseVector(new[] {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)});
+            var source = new DenseVector(new[] {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(float.NaN, 1)});
+            var residual = new DenseVector(new[] {new Complex32(1000.0f, 1), new Complex32(1000.0f, 1), new Complex32(2001.0f, 1)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -234,12 +238,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new ResidualStopCriterium(1e-3f, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) });
-            var source = new DenseVector(new[] { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) });
-            var residual = new DenseVector(new[] { new Complex32(1000.0f, 1), new Complex32(float.NaN, 1), new Complex32(2001.0f, 1) });
+            var solution = new DenseVector(new[] {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)});
+            var source = new DenseVector(new[] {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)});
+            var residual = new DenseVector(new[] {new Complex32(1000.0f, 1), new Complex32(float.NaN, 1), new Complex32(2001.0f, 1)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -255,12 +259,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new ResidualStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { Complex32.One, Complex32.One, Complex32.One });
-            var source = new DenseVector(new[] { Complex32.One, Complex32.One, Complex32.One });
-            var residual = new DenseVector(new[] { Complex32.Zero, Complex32.Zero, Complex32.Zero });
+            var solution = new DenseVector(new[] {Complex32.One, Complex32.One, Complex32.One});
+            var source = new DenseVector(new[] {Complex32.One, Complex32.One, Complex32.One});
+            var residual = new DenseVector(new[] {Complex32.Zero, Complex32.Zero, Complex32.Zero});
 
             criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -273,19 +277,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             // the solution vector isn't actually being used so ...
-            var solution = new DenseVector(new[] { new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN) });
+            var solution = new DenseVector(new[] {new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN)});
 
             // Set the source values
-            var source = new DenseVector(new[] { new Complex32(1.000f, 1), new Complex32(1.000f, 1), new Complex32(2.001f, 1) });
+            var source = new DenseVector(new[] {new Complex32(1.000f, 1), new Complex32(1.000f, 1), new Complex32(2.001f, 1)});
 
             // Set the residual values
-            var residual = new DenseVector(new[] { new Complex32(0.001f, 0), new Complex32(0.001f, 0), new Complex32(0.002f, 0) });
+            var residual = new DenseVector(new[] {new Complex32(0.001f, 0), new Complex32(0.001f, 0), new Complex32(0.002f, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should still be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
 
             criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -297,15 +301,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new ResidualStopCriterium(1e-3f, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { new Complex32(0.001f, 1), new Complex32(0.001f, 1), new Complex32(0.002f, 1) });
-            var source = new DenseVector(new[] { new Complex32(0.001f, 1), new Complex32(0.001f, 1), new Complex32(0.002f, 1) });
-            var residual = new DenseVector(new[] { new Complex32(1.000f, 0), new Complex32(1.000f, 0), new Complex32(2.001f, 0) });
+            var solution = new DenseVector(new[] {new Complex32(0.001f, 1), new Complex32(0.001f, 1), new Complex32(0.002f, 1)});
+            var source = new DenseVector(new[] {new Complex32(0.001f, 1), new Complex32(0.001f, 1), new Complex32(0.002f, 1)});
+            var residual = new DenseVector(new[] {new Complex32(1.000f, 0), new Complex32(1.000f, 0), new Complex32(2.001f, 0)});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -318,7 +322,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(ResidualStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (ResidualStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as ResidualStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Complex32/SparseMatrixTests.cs

@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         /// <returns>The new vector. </returns>
         protected override Vector CreateVector(Complex32[] data)
         {
-            return new SparseVector(data);
+            return SparseVector.OfEnumerable(data);
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorArithmeticTheory.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -41,13 +41,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Datapoints]
         Vector<Complex32>[] denseVectors = new Vector<Complex32>[]
             {
-                new SparseVector(new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1) }),
-                new SparseVector(new[] { new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0) }),
+                SparseVector.OfEnumerable(new[] {new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1), new Complex32(5, 1)}),
+                SparseVector.OfEnumerable(new[] {new Complex32(2, -1), new Complex32(0, 0), new Complex32(0, 2), new Complex32(-5, 1), new Complex32(0, 0)}),
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
 
         [Datapoints]
-        private Complex32[] scalars = new[] { new Complex32(2f, -1f) };
+        Complex32[] scalars = new[] {new Complex32(2f, -1f)};
     }
 }

src/UnitTests/LinearAlgebraTests/Complex32/SparseVectorTest.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         {
             var data = new Complex32[Data.Length];
             Array.Copy(Data, data, Data.Length);
-            var vector = new SparseVector(data);
+            var vector = SparseVector.OfEnumerable(data);
 
             for (var i = 0; i < data.Length; i++)
             {
@@ -91,8 +91,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanCreateSparseVectorFromAnotherSparseVector()
         {
-            var vector = new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -107,8 +107,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanCreateSparseVectorFromAnotherVector()
         {
-            var vector = (Vector<Complex32>)new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = (Vector<Complex32>) SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -124,7 +124,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CanCreateSparseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new SparseVector(vector);
+            var other = SparseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -150,9 +150,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanConvertSparseVectorToArray()
         {
-            var vector = new SparseVector(Data);
+            var vector = SparseVector.OfEnumerable(Data);
             var array = vector.ToArray();
-            Assert.IsInstanceOf(typeof(Complex32[]), array);
+            Assert.IsInstanceOf(typeof (Complex32[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -162,9 +162,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanConvertArrayToSparseVector()
         {
-            var array = new[] { new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1) };
-            var vector = new SparseVector(array);
-            Assert.IsInstanceOf(typeof(SparseVector), vector);
+            var array = new[] {new Complex32(1, 1), new Complex32(2, 1), new Complex32(3, 1), new Complex32(4, 1)};
+            var vector = SparseVector.OfEnumerable(array);
+            Assert.IsInstanceOf(typeof (SparseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
 
@@ -174,32 +174,32 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanMultiplySparseVectorByComplexUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector * new Complex32(2.0f, 1);
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector*new Complex32(2.0f, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
 
-            vector = vector * 1.0f;
+            vector = vector*1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
 
-            vector = new SparseVector(Data);
-            vector = new Complex32(2.0f, 1) * vector;
+            vector = SparseVector.OfEnumerable(Data);
+            vector = new Complex32(2.0f, 1)*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
 
-            vector = 1.0f * vector;
+            vector = 1.0f*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * new Complex32(2.0f, 1), vector[i]);
+                Assert.AreEqual(Data[i]*new Complex32(2.0f, 1), vector[i]);
             }
         }
 
@@ -209,18 +209,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanDivideSparseVectorByComplexUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector / new Complex32(2.0f, 1);
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector/new Complex32(2.0f, 1);
 
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex32(2.0f, 1), vector[i], 7);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7);
             }
 
-            vector = vector / 1.0f;
+            vector = vector/1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                AssertHelpers.AlmostEqual(Data[i] / new Complex32(2.0f, 1), vector[i], 7);
+                AssertHelpers.AlmostEqual(Data[i]/new Complex32(2.0f, 1), vector[i], 7);
             }
         }
 
@@ -237,7 +237,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }
@@ -261,7 +261,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         public void CheckSparseMechanismBySettingValues()
         {
             var vector = new SparseVector(10000);
-            var storage = (SparseVectorStorage<Complex32>)vector.Storage;
+            var storage = (SparseVectorStorage<Complex32>) vector.Storage;
 
             // Add non-zero elements
             vector[200] = new Complex32(1.5f, 1);
@@ -315,7 +315,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
             // Multiply by 0
             vector *= 0;
 
-            var storage = (SparseVectorStorage<Complex32>)vector.Storage;
+            var storage = (SparseVectorStorage<Complex32>) vector.Storage;
             Assert.AreEqual(Complex32.Zero, vector[200]);
             Assert.AreEqual(Complex32.Zero, vector[500]);
             Assert.AreEqual(Complex32.Zero, vector[800]);
@@ -350,19 +350,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32
         [Test]
         public void CanPointwiseMultiplySparseVector()
         {
-            var zeroArray = new[] { Complex32.Zero, new Complex32(1.0f, 1), Complex32.Zero, new Complex32(1.0f, 1), Complex32.Zero };
-            var vector1 = new SparseVector(Data);
-            var vector2 = new SparseVector(zeroArray);
+            var zeroArray = new[] {Complex32.Zero, new Complex32(1.0f, 1), Complex32.Zero, new Complex32(1.0f, 1), Complex32.Zero};
+            var vector1 = SparseVector.OfEnumerable(Data);
+            var vector2 = SparseVector.OfEnumerable(zeroArray);
             var result = new SparseVector(vector1.Count);
 
             vector1.PointwiseMultiply(vector2, result);
 
             for (var i = 0; i < vector1.Count; i++)
             {
-                Assert.AreEqual(Data[i] * zeroArray[i], result[i]);
+                Assert.AreEqual(Data[i]*zeroArray[i], result[i]);
             }
 
-            var resultStorage = (SparseVectorStorage<Complex32>)result.Storage;
+            var resultStorage = (SparseVectorStorage<Complex32>) result.Storage;
             Assert.AreEqual(2, resultStorage.ValueCount);
         }
 

src/UnitTests/LinearAlgebraTests/Double/DenseVectorTests.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -89,7 +93,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateDenseVectorFromAnotherDenseVector()
         {
             var vector = new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -105,7 +109,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateDenseVectorFromAnotherVector()
         {
             var vector = (Vector<double>)new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -121,7 +125,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateDenseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -135,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateDenseVectorWithConstantValues()
         {
-            var vector = new DenseVector(5, 5);
+            var vector = DenseVector.Create(5, i => 5);
             foreach (var t in vector)
             {
                 Assert.AreEqual(t, 5);

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -131,16 +135,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -209,16 +213,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -258,16 +262,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new BiCgStab(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -289,10 +293,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10)
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10)
+                });
             var solver = new BiCgStab(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -302,7 +306,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new GpBiCg(monitor);
 
             // Solve equation Ax = y
@@ -131,16 +135,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -260,16 +264,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new GpBiCg(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -291,10 +295,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10)
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10)
+                });
             var solver = new GpBiCg(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -304,7 +308,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new MlkBiCgStab(monitor);
 
@@ -132,16 +136,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -259,16 +263,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new MlkBiCgStab(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -290,10 +294,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10)
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10)
+                });
             var solver = new MlkBiCgStab(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -303,7 +307,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -43,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const double ConvergenceBoundary = 1e-10;
+        const double ConvergenceBoundary = 1e-10;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -86,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new TFQMR(monitor);
 
@@ -132,16 +136,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             matrix.Multiply(Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -210,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -255,16 +259,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10),
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10),
+                });
             var solver = new TFQMR(monitor);
 
             var resultx = solver.Solve(matrixA, vectorb);
             Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
 
-            var matrixBReconstruct = matrixA * resultx;
+            var matrixBReconstruct = matrixA*resultx;
 
             // Check the reconstruction.
             for (var i = 0; i < order; i++)
@@ -286,10 +290,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(1000),
-                                           new ResidualStopCriterium(1e-10)
-                                       });
+                {
+                    new IterationCountStopCriterium(1000),
+                    new ResidualStopCriterium(1e-10)
+                });
             var solver = new TFQMR(monitor);
             var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -299,7 +303,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Iterative
             // The solution X has the same number of columns as B
             Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-            var matrixBReconstruct = matrixA * matrixX;
+            var matrixBReconstruct = matrixA*matrixX;
 
             // Check the reconstruction.
             for (var i = 0; i < matrixB.RowCount; i++)

src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -57,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         [Test]
         public void CreateWithEmptyCollection()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { });
+            var iterator = new Iterator(new IIterationStopCriterium[] {});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -68,7 +72,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         [Test]
         public void CreateWithCollectionWithNulls()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { null, null });
+            var iterator = new Iterator(new IIterationStopCriterium[] {null, null});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -80,10 +84,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void CreateWithDuplicatesThrowsArgumentException()
         {
             Assert.Throws<ArgumentException>(() => new Iterator(new IIterationStopCriterium[]
-                                                                {
-                                                                    new FailureStopCriterium(),
-                                                                    new FailureStopCriterium()
-                                                                }));
+                {
+                    new FailureStopCriterium(),
+                    new FailureStopCriterium()
+                }));
         }
 
         /// <summary>
@@ -93,12 +97,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void CreateWithCollection()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.IsNotNull(iterator, "Should have an iterator");
 
@@ -140,12 +144,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void Add()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator();
             Assert.AreEqual(0, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -170,12 +174,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void RemoveWithNullStopCriteriumThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -189,11 +193,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void RemoveWithNonExistingStopCriterium()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -208,12 +212,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void Remove()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -233,9 +237,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
             var iterator = new Iterator();
             Assert.Throws<ArgumentException>(() => iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -245,19 +249,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -267,19 +271,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -289,19 +293,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatusWithNullSourceVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 5),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -311,18 +315,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatusWithNullResidualVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -333,29 +337,29 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
         }
 
         /// <summary>
@@ -365,27 +369,27 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             iterator.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), iterator.Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[0].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[1].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[2].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), iterator.Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[0].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[1].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[2].Status, "Incorrect status");
         }
 
         /// <summary>
@@ -395,17 +399,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void Clone()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
 
             var iterator = new Iterator(criteria);
 
             var clonedIterator = iterator.Clone();
-            Assert.IsInstanceOf(typeof(Iterator), clonedIterator, "Incorrect type");
+            Assert.IsInstanceOf(typeof (Iterator), clonedIterator, "Incorrect type");
 
             var clone = clonedIterator as Iterator;
             Assert.IsNotNull(clone);

src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -108,9 +112,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -122,8 +126,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -143,11 +147,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { (i + 1) * (Increase + 0.1) }));
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {(i + 1)*(Increase + 0.1)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -163,15 +167,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. We should not diverge because we won't have enough increase
-            for (var i = 0; i < Iterations * 2; i++)
+            for (var i = 0; i < Iterations*2; i++)
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { (i + 1) * (Increase - 0.01) }));
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {(i + 1)*(Increase - 0.01)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -191,21 +195,21 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { (i + 1) * (Increase - 0.01) }));
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {(i + 1)*(Increase - 0.01)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
             criterium.DetermineStatus(
                 Iterations,
-                new DenseVector(new[] { 1.0 }),
-                new DenseVector(new[] { 1.0 }),
-                new DenseVector(new[] { double.NaN }));
+                new DenseVector(new[] {1.0}),
+                new DenseVector(new[] {1.0}),
+                new DenseVector(new[] {double.NaN}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -226,22 +230,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
                 previous *= 1 + Increase + 0.01;
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { 1.0 }),
-                    new DenseVector(new[] { previous }));
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {1.0}),
+                    new DenseVector(new[] {previous}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01;
             criterium.DetermineStatus(
                 Iterations - 1,
-                new DenseVector(new[] { 1.0 }),
-                new DenseVector(new[] { 1.0 }),
-                new DenseVector(new[] { previous }));
+                new DenseVector(new[] {1.0}),
+                new DenseVector(new[] {1.0}),
+                new DenseVector(new[] {previous}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -258,18 +262,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             // Add residuals. Blow it up instantly
             criterium.DetermineStatus(
                 1,
-                new DenseVector(new[] { 1.0 }),
-                new DenseVector(new[] { 1.0 }),
-                new DenseVector(new[] { double.NaN }));
+                new DenseVector(new[] {1.0}),
+                new DenseVector(new[] {1.0}),
+                new DenseVector(new[] {double.NaN}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
 
             Assert.AreEqual(Increase, criterium.MaximumRelativeIncrease, "Incorrect maximum");
             Assert.AreEqual(Iterations, criterium.MinimumNumberOfIterations, "Incorrect iteration count");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -285,7 +289,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(DivergenceStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (DivergenceStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as DivergenceStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -57,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 4), new DenseVector(3, 5), new DenseVector(3, 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -69,7 +73,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -81,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), null));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), null));
         }
 
         /// <summary>
@@ -93,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -81,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
         }
 
         /// <summary>
@@ -93,11 +97,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
-            criterium.DetermineStatus(10, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
         }
 
         /// <summary>
@@ -109,11 +113,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -127,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             Assert.AreEqual(10, criterium.MaximumNumberOfIterations, "Incorrect maximum");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(IterationCountStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (IterationCountStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as IterationCountStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -106,9 +110,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -123,8 +127,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -138,9 +142,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
+                DenseVector.Create(3, i => 4),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -154,8 +158,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -170,9 +174,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(4, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -186,9 +190,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(4, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -202,9 +206,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(4, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -216,12 +220,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new ResidualStopCriterium(1e-3, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 });
-            var source = new DenseVector(new[] { 1.0, 1.0, double.NaN });
-            var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 });
+            var solution = new DenseVector(new[] {1.0, 1.0, 2.0});
+            var source = new DenseVector(new[] {1.0, 1.0, double.NaN});
+            var residual = new DenseVector(new[] {1000.0, 1000.0, 2001.0});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -233,12 +237,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new ResidualStopCriterium(1e-3, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 });
-            var source = new DenseVector(new[] { 1.0, 1.0, 2.0 });
-            var residual = new DenseVector(new[] { 1000.0, double.NaN, 2001.0 });
+            var solution = new DenseVector(new[] {1.0, 1.0, 2.0});
+            var source = new DenseVector(new[] {1.0, 1.0, 2.0});
+            var residual = new DenseVector(new[] {1000.0, double.NaN, 2001.0});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -250,12 +254,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new ResidualStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0, 1.0, 1.0 });
-            var source = new DenseVector(new[] { 1.0, 1.0, 1.0 });
-            var residual = new DenseVector(new[] { 0.0, 0.0, 0.0 });
+            var solution = new DenseVector(new[] {1.0, 1.0, 1.0});
+            var source = new DenseVector(new[] {1.0, 1.0, 1.0});
+            var residual = new DenseVector(new[] {0.0, 0.0, 0.0});
 
             criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -268,19 +272,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             // the solution vector isn't actually being used so ...
-            var solution = new DenseVector(new[] { double.NaN, double.NaN, double.NaN });
+            var solution = new DenseVector(new[] {double.NaN, double.NaN, double.NaN});
 
             // Set the source values
-            var source = new DenseVector(new[] { 1.000, 1.000, 2.001 });
+            var source = new DenseVector(new[] {1.000, 1.000, 2.001});
 
             // Set the residual values
-            var residual = new DenseVector(new[] { 0.001, 0.001, 0.002 });
+            var residual = new DenseVector(new[] {0.001, 0.001, 0.002});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should still be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
 
             criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -292,15 +296,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new ResidualStopCriterium(1e-3, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 0.001, 0.001, 0.002 });
-            var source = new DenseVector(new[] { 0.001, 0.001, 0.002 });
-            var residual = new DenseVector(new[] { 1.000, 1.000, 2.001 });
+            var solution = new DenseVector(new[] {0.001, 0.001, 0.002});
+            var source = new DenseVector(new[] {0.001, 0.001, 0.002});
+            var residual = new DenseVector(new[] {1.000, 1.000, 2.001});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -313,7 +317,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(ResidualStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (ResidualStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as ResidualStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Double/SparseMatrixTests.cs

@@ -80,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         /// <returns>The new vector. </returns>
         protected override Vector CreateVector(double[] data)
         {
-            return new SparseVector(data);
+            return SparseVector.OfEnumerable(data);
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Double/SparseVectorArithmeticTheory.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -40,14 +40,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Datapoints]
         Vector<double>[] denseVectors = new Vector<double>[]
             {
-                new SparseVector(new double[] { 1, 2, 3, 4, 5 }),
-                new SparseVector(new double[] { 2, 0, 0, -5, 0 }),
+                SparseVector.OfEnumerable(new double[] {1, 2, 3, 4, 5}),
+                SparseVector.OfEnumerable(new double[] {2, 0, 0, -5, 0}),
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
 
         [Datapoints]
-        private double[] scalars = new[] { 2d };
+        double[] scalars = new[] {2d};
 
     }
 }

src/UnitTests/LinearAlgebraTests/Double/SparseVectorTest.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -76,7 +76,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         {
             var data = new double[Data.Length];
             Array.Copy(Data, data, Data.Length);
-            var vector = new SparseVector(data);
+            var vector = SparseVector.OfEnumerable(data);
 
             for (var i = 0; i < data.Length; i++)
             {
@@ -90,8 +90,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateSparseVectorFromAnotherSparseVector()
         {
-            var vector = new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -106,8 +106,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanCreateSparseVectorFromAnotherVector()
         {
-            var vector = (Vector<double>)new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = (Vector<double>)SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -123,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CanCreateSparseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new SparseVector(vector);
+            var other = SparseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -149,9 +149,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanConvertSparseVectorToArray()
         {
-            var vector = new SparseVector(Data);
+            var vector = SparseVector.OfEnumerable(Data);
             var array = vector.ToArray();
-            Assert.IsInstanceOf(typeof(double[]), array);
+            Assert.IsInstanceOf(typeof (double[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -161,9 +161,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanConvertArrayToSparseVector()
         {
-            var array = new[] { 0.0, 1.0, 2.0, 3.0, 4.0 };
-            var vector = new SparseVector(array);
-            Assert.IsInstanceOf(typeof(SparseVector), vector);
+            var array = new[] {0.0, 1.0, 2.0, 3.0, 4.0};
+            var vector = SparseVector.OfEnumerable(array);
+            Assert.IsInstanceOf(typeof (SparseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
 
@@ -173,32 +173,32 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanMultiplySparseVectorByScalarUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector * 2.0;
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector*2.0;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0, vector[i]);
+                Assert.AreEqual(Data[i]*2.0, vector[i]);
             }
 
-            vector = vector * 1.0;
+            vector = vector*1.0;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0, vector[i]);
+                Assert.AreEqual(Data[i]*2.0, vector[i]);
             }
 
-            vector = new SparseVector(Data);
-            vector = 2.0 * vector;
+            vector = SparseVector.OfEnumerable(Data);
+            vector = 2.0*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0, vector[i]);
+                Assert.AreEqual(Data[i]*2.0, vector[i]);
             }
 
-            vector = 1.0 * vector;
+            vector = 1.0*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0, vector[i]);
+                Assert.AreEqual(Data[i]*2.0, vector[i]);
             }
         }
 
@@ -208,18 +208,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanDivideSparseVectorByScalarUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector / 2.0;
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector/2.0;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] / 2.0, vector[i]);
+                Assert.AreEqual(Data[i]/2.0, vector[i]);
             }
 
-            vector = vector / 1.0;
+            vector = vector/1.0;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] / 2.0, vector[i]);
+                Assert.AreEqual(Data[i]/2.0, vector[i]);
             }
         }
 
@@ -236,7 +236,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }
@@ -260,7 +260,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         public void CheckSparseMechanismBySettingValues()
         {
             var vector = new SparseVector(10000);
-            var storage = (SparseVectorStorage<double>)vector.Storage;
+            var storage = (SparseVectorStorage<double>) vector.Storage;
 
             // Add non-zero elements
             vector[200] = 1.5;
@@ -314,7 +314,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
             // Multiply by 0
             vector *= 0;
 
-            var storage = (SparseVectorStorage<double>)vector.Storage;
+            var storage = (SparseVectorStorage<double>) vector.Storage;
             Assert.AreEqual(0, vector[200]);
             Assert.AreEqual(0, vector[500]);
             Assert.AreEqual(0, vector[800]);
@@ -349,19 +349,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanPointwiseMultiplySparseVector()
         {
-            var zeroArray = new[] { 0.0, 1.0, 0.0, 1.0, 0.0 };
-            var vector1 = new SparseVector(Data);
-            var vector2 = new SparseVector(zeroArray);
+            var zeroArray = new[] {0.0, 1.0, 0.0, 1.0, 0.0};
+            var vector1 = SparseVector.OfEnumerable(Data);
+            var vector2 = SparseVector.OfEnumerable(zeroArray);
             var result = new SparseVector(vector1.Count);
 
             vector1.PointwiseMultiply(vector2, result);
 
             for (var i = 0; i < vector1.Count; i++)
             {
-                Assert.AreEqual(Data[i] * zeroArray[i], result[i]);
+                Assert.AreEqual(Data[i]*zeroArray[i], result[i]);
             }
 
-            var resultStorage = (SparseVectorStorage<double>)result.Storage;
+            var resultStorage = (SparseVectorStorage<double>) result.Storage;
             Assert.AreEqual(2, resultStorage.ValueCount);
         }
 
@@ -371,8 +371,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double
         [Test]
         public void CanOuterMultiplySparseVectors()
         {
-            var vector1 = new SparseVector(new[] { 2.0, 2.0, 0.0, 0.0 });
-            var vector2 = new SparseVector(new[] { 2.0, 2.0, 0.0, 0.0 });
+            var vector1 = SparseVector.OfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
+            var vector2 = SparseVector.OfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
             var result = vector1.OuterProduct(vector2);
 
             Assert.AreEqual(4.0, result[0, 0]);

src/UnitTests/LinearAlgebraTests/Single/DenseVectorTests.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -89,7 +93,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanCreateDenseVectorFromAnotherDenseVector()
         {
             var vector = new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -104,8 +108,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanCreateDenseVectorFromAnotherVector()
         {
-            var vector = (Vector<float>)new DenseVector(Data);
-            var other = new DenseVector(vector);
+            var vector = (Vector<float>) new DenseVector(Data);
+            var other = DenseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -121,7 +125,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanCreateDenseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new DenseVector(vector);
+            var other = DenseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -135,7 +139,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanCreateDenseVectorWithConstantValues()
         {
-            var vector = new DenseVector(5, 5);
+            var vector = DenseVector.Create(5, i => 5);
             foreach (var t in vector)
             {
                 Assert.AreEqual(t, 5);
@@ -161,8 +165,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanConvertDenseVectorToArray()
         {
             var vector = new DenseVector(Data);
-            var array = (float[])vector;
-            Assert.IsInstanceOf(typeof(float[]), array);
+            var array = (float[]) vector;
+            Assert.IsInstanceOf(typeof (float[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -172,9 +176,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanConvertArrayToDenseVector()
         {
-            var array = new[] { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f };
-            var vector = (DenseVector)array;
-            Assert.IsInstanceOf(typeof(DenseVector), vector);
+            var array = new[] {0.0f, 1.0f, 2.0f, 3.0f, 4.0f};
+            var vector = (DenseVector) array;
+            Assert.IsInstanceOf(typeof (DenseVector), vector);
             CollectionAssert.AreEqual(array, array);
         }
 
@@ -206,7 +210,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, result[i]);
+                Assert.AreEqual(Data[i]*2.0f, result[i]);
             }
         }
 
@@ -249,31 +253,31 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanMultiplyDenseVectorByScalarUsingOperators()
         {
             var vector = new DenseVector(Data);
-            vector = vector * 2.0f;
+            vector = vector*2.0f;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
 
-            vector = vector * 1.0f;
+            vector = vector*1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
 
             vector = new DenseVector(Data);
-            vector = 2.0f * vector;
+            vector = 2.0f*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
 
-            vector = 1.0f * vector;
+            vector = 1.0f*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
         }
 
@@ -284,17 +288,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanDivideDenseVectorByScalarUsingOperators()
         {
             var vector = new DenseVector(Data);
-            vector = vector / 2.0f;
+            vector = vector/2.0f;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] / 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]/2.0f, vector[i]);
             }
 
-            vector = vector / 1.0f;
+            vector = vector/1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] / 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]/2.0f, vector[i]);
             }
         }
 
@@ -311,7 +315,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
 {
     using System;
@@ -42,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -85,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -127,19 +132,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -208,16 +213,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new BiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -255,10 +260,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new BiCgStab(monitor);
                 var resultx = solver.Solve(matrixA, vectorb);
 
@@ -269,12 +274,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -296,10 +301,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new BiCgStab(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -315,14 +320,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float) Math.Pow(1.0/10.0, iteration - 3));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
 {
     using System;
@@ -42,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -85,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new GpBiCg(monitor);
 
             // Solve equation Ax = y
@@ -127,19 +132,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -209,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new GpBiCg(monitor);
 
@@ -257,10 +262,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new GpBiCg(monitor);
                 var resultx = solver.Solve(matrixA, vectorb);
 
@@ -271,12 +276,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -298,10 +303,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new GpBiCg(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -317,14 +322,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float) Math.Pow(1.0/10.0, iteration - 3));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
 {
     using System;
@@ -42,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -85,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new MlkBiCgStab(monitor);
 
@@ -128,19 +133,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new MlkBiCgStab(monitor);
 
             // Solve equation Ax = y
@@ -209,7 +214,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Due to datatype "float" it can happen that solution will not converge for specific random starting vectors
             // That's why we will do 3 tries
@@ -217,12 +222,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             {
                 // Create an iteration monitor which will keep track of iterative convergence
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium(ConvergenceBoundary),
-                                               new DivergenceStopCriterium(),
-                                               new FailureStopCriterium()
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium(ConvergenceBoundary),
+                        new DivergenceStopCriterium(),
+                        new FailureStopCriterium()
+                    });
                 var solver = new MlkBiCgStab(monitor);
 
                 // Solve equation Ax = y
@@ -273,10 +278,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new MlkBiCgStab(monitor);
                 var resultx = solver.Solve(matrixA, vectorb);
 
@@ -287,12 +292,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -316,10 +321,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new MlkBiCgStab(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -335,14 +340,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float) Math.Pow(1.0/10.0, iteration - 3));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
 {
     using System;
@@ -42,12 +47,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
         /// <summary>
         /// Convergence boundary.
         /// </summary>
-        private const float ConvergenceBoundary = 1e-5f;
+        const float ConvergenceBoundary = 1e-5f;
 
         /// <summary>
         /// Maximum iterations.
         /// </summary>
-        private const int MaximumIterations = 1000;
+        const int MaximumIterations = 1000;
 
         /// <summary>
         /// Solve wide matrix throws <c>ArgumentException</c>.
@@ -85,16 +90,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
 
             var solver = new TFQMR(monitor);
 
@@ -128,19 +133,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             Matrix matrix = SparseMatrix.Identity(100);
 
             // Scale it with a funny number
-            matrix.Multiply((float)Math.PI, matrix);
+            matrix.Multiply((float) Math.PI, matrix);
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -209,16 +214,16 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
             }
 
             // Create the y vector
-            Vector y = new DenseVector(matrix.RowCount, 1);
+            Vector y = DenseVector.Create(matrix.RowCount, i => 1);
 
             // Create an iteration monitor which will keep track of iterative convergence
             var monitor = new Iterator(new IIterationStopCriterium[]
-                                       {
-                                           new IterationCountStopCriterium(MaximumIterations),
-                                           new ResidualStopCriterium(ConvergenceBoundary),
-                                           new DivergenceStopCriterium(),
-                                           new FailureStopCriterium()
-                                       });
+                {
+                    new IterationCountStopCriterium(MaximumIterations),
+                    new ResidualStopCriterium(ConvergenceBoundary),
+                    new DivergenceStopCriterium(),
+                    new FailureStopCriterium()
+                });
             var solver = new TFQMR(monitor);
 
             // Solve equation Ax = y
@@ -256,10 +261,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var vectorb = MatrixLoader.GenerateRandomDenseVector(order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration)),
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration)),
+                    });
                 var solver = new TFQMR(monitor);
                 var resultx = solver.Solve(matrixA, vectorb);
 
@@ -270,12 +275,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 }
 
                 Assert.AreEqual(matrixA.ColumnCount, resultx.Count);
-                var matrixBReconstruct = matrixA * resultx;
+                var matrixBReconstruct = matrixA*resultx;
 
                 // Check the reconstruction.
                 for (var i = 0; i < order; i++)
                 {
-                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float)Math.Pow(1.0 / 10.0, iteration - 3));
+                    Assert.AreEqual(vectorb[i], matrixBReconstruct[i], (float) Math.Pow(1.0/10.0, iteration - 3));
                 }
 
                 return;
@@ -297,10 +302,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 var matrixB = MatrixLoader.GenerateRandomDenseMatrix(order, order);
 
                 var monitor = new Iterator(new IIterationStopCriterium[]
-                                           {
-                                               new IterationCountStopCriterium(MaximumIterations),
-                                               new ResidualStopCriterium((float)Math.Pow(1.0 / 10.0, iteration))
-                                           });
+                    {
+                        new IterationCountStopCriterium(MaximumIterations),
+                        new ResidualStopCriterium((float) Math.Pow(1.0/10.0, iteration))
+                    });
                 var solver = new TFQMR(monitor);
                 var matrixX = solver.Solve(matrixA, matrixB);
 
@@ -316,14 +321,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Iterative
                 // The solution X has the same number of columns as B
                 Assert.AreEqual(matrixB.ColumnCount, matrixX.ColumnCount);
 
-                var matrixBReconstruct = matrixA * matrixX;
+                var matrixBReconstruct = matrixA*matrixX;
 
                 // Check the reconstruction.
                 for (var i = 0; i < matrixB.RowCount; i++)
                 {
                     for (var j = 0; j < matrixB.ColumnCount; j++)
                     {
-                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float)Math.Pow(1.0 / 10.0, iteration - 4));
+                        Assert.AreEqual(matrixB[i, j], matrixBReconstruct[i, j], (float) Math.Pow(1.0/10.0, iteration - 4));
                     }
                 }
 

src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
 {
     using System;
@@ -56,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         [Test]
         public void CreateWithEmptyCollection()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { });
+            var iterator = new Iterator(new IIterationStopCriterium[] {});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -67,7 +72,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         [Test]
         public void CreateWithCollectionWithNulls()
         {
-            var iterator = new Iterator(new IIterationStopCriterium[] { null, null });
+            var iterator = new Iterator(new IIterationStopCriterium[] {null, null});
             Assert.IsNotNull(iterator, "Should have an iterator");
             Assert.AreEqual(0, iterator.NumberOfCriteria, "There shouldn't be any criteria");
         }
@@ -79,10 +84,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void CreateWithDuplicatesThrowsArgumentException()
         {
             Assert.Throws<ArgumentException>(() => new Iterator(new IIterationStopCriterium[]
-                                                                {
-                                                                    new FailureStopCriterium(),
-                                                                    new FailureStopCriterium()
-                                                                }));
+                {
+                    new FailureStopCriterium(),
+                    new FailureStopCriterium()
+                }));
         }
 
         /// <summary>
@@ -92,12 +97,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void CreateWithCollection()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.IsNotNull(iterator, "Should have an iterator");
 
@@ -139,12 +144,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void Add()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator();
             Assert.AreEqual(0, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -169,12 +174,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void RemoveWithNullStopCriteriumThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -188,11 +193,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void RemoveWithNonExistingStopCriterium()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -207,12 +212,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void Remove()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
             Assert.AreEqual(criteria.Count, iterator.NumberOfCriteria, "Incorrect criterium count");
 
@@ -232,9 +237,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
             var iterator = new Iterator();
             Assert.Throws<ArgumentException>(() => iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -244,19 +249,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -266,19 +271,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -288,19 +293,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatusWithNullSourceVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 5),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -310,18 +315,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatusWithNullResidualVectorThrowsArgumentNullException()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
             var iterator = new Iterator(criteria);
 
             Assert.Throws<ArgumentNullException>(() => iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -332,29 +337,29 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             // Second step, should run out of iterations.
             iterator.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), iterator.Status, "Incorrect status");
         }
 
         /// <summary>
@@ -364,27 +369,27 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(1)
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(1)
+                };
 
             var iterator = new Iterator(criteria);
 
             // First step, nothing should happen.
             iterator.DetermineStatus(
                 0,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4));
-            Assert.IsInstanceOf(typeof(CalculationRunning), iterator.Status, "Incorrect status");
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4));
+            Assert.IsInstanceOf(typeof (CalculationRunning), iterator.Status, "Incorrect status");
 
             iterator.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), iterator.Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[0].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[1].Status, "Incorrect status");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criteria[2].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), iterator.Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[0].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[1].Status, "Incorrect status");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criteria[2].Status, "Incorrect status");
         }
 
         /// <summary>
@@ -394,17 +399,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void Clone()
         {
             var criteria = new List<IIterationStopCriterium>
-                           {
-                               new FailureStopCriterium(),
-                               new DivergenceStopCriterium(),
-                               new IterationCountStopCriterium(),
-                               new ResidualStopCriterium()
-                           };
+                {
+                    new FailureStopCriterium(),
+                    new DivergenceStopCriterium(),
+                    new IterationCountStopCriterium(),
+                    new ResidualStopCriterium()
+                };
 
             var iterator = new Iterator(criteria);
 
             var clonedIterator = iterator.Clone();
-            Assert.IsInstanceOf(typeof(Iterator), clonedIterator, "Incorrect type");
+            Assert.IsInstanceOf(typeof (Iterator), clonedIterator, "Incorrect type");
 
             var clone = clonedIterator as Iterator;
             Assert.IsNotNull(clone);

src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCriterium
 {
     using System;
@@ -107,9 +112,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -121,8 +126,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(0.5, 15);
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -142,11 +147,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { (i + 1) * (Increase + 0.1f) }));
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {(i + 1)*(Increase + 0.1f)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -162,15 +167,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. We should not diverge because we won't have enough increase
-            for (var i = 0; i < Iterations * 2; i++)
+            for (var i = 0; i < Iterations*2; i++)
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { (i + 1) * (Increase - 0.01f) }));
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {(i + 1)*(Increase - 0.01f)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
         }
 
@@ -190,21 +195,21 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             {
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { (i + 1) * (Increase - 0.01f) }));
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {(i + 1)*(Increase - 0.01f)}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
             criterium.DetermineStatus(
                 Iterations,
-                new DenseVector(new[] { 1.0f }),
-                new DenseVector(new[] { 1.0f }),
-                new DenseVector(new[] { float.NaN }));
+                new DenseVector(new[] {1.0f}),
+                new DenseVector(new[] {1.0f}),
+                new DenseVector(new[] {float.NaN}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -225,22 +230,22 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
                 previous *= 1 + Increase + 0.01f;
                 criterium.DetermineStatus(
                     i,
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { 1.0f }),
-                    new DenseVector(new[] { previous }));
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {1.0f}),
+                    new DenseVector(new[] {previous}));
 
-                Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01f;
             criterium.DetermineStatus(
                 Iterations - 1,
-                new DenseVector(new[] { 1.0f }),
-                new DenseVector(new[] { 1.0f }),
-                new DenseVector(new[] { previous }));
+                new DenseVector(new[] {1.0f}),
+                new DenseVector(new[] {1.0f}),
+                new DenseVector(new[] {previous}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -257,18 +262,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             // Add residuals. Blow it up instantly
             criterium.DetermineStatus(
                 1,
-                new DenseVector(new[] { 1.0f }),
-                new DenseVector(new[] { 1.0f }),
-                new DenseVector(new[] { float.NaN }));
+                new DenseVector(new[] {1.0f}),
+                new DenseVector(new[] {1.0f}),
+                new DenseVector(new[] {float.NaN}));
 
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
 
             Assert.AreEqual(Increase, criterium.MaximumRelativeIncrease, "Incorrect maximum");
             Assert.AreEqual(Iterations, criterium.MinimumNumberOfIterations, "Incorrect iteration count");
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Status check fail.");
         }
 
         /// <summary>
@@ -284,7 +289,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(DivergenceStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (DivergenceStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as DivergenceStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCriterium
 {
     using System;
@@ -56,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 4), new DenseVector(3, 5), new DenseVector(3, 6)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 5), DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -68,7 +73,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, null, DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -80,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), null));
+            Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), null));
         }
 
         /// <summary>
@@ -92,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, new DenseVector(3, 4), new DenseVector(3, 6), new DenseVector(4, 4)));
+            Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(1, DenseVector.Create(3, i => 4), DenseVector.Create(3, i => 6), DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -104,12 +109,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
-            var source = new DenseVector(new[] { 1001.0f, 0, 2003.0f });
-            var residual = new DenseVector(new[] { 1000, float.NaN, 2001 });
+            var solution = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
+            var source = new DenseVector(new[] {1001.0f, 0, 2003.0f});
+            var residual = new DenseVector(new[] {1000, float.NaN, 2001});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
         }
 
         /// <summary>
@@ -121,12 +126,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1, 1, float.NaN });
-            var source = new DenseVector(new[] { 1001.0f, 0.0f, 2003.0f });
-            var residual = new DenseVector(new[] { 1000.0f, 1000.0f, 2001.0f });
+            var solution = new DenseVector(new[] {1, 1, float.NaN});
+            var source = new DenseVector(new[] {1001.0f, 0.0f, 2003.0f});
+            var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
         }
 
         /// <summary>
@@ -138,12 +143,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 3.0f, 2.0f, 1.0f });
-            var source = new DenseVector(new[] { 1001.0f, 0.0f, 2003.0f });
-            var residual = new DenseVector(new[] { 1.0f, 2.0f, 3.0f });
+            var solution = new DenseVector(new[] {3.0f, 2.0f, 1.0f});
+            var source = new DenseVector(new[] {1001.0f, 0.0f, 2003.0f});
+            var residual = new DenseVector(new[] {1.0f, 2.0f, 3.0f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
         }
 
         /// <summary>
@@ -155,15 +160,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
-            var source = new DenseVector(new[] { 1001.0f, 0.0f, 2003.0f });
-            var residual = new DenseVector(new[] { 1000.0f, 1000.0f, 2001.0f });
+            var solution = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
+            var source = new DenseVector(new[] {1001.0f, 0.0f, 2003.0f});
+            var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -176,7 +181,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(FailureStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (FailureStopCriterium), clone, "Wrong criterium type");
         }
     }
 }

src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -81,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3)));
+            Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(-1, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3)));
         }
 
         /// <summary>
@@ -93,11 +97,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
-            criterium.DetermineStatus(10, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
         }
 
         /// <summary>
@@ -109,11 +113,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, new DenseVector(3, 1), new DenseVector(3, 2), new DenseVector(3, 3));
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -127,7 +131,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             Assert.AreEqual(10, criterium.MaximumNumberOfIterations, "Incorrect maximum");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(IterationCountStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (IterationCountStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as IterationCountStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs

@@ -3,7 +3,9 @@
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
-// Copyright (c) 2009-2010 Math.NET
+//
+// Copyright (c) 2009-2013 Math.NET
+//
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
 // files (the "Software"), to deal in the Software without
@@ -12,8 +14,10 @@
 // copies of the Software, and to permit persons to whom the
 // Software is furnished to do so, subject to the following
 // conditions:
+//
 // The above copyright notice and this permission notice shall be
 // included in all copies or substantial portions of the Software.
+//
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -23,6 +27,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCriterium
 {
     using System;
@@ -105,9 +110,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
                 -1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -122,8 +127,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
                 null,
-                new DenseVector(3, 5),
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 5),
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -137,9 +142,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
+                DenseVector.Create(3, i => 4),
                 null,
-                new DenseVector(3, 6)));
+                DenseVector.Create(3, i => 6)));
         }
 
         /// <summary>
@@ -153,8 +158,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 5),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 5),
                 null));
         }
 
@@ -169,9 +174,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(4, 4),
-                new DenseVector(3, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -185,9 +190,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(4, 4),
-                new DenseVector(3, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4),
+                DenseVector.Create(3, i => 4)));
         }
 
         /// <summary>
@@ -201,9 +206,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
 
             Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
                 1,
-                new DenseVector(3, 4),
-                new DenseVector(3, 4),
-                new DenseVector(4, 4)));
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(3, i => 4),
+                DenseVector.Create(4, i => 4)));
         }
 
         /// <summary>
@@ -215,12 +220,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new ResidualStopCriterium(1e-3f, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
-            var source = new DenseVector(new[] { 1.0f, 1.0f, float.NaN });
-            var residual = new DenseVector(new[] { 1000.0f, 1000.0f, 2001.0f });
+            var solution = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
+            var source = new DenseVector(new[] {1.0f, 1.0f, float.NaN});
+            var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -232,12 +237,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new ResidualStopCriterium(1e-3f, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
-            var source = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
-            var residual = new DenseVector(new[] { 1000.0f, float.NaN, 2001.0f });
+            var solution = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
+            var source = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
+            var residual = new DenseVector(new[] {1000.0f, float.NaN, 2001.0f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationDiverged), criterium.Status, "Should be diverged");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
         }
 
         /// <summary>
@@ -249,12 +254,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new ResidualStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0f, 1.0f, 1.0f });
-            var source = new DenseVector(new[] { 1.0f, 1.0f, 1.0f });
-            var residual = new DenseVector(new[] { 0.0f, 0.0f, 0.0f });
+            var solution = new DenseVector(new[] {1.0f, 1.0f, 1.0f});
+            var source = new DenseVector(new[] {1.0f, 1.0f, 1.0f});
+            var residual = new DenseVector(new[] {0.0f, 0.0f, 0.0f});
 
             criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -267,19 +272,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             // the solution vector isn't actually being used so ...
-            var solution = new DenseVector(new[] { float.NaN, float.NaN, float.NaN });
+            var solution = new DenseVector(new[] {float.NaN, float.NaN, float.NaN});
 
             // Set the source values
-            var source = new DenseVector(new[] { 1.000f, 1.000f, 2.001f });
+            var source = new DenseVector(new[] {1.000f, 1.000f, 2.001f});
 
             // Set the residual values
-            var residual = new DenseVector(new[] { 0.001f, 0.001f, 0.002f });
+            var residual = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should still be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
 
             criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
+            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
         }
 
         /// <summary>
@@ -291,15 +296,15 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new ResidualStopCriterium(1e-3f, 10);
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 0.001f, 0.001f, 0.002f });
-            var source = new DenseVector(new[] { 0.001f, 0.001f, 0.002f });
-            var residual = new DenseVector(new[] { 1.000f, 1.000f, 2.001f });
+            var solution = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
+            var source = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
+            var residual = new DenseVector(new[] {1.000f, 1.000f, 2.001f});
 
             criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
 
             criterium.ResetToPrecalculationState();
-            Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
+            Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
         }
 
         /// <summary>
@@ -312,7 +317,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             Assert.IsNotNull(criterium, "There should be a criterium");
 
             var clone = criterium.Clone();
-            Assert.IsInstanceOf(typeof(ResidualStopCriterium), clone, "Wrong criterium type");
+            Assert.IsInstanceOf(typeof (ResidualStopCriterium), clone, "Wrong criterium type");
 
             var clonedCriterium = clone as ResidualStopCriterium;
             Assert.IsNotNull(clonedCriterium);

src/UnitTests/LinearAlgebraTests/Single/SparseMatrixTests.cs

@@ -79,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         /// <returns>The new vector. </returns>
         protected override Vector CreateVector(float[] data)
         {
-            return new SparseVector(data);
+            return SparseVector.OfEnumerable(data);
         }
 
         /// <summary>

src/UnitTests/LinearAlgebraTests/Single/SparseVectorArithmeticTheory.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -40,13 +40,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Datapoints]
         Vector<float>[] denseVectors = new Vector<float>[]
             {
-                new SparseVector(new float[] { 1, 2, 3, 4, 5 }),
-                new SparseVector(new float[] { 2, 0, 0, -5, 0 }),
+                SparseVector.OfEnumerable(new float[] {1, 2, 3, 4, 5}),
+                SparseVector.OfEnumerable(new float[] {2, 0, 0, -5, 0}),
                 new SparseVector(5),
                 new SparseVector(int.MaxValue)
             };
 
         [Datapoints]
-        private float[] scalars = new[] { 2f };
+        float[] scalars = new[] {2f};
     }
 }

src/UnitTests/LinearAlgebraTests/Single/SparseVectorTest.cs

@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2011 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         {
             var data = new float[Data.Length];
             Array.Copy(Data, data, Data.Length);
-            var vector = new SparseVector(data);
+            var vector = SparseVector.OfEnumerable(data);
 
             for (var i = 0; i < data.Length; i++)
             {
@@ -91,8 +91,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanCreateSparseVectorFromAnotherSparseVector()
         {
-            var vector = new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -107,8 +107,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanCreateSparseVectorFromAnotherVector()
         {
-            var vector = (Vector<float>)new SparseVector(Data);
-            var other = new SparseVector(vector);
+            var vector = (Vector<float>)SparseVector.OfEnumerable(Data);
+            var other = SparseVector.OfVector(vector);
 
             Assert.AreNotSame(vector, other);
             for (var i = 0; i < Data.Length; i++)
@@ -124,7 +124,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CanCreateSparseVectorFromUserDefinedVector()
         {
             var vector = new UserDefinedVector(Data);
-            var other = new SparseVector(vector);
+            var other = SparseVector.OfVector(vector);
 
             for (var i = 0; i < Data.Length; i++)
             {
@@ -150,9 +150,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanConvertSparseVectorToArray()
         {
-            var vector = new SparseVector(Data);
+            var vector = SparseVector.OfEnumerable(Data);
             var array = vector.ToArray();
-            Assert.IsInstanceOf(typeof(float[]), array);
+            Assert.IsInstanceOf(typeof (float[]), array);
             CollectionAssert.AreEqual(vector, array);
         }
 
@@ -162,10 +162,10 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanConvertArrayToSparseVector()
         {
-            var array = new[] { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f };
-            var vector = new SparseVector(array);
-            Assert.IsInstanceOf(typeof(SparseVector), vector);
-            CollectionAssert.AreEqual(array, array);
+            var array = new[] {0.0f, 1.0f, 2.0f, 3.0f, 4.0f};
+            var vector = SparseVector.OfEnumerable(array);
+            Assert.IsInstanceOf(typeof (SparseVector), vector);
+            CollectionAssert.AreEqual(vector, array);
         }
 
         /// <summary>
@@ -174,32 +174,32 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanMultiplySparseVectorByScalarUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector * 2.0f;
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector*2.0f;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
 
-            vector = vector * 1.0f;
+            vector = vector*1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
 
-            vector = new SparseVector(Data);
-            vector = 2.0f * vector;
+            vector = SparseVector.OfEnumerable(Data);
+            vector = 2.0f*vector;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
 
-            vector = 1.0f * vector;
+            vector = 1.0f*vector;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] * 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]*2.0f, vector[i]);
             }
         }
 
@@ -209,18 +209,18 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanDivideSparseVectorByScalarUsingOperators()
         {
-            var vector = new SparseVector(Data);
-            vector = vector / 2.0f;
+            var vector = SparseVector.OfEnumerable(Data);
+            vector = vector/2.0f;
 
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] / 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]/2.0f, vector[i]);
             }
 
-            vector = vector / 1.0f;
+            vector = vector/1.0f;
             for (var i = 0; i < Data.Length; i++)
             {
-                Assert.AreEqual(Data[i] / 2.0f, vector[i]);
+                Assert.AreEqual(Data[i]/2.0f, vector[i]);
             }
         }
 
@@ -237,7 +237,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             {
                 for (var j = 0; j < vector2.Count; j++)
                 {
-                    Assert.AreEqual(m[i, j], vector1[i] * vector2[j]);
+                    Assert.AreEqual(m[i, j], vector1[i]*vector2[j]);
                 }
             }
         }
@@ -261,7 +261,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         public void CheckSparseMechanismBySettingValues()
         {
             var vector = new SparseVector(10000);
-            var storage = (SparseVectorStorage<float>)vector.Storage;
+            var storage = (SparseVectorStorage<float>) vector.Storage;
 
             // Add non-zero elements
             vector[200] = 1.5f;
@@ -315,7 +315,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
             // Multiply by 0
             vector *= 0;
 
-            var storage = (SparseVectorStorage<float>)vector.Storage;
+            var storage = (SparseVectorStorage<float>) vector.Storage;
             Assert.AreEqual(0, vector[200]);
             Assert.AreEqual(0, vector[500]);
             Assert.AreEqual(0, vector[800]);
@@ -350,19 +350,19 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single
         [Test]
         public void CanPointwiseMultiplySparseVector()
         {
-            var zeroArray = new[] { 0.0f, 1.0f, 0.0f, 1.0f, 0.0f };
-            var vector1 = new SparseVector(Data);
-            var vector2 = new SparseVector(zeroArray);
+            var zeroArray = new[] {0.0f, 1.0f, 0.0f, 1.0f, 0.0f};
+            var vector1 = SparseVector.OfEnumerable(Data);
+            var vector2 = SparseVector.OfEnumerable(zeroArray);
             var result = new SparseVector(vector1.Count);
 
             vector1.PointwiseMultiply(vector2, result);
 
             for (var i = 0; i < vector1.Count; i++)
             {
-                Assert.AreEqual(Data[i] * zeroArray[i], result[i]);
+                Assert.AreEqual(Data[i]*zeroArray[i], result[i]);
             }
 
-            var resultStorage = (SparseVectorStorage<float>)result.Storage;
+            var resultStorage = (SparseVectorStorage<float>) result.Storage;
             Assert.AreEqual(2, resultStorage.ValueCount);
         }