public void DetermineStatus()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
// Note that the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { double.NaN, double.NaN, double.NaN });
// Set the source values
var source = new DenseVector(new[] { 1.000, 1.000, 2.001 });
// Set the residual values
var residual = new DenseVector(new[] { 0.001, 0.001, 0.002 });
criterium.DetermineStatus(5, solution, source, residual);
Assert.IsInstanceOfType(typeof(CalculationRunning), criterium.Status, "Should still be running");
criterium.DetermineStatus(16, solution, source, residual);
Assert.IsInstanceOfType(typeof(CalculationConverged), criterium.Status, "Should be done");
}
public void DetermineStatusWithResidualNaN()
{
var criterium = new ResidualStopCriterium <Complex32>(1e-3f, 10);
var solution = new DenseVector(new[] { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) });
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) });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
{
var criterium = new ResidualStopCriterium(1e-6f, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentNullException>(() => criterium.DetermineStatus(
1,
null,
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
public void DetermineStatusWithIllegalIterationNumberThrowsArgumentOutOfRangeException()
{
var criterium = new ResidualStopCriterium(1e-6f, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
-1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { double.NaN, double.NaN, double.NaN });
// Set the source values
var source = new DenseVector(new[] { 1.000, 1.000, 2.001 });
// 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");
criterium.DetermineStatus(16, solution, source, residual);
Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
}
public void DetermineStatusWithNonMatchingSourceVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentException>(() => criterium.DetermineStatus(
1,
new DenseVector(3, 4),
new DenseVector(4, 4),
new DenseVector(3, 4)));
}
public void DetermineStatusWithNullSourceVector()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
criterium.DetermineStatus(1,
new DenseVector(3, 4),
null,
new DenseVector(3, 6));
Assert.Fail();
}
public void DetermineStatusWithIllegalIterationNumber()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
criterium.DetermineStatus(-1,
new DenseVector(3, 4),
new DenseVector(3, 5),
new DenseVector(3, 6));
Assert.Fail();
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium <Complex32>(1e-3f, 10);
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN) });
// Set the source values
var source = new DenseVector(new[] { new Complex32(1.000f, 1), new Complex32(1.000f, 1), new Complex32(2.001f, 1) });
// Set the residual values
var residual = new DenseVector(new[] { new Complex32(0.001f, 0), new Complex32(0.001f, 0), new Complex32(0.002f, 0) });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should still be running");
var status2 = criterium.DetermineStatus(16, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status2, "Should be done");
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium <Complex32>(1e-6);
var solution = new DenseVector(new[] { Complex32.One, Complex32.One, Complex32.One });
var source = new DenseVector(new[] { Complex32.One, Complex32.One, Complex32.One });
var residual = new DenseVector(new[] { Complex32.Zero, Complex32.Zero, Complex32.Zero });
var status = criterium.DetermineStatus(0, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status, "Should be done");
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium(1e-3f, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN) });
// Set the source values
var source = new DenseVector(new[] { new Complex32(1.000f, 1), new Complex32(1.000f, 1), new Complex32(2.001f, 1) });
// 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");
criterium.DetermineStatus(16, solution, source, residual);
Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
}
public void DetermineStatusWithNonMatchingResidualVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium(1e-6f, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentException>(() => criterium.DetermineStatus(
1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 4),
DenseVector.Create(4, i => 4)));
}
public void DetermineStatusWithNullResidualVectorThrowsArgumentNullException()
{
var criterium = new ResidualStopCriterium(1e-6f, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws <ArgumentNullException>(() => criterium.DetermineStatus(
1,
new DenseVector(3, 4),
new DenseVector(3, 5),
null));
}
public void DetermineStatusWithSourceNaN()
{
var criterium = new ResidualStopCriterium <float>(1e-3f, 10);
var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
var source = new DenseVector(new[] { 1.0f, 1.0f, float.NaN });
var residual = new DenseVector(new[] { 1000.0f, 1000.0f, 2001.0f });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium <double>(1e-3, 10);
// the solution vector isn't actually being used so ...
var solution = Vector <double> .Build.Dense(new[] { double.NaN, double.NaN, double.NaN });
// Set the source values
var source = Vector <double> .Build.Dense(new[] { 1.000, 1.000, 2.001 });
// Set the residual values
var residual = Vector <double> .Build.Dense(new[] { 0.001, 0.001, 0.002 });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should still be running");
var status2 = criterium.DetermineStatus(16, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status2, "Should be done");
}
public void DetermineStatusWithSourceNaN()
{
var criterium = new ResidualStopCriterium(1e-3f, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { 1.0f, 1.0f, 2.0f });
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");
}
public void DetermineStatusWithResidualNaN()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) });
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");
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium();
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { Complex.One, Complex.One, Complex.One });
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");
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium <double>(1e-12);
var solution = Vector <double> .Build.Dense(new[] { 1.0, 1.0, 1.0 });
var source = Vector <double> .Build.Dense(new[] { 1.0, 1.0, 1.0 });
var residual = Vector <double> .Build.Dense(new[] { 0.0, 0.0, 0.0 });
var status = criterium.DetermineStatus(0, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status, "Should be done");
}
public void DetermineStatusWithResidualNaN()
{
var criterium = new ResidualStopCriterium <double>(1e-3, 10);
var solution = Vector <double> .Build.Dense(new[] { 1.0, 1.0, 2.0 });
var source = Vector <double> .Build.Dense(new[] { 1.0, 1.0, 2.0 });
var residual = Vector <double> .Build.Dense(new[] { 1000.0, double.NaN, 2001.0 });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN) });
// Set the source values
var source = new DenseVector(new[] { new Complex(1.000, 1), new Complex(1.000, 1), new Complex(2.001, 1) });
// Set the residual values
var residual = new DenseVector(new[] { new Complex(0.001, 0), new Complex(0.001, 0), new Complex(0.002, 0) });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Running, status, "Should still be running");
var status2 = criterium.DetermineStatus(16, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status2, "Should be done");
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium(1e-3f, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { float.NaN, float.NaN, float.NaN });
// Set the source values
var source = new DenseVector(new[] { 1.000f, 1.000f, 2.001f });
// Set the residual values
var residual = new DenseVector(new[] { 0.001f, 0.001f, 0.002f });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Running, status, "Should still be running");
var status2 = criterium.DetermineStatus(16, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status2, "Should be done");
}
public void DetermineStatusWithResidualNaN()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1) });
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) });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium();
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { 1.0f, 1.0f, 1.0f });
var source = new DenseVector(new[] { 1.0f, 1.0f, 1.0f });
var residual = new DenseVector(new[] { 0.0f, 0.0f, 0.0f });
var status = criterium.DetermineStatus(0, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status, "Should be done");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium <Complex32>(1e-3f, 10);
var solution = new DenseVector(new[] { new Complex32(0.001f, 1), new Complex32(0.001f, 1), new Complex32(0.002f, 1) });
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) });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
criterium.Reset();
Assert.AreEqual(IterationStatus.Continue, criterium.Status, "Should not have started");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium <double>(1e-3, 10);
var solution = new DenseVector(new[] { 0.001, 0.001, 0.002 });
var source = new DenseVector(new[] { 0.001, 0.001, 0.002 });
var residual = new DenseVector(new[] { 1.000, 1.000, 2.001 });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
criterium.Reset();
Assert.AreEqual(IterationStatus.Continue, criterium.Status, "Should not have started");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1) });
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");
criterium.ResetToPrecalculationState();
Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium(1e-3f, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { 0.001f, 0.001f, 0.002f });
var source = new DenseVector(new[] { 0.001f, 0.001f, 0.002f });
var residual = new DenseVector(new[] { 1.000f, 1.000f, 2.001f });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Running, status, "Should be running");
criterium.ResetToPrecalculationState();
Assert.AreEqual(IterationStatus.Indetermined, criterium.Status, "Should not have started");
}
public void DetermineStatusWithIllegalIterationNumberThrowsArgumentOutOfRangeException()
{
var criterium = new ResidualStopCriterium<double>(1e-8, 50);
Assert.That(() => criterium.DetermineStatus(
-1,
Vector<double>.Build.Dense(3, 4),
Vector<double>.Build.Dense(3, 5),
Vector<double>.Build.Dense(3, 6)), Throws.TypeOf<ArgumentOutOfRangeException>());
}
public void DetermineStatusWithIllegalIterationNumberThrowsArgumentOutOfRangeException()
{
var criterium = new ResidualStopCriterium<Complex>(1e-8, 50);
Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
-1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
public void DetermineStatusWithIllegalIterationNumberThrowsArgumentOutOfRangeException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
-1,
new DenseVector(3, 4),
new DenseVector(3, 5),
new DenseVector(3, 6)));
}
public void DetermineStatusWithNullSourceVector()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
criterium.DetermineStatus(1,
new DenseVector(3, 4),
null,
new DenseVector(3, 6));
Assert.Fail();
}
public void DetermineStatusWithNonMatchingSourceVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium<float>(1e-6f, 50);
Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
1,
Vector<float>.Build.Dense(3, 4),
Vector<float>.Build.Dense(4, 4),
Vector<float>.Build.Dense(3, 4)));
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium<float>(1e-3f, 10);
var solution = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
var source = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
var residual = new DenseVector(new[] {1.000f, 1.000f, 2.001f});
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
criterium.Reset();
Assert.AreEqual(IterationStatus.Continue, criterium.Status, "Should not have started");
}
public void DetermineStatusWithIllegalIterationNumber()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
criterium.DetermineStatus(-1,
new DenseVector(3, 4),
new DenseVector(3, 5),
new DenseVector(3, 6));
Assert.Fail();
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium<float>(1e-6);
var solution = new DenseVector(new[] {1.0f, 1.0f, 1.0f});
var source = new DenseVector(new[] {1.0f, 1.0f, 1.0f});
var residual = new DenseVector(new[] {0.0f, 0.0f, 0.0f});
var status = criterium.DetermineStatus(0, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status, "Should be done");
}
public void DetermineStatusWithSourceNaN()
{
var criterium = new ResidualStopCriterium(1e-3f, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { new Complex32(1.0f, 1), new Complex32(1.0f, 1), new Complex32(2.0f, 1) });
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");
}
public void DetermineStatusWithNonMatchingResidualVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
1,
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 4),
DenseVector.Create(4, i => 4)));
}
public void DetermineStatusWithNonMatchingSolutionVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium(1e-6f, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
1,
new DenseVector(4, 4),
new DenseVector(3, 4),
new DenseVector(3, 4)));
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium(1e-3f, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] { new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN), new Complex32(float.NaN, float.NaN) });
// Set the source values
var source = new DenseVector(new[] { new Complex32(1.000f, 1), new Complex32(1.000f, 1), new Complex32(2.001f, 1) });
// 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");
criterium.DetermineStatus(16, solution, source, residual);
Assert.IsInstanceOf(typeof(CalculationConverged), criterium.Status, "Should be done");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium<double>(1e-3, 10);
var solution = Vector<double>.Build.Dense(new[] { 0.001, 0.001, 0.002 });
var source = Vector<double>.Build.Dense(new[] { 0.001, 0.001, 0.002 });
var residual = Vector<double>.Build.Dense(new[] { 1.000, 1.000, 2.001 });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
criterium.Reset();
Assert.AreEqual(IterationStatus.Continue, criterium.Status, "Should not have started");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium<Complex>(1e-3, 10);
var solution = new DenseVector(new[] {new Complex(0.001, 1), new Complex(0.001, 1), new Complex(0.002, 1)});
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)});
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should be running");
criterium.Reset();
Assert.AreEqual(IterationStatus.Continue, criterium.Status, "Should not have started");
}
public void DetermineStatusWithNullSolutionVectorThrowsArgumentNullException()
{
var criterium = new ResidualStopCriterium(1e-6f, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
1,
null,
DenseVector.Create(3, i => 5),
DenseVector.Create(3, i => 6)));
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium<float>(1e-3f, 10);
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] {float.NaN, float.NaN, float.NaN});
// Set the source values
var source = new DenseVector(new[] {1.000f, 1.000f, 2.001f});
// Set the residual values
var residual = new DenseVector(new[] {0.001f, 0.001f, 0.002f});
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should still be running");
var status2 = criterium.DetermineStatus(16, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status2, "Should be done");
}
public void DetermineStatusWithSourceNaN()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { 1.0, 1.0, 2.0 });
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");
}
public void DetermineStatusWithIllegalIterationNumberThrowsArgumentOutOfRangeException()
{
var criterium = new ResidualStopCriterium<float>(1e-6f, 50);
Assert.Throws<ArgumentOutOfRangeException>(() => criterium.DetermineStatus(
-1,
Vector<float>.Build.Dense(3, 4),
Vector<float>.Build.Dense(3, 5),
Vector<float>.Build.Dense(3, 6)));
}
public void DetermineStatusWithNonMatchingSolutionVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium<Complex>(1e-8, 50);
Assert.Throws<ArgumentException>(() => criterium.DetermineStatus(
1,
DenseVector.Create(4, i => 4),
DenseVector.Create(3, i => 4),
DenseVector.Create(3, i => 4)));
}
public void DetermineStatusWithSourceNaN()
{
var criterium = new ResidualStopCriterium<float>(1e-3f, 10);
var solution = new DenseVector(new[] {1.0f, 1.0f, 2.0f});
var source = new DenseVector(new[] {1.0f, 1.0f, float.NaN});
var residual = new DenseVector(new[] {1000.0f, 1000.0f, 2001.0f});
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void DetermineStatus()
{
var criterium = new ResidualStopCriterium<Complex>(1e-3, 10);
// the solution vector isn't actually being used so ...
var solution = new DenseVector(new[] {new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN), new Complex(double.NaN, double.NaN)});
// Set the source values
var source = new DenseVector(new[] {new Complex(1.000, 1), new Complex(1.000, 1), new Complex(2.001, 1)});
// Set the residual values
var residual = new DenseVector(new[] {new Complex(0.001, 0), new Complex(0.001, 0), new Complex(0.002, 0)});
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Continue, status, "Should still be running");
var status2 = criterium.DetermineStatus(16, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status2, "Should be done");
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium();
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { 1.0, 1.0, 1.0 });
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");
}
public void DetermineStatusWithNonMatchingSourceVectorThrowsArgumentException()
{
var criterium = new ResidualStopCriterium<double>(1e-8, 50);
Assert.That(() => criterium.DetermineStatus(
1,
Vector<double>.Build.Dense(3, 4),
Vector<double>.Build.Dense(4, 4),
Vector<double>.Build.Dense(3, 4)), Throws.ArgumentException);
}
public void DetermineStatusWithNullSourceVectorThrowsArgumentNullException()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
Assert.Throws<ArgumentNullException>(() => criterium.DetermineStatus(
1,
new DenseVector(3, 4),
null,
new DenseVector(3, 6)));
}
public void DetermineStatusWithResidualNaN()
{
var criterium = new ResidualStopCriterium<Complex>(1e-3, 10);
var solution = new DenseVector(new[] {new Complex(1.0, 1), new Complex(1.0, 1), new Complex(2.0, 1)});
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)});
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void ResetCalculationState()
{
var criterium = new ResidualStopCriterium(1e-3, 10);
Assert.IsNotNull(criterium, "There should be a criterium");
var solution = new DenseVector(new[] { 0.001, 0.001, 0.002 });
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");
criterium.ResetToPrecalculationState();
Assert.IsInstanceOf(typeof(CalculationIndetermined), criterium.Status, "Should not have started");
}
public void DetermineStatusWithSourceNaN()
{
var criterium = new ResidualStopCriterium<double>(1e-3, 10);
var solution = Vector<double>.Build.Dense(new[] { 1.0, 1.0, 2.0 });
var source = Vector<double>.Build.Dense(new[] { 1.0, 1.0, double.NaN });
var residual = Vector<double>.Build.Dense(new[] { 1000.0, 1000.0, 2001.0 });
var status = criterium.DetermineStatus(5, solution, source, residual);
Assert.AreEqual(IterationStatus.Diverged, status, "Should be diverged");
}
public void DetermineStatusWithNonMatchingSolutionVector()
{
var criterium = new ResidualStopCriterium(1e-8, 50);
Assert.IsNotNull(criterium, "There should be a criterium");
criterium.DetermineStatus(1,
new DenseVector(4, 4),
new DenseVector(3, 4),
new DenseVector(3, 4));
}
public void DetermineStatusWithConvergenceAtFirstIteration()
{
var criterium = new ResidualStopCriterium<Complex>(1e-12);
var solution = new DenseVector(new[] {Complex.One, Complex.One, Complex.One});
var source = new DenseVector(new[] {Complex.One, Complex.One, Complex.One});
var residual = new DenseVector(new[] {Complex.Zero, Complex.Zero, Complex.Zero});
var status = criterium.DetermineStatus(0, solution, source, residual);
Assert.AreEqual(IterationStatus.Converged, status, "Should be done");
}
