diff --git a/src/Examples/LinearAlgebra/IterativeSolvers/BiCgStabSolver.cs b/src/Examples/LinearAlgebra/IterativeSolvers/BiCgStabSolver.cs
index d321d9b6..b0536dc6 100644
--- a/src/Examples/LinearAlgebra/IterativeSolvers/BiCgStabSolver.cs
+++ b/src/Examples/LinearAlgebra/IterativeSolvers/BiCgStabSolver.cs
@@ -32,7 +32,6 @@ using System;
 using System.Globalization;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 
 namespace Examples.LinearAlgebra.IterativeSolversExamples
diff --git a/src/Examples/LinearAlgebra/IterativeSolvers/CompositeSolverExample.cs b/src/Examples/LinearAlgebra/IterativeSolvers/CompositeSolverExample.cs
index c2e0a797..9c6ed264 100644
--- a/src/Examples/LinearAlgebra/IterativeSolvers/CompositeSolverExample.cs
+++ b/src/Examples/LinearAlgebra/IterativeSolvers/CompositeSolverExample.cs
@@ -33,7 +33,6 @@ using System.Globalization;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 
 namespace Examples.LinearAlgebra.IterativeSolversExamples
diff --git a/src/Examples/LinearAlgebra/IterativeSolvers/GpBiCgSolver.cs b/src/Examples/LinearAlgebra/IterativeSolvers/GpBiCgSolver.cs
index 31f6e090..3d22b198 100644
--- a/src/Examples/LinearAlgebra/IterativeSolvers/GpBiCgSolver.cs
+++ b/src/Examples/LinearAlgebra/IterativeSolvers/GpBiCgSolver.cs
@@ -32,7 +32,6 @@ using System;
 using System.Globalization;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 
 namespace Examples.LinearAlgebra.IterativeSolversExamples
diff --git a/src/Examples/LinearAlgebra/IterativeSolvers/MlkBiCgStabSolver.cs b/src/Examples/LinearAlgebra/IterativeSolvers/MlkBiCgStabSolver.cs
index 242675e7..97832be3 100644
--- a/src/Examples/LinearAlgebra/IterativeSolvers/MlkBiCgStabSolver.cs
+++ b/src/Examples/LinearAlgebra/IterativeSolvers/MlkBiCgStabSolver.cs
@@ -32,7 +32,6 @@ using System;
 using System.Globalization;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 
 namespace Examples.LinearAlgebra.IterativeSolversExamples
diff --git a/src/Examples/LinearAlgebra/IterativeSolvers/TFQMRSolver.cs b/src/Examples/LinearAlgebra/IterativeSolvers/TFQMRSolver.cs
index 67797b07..e091e4cc 100644
--- a/src/Examples/LinearAlgebra/IterativeSolvers/TFQMRSolver.cs
+++ b/src/Examples/LinearAlgebra/IterativeSolvers/TFQMRSolver.cs
@@ -32,7 +32,6 @@ using System;
 using System.Globalization;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 
 namespace Examples.LinearAlgebra.IterativeSolversExamples
diff --git a/src/Numerics/LinearAlgebra/Builder.cs b/src/Numerics/LinearAlgebra/Builder.cs
index b7de0309..a63bfd15 100644
--- a/src/Numerics/LinearAlgebra/Builder.cs
+++ b/src/Numerics/LinearAlgebra/Builder.cs
@@ -33,7 +33,7 @@ using MathNet.Numerics.LinearAlgebra.Solvers;
 
 namespace MathNet.Numerics.LinearAlgebra.Double
 {
-    using Solvers.StopCriterium;
+    using Solvers;
 
     internal class GenericBuilder : IGenericBuilder<double>
     {
@@ -82,7 +82,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
 
 namespace MathNet.Numerics.LinearAlgebra.Single
 {
-    using Solvers.StopCriterium;
+    using Solvers;
 
     internal class GenericBuilder : IGenericBuilder<float>
     {
@@ -131,7 +131,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single
 
 namespace MathNet.Numerics.LinearAlgebra.Complex
 {
-    using Solvers.StopCriterium;
+    using Solvers;
 
 #if NOSYSNUMERICS
     using Complex = Numerics.Complex;
@@ -186,7 +186,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex
 
 namespace MathNet.Numerics.LinearAlgebra.Complex32
 {
-    using Solvers.StopCriterium;
+    using Solvers;
 
     internal class GenericBuilder : IGenericBuilder<Numerics.Complex32>
     {
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/DiagonalPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/DiagonalPreconditioner.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/DiagonalPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Complex/Solvers/DiagonalPreconditioner.cs
index de29381d..e79f8874 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/DiagonalPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/DiagonalPreconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 {
 
 #if NOSYSNUMERICS
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/DivergenceStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Complex/Solvers/DivergenceStopCriterium.cs
index c2677c38..407bbd2e 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/DivergenceStopCriterium.cs
@@ -32,7 +32,7 @@ using MathNet.Numerics.LinearAlgebra.Solvers;
 using System;
 using System.Diagnostics;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 {
 
 #if NOSYSNUMERICS
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/FailureStopCriterium.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Complex/Solvers/FailureStopCriterium.cs
index 93b3239b..af1b05dd 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/FailureStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 {
 
 #if NOSYSNUMERICS
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/ILU0Preconditioner.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/ILU0Preconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/ILU0Preconditioner.cs
rename to src/Numerics/LinearAlgebra/Complex/Solvers/ILU0Preconditioner.cs
index c855e51f..400966b1 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/ILU0Preconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/ILU0Preconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 {
 
 #if NOSYSNUMERICS
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/ILUTPPreconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/ILUTPPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Complex/Solvers/ILUTPPreconditioner.cs
index de4132f1..a166c9f2 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/ILUTPPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/ILUTPPreconditioner.cs
@@ -33,7 +33,7 @@ using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 {
 
 #if NOSYSNUMERICS
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs
index aba3ac8b..75d13b16 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/ResidualStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
 {
 
 #if NOSYSNUMERICS
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/DiagonalPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/DiagonalPreconditioner.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/DiagonalPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Complex32/Solvers/DiagonalPreconditioner.cs
index 04c830a6..be1eeeca 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/DiagonalPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/DiagonalPreconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     using Numerics;
 
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/DivergenceStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Complex32/Solvers/DivergenceStopCriterium.cs
index ede15238..1778478a 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/DivergenceStopCriterium.cs
@@ -32,7 +32,7 @@ using MathNet.Numerics.LinearAlgebra.Solvers;
 using System;
 using System.Diagnostics;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     using Numerics;
 
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/FailureStopCriterium.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Complex32/Solvers/FailureStopCriterium.cs
index 43fbbdf3..d5971f72 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/FailureStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     using Numerics;
 
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/ILU0Preconditioner.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/ILU0Preconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/ILU0Preconditioner.cs
rename to src/Numerics/LinearAlgebra/Complex32/Solvers/ILU0Preconditioner.cs
index 2d5dfa84..29f3aaf9 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/ILU0Preconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/ILU0Preconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     using Numerics;
 
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/ILUTPPreconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/ILUTPPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Complex32/Solvers/ILUTPPreconditioner.cs
index 1ad9768c..d4c74425 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/ILUTPPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/ILUTPPreconditioner.cs
@@ -33,7 +33,7 @@ using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     using Numerics;
 
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs
index 77e144dc..e2993a84 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/ResidualStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
 {
     using Numerics;
 
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/DiagonalPreconditioner.cs b/src/Numerics/LinearAlgebra/Double/Solvers/DiagonalPreconditioner.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/DiagonalPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/DiagonalPreconditioner.cs
index 75c2a1e7..0f051eae 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/DiagonalPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/DiagonalPreconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// A diagonal preconditioner. The preconditioner uses the inverse
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/DivergenceStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/DivergenceStopCriterium.cs
index 116c65e2..4502be29 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/DivergenceStopCriterium.cs
@@ -32,7 +32,7 @@ using MathNet.Numerics.LinearAlgebra.Solvers;
 using System;
 using System.Diagnostics;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// Monitors an iterative calculation for signs of divergence.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/FailureStopCriterium.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/FailureStopCriterium.cs
index ea0973ac..8a68a3b3 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/FailureStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals for NaN's.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/ILU0Preconditioner.cs b/src/Numerics/LinearAlgebra/Double/Solvers/ILU0Preconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/ILU0Preconditioner.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/ILU0Preconditioner.cs
index 9ed18d9b..2fa98038 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/ILU0Preconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/ILU0Preconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// An incomplete, level 0, LU factorization preconditioner.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Double/Solvers/ILUTPPreconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/ILUTPPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/ILUTPPreconditioner.cs
index 651a57f6..a9e680ab 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/ILUTPPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/ILUTPPreconditioner.cs
@@ -33,7 +33,7 @@ using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// This class performs an Incomplete LU factorization with drop tolerance
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/MILU0Preconditioner.cs b/src/Numerics/LinearAlgebra/Double/Solvers/MILU0Preconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/MILU0Preconditioner.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/MILU0Preconditioner.cs
index 70e6e478..e14043c3 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/MILU0Preconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/MILU0Preconditioner.cs
@@ -33,7 +33,7 @@ using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.LinearAlgebra.Storage;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// Milu0 is a simple milu(0) preconditioner.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs
index 4342be07..02b9f2d8 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/ResidualStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 {
     /// <summary>
     /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals as stop criterium.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/DiagonalPreconditioner.cs b/src/Numerics/LinearAlgebra/Single/Solvers/DiagonalPreconditioner.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/DiagonalPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Single/Solvers/DiagonalPreconditioner.cs
index 4318b66a..dbe5effb 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/DiagonalPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/DiagonalPreconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// A diagonal preconditioner. The preconditioner uses the inverse
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/DivergenceStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Single/Solvers/DivergenceStopCriterium.cs
index c2c4e7c3..d4140656 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/DivergenceStopCriterium.cs
@@ -32,7 +32,7 @@ using MathNet.Numerics.LinearAlgebra.Solvers;
 using System;
 using System.Diagnostics;
 
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// Monitors an iterative calculation for signs of divergence.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/FailureStopCriterium.cs
similarity index 98%
rename from src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Single/Solvers/FailureStopCriterium.cs
index 3c46508b..4e19c78d 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/FailureStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals for NaN's.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/ILU0Preconditioner.cs b/src/Numerics/LinearAlgebra/Single/Solvers/ILU0Preconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/ILU0Preconditioner.cs
rename to src/Numerics/LinearAlgebra/Single/Solvers/ILU0Preconditioner.cs
index 89e31167..5e754d00 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/ILU0Preconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/ILU0Preconditioner.cs
@@ -32,7 +32,7 @@ using System;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// An incomplete, level 0, LU factorization preconditioner.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/ILUTPPreconditioner.cs b/src/Numerics/LinearAlgebra/Single/Solvers/ILUTPPreconditioner.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/ILUTPPreconditioner.cs
rename to src/Numerics/LinearAlgebra/Single/Solvers/ILUTPPreconditioner.cs
index 046d8dbf..172860aa 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/ILUTPPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/ILUTPPreconditioner.cs
@@ -33,7 +33,7 @@ using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
+namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// This class performs an Incomplete LU factorization with drop tolerance
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs
similarity index 99%
rename from src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs
rename to src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs
index 63078e0c..37e9f37d 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/ResidualStopCriterium.cs
@@ -33,7 +33,7 @@ using System.Diagnostics;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using MathNet.Numerics.Properties;
 
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
+namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 {
     /// <summary>
     /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals as stop criterium.
diff --git a/src/Numerics/LinearAlgebra/Solvers/UnitPreconditioner.cs b/src/Numerics/LinearAlgebra/Solvers/UnitPreconditioner.cs
index 3d84a184..1079ebcc 100644
--- a/src/Numerics/LinearAlgebra/Solvers/UnitPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Solvers/UnitPreconditioner.cs
@@ -38,7 +38,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
     /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
-    internal sealed class UnitPreconditioner<T> : IPreconditioner<T> where T : struct, IEquatable<T>, IFormattable
+    public sealed class UnitPreconditioner<T> : IPreconditioner<T> where T : struct, IEquatable<T>, IFormattable
     {
         /// <summary>
         /// The coefficient matrix on which this preconditioner operates.
diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj
index b092ccd8..870394e0 100644
--- a/src/Numerics/Numerics.csproj
+++ b/src/Numerics/Numerics.csproj
@@ -122,7 +122,7 @@
     <Compile Include="Distributions\Wishart.cs" />
     <Compile Include="Distributions\Zipf.cs" />
     <Compile Include="LinearAlgebra\Builder.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\Preconditioners\MILU0Preconditioner.cs" />
+    <Compile Include="LinearAlgebra\Double\Solvers\MILU0Preconditioner.cs" />
     <Compile Include="LinearAlgebra\Matrix.Solve.cs" />
     <Compile Include="LinearAlgebra\Solvers\CancellationStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Solvers\IterationStatus.cs" />
@@ -244,12 +244,12 @@
     <Compile Include="LinearAlgebra\Complex32\Solvers\GpBiCg.cs" />
     <Compile Include="LinearAlgebra\Complex32\Solvers\MlkBiCgStab.cs" />
     <Compile Include="LinearAlgebra\Complex32\Solvers\TFQMR.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\Preconditioners\DiagonalPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\Preconditioners\ILUTPPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\Preconditioners\ILU0Preconditioner.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\StopCriterium\DivergenceStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\StopCriterium\FailureStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\StopCriterium\ResidualStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Complex32\Solvers\DiagonalPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Complex32\Solvers\ILUTPPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Complex32\Solvers\ILU0Preconditioner.cs" />
+    <Compile Include="LinearAlgebra\Complex32\Solvers\DivergenceStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Complex32\Solvers\FailureStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Complex32\Solvers\ResidualStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Complex32\SparseVector.cs" />
     <Compile Include="LinearAlgebra\Complex\Factorization\DenseGramSchmidt.cs" />
     <Compile Include="LinearAlgebra\Complex\Factorization\DenseEvd.cs" />
@@ -268,12 +268,12 @@
     <Compile Include="LinearAlgebra\Complex\Solvers\GpBiCg.cs" />
     <Compile Include="LinearAlgebra\Complex\Solvers\MlkBiCgStab.cs" />
     <Compile Include="LinearAlgebra\Complex\Solvers\TFQMR.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\Preconditioners\DiagonalPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\Preconditioners\ILUTPPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\Preconditioners\ILU0Preconditioner.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\StopCriterium\DivergenceStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\StopCriterium\FailureStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\StopCriterium\ResidualStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Complex\Solvers\DiagonalPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Complex\Solvers\ILUTPPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Complex\Solvers\ILU0Preconditioner.cs" />
+    <Compile Include="LinearAlgebra\Complex\Solvers\DivergenceStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Complex\Solvers\FailureStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Complex\Solvers\ResidualStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Complex\SparseVector.cs" />
     <Compile Include="LinearAlgebra\Double\DenseVector.cs" />
     <Compile Include="LinearAlgebra\Double\Factorization\DenseGramSchmidt.cs" />
@@ -308,12 +308,12 @@
     <Compile Include="LinearAlgebra\Single\Solvers\GpBiCg.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\MlkBiCgStab.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\TFQMR.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\DiagonalPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\ILUTPPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\ILU0Preconditioner.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\StopCriterium\DivergenceStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\StopCriterium\FailureStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\StopCriterium\ResidualStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Single\Solvers\DiagonalPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Single\Solvers\ILUTPPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Single\Solvers\ILU0Preconditioner.cs" />
+    <Compile Include="LinearAlgebra\Single\Solvers\DivergenceStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Single\Solvers\FailureStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Single\Solvers\ResidualStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Single\SparseMatrix.cs" />
     <Compile Include="LinearAlgebra\Single\SparseVector.cs" />
     <Compile Include="LinearAlgebra\Factorization\Cholesky.cs" />
@@ -335,15 +335,15 @@
     <Compile Include="LinearAlgebra\Double\Solvers\GpBiCg.cs" />
     <Compile Include="LinearAlgebra\Double\Solvers\MlkBiCgStab.cs" />
     <Compile Include="LinearAlgebra\Double\Solvers\TFQMR.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\Preconditioners\DiagonalPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\Preconditioners\ILUTPPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\Preconditioners\ILU0Preconditioner.cs">
+    <Compile Include="LinearAlgebra\Double\Solvers\DiagonalPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Double\Solvers\ILUTPPreconditioner.cs" />
+    <Compile Include="LinearAlgebra\Double\Solvers\ILU0Preconditioner.cs">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="LinearAlgebra\Solvers\UnitPreconditioner.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\StopCriterium\DivergenceStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\StopCriterium\FailureStopCriterium.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\StopCriterium\ResidualStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Double\Solvers\DivergenceStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Double\Solvers\FailureStopCriterium.cs" />
+    <Compile Include="LinearAlgebra\Double\Solvers\ResidualStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Double\SparseVector.cs" />
     <Compile Include="LinearAlgebra\Matrix.Arithmetic.cs" />
     <Compile Include="LinearAlgebra\Matrix.cs" />
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/BiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/BiCgStabTest.cs
index 18a872d2..1c36dab4 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/BiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/BiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs
index e31c685a..9ee639f4 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/GpBiCgTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs
index 3f576ee4..08c124d2 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/MlkBiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs
index 13c32d56..df8050df 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Iterative/TFQMRTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs
index d88f7975..59e9c326 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/IteratorTest.cs
@@ -31,7 +31,7 @@
 using System;
 using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -66,12 +66,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium<Complex>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<Complex>(),
-                    new ResidualStopCriterium()
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<Complex>(),
+                new ResidualStopCriterium()
+            };
             var iterator = new Iterator<Complex>(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
@@ -88,11 +88,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium<Complex>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<Complex>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<Complex>(1)
+            };
 
             var iterator = new Iterator<Complex>(criteria);
 
@@ -120,11 +120,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium<Complex>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<Complex>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<Complex>(1)
+            };
 
             var iterator = new Iterator<Complex>(criteria);
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs
index 39d24c01..95104328 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.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
@@ -26,7 +30,7 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -63,7 +67,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
-            Assert.AreEqual(typeof(DiagonalPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (DiagonalPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IluptElementSorterTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IluptElementSorterTest.cs
index afb407bb..0eaa537a 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IluptElementSorterTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IluptElementSorterTest.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
@@ -26,12 +30,17 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Preconditioners
 {
-    using System.Numerics;
+
+#if NOSYSNUMERICS
+    using Complex = Numerics.Complex;
+#else
+    using Complex = System.Numerics.Complex;
+#endif
 
     /// <summary>
     /// Test for element sort algorithm of Ilupt class.
@@ -45,7 +54,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         [Test]
         public void HeapSortWithIncreasingIntegerArray()
         {
-            var sortedIndices = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+            var sortedIndices = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -59,7 +68,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         [Test]
         public void HeapSortWithDecreasingIntegerArray()
         {
-            var sortedIndices = new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+            var sortedIndices = new[] {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -73,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         [Test]
         public void HeapSortWithRandomIntegerArray()
         {
-            var sortedIndices = new[] { 5, 2, 8, 6, 0, 4, 1, 7, 3, 9 };
+            var sortedIndices = new[] {5, 2, 8, 6, 0, 4, 1, 7, 3, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -87,7 +96,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         [Test]
         public void HeapSortWithDuplicateEntries()
         {
-            var sortedIndices = new[] { 1, 1, 1, 1, 2, 2, 2, 2, 3, 4 };
+            var sortedIndices = new[] {1, 1, 1, 1, 2, 2, 2, 2, 3, 4};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -128,7 +137,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         [Test]
         public void HeapSortWithSpecialConstructedIntegerArray()
         {
-            var sortedIndices = new[] { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };
+            var sortedIndices = new[] {0, 0, 0, 0, 0, 1, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -139,7 +148,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
                 }
             }
 
-            sortedIndices = new[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+            sortedIndices = new[] {1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -150,7 +159,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
                 }
             }
 
-            sortedIndices = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+            sortedIndices = new[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -161,7 +170,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
                 }
             }
 
-            sortedIndices = new[] { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 };
+            sortedIndices = new[] {1, 1, 1, 0, 1, 1, 1, 1, 1, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs
index 8e27d0ff..383bb537 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -50,17 +54,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <summary>
         /// The drop tolerance.
         /// </summary>
-        private double _dropTolerance = 0.1;
+        double _dropTolerance = 0.1;
 
         /// <summary>
         /// The fill level.
         /// </summary>
-        private double _fillLevel = 1.0;
+        double _fillLevel = 1.0;
 
         /// <summary>
         /// The pivot tolerance.
         /// </summary>
-        private double _pivotTolerance = 1.0;
+        double _pivotTolerance = 1.0;
 
         /// <summary>
         /// Setup default parameters.
@@ -80,7 +84,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="ilutp">Ilutp instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
+        static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
         {
             var type = ilutp.GetType();
             var methodInfo = type.GetMethod(
@@ -91,7 +95,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilutp, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -99,7 +103,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "UpperTriangle");
         }
@@ -109,7 +113,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "LowerTriangle");
         }
@@ -119,7 +123,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Pivots array.</returns>
-        private static int[] GetPivots(ILUTPPreconditioner ilutp)
+        static int[] GetPivots(ILUTPPreconditioner ilutp)
         {
             return GetMethod<int[]>(ilutp, "Pivots");
         }
@@ -129,7 +133,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// </summary>
         /// <param name="size">Matrix order.</param>
         /// <returns>Reverse Unit matrix.</returns>
-        private static SparseMatrix CreateReverseUnitMatrix(int size)
+        static SparseMatrix CreateReverseUnitMatrix(int size)
         {
             var matrix = new SparseMatrix(size);
             for (var i = 0; i < size; i++)
@@ -144,14 +148,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// Create preconditioner (internal)
         /// </summary>
         /// <returns>Ilutp instance.</returns>
-        private ILUTPPreconditioner InternalCreatePreconditioner()
+        ILUTPPreconditioner InternalCreatePreconditioner()
         {
             var result = new ILUTPPreconditioner
-                         {
-                             DropTolerance = _dropTolerance,
-                             FillLevel = _fillLevel,
-                             PivotTolerance = _pivotTolerance
-                         };
+            {
+                DropTolerance = _dropTolerance,
+                FillLevel = _fillLevel,
+                PivotTolerance = _pivotTolerance
+            };
             return result;
         }
 
@@ -176,7 +180,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
-            Assert.AreEqual(typeof(ILUTPPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILUTPPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
@@ -249,11 +253,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 0.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 0.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
 
@@ -305,11 +309,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 1.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
             var u = GetUpperTriangle(ilu);
@@ -342,11 +346,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
             var newMatrix = CreateReverseUnitMatrix(Size);
             var vector = CreateStandardBcVector(Size);
             var preconditioner = new ILUTPPreconditioner
-                                 {
-                                     PivotTolerance = 1.0,
-                                     DropTolerance = 0,
-                                     FillLevel = 10
-                                 };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             preconditioner.Initialize(newMatrix);
             var result = new DenseVector(vector.Count);
             preconditioner.Approximate(vector, result);
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs
index b2b8055f..db6f37d2 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -54,7 +58,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
+        static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
         {
             var type = ilu.GetType();
             var methodInfo = type.GetMethod(
@@ -65,7 +69,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilu, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -73,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static Matrix<Complex> GetUpperTriangle(ILU0Preconditioner ilu)
+        static Matrix<Complex> GetUpperTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<Complex>>(ilu, "UpperTriangle");
         }
@@ -83,7 +87,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static Matrix<Complex> GetLowerTriangle(ILU0Preconditioner ilu)
+        static Matrix<Complex> GetLowerTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<Complex>>(ilu, "LowerTriangle");
         }
@@ -106,7 +110,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
-            Assert.AreEqual(typeof(ILU0Preconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILU0Preconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs
index 0ee71541..fb19072a 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.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
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs
index 55eef377..89088d98 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.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
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 77f974e8..289d44f2 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 41756825..26f10323 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 90126415..8f5eb0f0 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/BiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/BiCgStabTest.cs
index 50e9c20e..6178c09a 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/BiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/BiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs
index 35994b0d..d5eb5900 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/GpBiCgTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs
index 3f83dd8c..1b87774b 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/MlkBiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs
index 354d4f6c..d59b77f4 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Iterative/TFQMRTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs
index f6dcd299..cd3e33c7 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/IteratorTest.cs
@@ -31,7 +31,7 @@
 using System;
 using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -66,12 +66,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium<Complex32>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<Complex32>(),
-                    new ResidualStopCriterium()
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<Complex32>(),
+                new ResidualStopCriterium()
+            };
             var iterator = new Iterator<Complex32>(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
@@ -88,11 +88,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium<Complex32>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<Complex32>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<Complex32>(1)
+            };
 
             var iterator = new Iterator<Complex32>(criteria);
 
@@ -120,11 +120,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium<Complex32>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<Complex32>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<Complex32>(1)
+            };
 
             var iterator = new Iterator<Complex32>(criteria);
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs
index 88ac3f40..87536c57 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.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
@@ -26,7 +30,7 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -58,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
-            Assert.AreEqual(typeof(DiagonalPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (DiagonalPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IluptElementSorterTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IluptElementSorterTest.cs
index 2564fdd1..2d4e6cc0 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IluptElementSorterTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IluptElementSorterTest.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
@@ -24,12 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra.Complex32;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Preconditioners
 {
-    using LinearAlgebra.Complex32;
-    using LinearAlgebra.Complex32.Solvers.Preconditioners;
-    using NUnit.Framework;
-
     /// <summary>
     /// Test for element sort algorithm of Ilupt class.
     /// </summary>
@@ -42,7 +46,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         [Test]
         public void HeapSortWithIncreasingIntegerArray()
         {
-            var sortedIndices = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+            var sortedIndices = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -56,7 +60,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         [Test]
         public void HeapSortWithDecreasingIntegerArray()
         {
-            var sortedIndices = new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+            var sortedIndices = new[] {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -70,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         [Test]
         public void HeapSortWithRandomIntegerArray()
         {
-            var sortedIndices = new[] { 5, 2, 8, 6, 0, 4, 1, 7, 3, 9 };
+            var sortedIndices = new[] {5, 2, 8, 6, 0, 4, 1, 7, 3, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -84,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         [Test]
         public void HeapSortWithDuplicateEntries()
         {
-            var sortedIndices = new[] { 1, 1, 1, 1, 2, 2, 2, 2, 3, 4 };
+            var sortedIndices = new[] {1, 1, 1, 1, 2, 2, 2, 2, 3, 4};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -125,7 +129,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         [Test]
         public void HeapSortWithSpecialConstructedIntegerArray()
         {
-            var sortedIndices = new[] { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };
+            var sortedIndices = new[] {0, 0, 0, 0, 0, 1, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -136,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
                 }
             }
 
-            sortedIndices = new[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+            sortedIndices = new[] {1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -147,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
                 }
             }
 
-            sortedIndices = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+            sortedIndices = new[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -158,7 +162,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
                 }
             }
 
-            sortedIndices = new[] { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 };
+            sortedIndices = new[] {1, 1, 1, 0, 1, 1, 1, 1, 1, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs
index b9aa53fd..d3e30a61 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -45,17 +49,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <summary>
         /// The drop tolerance.
         /// </summary>
-        private double _dropTolerance = 0.1;
+        double _dropTolerance = 0.1;
 
         /// <summary>
         /// The fill level.
         /// </summary>
-        private double _fillLevel = 1.0;
+        double _fillLevel = 1.0;
 
         /// <summary>
         /// The pivot tolerance.
         /// </summary>
-        private double _pivotTolerance = 1.0;
+        double _pivotTolerance = 1.0;
 
         /// <summary>
         /// Setup default parameters.
@@ -75,7 +79,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="ilutp">Ilutp instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
+        static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
         {
             var type = ilutp.GetType();
             var methodInfo = type.GetMethod(
@@ -86,7 +90,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilutp, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -94,7 +98,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "UpperTriangle");
         }
@@ -104,7 +108,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "LowerTriangle");
         }
@@ -114,7 +118,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Pivots array.</returns>
-        private static int[] GetPivots(ILUTPPreconditioner ilutp)
+        static int[] GetPivots(ILUTPPreconditioner ilutp)
         {
             return GetMethod<int[]>(ilutp, "Pivots");
         }
@@ -124,7 +128,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// </summary>
         /// <param name="size">Matrix order.</param>
         /// <returns>Reverse Unit matrix.</returns>
-        private static SparseMatrix CreateReverseUnitMatrix(int size)
+        static SparseMatrix CreateReverseUnitMatrix(int size)
         {
             var matrix = new SparseMatrix(size);
             for (var i = 0; i < size; i++)
@@ -139,14 +143,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// Create preconditioner (internal)
         /// </summary>
         /// <returns>Ilutp instance.</returns>
-        private ILUTPPreconditioner InternalCreatePreconditioner()
+        ILUTPPreconditioner InternalCreatePreconditioner()
         {
             var result = new ILUTPPreconditioner
-                         {
-                             DropTolerance = _dropTolerance,
-                             FillLevel = _fillLevel,
-                             PivotTolerance = _pivotTolerance
-                         };
+            {
+                DropTolerance = _dropTolerance,
+                FillLevel = _fillLevel,
+                PivotTolerance = _pivotTolerance
+            };
             return result;
         }
 
@@ -171,7 +175,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
-            Assert.AreEqual(typeof(ILUTPPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILUTPPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
@@ -244,11 +248,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 0.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 0.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
 
@@ -300,11 +304,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 1.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
             var u = GetUpperTriangle(ilu);
@@ -337,11 +341,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
             var newMatrix = CreateReverseUnitMatrix(Size);
             var vector = CreateStandardBcVector(Size);
             var preconditioner = new ILUTPPreconditioner
-                                 {
-                                     PivotTolerance = 1.0,
-                                     DropTolerance = 0,
-                                     FillLevel = 10
-                                 };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             preconditioner.Initialize(newMatrix);
             var result = new DenseVector(vector.Count);
             preconditioner.Approximate(vector, result);
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs
index d6b9705b..d7a7d90a 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -49,7 +53,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
+        static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
         {
             var type = ilu.GetType();
             var methodInfo = type.GetMethod(
@@ -60,7 +64,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilu, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -68,7 +72,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static Matrix<Complex32> GetUpperTriangle(ILU0Preconditioner ilu)
+        static Matrix<Complex32> GetUpperTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<Complex32>>(ilu, "UpperTriangle");
         }
@@ -78,7 +82,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static Matrix<Complex32> GetLowerTriangle(ILU0Preconditioner ilu)
+        static Matrix<Complex32> GetLowerTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<Complex32>>(ilu, "LowerTriangle");
         }
@@ -101,7 +105,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
-            Assert.AreEqual(typeof(ILU0Preconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILU0Preconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs
index c09bcd4c..146bdcf7 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.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
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs
index add1d8f3..87ee35ee 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.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
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 96e4aeca..6192da34 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 3890d85d..f68d8fa5 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 5612f337..bd1600f5 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Complex32.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs
index 6f7e742c..9daf053e 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/BiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs
index a9a43ab1..de9c6a3c 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/GpBiCgTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs
index a6290895..844212c1 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/MlkBiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs
index dfd59338..f060c845 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Iterative/TFQMRTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs
index 0709cf20..68b4679f 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/IteratorTest.cs
@@ -31,7 +31,7 @@
 using System;
 using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -64,12 +64,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium<double>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<double>(),
-                    new ResidualStopCriterium()
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<double>(),
+                new ResidualStopCriterium()
+            };
             var iterator = new Iterator<double>(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
@@ -86,11 +86,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium<double>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<double>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<double>(1)
+            };
 
             var iterator = new Iterator<double>(criteria);
 
@@ -118,11 +118,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium<double>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<double>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<double>(1)
+            };
 
             var iterator = new Iterator<double>(criteria);
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs
index 0e96356a..1c8b3032 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.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
@@ -26,7 +30,7 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -56,7 +60,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
-            Assert.AreEqual(typeof(DiagonalPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (DiagonalPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IluptElementSorterTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IluptElementSorterTest.cs
index 212473ae..9ea7b974 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IluptElementSorterTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IluptElementSorterTest.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
@@ -24,12 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra.Double;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners
 {
-    using LinearAlgebra.Double;
-    using LinearAlgebra.Double.Solvers.Preconditioners;
-    using NUnit.Framework;
-
     /// <summary>
     /// Test for element sort algorithm of Ilupt class.
     /// </summary>
@@ -42,7 +46,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         [Test]
         public void HeapSortWithIncreasingIntegerArray()
         {
-            var sortedIndices = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+            var sortedIndices = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -56,7 +60,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         [Test]
         public void HeapSortWithDecreasingIntegerArray()
         {
-            var sortedIndices = new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+            var sortedIndices = new[] {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -70,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         [Test]
         public void HeapSortWithRandomIntegerArray()
         {
-            var sortedIndices = new[] { 5, 2, 8, 6, 0, 4, 1, 7, 3, 9 };
+            var sortedIndices = new[] {5, 2, 8, 6, 0, 4, 1, 7, 3, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -84,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         [Test]
         public void HeapSortWithDuplicateEntries()
         {
-            var sortedIndices = new[] { 1, 1, 1, 1, 2, 2, 2, 2, 3, 4 };
+            var sortedIndices = new[] {1, 1, 1, 1, 2, 2, 2, 2, 3, 4};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -125,7 +129,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         [Test]
         public void HeapSortWithSpecialConstructedIntegerArray()
         {
-            var sortedIndices = new[] { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };
+            var sortedIndices = new[] {0, 0, 0, 0, 0, 1, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -136,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
                 }
             }
 
-            sortedIndices = new[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+            sortedIndices = new[] {1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -147,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
                 }
             }
 
-            sortedIndices = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+            sortedIndices = new[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -158,7 +162,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
                 }
             }
 
-            sortedIndices = new[] { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 };
+            sortedIndices = new[] {1, 1, 1, 0, 1, 1, 1, 1, 1, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs
index f9ba3c90..70873a67 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -43,17 +47,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <summary>
         /// The drop tolerance.
         /// </summary>
-        private double _dropTolerance = 0.1;
+        double _dropTolerance = 0.1;
 
         /// <summary>
         /// The fill level.
         /// </summary>
-        private double _fillLevel = 1.0;
+        double _fillLevel = 1.0;
 
         /// <summary>
         /// The pivot tolerance.
         /// </summary>
-        private double _pivotTolerance = 1.0;
+        double _pivotTolerance = 1.0;
 
         /// <summary>
         /// Setup default parameters.
@@ -73,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="ilutp">Ilutp instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
+        static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
         {
             var type = ilutp.GetType();
             var methodInfo = type.GetMethod(
@@ -84,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilutp, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -92,7 +96,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "UpperTriangle");
         }
@@ -102,7 +106,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "LowerTriangle");
         }
@@ -112,7 +116,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Pivots array.</returns>
-        private static int[] GetPivots(ILUTPPreconditioner ilutp)
+        static int[] GetPivots(ILUTPPreconditioner ilutp)
         {
             return GetMethod<int[]>(ilutp, "Pivots");
         }
@@ -122,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// </summary>
         /// <param name="size">Matrix order.</param>
         /// <returns>Reverse Unit matrix.</returns>
-        private static SparseMatrix CreateReverseUnitMatrix(int size)
+        static SparseMatrix CreateReverseUnitMatrix(int size)
         {
             var matrix = new SparseMatrix(size);
             for (var i = 0; i < size; i++)
@@ -137,14 +141,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// Create preconditioner (internal)
         /// </summary>
         /// <returns>Ilutp instance.</returns>
-        private ILUTPPreconditioner InternalCreatePreconditioner()
+        ILUTPPreconditioner InternalCreatePreconditioner()
         {
             var result = new ILUTPPreconditioner
-                         {
-                             DropTolerance = _dropTolerance,
-                             FillLevel = _fillLevel,
-                             PivotTolerance = _pivotTolerance
-                         };
+            {
+                DropTolerance = _dropTolerance,
+                FillLevel = _fillLevel,
+                PivotTolerance = _pivotTolerance
+            };
             return result;
         }
 
@@ -169,7 +173,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
-            Assert.AreEqual(typeof(ILUTPPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILUTPPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
@@ -241,11 +245,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 0.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 0.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
 
@@ -296,11 +300,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 1.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
             var u = GetUpperTriangle(ilu);
@@ -332,11 +336,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
             var newMatrix = CreateReverseUnitMatrix(Size);
             var vector = CreateStandardBcVector(Size);
             var preconditioner = new ILUTPPreconditioner
-                                 {
-                                     PivotTolerance = 1.0,
-                                     DropTolerance = 0,
-                                     FillLevel = 10
-                                 };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             preconditioner.Initialize(newMatrix);
             var result = new DenseVector(vector.Count);
             preconditioner.Approximate(vector, result);
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs
index 46608b66..7cf086c8 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -47,7 +51,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
+        static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
         {
             var type = ilu.GetType();
             var methodInfo = type.GetMethod(
@@ -58,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilu, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -66,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static Matrix<double> GetUpperTriangle(ILU0Preconditioner ilu)
+        static Matrix<double> GetUpperTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<double>>(ilu, "UpperTriangle");
         }
@@ -76,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static Matrix<double> GetLowerTriangle(ILU0Preconditioner ilu)
+        static Matrix<double> GetLowerTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<double>>(ilu, "LowerTriangle");
         }
@@ -99,7 +103,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
-            Assert.AreEqual(typeof(ILU0Preconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILU0Preconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs
index a5e9c264..28a3bca9 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.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
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs
index b5da8a61..5a74a3bf 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs
@@ -26,7 +26,6 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -56,7 +55,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
-            Assert.AreEqual(typeof(UnitPreconditioner<double>), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (UnitPreconditioner<double>), preconditioner.GetType(), "#01");
 
             // Unit preconditioner is doing nothing. Vector and result should be equal
             for (var i = 0; i < vector.Count; i++)
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 1b2088bb..4431f923 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 79ae6981..a2c49cf1 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -28,11 +28,11 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCriterium
 {
@@ -85,9 +85,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 });
-            var source = new DenseVector(new[] { 1001.0, 0, 2003.0 });
-            var residual = new DenseVector(new[] { 1000, double.NaN, 2001 });
+            var solution = new DenseVector(new[] {1.0, 1.0, 2.0});
+            var source = new DenseVector(new[] {1001.0, 0, 2003.0});
+            var residual = new DenseVector(new[] {1000, double.NaN, 2001});
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Failure, status, "Should be failed");
@@ -102,9 +102,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0, 1.0, double.NaN });
-            var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 });
-            var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 });
+            var solution = new DenseVector(new[] {1.0, 1.0, double.NaN});
+            var source = new DenseVector(new[] {1001.0, 0.0, 2003.0});
+            var residual = new DenseVector(new[] {1000.0, 1000.0, 2001.0});
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Failure, status, "Should be failed");
@@ -119,9 +119,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 3.0, 2.0, 1.0 });
-            var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 });
-            var residual = new DenseVector(new[] { 1.0, 2.0, 3.0 });
+            var solution = new DenseVector(new[] {3.0, 2.0, 1.0});
+            var source = new DenseVector(new[] {1001.0, 0.0, 2003.0});
+            var residual = new DenseVector(new[] {1.0, 2.0, 3.0});
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
@@ -136,9 +136,9 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new FailureStopCriterium();
             Assert.IsNotNull(criterium, "There should be a criterium");
 
-            var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 });
-            var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 });
-            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[] {1001.0, 0.0, 2003.0});
+            var residual = new DenseVector(new[] {1000.0, 1000.0, 2001.0});
 
             var status = criterium.DetermineStatus(5, solution, source, residual);
             Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
@@ -156,7 +156,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             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");
         }
     }
 }
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 9098f2e3..3fe3e527 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Double.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs
index b714f960..f41b6935 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/BiCgStabTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs
index 8a580d9b..46237857 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/GpBiCgTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs
index 4743920b..db1453cd 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/MlkBiCgStabTest.cs
@@ -32,7 +32,6 @@ using System;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs
index ba92422a..d36ed3e7 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Iterative/TFQMRTest.cs
@@ -31,7 +31,6 @@
 using System;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs
index 1229914f..ea176e98 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/IteratorTest.cs
@@ -31,7 +31,7 @@
 using System;
 using System.Collections.Generic;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -64,12 +64,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatusWithNegativeIterationNumberThrowsArgumentOutOfRangeException()
         {
             var criteria = new List<IIterationStopCriterium<float>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<float>(),
-                    new ResidualStopCriterium()
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<float>(),
+                new ResidualStopCriterium()
+            };
             var iterator = new Iterator<float>(criteria);
 
             Assert.Throws<ArgumentOutOfRangeException>(() => iterator.DetermineStatus(
@@ -86,11 +86,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void DetermineStatus()
         {
             var criteria = new List<IIterationStopCriterium<float>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<float>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<float>(1)
+            };
 
             var iterator = new Iterator<float>(criteria);
 
@@ -118,11 +118,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers
         public void ResetToPrecalculationState()
         {
             var criteria = new List<IIterationStopCriterium<float>>
-                {
-                    new FailureStopCriterium(),
-                    new DivergenceStopCriterium(),
-                    new IterationCountStopCriterium<float>(1)
-                };
+            {
+                new FailureStopCriterium(),
+                new DivergenceStopCriterium(),
+                new IterationCountStopCriterium<float>(1)
+            };
 
             var iterator = new Iterator<float>(criteria);
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs
index e2e555ac..e375e91d 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.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
@@ -26,7 +30,7 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -56,7 +60,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
-            Assert.AreEqual(typeof(DiagonalPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (DiagonalPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
@@ -65,7 +69,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
 
             for (var i = 0; i < product.Count; i++)
             {
-                Assert.IsTrue(((double)vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i);
+                Assert.IsTrue(((double) vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i);
             }
         }
     }
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IluptElementSorterTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IluptElementSorterTest.cs
index 47d9dbbe..c2fc598a 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IluptElementSorterTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IluptElementSorterTest.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
@@ -24,12 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using MathNet.Numerics.LinearAlgebra.Single;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
+using NUnit.Framework;
+
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Preconditioners
 {
-    using LinearAlgebra.Single;
-    using LinearAlgebra.Single.Solvers.Preconditioners;
-    using NUnit.Framework;
-
     /// <summary>
     /// Test for element sort algorithm of Ilupt class.
     /// </summary>
@@ -42,7 +46,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         [Test]
         public void HeapSortWithIncreasingIntegerArray()
         {
-            var sortedIndices = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+            var sortedIndices = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -56,7 +60,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         [Test]
         public void HeapSortWithDecreasingIntegerArray()
         {
-            var sortedIndices = new[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
+            var sortedIndices = new[] {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -70,7 +74,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         [Test]
         public void HeapSortWithRandomIntegerArray()
         {
-            var sortedIndices = new[] { 5, 2, 8, 6, 0, 4, 1, 7, 3, 9 };
+            var sortedIndices = new[] {5, 2, 8, 6, 0, 4, 1, 7, 3, 9};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -84,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         [Test]
         public void HeapSortWithDuplicateEntries()
         {
-            var sortedIndices = new[] { 1, 1, 1, 1, 2, 2, 2, 2, 3, 4 };
+            var sortedIndices = new[] {1, 1, 1, 1, 2, 2, 2, 2, 3, 4};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -125,7 +129,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         [Test]
         public void HeapSortWithSpecialConstructedIntegerArray()
         {
-            var sortedIndices = new[] { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };
+            var sortedIndices = new[] {0, 0, 0, 0, 0, 1, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -136,7 +140,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
                 }
             }
 
-            sortedIndices = new[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+            sortedIndices = new[] {1, 0, 0, 0, 0, 0, 0, 0, 0, 0};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -147,7 +151,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
                 }
             }
 
-            sortedIndices = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
+            sortedIndices = new[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
@@ -158,7 +162,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
                 }
             }
 
-            sortedIndices = new[] { 1, 1, 1, 0, 1, 1, 1, 1, 1, 1 };
+            sortedIndices = new[] {1, 1, 1, 0, 1, 1, 1, 1, 1, 1};
             ILUTPElementSorter.SortIntegersDecreasing(sortedIndices);
             for (var i = 0; i < sortedIndices.Length; i++)
             {
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs
index 4c33d82d..53e828d5 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -43,17 +47,17 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <summary>
         /// The drop tolerance.
         /// </summary>
-        private double _dropTolerance = 0.1;
+        double _dropTolerance = 0.1;
 
         /// <summary>
         /// The fill level.
         /// </summary>
-        private double _fillLevel = 1.0;
+        double _fillLevel = 1.0;
 
         /// <summary>
         /// The pivot tolerance.
         /// </summary>
-        private double _pivotTolerance = 1.0;
+        double _pivotTolerance = 1.0;
 
         /// <summary>
         /// Setup default parameters.
@@ -73,7 +77,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="ilutp">Ilutp instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
+        static T GetMethod<T>(ILUTPPreconditioner ilutp, string methodName)
         {
             var type = ilutp.GetType();
             var methodInfo = type.GetMethod(
@@ -84,7 +88,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilutp, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -92,7 +96,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetUpperTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "UpperTriangle");
         }
@@ -102,7 +106,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
+        static SparseMatrix GetLowerTriangle(ILUTPPreconditioner ilutp)
         {
             return GetMethod<SparseMatrix>(ilutp, "LowerTriangle");
         }
@@ -112,7 +116,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// </summary>
         /// <param name="ilutp">Ilutp instance.</param>
         /// <returns>Pivots array.</returns>
-        private static int[] GetPivots(ILUTPPreconditioner ilutp)
+        static int[] GetPivots(ILUTPPreconditioner ilutp)
         {
             return GetMethod<int[]>(ilutp, "Pivots");
         }
@@ -122,7 +126,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// </summary>
         /// <param name="size">Matrix order.</param>
         /// <returns>Reverse Unit matrix.</returns>
-        private static SparseMatrix CreateReverseUnitMatrix(int size)
+        static SparseMatrix CreateReverseUnitMatrix(int size)
         {
             var matrix = new SparseMatrix(size);
             for (var i = 0; i < size; i++)
@@ -137,14 +141,14 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// Create preconditioner (internal)
         /// </summary>
         /// <returns>Ilutp instance.</returns>
-        private ILUTPPreconditioner InternalCreatePreconditioner()
+        ILUTPPreconditioner InternalCreatePreconditioner()
         {
             var result = new ILUTPPreconditioner
-                         {
-                             DropTolerance = _dropTolerance,
-                             FillLevel = _fillLevel,
-                             PivotTolerance = _pivotTolerance
-                         };
+            {
+                DropTolerance = _dropTolerance,
+                FillLevel = _fillLevel,
+                PivotTolerance = _pivotTolerance
+            };
             return result;
         }
 
@@ -169,7 +173,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
-            Assert.AreEqual(typeof(ILUTPPreconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILUTPPreconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
@@ -177,7 +181,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
             matrix.Multiply(result, product);
             for (var i = 0; i < product.Count; i++)
             {
-                Assert.IsTrue(((double)vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i);
+                Assert.IsTrue(((double) vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i);
             }
         }
 
@@ -241,11 +245,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 0.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 0.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
 
@@ -274,7 +278,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
             {
                 for (var j = 0; j < sparseMatrix.ColumnCount; j++)
                 {
-                    Assert.IsTrue(((double)sparseMatrix[i, j]).AlmostEqualInDecimalPlaces(original[i, j], 5), "#03-" + i + "-" + j);
+                    Assert.IsTrue(((double) sparseMatrix[i, j]).AlmostEqualInDecimalPlaces(original[i, j], 5), "#03-" + i + "-" + j);
                 }
             }
         }
@@ -296,11 +300,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
             sparseMatrix[2, 1] = 8;
             sparseMatrix[2, 2] = 9;
             var ilu = new ILUTPPreconditioner
-                      {
-                          PivotTolerance = 1.0,
-                          DropTolerance = 0,
-                          FillLevel = 10
-                      };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             ilu.Initialize(sparseMatrix);
             var l = GetLowerTriangle(ilu);
             var u = GetUpperTriangle(ilu);
@@ -317,7 +321,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
             {
                 for (var j = 0; j < sparseMatrix.ColumnCount; j++)
                 {
-                    Assert.IsTrue(((double)sparseMatrix[i, j]).AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j);
+                    Assert.IsTrue(((double) sparseMatrix[i, j]).AlmostEqual(original[i, j], -Epsilon.Magnitude()), "#01-" + i + "-" + j);
                 }
             }
         }
@@ -332,11 +336,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
             var newMatrix = CreateReverseUnitMatrix(Size);
             var vector = CreateStandardBcVector(Size);
             var preconditioner = new ILUTPPreconditioner
-                                 {
-                                     PivotTolerance = 1.0,
-                                     DropTolerance = 0,
-                                     FillLevel = 10
-                                 };
+            {
+                PivotTolerance = 1.0,
+                DropTolerance = 0,
+                FillLevel = 10
+            };
             preconditioner.Initialize(newMatrix);
             var result = new DenseVector(vector.Count);
             preconditioner.Approximate(vector, result);
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs
index 9d6462ab..e21142b3 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.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
@@ -28,7 +32,7 @@ using System;
 using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -47,7 +51,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <param name="methodName">Method name.</param>
         /// <returns>Result of the method invocation.</returns>
-        private static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
+        static T GetMethod<T>(ILU0Preconditioner ilu, string methodName)
         {
             var type = ilu.GetType();
             var methodInfo = type.GetMethod(
@@ -58,7 +62,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
                 new Type[0],
                 null);
             var obj = methodInfo.Invoke(ilu, null);
-            return (T)obj;
+            return (T) obj;
         }
 
         /// <summary>
@@ -66,7 +70,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Upper triangle.</returns>
-        private static Matrix<float> GetUpperTriangle(ILU0Preconditioner ilu)
+        static Matrix<float> GetUpperTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<float>>(ilu, "UpperTriangle");
         }
@@ -76,7 +80,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// </summary>
         /// <param name="ilu"><c>IncompleteLU</c> instance.</param>
         /// <returns>Lower triangle.</returns>
-        private static Matrix<float> GetLowerTriangle(ILU0Preconditioner ilu)
+        static Matrix<float> GetLowerTriangle(ILU0Preconditioner ilu)
         {
             return GetMethod<Matrix<float>>(ilu, "LowerTriangle");
         }
@@ -99,7 +103,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
-            Assert.AreEqual(typeof(ILU0Preconditioner), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (ILU0Preconditioner), preconditioner.GetType(), "#01");
 
             // Compute M * result = product
             // compare vector and product. Should be equal
@@ -108,7 +112,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
 
             for (var i = 0; i < product.Count; i++)
             {
-                Assert.IsTrue(((double)vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i);
+                Assert.IsTrue(((double) vector[i]).AlmostEqual(product[i], -Epsilon.Magnitude()), "#02-" + i);
             }
         }
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs
index b74e89f9..e1ecdca4 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.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
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs
index d076e1c5..12782e9b 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.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
@@ -26,7 +30,6 @@
 
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
@@ -56,7 +59,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="result">Result vector.</param>
         protected override void CheckResult(IPreconditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
-            Assert.AreEqual(typeof(UnitPreconditioner<float>), preconditioner.GetType(), "#01");
+            Assert.AreEqual(typeof (UnitPreconditioner<float>), preconditioner.GetType(), "#01");
 
             // Unit preconditioner is doing nothing. Vector and result should be equal
             for (var i = 0; i < vector.Count; i++)
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 91cd5b53..0b50fd2f 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 092a1125..a6d03da0 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -28,11 +28,11 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
-using System;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCriterium
 {
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index a817dc0a..e64ec33e 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -30,7 +30,7 @@
 
 using System;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium;
+using MathNet.Numerics.LinearAlgebra.Single.Solvers;
 using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;