/// <summary>
 /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
 /// </summary>
 public void ResetToPrecalculationState()
 {
     _status = DefaultStatus;
     _lastIteration = DefaultLastIterationNumber;
 }

 /// <summary>
 /// Set status to <see cref="CalculationFailure"/>
 /// </summary>
 private void SetStatusToFailed()
 {
     if (!(_status is CalculationFailure))
     {
         _status = new CalculationFailure();
     }
 }

 /// <summary>
 /// Set status to <see cref="CalculationRunning"/>
 /// </summary>
 private void SetStatusToRunning()
 {
     if (!(_status is CalculationRunning))
     {
         _status = new CalculationRunning();
     }
 }

 /// <summary>
 /// Set status to <see cref="CalculationDiverged"/>
 /// </summary>
 private void SetStatusToDiverged()
 {
     if (!(_status is CalculationDiverged))
     {
         _status = new CalculationDiverged();
     }
 }

 /// <summary>
 /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
 /// </summary>
 public void ResetToPrecalculationState()
 {
     _status = DefaultStatus;
     _lastIteration = DefaultLastIterationNumber;
     _residualHistory = null;
 }

 /// <summary>
 /// Set status to <see cref="CalculationFailure"/>
 /// </summary>
 private void SetStatusToFinished()
 {
     if (!(_status is CalculationStoppedWithoutConvergence))
     {
         _status = new CalculationStoppedWithoutConvergence();
     }
 }

 /// <summary>
 /// Resets the <see cref="IterationCountStopCriterium"/> to the pre-calculation state.
 /// </summary>
 public void ResetToPrecalculationState()
 {
     _status = DefaultStatus;
 }

        /// <summary>
        /// Resets the <see cref="IIterator"/> to the pre-calculation state.
        /// </summary>
        public void ResetToPrecalculationState()
        {
            // Indicate that we're no longer cancelled.
            _wasIterationCancelled = false;

            // Reset the status.
            _status = DefaultStatus;

            // Reset the stop-criteria
            foreach (var stopCriterium in _stopCriterias.Select(pair => pair.Value))
            {
                stopCriterium.ResetToPrecalculationState();
            }
        }

 /// <summary>
 /// Indicates to the iterator that the iterative process has been cancelled.
 /// </summary>
 /// <remarks>
 /// Does not reset the stop-criteria.
 /// </remarks>
 public void IterationCancelled()
 {
     _wasIterationCancelled = true;
     _status = new CalculationCancelled();
 }

        /// <summary>
        /// Determines the status of the iterative calculation based on the stop criteria stored
        /// by the current <c>IIterator</c>. Result is set into <c>Status</c> field.
        /// </summary>
        /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
        /// <param name="solutionVector">The vector containing the current solution values.</param>
        /// <param name="sourceVector">The right hand side vector.</param>
        /// <param name="residualVector">The vector containing the current residual vectors.</param>
        /// <remarks>
        /// The individual iterators may internally track the progress of the calculation based
        /// 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 solutionVector, Vector sourceVector, Vector residualVector)
        {
            if (_stopCriterias.Count == 0)
            {
                throw new ArgumentException(Resources.StopCriteriumMissing);
            }

            if (iterationNumber < 0)
            {
                throw new ArgumentOutOfRangeException("iterationNumber");
            }

            if (solutionVector == null)
            {
                throw new ArgumentNullException("solutionVector");
            }

            if (sourceVector == null)
            {
                throw new ArgumentNullException("sourceVector");
            }

            if (residualVector == null)
            {
                throw new ArgumentNullException("residualVector");
            }

            // While we're cancelled we don't call on the stop-criteria.
            if (_wasIterationCancelled)
            {
                return;
            }

            foreach (var stopCriterium in _stopCriterias.Select(pair => pair.Value))
            {
                stopCriterium.DetermineStatus(iterationNumber, solutionVector, sourceVector, residualVector);
                var status = stopCriterium.Status;

                // Check if the status is:
                // - Running --> keep going
                // - Indetermined --> keep going
                // Anything else:
                // Stop looping and set that status
                if ((status is CalculationRunning) || (status is CalculationIndetermined))
                {
                    continue;
                }

                _status = status;
                return;
            }

            // Got all the way through
            // So we're running because we had vectors passed to us.
            if (!(_status is CalculationRunning))
            {
                _status = new CalculationRunning();
            }
        }