diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs
index b742400e..4f8a5626 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs
@@ -224,7 +224,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<Complex> solutionVector, Vector<Complex> sourceVector, Vector<Complex> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<Complex> solutionVector, Vector<Complex> sourceVector, Vector<Complex> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -240,7 +240,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             if ((_residualHistory == null) || (_residualHistory.Length != RequiredHistoryLength))
@@ -264,7 +264,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             if (double.IsNaN(_residualHistory[_residualHistory.Length - 1]))
             {
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // Check if we are diverging and if so set the status
@@ -278,6 +278,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -362,20 +363,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             _residualHistory = null;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="LinearAlgebra.Solvers.StopLevel.Divergence"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Divergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="DivergenceStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs
index e578ec20..7351cfa8 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs
@@ -82,7 +82,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<Complex> solutionVector, Vector<Complex> sourceVector, Vector<Complex> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<Complex> solutionVector, Vector<Complex> sourceVector, Vector<Complex> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -108,7 +108,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             // Store the infinity norms of both the solution and residual vectors
@@ -125,6 +125,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -170,20 +171,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="CalculationFailure"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.CalculationFailure;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="FailureStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs
index a1f386ae..2a66ac40 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs
@@ -229,7 +229,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<Complex> solutionVector, Vector<Complex> sourceVector, Vector<Complex> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<Complex> solutionVector, Vector<Complex> sourceVector, Vector<Complex> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -277,7 +277,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             {
                 _iterationCount = 0;
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // ||r_i|| <= stop_tol * ||b||
@@ -305,6 +305,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -378,20 +379,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="StopLevel"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Convergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="ResidualStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs
index 45a55e18..97fbac8c 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs
@@ -219,7 +219,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<Complex32> solutionVector, Vector<Complex32> sourceVector, Vector<Complex32> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<Complex32> solutionVector, Vector<Complex32> sourceVector, Vector<Complex32> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -235,7 +235,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             if ((_residualHistory == null) || (_residualHistory.Length != RequiredHistoryLength))
@@ -259,7 +259,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             if (double.IsNaN(_residualHistory[_residualHistory.Length - 1]))
             {
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // Check if we are diverging and if so set the status
@@ -273,6 +273,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -357,20 +358,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             _residualHistory = null;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="LinearAlgebra.Solvers.StopLevel.Divergence"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Divergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="DivergenceStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs
index ffd59193..a881e558 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<Complex32> solutionVector, Vector<Complex32> sourceVector, Vector<Complex32> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<Complex32> solutionVector, Vector<Complex32> sourceVector, Vector<Complex32> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -103,7 +103,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             // Store the infinity norms of both the solution and residual vectors
@@ -120,6 +120,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -165,20 +166,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="CalculationFailure"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.CalculationFailure;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="FailureStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs
index 6f3a0043..8234ce0a 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs
@@ -224,7 +224,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<Complex32> solutionVector, Vector<Complex32> sourceVector, Vector<Complex32> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<Complex32> solutionVector, Vector<Complex32> sourceVector, Vector<Complex32> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -272,7 +272,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             {
                 _iterationCount = 0;
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // ||r_i|| <= stop_tol * ||b||
@@ -300,6 +300,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -373,20 +374,6 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="StopLevel"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Convergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="ResidualStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs
index 29beaba8..b44cd30f 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs
@@ -217,7 +217,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<double> solutionVector, Vector<double> sourceVector, Vector<double> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<double> solutionVector, Vector<double> sourceVector, Vector<double> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -233,7 +233,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             if ((_residualHistory == null) || (_residualHistory.Length != RequiredHistoryLength))
@@ -257,7 +257,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             if (double.IsNaN(_residualHistory[_residualHistory.Length - 1]))
             {
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // Check if we are diverging and if so set the status
@@ -271,6 +271,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -355,20 +356,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             _residualHistory = null;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="LinearAlgebra.Solvers.StopLevel.Divergence"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Divergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="DivergenceStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs
index a37934fb..dd009098 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs
@@ -75,7 +75,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<double> solutionVector, Vector<double> sourceVector, Vector<double> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<double> solutionVector, Vector<double> sourceVector, Vector<double> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -101,7 +101,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             // Store the infinity norms of both the solution and residual vectors
@@ -118,6 +118,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -163,20 +164,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="CalculationFailure"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.CalculationFailure;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="FailureStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs
index 11d03121..42d8a68e 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs
@@ -222,7 +222,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<double> solutionVector, Vector<double> sourceVector, Vector<double> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<double> solutionVector, Vector<double> sourceVector, Vector<double> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -270,7 +270,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             {
                 _iterationCount = 0;
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // ||r_i|| <= stop_tol * ||b||
@@ -298,6 +298,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -371,20 +372,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="StopLevel"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Convergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="ResidualStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs
index 2998f50e..7307af6c 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs
@@ -217,7 +217,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<float> solutionVector, Vector<float> sourceVector, Vector<float> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<float> solutionVector, Vector<float> sourceVector, Vector<float> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -233,7 +233,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             if ((_residualHistory == null) || (_residualHistory.Length != RequiredHistoryLength))
@@ -257,7 +257,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             if (double.IsNaN(_residualHistory[_residualHistory.Length - 1]))
             {
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // Check if we are diverging and if so set the status
@@ -271,6 +271,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -355,20 +356,6 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             _residualHistory = null;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="LinearAlgebra.Solvers.StopLevel.Divergence"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Divergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="DivergenceStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs
index 75cf64b2..10e3ea86 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs
@@ -75,7 +75,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<float> solutionVector, Vector<float> sourceVector, Vector<float> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<float> solutionVector, Vector<float> sourceVector, Vector<float> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -101,7 +101,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             {
                 // We have already stored the actual last iteration number
                 // For now do nothing. We only care about the next step.
-                return;
+                return _status;
             }
 
             // Store the infinity norms of both the solution and residual vectors
@@ -118,6 +118,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -163,20 +164,6 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="CalculationFailure"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.CalculationFailure;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="FailureStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs b/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs
index b742745b..3859a42a 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs
@@ -222,7 +222,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<float> solutionVector, Vector<float> sourceVector, Vector<float> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<float> solutionVector, Vector<float> sourceVector, Vector<float> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -270,7 +270,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             {
                 _iterationCount = 0;
                 SetStatusToDiverged();
-                return;
+                return _status;
             }
 
             // ||r_i|| <= stop_tol * ||b||
@@ -298,6 +298,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             }
 
             _lastIteration = iterationNumber;
+            return _status;
         }
 
         /// <summary>
@@ -371,20 +372,6 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
             _lastIteration = DefaultLastIterationNumber;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="StopLevel"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get
-            {
-                return StopLevel.Convergence;
-            }
-        }
-
         /// <summary>
         /// Clones the current <see cref="ResidualStopCriterium"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Solvers/IIterationStopCriterium.cs b/src/Numerics/LinearAlgebra/Solvers/IIterationStopCriterium.cs
index b7366694..24495194 100644
--- a/src/Numerics/LinearAlgebra/Solvers/IIterationStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Solvers/IIterationStopCriterium.cs
@@ -50,7 +50,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        void DetermineStatus(int iterationNumber, Vector<T> solutionVector, Vector<T> sourceVector, Vector<T> residualVector);
+        ICalculationStatus DetermineStatus(int iterationNumber, Vector<T> solutionVector, Vector<T> sourceVector, Vector<T> residualVector);
 
         /// <summary>
         /// Gets the current calculation status.
@@ -66,12 +66,6 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// calculation.</remarks>
         void ResetToPrecalculationState();
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// IIterationStopCriterium monitors.
-        /// </summary>
-        StopLevel StopLevel { get; }
-
         IIterationStopCriterium<T> Clone();
     }
 }
diff --git a/src/Numerics/LinearAlgebra/Solvers/IterationCountStopCriterium.cs b/src/Numerics/LinearAlgebra/Solvers/IterationCountStopCriterium.cs
index d9667b35..e7a5c781 100644
--- a/src/Numerics/LinearAlgebra/Solvers/IterationCountStopCriterium.cs
+++ b/src/Numerics/LinearAlgebra/Solvers/IterationCountStopCriterium.cs
@@ -126,7 +126,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// on the invocation of this method. Therefore this method should only be called if the 
         /// calculation has moved forwards at least one step.
         /// </remarks>
-        public void DetermineStatus(int iterationNumber, Vector<T> solutionVector, Vector<T> sourceVector, Vector<T> residualVector)
+        public ICalculationStatus DetermineStatus(int iterationNumber, Vector<T> solutionVector, Vector<T> sourceVector, Vector<T> residualVector)
         {
             if (iterationNumber < 0)
             {
@@ -141,6 +141,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
             {
                 SetStatusToRunning();
             }
+            return _status;
         }
 
         /// <summary>
@@ -182,17 +183,6 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
             _status = DefaultStatus;
         }
 
-        /// <summary>
-        /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IterationCountStopCriterium{T}"/> monitors.
-        /// </summary>
-        /// <value>Returns <see cref="StopLevel"/>.</value>
-        public StopLevel StopLevel
-        {
-            [DebuggerStepThrough]
-            get { return StopLevel.StoppedWithoutConvergence; }
-        }
-
         /// <summary>
         /// Clones the current <see cref="IterationCountStopCriterium{T}"/> and its settings.
         /// </summary>
diff --git a/src/Numerics/LinearAlgebra/Solvers/Iterator.cs b/src/Numerics/LinearAlgebra/Solvers/Iterator.cs
index 6e3d2c05..bc8bb718 100644
--- a/src/Numerics/LinearAlgebra/Solvers/Iterator.cs
+++ b/src/Numerics/LinearAlgebra/Solvers/Iterator.cs
@@ -50,7 +50,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// The collection that holds all the stop criteria and the flag indicating if they should be added
         /// to the child iterators.
         /// </summary>
-        readonly Dictionary<Type, IIterationStopCriterium<T>> _stopCriterias = new Dictionary<Type, IIterationStopCriterium<T>>();
+        readonly List<IIterationStopCriterium<T>> _stopCriterias = new List<IIterationStopCriterium<T>>();
 
         /// <summary>
         /// The status of the iterator.
@@ -98,7 +98,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <param name="stopCriterium">The stop criterium to add.</param>
         public void Add(IIterationStopCriterium<T> stopCriterium)
         {
-            _stopCriterias[stopCriterium.GetType()] = stopCriterium;
+            _stopCriterias.Add(stopCriterium);
         }
 
         /// <summary>
@@ -107,7 +107,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <param name="stopCriterium">The stop criterium that must be removed.</param>
         public void Remove(IIterationStopCriterium<T> stopCriterium)
         {
-            _stopCriterias.Remove(stopCriterium.GetType());
+            _stopCriterias.Remove(stopCriterium);
         }
 
         /// <summary>
@@ -117,7 +117,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <returns><c>true</c> if the <see cref="IIterator{T}"/> contains the stop criterium; otherwise <c>false</c>.</returns>
         public bool Contains(IIterationStopCriterium<T> stopCriterium)
         {
-            return _stopCriterias.ContainsKey(stopCriterium.GetType());
+            return _stopCriterias.Contains(stopCriterium);
         }
 
         /// <summary>
@@ -135,7 +135,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <remarks>Used for testing only.</remarks>
         internal IEnumerable<IIterationStopCriterium<T>> StoredStopCriteria
         {
-            get { return _stopCriterias.Select(criterium => criterium.Value); }
+            get { return _stopCriterias; }
         }
 
         /// <summary>
@@ -181,10 +181,9 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
                 return;
             }
 
-            foreach (var stopCriterium in _stopCriterias.Select(pair => pair.Value))
+            foreach (var stopCriterium in _stopCriterias)
             {
-                stopCriterium.DetermineStatus(iterationNumber, solutionVector, sourceVector, residualVector);
-                var status = stopCriterium.Status;
+                var status = stopCriterium.DetermineStatus(iterationNumber, solutionVector, sourceVector, residualVector);
 
                 // Check if the status is:
                 // - Running --> keep going
@@ -228,7 +227,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
             _status = DefaultStatus;
 
             // Reset the stop-criteria
-            foreach (var stopCriterium in _stopCriterias.Select(pair => pair.Value))
+            foreach (var stopCriterium in _stopCriterias)
             {
                 stopCriterium.ResetToPrecalculationState();
             }
@@ -240,7 +239,7 @@ namespace MathNet.Numerics.LinearAlgebra.Solvers
         /// <returns>The deep clone of the current iterator.</returns>
         public IIterator<T> Clone()
         {
-            var stopCriteria = _stopCriterias.Select(pair => pair.Value).Select(stopCriterium => stopCriterium.Clone()).ToList();
+            var stopCriteria = _stopCriterias.Select(stopCriterium => stopCriterium.Clone()).ToList();
             return new Iterator<T>(stopCriteria);
         }
     }
diff --git a/src/Numerics/LinearAlgebra/Solvers/StopLevel.cs b/src/Numerics/LinearAlgebra/Solvers/StopLevel.cs
deleted file mode 100644
index 294933b3..00000000
--- a/src/Numerics/LinearAlgebra/Solvers/StopLevel.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-// <copyright file="StopLevel.cs" company="Math.NET">
-// Math.NET Numerics, part of the Math.NET Project
-// http://numerics.mathdotnet.com
-// http://github.com/mathnet/mathnet-numerics
-// http://mathnetnumerics.codeplex.com
-//
-// 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
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// 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
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-// </copyright>
-
-namespace MathNet.Numerics.LinearAlgebra.Solvers
-{
-    /// <summary>
-    /// Iteration stop criteria. 
-    /// </summary>
-    public enum StopLevel
-    {
-        /// <summary>
-        /// Monitor calculation failures in the iterative calculation.
-        /// </summary>
-        CalculationFailure,
-
-        /// <summary>
-        /// Monitor the calculation for signs of divergence.
-        /// </summary>
-        Divergence,
-
-        /// <summary>
-        /// Guard the calculation against unlimited continuation
-        /// by monitoring user specified limits, e.g. the maximum number of iterations.
-        /// </summary>
-        StoppedWithoutConvergence,
-
-        /// <summary>
-        /// Monitor the calculation for convergence, usually
-        /// based on the residuals of the calculation.
-        /// </summary>
-        Convergence
-    }
-}
diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj
index 0a9a363b..3ba13983 100644
--- a/src/Numerics/Numerics.csproj
+++ b/src/Numerics/Numerics.csproj
@@ -357,7 +357,6 @@
     <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\Solvers\StopLevel.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/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index bf5eda77..5b81b2d0 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -147,13 +147,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 1; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex((i + 1)*(Increase + 0.1), 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -171,13 +171,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             // Add residuals. We should not diverge because we won't have enough increase
             for (var i = 0; i < Iterations*2; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex((i + 1)*(Increase - 0.01), 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -195,23 +195,23 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 5; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex((i + 1)*(Increase - 0.01), 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations,
                 new DenseVector(new[] {new Complex(1.0, 0)}),
                 new DenseVector(new[] {new Complex(1.0, 0)}),
                 new DenseVector(new[] {new Complex(double.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -230,24 +230,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             for (var i = 0; i < Iterations - 1; i++)
             {
                 previous *= 1 + Increase + 0.01;
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex(1.0, 0)}),
                     new DenseVector(new[] {new Complex(previous, 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01;
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations - 1,
                 new DenseVector(new[] {new Complex(1.0, 0)}),
                 new DenseVector(new[] {new Complex(1.0, 0)}),
                 new DenseVector(new[] {new Complex(previous, 0)}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -262,13 +262,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. Blow it up instantly
-            criterium.DetermineStatus(
+            var status = criterium.DetermineStatus(
                 1,
                 new DenseVector(new[] {new Complex(1.0, 0)}),
                 new DenseVector(new[] {new Complex(1.0, 0)}),
                 new DenseVector(new[] {new Complex(double.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index f988b800..0b200356 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -115,8 +115,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
             var residual = new DenseVector(new[] {new Complex(1000, 0), new Complex(double.NaN, 0), new Complex(2001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -132,8 +132,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
             var residual = new DenseVector(new[] {new Complex(1000, 0), new Complex(1000, 0), new Complex(2001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -149,8 +149,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
             var residual = new DenseVector(new[] {new Complex(1.0, 0), new Complex(2.0, 0), new Complex(3, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
         }
 
         /// <summary>
@@ -166,8 +166,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(1001.0, 0), Complex.Zero, new Complex(2003.0, 0)});
             var residual = new DenseVector(new[] {new Complex(1000, 0), new Complex(1000, 0), new Complex(2001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index 985b9a1b..bd7dd0f7 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -99,11 +99,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium<Complex>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
-            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), status2, "Should be finished");
         }
 
         /// <summary>
@@ -115,8 +115,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var criterium = new IterationCountStopCriterium<Complex>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 820d8ef4..fef7fd3e 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -226,8 +226,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(double.NaN, 1)});
             var residual = new DenseVector(new[] {new Complex(1000.0, 1), new Complex(1000.0, 1), new Complex(2001.0, 1)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -243,8 +243,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)});
             var residual = new DenseVector(new[] {new Complex(1000.0, 1), new Complex(double.NaN, 1), new Complex(2001.0, 1)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -264,8 +264,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {Complex.One, Complex.One, Complex.One});
             var residual = new DenseVector(new[] {Complex.Zero, Complex.Zero, Complex.Zero});
 
-            criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status = criterium.DetermineStatus(0, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status, "Should be done");
         }
 
         /// <summary>
@@ -286,11 +286,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             // Set the residual values
             var residual = new DenseVector(new[] {new Complex(0.001, 0), new Complex(0.001, 0), new Complex(0.002, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should still be running");
 
-            criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status2 = criterium.DetermineStatus(16, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status2, "Should be done");
         }
 
         /// <summary>
@@ -306,8 +306,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.StopCrit
             var source = new DenseVector(new[] {new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1)});
             var residual = new DenseVector(new[] {new Complex(1.000, 0), new Complex(1.000, 0), new Complex(2.001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 94be71cf..fd1a09f9 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -147,12 +147,12 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 1; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32((i + 1)*(Increase + 0.1f), 0)}));
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -170,13 +170,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             // Add residuals. We should not diverge because we won't have enough increase
             for (var i = 0; i < Iterations*2; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32((i + 1)*(Increase - 0.01f), 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -194,23 +194,23 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 5; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32((i + 1)*(Increase - 0.01f), 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations,
                 new DenseVector(new[] {new Complex32(1.0f, 0)}),
                 new DenseVector(new[] {new Complex32(1.0f, 0)}),
                 new DenseVector(new[] {new Complex32(float.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -229,24 +229,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             for (var i = 0; i < Iterations - 1; i++)
             {
                 previous *= 1 + Increase + 0.01f;
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32(1.0f, 0)}),
                     new DenseVector(new[] {new Complex32(previous, 0)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01f;
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations - 1,
                 new DenseVector(new[] {new Complex32(1.0f, 0)}),
                 new DenseVector(new[] {new Complex32(1.0f, 0)}),
                 new DenseVector(new[] {new Complex32(previous, 0)}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -261,13 +261,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. Blow it up instantly
-            criterium.DetermineStatus(
+            var status = criterium.DetermineStatus(
                 1,
                 new DenseVector(new[] {new Complex32(1.0f, 0)}),
                 new DenseVector(new[] {new Complex32(1.0f, 0)}),
                 new DenseVector(new[] {new Complex32(float.NaN, 0)}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index e36ab8ef..98bf9722 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -115,8 +115,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
             var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(float.NaN, 0), new Complex32(2001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -132,8 +132,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
             var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -149,8 +149,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
             var residual = new DenseVector(new[] {new Complex32(1.0f, 0), new Complex32(2.0f, 0), new Complex32(3, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
         }
 
         /// <summary>
@@ -166,8 +166,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(1001.0f, 0), Complex32.Zero, new Complex32(2003.0f, 0)});
             var residual = new DenseVector(new[] {new Complex32(1000, 0), new Complex32(1000, 0), new Complex32(2001, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index 9e638947..a6cfa27e 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -99,11 +99,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium<Complex32>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
-            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), status2, "Should be finished");
         }
 
         /// <summary>
@@ -115,8 +115,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var criterium = new IterationCountStopCriterium<Complex32>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index 044de11d..19f6cce4 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -226,8 +226,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(float.NaN, 1)});
             var residual = new DenseVector(new[] {new Complex32(1000.0f, 1), new Complex32(1000.0f, 1), new Complex32(2001.0f, 1)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -243,8 +243,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1)});
             var residual = new DenseVector(new[] {new Complex32(1000.0f, 1), new Complex32(float.NaN, 1), new Complex32(2001.0f, 1)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -264,8 +264,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {Complex32.One, Complex32.One, Complex32.One});
             var residual = new DenseVector(new[] {Complex32.Zero, Complex32.Zero, Complex32.Zero});
 
-            criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status = criterium.DetermineStatus(0, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status, "Should be done");
         }
 
         /// <summary>
@@ -286,11 +286,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             // Set the residual values
             var residual = new DenseVector(new[] {new Complex32(0.001f, 0), new Complex32(0.001f, 0), new Complex32(0.002f, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should still be running");
 
-            criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status2 = criterium.DetermineStatus(16, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status2, "Should be done");
         }
 
         /// <summary>
@@ -306,8 +306,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.StopCr
             var source = new DenseVector(new[] {new Complex32(0.001f, 1), new Complex32(0.001f, 1), new Complex32(0.002f, 1)});
             var residual = new DenseVector(new[] {new Complex32(1.000f, 0), new Complex32(1.000f, 0), new Complex32(2.001f, 0)});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index 5a4a37d0..f29581ca 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -145,13 +145,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 1; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {(i + 1)*(Increase + 0.1)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -169,13 +169,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             // Add residuals. We should not diverge because we won't have enough increase
             for (var i = 0; i < Iterations*2; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {(i + 1)*(Increase - 0.01)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -193,23 +193,23 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 5; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {(i + 1)*(Increase - 0.01)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations,
                 new DenseVector(new[] {1.0}),
                 new DenseVector(new[] {1.0}),
                 new DenseVector(new[] {double.NaN}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -228,24 +228,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             for (var i = 0; i < Iterations - 1; i++)
             {
                 previous *= 1 + Increase + 0.01;
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {1.0}),
                     new DenseVector(new[] {previous}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01;
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations - 1,
                 new DenseVector(new[] {1.0}),
                 new DenseVector(new[] {1.0}),
                 new DenseVector(new[] {previous}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -260,13 +260,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. Blow it up instantly
-            criterium.DetermineStatus(
+            var status = criterium.DetermineStatus(
                 1,
                 new DenseVector(new[] {1.0}),
                 new DenseVector(new[] {1.0}),
                 new DenseVector(new[] {double.NaN}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index 47cc6fbf..dbd14365 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -113,8 +113,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] { 1001.0, 0, 2003.0 });
             var residual = new DenseVector(new[] { 1000, double.NaN, 2001 });
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof(CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -130,8 +130,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 });
             var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 });
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof(CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -147,8 +147,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 });
             var residual = new DenseVector(new[] { 1.0, 2.0, 3.0 });
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof(CalculationRunning), status, "Should be running");
         }
 
         /// <summary>
@@ -164,8 +164,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] { 1001.0, 0.0, 2003.0 });
             var residual = new DenseVector(new[] { 1000.0, 1000.0, 2001.0 });
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof(CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof(CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index 566dd755..22b579aa 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -97,11 +97,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<double>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
-            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), status2, "Should be finished");
         }
 
         /// <summary>
@@ -113,8 +113,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<double>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index eb3831f6..e9faa742 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -224,8 +224,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] {1.0, 1.0, double.NaN});
             var residual = new DenseVector(new[] {1000.0, 1000.0, 2001.0});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -241,8 +241,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] {1.0, 1.0, 2.0});
             var residual = new DenseVector(new[] {1000.0, double.NaN, 2001.0});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -258,8 +258,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] {1.0, 1.0, 1.0});
             var residual = new DenseVector(new[] {0.0, 0.0, 0.0});
 
-            criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status = criterium.DetermineStatus(0, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status, "Should be done");
         }
 
         /// <summary>
@@ -280,11 +280,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             // Set the residual values
             var residual = new DenseVector(new[] {0.001, 0.001, 0.002});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should still be running");
 
-            criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status2 = criterium.DetermineStatus(16, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status2, "Should be done");
         }
 
         /// <summary>
@@ -300,8 +300,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.StopCrite
             var source = new DenseVector(new[] {0.001, 0.001, 0.002});
             var residual = new DenseVector(new[] {1.000, 1.000, 2.001});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
index d76b008c..fecd30c4 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
@@ -145,13 +145,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 1; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {(i + 1)*(Increase + 0.1f)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -169,13 +169,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             // Add residuals. We should not diverge because we won't have enough increase
             for (var i = 0; i < Iterations*2; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {(i + 1)*(Increase - 0.01f)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
         }
 
@@ -193,23 +193,23 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             // Add residuals. We should not diverge because we'll have to few iterations
             for (var i = 0; i < Iterations - 5; i++)
             {
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {(i + 1)*(Increase - 0.01f)}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Now make it fail by throwing in a NaN
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations,
                 new DenseVector(new[] {1.0f}),
                 new DenseVector(new[] {1.0f}),
                 new DenseVector(new[] {float.NaN}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -228,24 +228,24 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             for (var i = 0; i < Iterations - 1; i++)
             {
                 previous *= 1 + Increase + 0.01f;
-                criterium.DetermineStatus(
+                var status = criterium.DetermineStatus(
                     i,
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {1.0f}),
                     new DenseVector(new[] {previous}));
 
-                Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Status check fail.");
+                Assert.IsInstanceOf(typeof (CalculationRunning), status, "Status check fail.");
             }
 
             // Add the final residual. Now we should have divergence
             previous *= 1 + Increase + 0.01f;
-            criterium.DetermineStatus(
+            var status2 = criterium.DetermineStatus(
                 Iterations - 1,
                 new DenseVector(new[] {1.0f}),
                 new DenseVector(new[] {1.0f}),
                 new DenseVector(new[] {previous}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status2, "Status check fail.");
         }
 
         /// <summary>
@@ -260,13 +260,13 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new DivergenceStopCriterium(Increase, Iterations);
 
             // Add residuals. Blow it up instantly
-            criterium.DetermineStatus(
+            var status = criterium.DetermineStatus(
                 1,
                 new DenseVector(new[] {1.0f}),
                 new DenseVector(new[] {1.0f}),
                 new DenseVector(new[] {float.NaN}));
 
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Status check fail.");
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Status check fail.");
 
             // Reset the state
             criterium.ResetToPrecalculationState();
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
index a42afbd6..58609468 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
@@ -113,8 +113,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1001.0f, 0, 2003.0f});
             var residual = new DenseVector(new[] {1000, float.NaN, 2001});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -130,8 +130,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1001.0f, 0.0f, 2003.0f});
             var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationFailure), criterium.Status, "Should be failed");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationFailure), status, "Should be failed");
         }
 
         /// <summary>
@@ -147,8 +147,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1001.0f, 0.0f, 2003.0f});
             var residual = new DenseVector(new[] {1.0f, 2.0f, 3.0f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
         }
 
         /// <summary>
@@ -164,8 +164,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1001.0f, 0.0f, 2003.0f});
             var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
index c86d58e2..3abff679 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
@@ -97,11 +97,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<float>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
-            criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), criterium.Status, "Should be finished");
+            var status2 = criterium.DetermineStatus(10, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationStoppedWithoutConvergence), status2, "Should be finished");
         }
 
         /// <summary>
@@ -113,8 +113,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var criterium = new IterationCountStopCriterium<float>(10);
             Assert.IsNotNull(criterium, "A criterium should have been created");
 
-            criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, DenseVector.Create(3, i => 1), DenseVector.Create(3, i => 2), DenseVector.Create(3, i => 3));
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
index a39c4193..00cf9771 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
@@ -224,8 +224,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1.0f, 1.0f, float.NaN});
             var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -241,8 +241,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
             var residual = new DenseVector(new[] {1000.0f, float.NaN, 2001.0f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationDiverged), criterium.Status, "Should be diverged");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationDiverged), status, "Should be diverged");
         }
 
         /// <summary>
@@ -258,8 +258,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {1.0f, 1.0f, 1.0f});
             var residual = new DenseVector(new[] {0.0f, 0.0f, 0.0f});
 
-            criterium.DetermineStatus(0, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status = criterium.DetermineStatus(0, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status, "Should be done");
         }
 
         /// <summary>
@@ -280,11 +280,11 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             // Set the residual values
             var residual = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should still be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should still be running");
 
-            criterium.DetermineStatus(16, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationConverged), criterium.Status, "Should be done");
+            var status2 = criterium.DetermineStatus(16, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationConverged), status2, "Should be done");
         }
 
         /// <summary>
@@ -300,8 +300,8 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.StopCrite
             var source = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
             var residual = new DenseVector(new[] {1.000f, 1.000f, 2.001f});
 
-            criterium.DetermineStatus(5, solution, source, residual);
-            Assert.IsInstanceOf(typeof (CalculationRunning), criterium.Status, "Should be running");
+            var status = criterium.DetermineStatus(5, solution, source, residual);
+            Assert.IsInstanceOf(typeof (CalculationRunning), status, "Should be running");
 
             criterium.ResetToPrecalculationState();
             Assert.IsInstanceOf(typeof (CalculationIndetermined), criterium.Status, "Should not have started");