/// <summary>
/// Tells if an algorithm that is currently in <paramref name="state"/> state
/// should stop (and don't make further steps) or not. Takes step count from
/// the <paramref name="state"/>.
/// </summary>
/// <param name="state">The current algorithm state.</param>
/// <returns>
/// <c>true</c> if an algorithm that is currently in <paramref name="state"/>
/// state should stop (and don't make further steps). Otherwise <c>false</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException"> if <paramref name="state"/>
/// is <c>null</c>.</exception>
public override bool ShouldStop(IAlgorithmState state)
{
bool shouldStop = base.ShouldStop(state);
if (!shouldStop)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
shouldStop = state.StepNumber >= this.Threshold;
}
return(shouldStop);
}
/// <summary>
/// Tells if an algorithm that is currently in <paramref name="state"/> state
/// should stop (and don't make further steps) or not. Stops if absolute value
/// of the difference between the quality of <paramref name="state"/>'s Best
/// Solution and <see cref="QualityProximityStopCondition"/>.Expectation is less
/// than or equal to <see cref="QualityProximityStopCondition.QualityThreshold"/>.
/// </summary>
/// <param name="state">The current algorithm state.</param>
/// <returns>
/// <c>true</c> if an algorithm that is currently in <paramref name="state"/>
/// state should stop (and don't make further steps). Otherwise <c>false</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException"> if <paramref name="state"/>
/// is <c>null</c>.</exception>
public override bool ShouldStop(IAlgorithmState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
Debug.Assert(state.BestSolution != null, "State best solution is null");
Debug.Assert(this.Expectation != null, "Expectation is null");
Debug.Assert(!double.IsNaN(this.QualityThreshold), "Quality threshold is NaN");
Debug.Assert(!double.IsInfinity(this.QualityThreshold), "Quality threshold is Infinity");
double qualityProximity = Math.Abs(state.BestSolution.Quality - Expectation.Quality);
Debug.Assert(!double.IsNaN(qualityProximity), "Quality proximity is NaN");
Debug.Assert(!double.IsInfinity(qualityProximity), "Quality proximity is Infinity");
return(qualityProximity.IsLessOrEqual(this.QualityThreshold));
}
/// <summary>
/// Tells if an algorithm that is currently in <paramref name="state"/> state
/// should stop (and don't make further steps) or not. Stops if the distance
/// between the <paramref name="state"/>'s Best Solution and the
/// <see cref="CoordinateProximityStopCondition"/>.Expectation is less than
/// or equal to <see cref="CoordinateProximityStopCondition"/>.DistanceThreshold.
/// </summary>
/// <param name="state">The current algorithm state.</param>
/// <returns>
/// <c>true</c> if an algorithm that is currently in <paramref name="state"/>
/// state should stop (and don't make further steps). Otherwise <c>false</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException"> if <paramref name="state"/>
/// is <c>null</c>.</exception>
public override bool ShouldStop(IAlgorithmState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
Debug.Assert(this.DistanceCalculator != null, "Distance calculator is null");
Debug.Assert(state.BestSolution != null, "State best solution is null");
Debug.Assert(this.Expectation != null, "Expectation is null");
Debug.Assert(!double.IsNaN(this.DistanceThreshold), "Distance threshold is NaN");
Debug.Assert(!double.IsInfinity(this.DistanceThreshold), "Distance threshold is Infinity");
double distance = this.DistanceCalculator.Calculate(state.BestSolution, this.Expectation);
Debug.Assert(!double.IsNaN(distance), "Distance is NaN");
Debug.Assert(!double.IsInfinity(distance), "Distance is Infinity");
return(distance.IsLessOrEqual(this.DistanceThreshold));
}
/// <summary>
/// Tells if an algorithm that is currently in <paramref name="state"/> state
/// should stop (and don't make further steps) or not.
/// </summary>
/// <param name="state">The current algorithm state.</param>
/// <returns>
/// <c>true</c> if an algorithm that is currently in <paramref name="state"/>
/// state should stop (and don't make further steps). Otherwise <c>false</c>.
/// </returns>
/// <exception cref="System.InvalidOperationException"> if unsupported
/// <see cref="StopConditionChain.AggregationOperator"/> is used to
/// chain stop conditions.</exception>
public bool ShouldStop(IAlgorithmState state)
{
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
switch (this.aggregationMode)
{
case StopConditionChain.AggregationOperator.And:
foreach (IStopCondition stopCondition in this.stopConditions)
{
Debug.Assert(stopCondition != null, "Stop condition is null");
if (!stopCondition.ShouldStop(state))
{
return(false);
}
}
return(true);
case StopConditionChain.AggregationOperator.Or:
foreach (IStopCondition stopCondition in this.stopConditions)
{
Debug.Assert(stopCondition != null, "Stop condition is null");
if (stopCondition.ShouldStop(state))
{
return(true);
}
}
return(false);
default:
throw new InvalidOperationException();
}
}
/// <summary>
/// Tells if an algorithm that is currently in <paramref name="state"/> state
/// should stop (and don't make further steps) or not.
/// </summary>
/// <param name="state">The current algorithm state.</param>
/// <returns>
/// <c>true</c> if an algorithm that is currently in <paramref name="state"/>
/// state should stop (and don't make further steps). Otherwise <c>false</c>.
/// </returns>
public virtual bool ShouldStop(IAlgorithmState state)
{
return(this.count >= this.Threshold);
}
/// <summary> /// Tells if an algorithm that is currently in <paramref name="state"/> state /// should stop (and don't make further steps) or not. /// </summary> /// <param name="state">The current algorithm state.</param> /// <returns> /// <c>true</c> if an algorithm that is currently in <paramref name="state"/> /// state should stop (and don't make further steps). Otherwise <c>false</c>. /// </returns> public abstract bool ShouldStop(IAlgorithmState state);
/// <summary>
/// Invokes the <see cref="ProgressChanged"/> event.
/// </summary>
/// <param name="state">The state of an algorithm from an abstract view.</param>
protected virtual void OnReport(IAlgorithmState <TStep> state)
{
ProgressChanged?.Invoke(this, state);
}
void IProgress <IAlgorithmState <TStep> > .Report(IAlgorithmState <TStep> value)
{
OnReport(value);
}
