C# ResidualStopCriterium.DetermineStatus方法代码示例

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

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