NM0

using System;

namespace ЧМ1
{
    class MainClass
    {
        public delegate double ff(double e, double t);
        public delegate double fff(double e);
        public static double F(double e)
        {
            double Fx = Math.Pow(e, 5) + 6 * Math.Pow(e, 4) - 58 * Math.Pow(e, 3) - 156 * e * e + 1017 * e - 809.5;
            return Fx;
        }
        public static double f(double e, double t)
        {
            double fx = e + t * 0.00008 * (Math.Pow(e, 5) + 6 * Math.Pow(e, 4) - 58 * Math.Pow(e, 3) - 156 * e * e + 1017 * e - 809.5);
            return fx;
        }
        public static double f0(double e, double t)
        {
            double fe = 1 + t * 0.00008 * (5 * Math.Pow(e, 4) + 24 * Math.Pow(e, 3) - 174 * Math.Pow(e, 2) - 312 * e + 1017);
            return fe;
        }
        public static double diff(double e)
        {
            double diffx = 5 * Math.Pow(e, 4) + 24 * Math.Pow(e, 3) - 174 * Math.Pow(e, 2) - 312 * e + 1017;
            return diffx;
        }
        public static double fdiff(double e, double t)
        {
            double fe = e + t * 0.0008 * (5 * Math.Pow(e, 4) + 24 * Math.Pow(e, 3) - 174 * Math.Pow(e, 2) - 312 * e + 1017);
            return fe;
        }
        public static double f1(double e, double t)
        {
            double fe = 1 + t * 0.0008 * (20 * Math.Pow(e, 3) + 72 * Math.Pow(e, 2) - 348 * e - 312);
            return fe;
        }
        public static double diff2(double e)
        {
            double dif = 20 * Math.Pow(e, 3) + 72 * Math.Pow(e, 2) - 348 * e - 312;
            return dif;
        }
        public static double fdiff2(double e, double t)
        {
            double fdif = e + t * 0.00006 * (20 * Math.Pow(e, 3) + 72 * Math.Pow(e, 2) - 348 * e - 312);
            return fdif;
        }
        public static double f2(double e, double t)
        {
            double fe = 1 + t * 0.00006 * (60 * e * e + 144 * e - 348);
            return fe;
        }
        public static double diff3(double e)
        {
            double dif = 60 * e * e + 144 * e - 348;
            return dif;
        }
        public static double iteration(double a, double eps, ff f, int k)
        {
            double x = 0;
            double d = 0;
            do
            {
                x = f(a, k);
                d = Math.Abs(a - x);
                a = x;
            }
            while (d > eps);
            return a;
        }
        public static double Newton(double e, double eps, fff f, fff f1)
        {
            double x = 0;
            double d = 0;
            do
            {
                x = e - f(e) / f1(e);
                d = Math.Abs(x - e);
                e = x;
            }
            while (d >= eps);
            return e;
        }
        public static void Main(string[] args)
        {
            double t = 0.00001;
            Console.WriteLine("Дано: ");
            Console.WriteLine("Функция: f(x) = x^5 +6x^4-58x^3-156x^2+1017x-809.5");
            double[] isol = new double[10];
            double x1 = (-72 + Math.Sqrt(72 * 72 + 60 * 348)) / 60;
            double x2 = (-72 - Math.Sqrt(72 * 72 + 60 * 348)) / 60;
            //Ищем интервалы изоляции для 5 корней исходной функции, последовательно находя корни всех производных 1-3 порядков
            double fu1 = diff2(x2);
            double fu2 = diff2(x1);
            int pot = 0;
            int r = 0;
            double[] root = new double[2 + pot];
            double[] ris = new double[root.Length * 2 + 2];
            root[0] = x2;
            root[1] = x1;
            double v = 0;
            double c = 0;
            int g = 0;
            do
            {
                if (r < root.Length)
                {
                    v = Math.Floor(root[r]);
                    c = v;
                    do
                    {
                        c--;
                    }
                    while (diff2(v) * diff2(c) > 0 || diff3(c) * diff3(v) < 0);
                    ris[g] = c;
                    g++;
                    ris[g] = v;
                    g++;
                }
                if (r == root.Length)
                {
                    v = Math.Floor(root[r - 1]) + 1;
                    c = v;
                    do
                    {
                        c++;
                    }
                    while (diff2(v) * diff2(c) > 0 || diff3(c) * diff3(v) < 0);
                    ris[g] = v;
                    g++;
                    ris[g] = c;
                }
                r++;
            }
            while (r < 3);
            bool prov = false;
            pot++;
            root = new double[2 + pot];
            Console.WriteLine("Проверка сходимости метода итераций");
            for (int k = 0; k < r; k++)
            {
                int u = 1;
                double Xo = ris[k + k] + 0.01;
                if (diff3(Xo) < 0)
                {
                    u = 1;
                }
                else
                {
                    u = -1;
                }
                for (double i = ris[k + k]; i < ris[k + k + 1]; i += 0.001)
                {
                    if (Math.Abs(f2(i, u)) > 1)
                    {
                        prov = true;
                    }
                }
                if (prov)
                {
                    Console.WriteLine("Итерационный процесс невозможен");
                }
                else
                {
                    double xx = iteration(Xo, t, fdiff2, u);
                    root[k] = Math.Round(xx, 3);
                }
            }
            ris = new double[root.Length * 2 + 2];
            r = 0;
            g = 0;
            //Вычисляем интервалы изоляции для первой производной
            do
            {
                if (r < root.Length)
                {

                    v = Math.Floor(root[r]);
                    c = v;
                    do
                    {
                        c--;
                    }
                    while (diff(v) * diff(c) > 0 || diff2(c) * diff2(v) < 0);
                    ris[g] = c;
                    g++;
                    ris[g] = v;
                    g++;
                }
                if (r == root.Length)
                {
                    v = Math.Floor(root[r - 1]) + 1;
                    c = v;
                    do
                    {
                        c++;
                    }
                    while (diff(v) * diff(c) > 0 || diff2(c) * diff2(v) < 0);
                    ris[g] = v;
                    g++;
                    ris[g] = c;
                }
                r++;
            }
            while (r < 4);
            prov = false;
            pot++;
            root = new double[2 + pot];
            for (int k = 0; k < r; k++)
            {
                double Xo = ris[k + k] + 0.01;
                if (diff(Xo) * diff3(Xo) > 0)
                {
                }
                else
                {
                    while (diff(Xo) * diff3(Xo) <= 0 && Xo < ris[k + k + 1])
                    {
                        Xo += 0.01;
                    }
                }
                root[k] = Math.Round(Newton(Xo, t, diff, diff2), 3);
            }
            ris = new double[root.Length * 2 + 2];
            r = 0;
            g = 0;
            do
            {
                if (r < root.Length)
                {

                    v = Math.Floor(root[r]);
                    c = v;
                    do
                    {
                        c--;
                    }
                    while (F(v) * F(c) > 0 || diff(c) * diff(v) < 0);
                    ris[g] = c;
                    g++;
                    ris[g] = v;
                    g++;
                }
                if (r == root.Length)
                {
                    v = Math.Floor(root[r - 1]) + 0.9;
                    c = v;
                    while (F(v) * F(c) > 0 || diff(c) * diff(v) < 0)
                    {
                        c++;
                    }
                    ris[g] = v;
                    g++;
                    ris[g] = c;
                }
                r++;
            }
            while (r < 5);
            Console.WriteLine("Интервалы изоляции исходной функции");
            for (int i = 0; i < r; i++)
            {
                Console.WriteLine("{0}. [{1};{2}]", i + 1, ris[i + i], ris[i + i + 1]);
            }
            prov = false;
            pot++;
            root = new double[2 + pot];
            Console.WriteLine("Проверка сходимости метода итераций");
            for (int k = 0; k < r; k++)
            {
                int u = 1;
                double Xo = ris[k + k] + 0.01;
                if (diff(Xo) < 0)
                {
                    u = 1;
                }
                else
                {
                    u = -1;
                }
                for (double i = ris[k + k]; i < ris[k + k + 1]; i += 0.001)
                {
                    if (Math.Abs(f0(i, u)) > 1)
                    {
                        prov = true;
                    }
                }
                if (prov)
                {
                    Console.WriteLine("Итерационный процесс невозможен");
                }
                else
                {
                    double xx = iteration(Xo, t, f, u);
                    root[k] = Math.Round(xx, 3);
                }
            }
            Console.WriteLine("Корни уравнения согласно методу итераций: ");
            for (int i = 0; i < r; i++)
            {
                Console.WriteLine("{0}. X = {1:f3}", i + 1, root[i]);
            }
            for (int k = 0; k<r; k++)
            {
                double Xo = ris[k + k];
                if (F(Xo) * diff2(Xo) > 0)
                {
                }
                else
                {
                    Console.WriteLine(k);
                    while (F(Xo) * diff2(Xo) <= 0 && Xo<ris[k + k + 1])
                    {
                        Xo += 0.01;
                    }
                    Xo -= 0.01;
                }
                root[k] = Math.Round(Newton(Xo, t, F, diff), 3);
            }
            Console.WriteLine("Корни уравнения согласно методу Ньютона: ");
            for (int i = 0; i < r; i++)
            {
                Console.WriteLine("{0}. X = {1:f3}", i + 1, root[i]);
            }
        }
    }
}