コード例 #1
0
        public void Pole()
        {
            Func <double, double> f1  = x => 1 / (x - 2) + 2;
            Func <double, double> df1 = x => - 1 / (x * x - 4 * x + 4);

            Assert.AreEqual(1.5, HybridNewtonRaphson.FindRoot(f1, df1, 1, 2, 1e-14, 100, 20));
            Assert.AreEqual(1.5, HybridNewtonRaphson.FindRoot(f1, df1, 1, 6, 1e-14, 100, 20));
            Assert.AreEqual(1.5, RealRoots.OfFunctionAndDerivative(f1, df1, 1, 6));

            Func <double, double> f2  = x => - 1 / (x - 2) + 2;
            Func <double, double> df2 = x => 1 / (x * x - 4 * x + 4);

            Assert.AreEqual(2.5, HybridNewtonRaphson.FindRoot(f2, df2, 2, 3, 1e-14, 100, 20));
            Assert.AreEqual(2.5, HybridNewtonRaphson.FindRoot(f2, df2, -2, 3, 1e-14, 100, 20));
            Assert.AreEqual(2.5, RealRoots.OfFunctionAndDerivative(f2, df2, -2, 3));

            Func <double, double> f3  = x => 1 / (x - 2) + x + 2;
            Func <double, double> df3 = x => - 1 / (x * x - 4 * x + 4) + 1;

            Assert.AreEqual(-Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f3, df3, -2, -1, 1e-14, 100, 20), 1e-14);
            Assert.AreEqual(Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f3, df3, 1, 1.99, 1e-14, 100, 20));
            Assert.AreEqual(Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f3, df3, -1.5, 1.99, 1e-14, 100, 20));
            Assert.AreEqual(Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f3, df3, 1, 6, 1e-14, 100, 20));

            Func <double, double> f4  = x => 1 / (2 - x) - x + 6;
            Func <double, double> df4 = x => 1 / (x * x - 4 * x + 4) - 1;

            Assert.AreEqual(4 + Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f4, df4, 5, 6, 1e-14, 100, 20), 1e-14);
            Assert.AreEqual(4 - Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f4, df4, 2.01, 3, 1e-14, 100, 20));
            Assert.AreEqual(4 - Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f4, df4, 2.01, 5, 1e-14, 100, 20));
            Assert.AreEqual(4 - Math.Sqrt(3), HybridNewtonRaphson.FindRoot(f4, df4, -2, 4, 1e-14, 100, 20));
        }
コード例 #2
0
        public void NoRoot()
        {
            Func <double, double> f1  = x => x * x + 4;
            Func <double, double> df1 = x => 2 * x;

            Assert.Throws <NonConvergenceException>(() => HybridNewtonRaphson.FindRoot(f1, df1, -5, 5, 1e-14, 50, 20));
        }
コード例 #3
0
        public void LocalMinima()
        {
            Func <double, double> f1  = x => x * x * x - 2 * x + 2;
            Func <double, double> df1 = x => 3 * x * x - 2;

            Assert.AreEqual(0, f1(HybridNewtonRaphson.FindRoot(f1, df1, -5, 5, 1e-14, 100, 20)));
            Assert.AreEqual(0, f1(HybridNewtonRaphson.FindRoot(f1, df1, -2, 4, 1e-14, 100, 20)));
        }
コード例 #4
0
        public void Cubic()
        {
            // with complex roots (looking for the real root only): 3x^3 + 4x^2 + 5x + 6, derivative 9x^2 + 8x + 5
            Func <double, double> f1  = x => Evaluate.Polynomial(x, 6, 5, 4, 3);
            Func <double, double> df1 = x => Evaluate.Polynomial(x, 5, 8, 9);

            Assert.AreEqual(-1.265328088928, HybridNewtonRaphson.FindRoot(f1, df1, -2, -1, 1e-10, 100, 20), 1e-6);
            Assert.AreEqual(-1.265328088928, HybridNewtonRaphson.FindRoot(f1, df1, -5, 5, 1e-10, 100, 20), 1e-6);

            // real roots only: 2x^3 + 4x^2 - 50x + 6, derivative 6x^2 + 8x - 50
            Func <double, double> f2  = x => Evaluate.Polynomial(x, 6, -50, 4, 2);
            Func <double, double> df2 = x => Evaluate.Polynomial(x, -50, 8, 6);

            Assert.AreEqual(-6.1466562197069, HybridNewtonRaphson.FindRoot(f2, df2, -8, -5, 1e-10, 100, 20), 1e-6);
            Assert.AreEqual(0.12124737195841, HybridNewtonRaphson.FindRoot(f2, df2, -1, 1, 1e-10, 100, 20), 1e-6);
            Assert.AreEqual(4.0254088477485, HybridNewtonRaphson.FindRoot(f2, df2, 3, 5, 1e-10, 100, 20), 1e-6);
        }
コード例 #5
0
        public void MultipleRoots()
        {
            // Roots at -2, 2
            Func <double, double> f1  = x => x * x - 4;
            Func <double, double> df1 = x => 2 * x;

            Assert.AreEqual(0, f1(HybridNewtonRaphson.FindRoot(f1, df1, -5, 5, 1e-14, 100, 20)));
            Assert.AreEqual(-2, HybridNewtonRaphson.FindRoot(f1, df1, -5, -1, 1e-14, 100, 20));
            Assert.AreEqual(2, HybridNewtonRaphson.FindRoot(f1, df1, 1, 4, 1e-14, 100, 20));
            Assert.AreEqual(0, f1(HybridNewtonRaphson.FindRoot(x => - f1(x), x => - df1(x), -5, 5, 1e-14, 100, 20)));
            Assert.AreEqual(-2, HybridNewtonRaphson.FindRoot(x => - f1(x), x => - df1(x), -5, -1, 1e-14, 100, 20));
            Assert.AreEqual(2, HybridNewtonRaphson.FindRoot(x => - f1(x), x => - df1(x), 1, 4, 1e-14, 100, 20));

            // Roots at 3, 4
            Func <double, double> f2  = x => (x - 3) * (x - 4);
            Func <double, double> df2 = x => 2 * x - 7;

            Assert.AreEqual(0, f2(HybridNewtonRaphson.FindRoot(f2, df2, -5, 5, 1e-14, 100, 20)));
            Assert.AreEqual(3, HybridNewtonRaphson.FindRoot(f2, df2, -5, 3.5, 1e-14, 100, 20));
            Assert.AreEqual(4, HybridNewtonRaphson.FindRoot(f2, df2, 3.2, 5, 1e-14, 100, 20));
            Assert.AreEqual(3, HybridNewtonRaphson.FindRoot(f2, df2, 2.1, 3.9, 0.001, 50, 20), 0.001);
            Assert.AreEqual(3, HybridNewtonRaphson.FindRoot(f2, df2, 2.1, 3.4, 0.001, 50, 20), 0.001);
        }