Browse Source

LA: simplify IIterationStopCriterium, drop StopLevel

optimization-1
Christoph Ruegg 13 years ago
parent
commit
00c0ef6612
  1. 21
      src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs
  2. 19
      src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs
  3. 19
      src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs
  4. 21
      src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs
  5. 19
      src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs
  6. 19
      src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs
  7. 21
      src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs
  8. 19
      src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs
  9. 19
      src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs
  10. 21
      src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs
  11. 19
      src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs
  12. 19
      src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/ResidualStopCriterium.cs
  13. 8
      src/Numerics/LinearAlgebra/Solvers/IIterationStopCriterium.cs
  14. 14
      src/Numerics/LinearAlgebra/Solvers/IterationCountStopCriterium.cs
  15. 19
      src/Numerics/LinearAlgebra/Solvers/Iterator.cs
  16. 60
      src/Numerics/LinearAlgebra/Solvers/StopLevel.cs
  17. 1
      src/Numerics/Numerics.csproj
  18. 28
      src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
  19. 16
      src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/FailureStopCriteriumTest.cs
  20. 12
      src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
  21. 24
      src/UnitTests/LinearAlgebraTests/Complex/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
  22. 28
      src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
  23. 16
      src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/FailureStopCriteriumTest.cs
  24. 12
      src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
  25. 24
      src/UnitTests/LinearAlgebraTests/Complex32/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
  26. 28
      src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
  27. 16
      src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/FailureStopCriteriumTest.cs
  28. 12
      src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
  29. 24
      src/UnitTests/LinearAlgebraTests/Double/Solvers/StopCriterium/ResidualStopCriteriumTest.cs
  30. 28
      src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/DivergenceStopCriteriumTest.cs
  31. 16
      src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/FailureStopCriteriumTest.cs
  32. 12
      src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/IterationCountStopCriteriumTest.cs
  33. 24
      src/UnitTests/LinearAlgebraTests/Single/Solvers/StopCriterium/ResidualStopCriteriumTest.cs

21
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>

19
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>

19
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>

21
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>

19
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>

19
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>

21
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>

19
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>

19
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>

21
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>

19
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>

19
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>

8
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();
}
}

14
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>

19
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);
}
}

60
src/Numerics/LinearAlgebra/Solvers/StopLevel.cs

@ -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
}
}

1
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" />

28
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();

16
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");

12
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");

24
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");

28
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();

16
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");

12
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");

24
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");

28
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();

16
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");

12
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");

24
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");

28
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();

16
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");

12
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");

24
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");

Loading…
Cancel
Save