Комбинированные методы решения нелинейных уравнений

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.XPath;

namespace Nonlinear_Iteration {
    class Program {

        //делегат для методов ф-ий
        delegate float function(float x);
        //делегат для методов производных
        delegate float derivative(float x);
        //делегат для Фи в простых итерациях
        delegate float Phi(float x);

        //выбор ф-ии >>
        static float test_function1(float x) {
            return (float)Math.Pow(x, 3) + 3 * x + 1;
        }

        static float test_function2(float x) {
            return x + (float)Math.Log(x, 10) - 0.5F;
        }

        static float test_function3(float x) {
            return (float)Math.Tan(0.4 * x + 0.4) - (float)Math.Pow(x, 2);
        }
        //<<

        //производная первого порядка
        static float derivative1(float x) {
            return 3 * (float)Math.Pow(x, 2) + 3;
        }

        static float derivative2(float x) {
            return 1 + (1 / ((float)Math.Log(10) * x));
        }

        static float derivative3(float x) {
            return -2 * x + (0.4F / (float)Math.Pow(Math.Cos(0.4 - 0.4 * x), 2));
        }
        //<<

        //производная второго порядка
        static float SecondDerivative(float x, int menu) {
            switch (menu) {
                case 1:
                    return 6 * x;
                case 2:
                    return -1 / ((float)Math.Log(10) * (float)Math.Pow(x, 2));
                case 3:
                    float up = 8 * (float)Math.Sin(0.4F * x + 0.4);
                    float down = 25 * (float)Math.Pow(Math.Cos(0.4F * x + 0.4F), 3);
                    return (up / down) - 2;
            }
            return 0;
        }

        //вычисление "x" для Ньютона
        static float CalculatingX(float x, function test_function, derivative derivative) {
            return x - (test_function(x) / derivative(x));
        }

        //вычисление "x" для Мод-го Ньютона
        static float ModCalculatingX(float x, float Dx0, function test_function) {
            return x - (test_function(x) / Dx0);
        }

        //вычисление "x" для метода секущих
        static float SecantCalc(float x, float xp, function test_function) {
            return x - (test_function(x) * (x - xp) / (test_function(x) - test_function(xp)));
        }

        //бета для Риддерса
        static float B(float x, float xp) {
            return (xp + x) / 2;
        }

        //вычисление "x" для Риддерса
        static float CalcXRidder(float x, float xp, function test_function) {
            float sqr = (float)Math.Pow(test_function(B(x, xp)), 2) - test_function(xp) * test_function(x);
            return B(x, xp) + (B(x, xp) - xp) * ((test_function(xp) - test_function(x)) * test_function(B(x, xp)) / (float)Math.Sqrt(sqr));
        }

        //вычисление "x" для Мюллера
        static float CalcXMuller(float x, float xp, float xp2, function test_function) {
            float a, b, c, q, res, znam1, znam2;
            q = (x - xp) / (xp - xp2);
            c = (1 + q) * test_function(x);
            b = (2 * q) * test_function(x) - (float)Math.Pow(1 + q, 2) * test_function(xp) + (float)Math.Pow(q, 2) * test_function(xp2);
            a = q * test_function(x) - q * (1 + q) * test_function(xp) + (float)Math.Pow(q, 2) * test_function(xp2);
            znam1 = b + (float)Math.Sqrt(Math.Pow(b, 2) - 4 * a * c);
            znam2 = b - (float)Math.Sqrt(Math.Pow(b, 2) - 4 * a * c);
            if (znam1 > znam2)
                res = x - (x - xp) * (2 * c / znam1);
            else
                res = x - (x - xp) * (2 * c / znam2);
            return res;
        }

        //Выбор Фи для простых итераций >>
        static float Phi1(float x) {
            return (float)Math.Pow(-3 * x - 1, 1 / 3f);
        }

        static float Phi2(float x) {
            return 0.5F - (float)Math.Log(x, 10);
        }

        static float Phi3(float x) {
            return (float)Math.Sqrt((float)Math.Tan(0.4f * x + 0.4));
        }
        //<<

        //производная от фи
        static float DerivativePhi(float x, int menu) {
            switch (menu) {
                case 1:
                    return 1 / (float)Math.Pow(-3 * x - 1, 2 / 3F);
                case 2:
                    return -(1 / (x * (float)Math.Log(10)));
                case 3:
                    float sec = 1 / (float)Math.Pow((float)Math.Cos(0.4f * x + 0.4), 2);
                    float znam = 5 * (float)Math.Sqrt(Math.Tan(0.4f * x + 0.4));
                    return sec / znam;
            }
            return 0;
        }

        //шаг
        static float h = 0.0003F;
        //точность
        static double eps = 0.0031;
        //Константа Фидия
        static float Ф = 1.618F;

        //Метод Ньютона и Половинного деления
        static void NewtonHD(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.0003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.1;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if ((result[i] * result[i - 1] <= 0) && (result[i] != 0 && result[i - 1] != 0)) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем x для уточнения корней
                        float x = (A + B) / 2;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (A + B) / 2;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        float xi = CalculatingX(x, test_function, derivative);
                        //вычисляем расстояние между точками
                        //float check = Math.Abs(x - xi);
                        float check = 1;
                        // x = x1, xi = x0;
                        while (check > eps) {
                            x = xi;
                            //вычисляем xk+1
                            xi = CalculatingX(x, test_function, derivative);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Ньютона и Хорд
        static void NewtonChord(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.03F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.00001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if ((result[i] * result[i - 1] <= 0) && (result[i] != 0 && result[i - 1] != 0)) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        //float x = (A + B) / 2;
                        float fa, fb, fx;
                        //вычисляем f(a)
                        fa = test_function(A);
                        //вычисляем f(b)
                        fb = test_function(B);

                        float x = (float)(A - (B - A) / (fb - fa) * fa);

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (float)(A - (B - A) / (fb - fa) * fa);
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        float xi = CalculatingX(x, test_function, derivative);
                        //вычисляем расстояние между точками
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем xk+1
                            xi = CalculatingX(x, test_function, derivative);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Ньютона и Золотого сечения
        static void NewtonGold(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if ((result[i] * result[i - 1] <= 0) && (result[i] != 0 && result[i - 1] != 0)) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float x;
                        float fa, fb, fx1, fx2;

                        //вычисляем x для уточнения корней
                        float x1 = B - (B - A) / Ф;
                        float x2 = A + (B - A) / Ф;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x1)
                            fx1 = test_function(x1);
                            //вычисляем f(x2)
                            fx2 = test_function(x2);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            if (x1 > x2)
                                A = fx1 * fa > 0 ? x1 : B = x1;
                            else
                                A = fx2 * fa > 0 ? x2 : B = x2;
                            //вычисляем новые значения x
                            x1 = B - (B - A) / Ф;
                            x2 = A + (B - A) / Ф;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        x = (x1 + x2) / 2;

                        float xi = CalculatingX(x, test_function, derivative);
                        //вычисляем расстояние между точками
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем xk+1
                            xi = CalculatingX(x, test_function, derivative);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Модифицированный метод Ньютона и половинного деления
        static void ModNewtonHD(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем x для уточнения корней
                        float x = (A + B) / 2;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (A + B) / 2;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }
                        //вычисляем производную x0
                        float DerX0 = derivative(x);
                        //вычисляем xk
                        float xi = ModCalculatingX(x, DerX0, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем новое значение x
                            xi = ModCalculatingX(x, DerX0, test_function);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Модифицированный метод Ньютона и хорд
        static void ModNewtonChord(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем f(a)
                        fa = test_function(A);
                        //вычисляем f(b)
                        fb = test_function(B);

                        float x = (float)(A - (B - A) / (fb - fa) * fa);

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (float)(A - (B - A) / (fb - fa) * fa);
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }
                        //вычисляем производную x0
                        float DerX0 = derivative(x);
                        //вычисляем xk
                        float xi = ModCalculatingX(x, DerX0, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем новое значение x
                            xi = ModCalculatingX(x, DerX0, test_function);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Модифицированный метод Ньютона и золотого сечения
        static void ModNewtonGold(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float x;
                        float fa, fb, fx1, fx2;

                        //вычисляем x для уточнения корней
                        float x1 = B - (B - A) / Ф;
                        float x2 = A + (B - A) / Ф;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x1)
                            fx1 = test_function(x1);
                            //вычисляем f(x2)
                            fx2 = test_function(x2);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            if (x1 > x2)
                                A = fx1 * fa > 0 ? x1 : B = x1;
                            else
                                A = fx2 * fa > 0 ? x2 : B = x2;
                            //вычисляем новые значения x
                            x1 = B - (B - A) / Ф;
                            x2 = A + (B - A) / Ф;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        x = (x1 + x2) / 2;
                        //вычисляем производную x0
                        float DerX0 = derivative(x);
                        //вычисляем xk
                        float xi = ModCalculatingX(x, DerX0, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем новое значение x
                            xi = ModCalculatingX(x, DerX0, test_function);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Секущих и половинного деления
        static void SecantHD(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем x для уточнения корней
                        float x = (A + B) / 2;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (A + B) / 2;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        float xp = x - (float)eps;

                        float xi = SecantCalc(x, xp, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем новое значение x
                            xi = SecantCalc(x, xp, test_function);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk-1
                            xp = x;
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Секущих и хорд
        static void SecantChord(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем f(a)
                        fa = test_function(A);
                        //вычисляем f(b)
                        fb = test_function(B);

                        float x = (float)(A - (B - A) / (fb - fa) * fa);

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (float)(A - (B - A) / (fb - fa) * fa);
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }
                        float xp = x - (float)eps;
                        float xi = SecantCalc(x, xp, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем новое значение x
                            xi = SecantCalc(x, xp, test_function);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk-1
                            xp = x;
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Секущих и золотого сечения
        static void SecantGold(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float x;
                        float fa, fb, fx1, fx2;

                        //вычисляем x для уточнения корней
                        float x1 = B - (B - A) / Ф;
                        float x2 = A + (B - A) / Ф;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x1)
                            fx1 = test_function(x1);
                            //вычисляем f(x2)
                            fx2 = test_function(x2);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            if (x1 > x2)
                                A = fx1 * fa > 0 ? x1 : B = x1;
                            else
                                A = fx2 * fa > 0 ? x2 : B = x2;
                            //вычисляем новые значения x
                            x1 = B - (B - A) / Ф;
                            x2 = A + (B - A) / Ф;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        x = (x1 + x2) / 2;
                        float xp = x - (float)eps;

                        float xi = SecantCalc(x, xp, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            //вычисляем новое значение x
                            xi = SecantCalc(x, xp, test_function);
                            //вычисляем расстояние между точками
                            check = Math.Abs(x - xi);
                            //запоминаем xk-1
                            xp = x;
                            //запоминаем xk
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод простых итераций и половинного деления
        static void SimpleIterationHD(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций

            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            Phi Phi = Phi1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    Phi = Phi1;
                    break;
                case 2:
                    test_function = test_function2;
                    Phi = Phi2;
                    break;
                case 3:
                    test_function = test_function3;
                    Phi = Phi3;
                    break;
            }


            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем x для уточнения корней
                        float x = (A + B) / 2;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (A + B) / 2;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }
                        float xi;
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(DerivativePhi(x, menu));

                        while (check >= 1) {
                            xi = Phi(x);
                            x = xi;
                            check = Math.Abs(DerivativePhi(x, menu));
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод простых итераций и хорд
        static void SimpleIterationChord(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            Phi Phi = Phi1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    Phi = Phi1;
                    break;
                case 2:
                    test_function = test_function2;
                    Phi = Phi2;
                    break;
                case 3:
                    test_function = test_function3;
                    Phi = Phi3;
                    break;
            }


            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        float fa, fb, fx;
                        //вычисляем f(a)
                        fa = test_function(A);
                        //вычисляем f(b)
                        fb = test_function(B);

                        float x = (float)(A - (B - A) / (fb - fa) * fa);

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (float)(A - (B - A) / (fb - fa) * fa);
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        float xi;
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(DerivativePhi(x, menu));

                        while (check >= 1) {
                            xi = Phi(x);
                            x = xi;
                            check = Math.Abs(DerivativePhi(x, menu));
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод простых итераций и золотого сечения
        static void SimpleIterationGold(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            Phi Phi = Phi1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    Phi = Phi1;
                    break;
                case 2:
                    test_function = test_function2;
                    Phi = Phi2;
                    break;
                case 3:
                    test_function = test_function3;
                    Phi = Phi3;
                    break;
            }


            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float x;
                        float fa, fb, fx1, fx2;

                        //вычисляем x для уточнения корней
                        float x1 = B - (B - A) / Ф;
                        float x2 = A + (B - A) / Ф;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x1)
                            fx1 = test_function(x1);
                            //вычисляем f(x2)
                            fx2 = test_function(x2);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            if (x1 > x2)
                                A = fx1 * fa > 0 ? x1 : B = x1;
                            else
                                A = fx2 * fa > 0 ? x2 : B = x2;
                            //вычисляем новые значения x
                            x1 = B - (B - A) / Ф;
                            x2 = A + (B - A) / Ф;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        x = (x1 + x2) / 2;

                        float xi;
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(DerivativePhi(x, menu));

                        while (check >= 1) {
                            xi = Phi(x);
                            x = xi;
                            check = Math.Abs(DerivativePhi(x, menu));
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Риддерса и половинного деления
        static void RidderHD(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float xp, xi;
                        xp = A;
                        float fa, fb, fx;
                        //вычисляем x для уточнения корней
                        float x = (A + B) / 2;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (A + B) / 2;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        xi = CalcXRidder(x, xp, test_function);

                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            xi = CalcXRidder(x, xp, test_function);
                            check = Math.Abs(x - xi);
                            xp = x;
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Риддерса и хорд
        static void RidderChord(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float xp, xi;
                        xp = A;
                        float fa, fb, fx;
                        //вычисляем f(a)
                        fa = test_function(A);
                        //вычисляем f(b)
                        fb = test_function(B);

                        float x = (float)(A - (B - A) / (fb - fa) * fa);

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (float)(A - (B - A) / (fb - fa) * fa);
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }
                        xi = CalcXRidder(x, xp, test_function);

                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            xi = CalcXRidder(x, xp, test_function);
                            check = Math.Abs(x - xi);
                            xp = x;
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Риддерса и золотого сечения
        static void RidderGold(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float x, xp, xi;
                        xp = A;
                        //вычисляем x для уточнения корней
                        float fa, fb, fx1, fx2;

                        //вычисляем x для уточнения корней
                        float x1 = B - (B - A) / Ф;
                        float x2 = A + (B - A) / Ф;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x1)
                            fx1 = test_function(x1);
                            //вычисляем f(x2)
                            fx2 = test_function(x2);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            if (x1 > x2)
                                A = fx1 * fa > 0 ? x1 : B = x1;
                            else
                                A = fx2 * fa > 0 ? x2 : B = x2;
                            //вычисляем новые значения x
                            x1 = B - (B - A) / Ф;
                            x2 = A + (B - A) / Ф;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        x = (x1 + x2) / 2;
                        xi = CalcXRidder(x, xp, test_function);

                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            xi = CalcXRidder(x, xp, test_function);
                            check = Math.Abs(x - xi);
                            xp = x;
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Мюллера и половинного деления
        static void MullerHD(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float xp, xp2, xi;
                        float fa, fb, fx;
                        //вычисляем x для уточнения корней
                        float x = (A + B) / 2;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (A + B) / 2;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        xp = B;
                        xp2 = (A + B) / 2;
                        xi = CalcXMuller(x, xp, xp2, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            xi = CalcXMuller(x, xp, xp2, test_function);
                            check = Math.Abs(x - xi);
                            xp2 = xp;
                            xp = x;
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Мюллера и хорд
        static void MullerChord(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float xp, xp2, xi;
                        float fa, fb, fx;
                        //вычисляем f(a)
                        fa = test_function(A);
                        //вычисляем f(b)
                        fb = test_function(B);

                        float x = (float)(A - (B - A) / (fb - fa) * fa);

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x)
                            fx = test_function(x);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            A = fx * fa > 0 ? x : B = x;
                            //вычисляем новое значение x
                            x = (float)(A - (B - A) / (fb - fa) * fa);
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        xp = B;
                        xp2 = (A + B) / 2;
                        xi = CalcXMuller(x, xp, xp2, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            xi = CalcXMuller(x, xp, xp2, test_function);
                            check = Math.Abs(x - xi);
                            xp2 = xp;
                            xp = x;
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        //Метод Мюллера и золотого сечения
        static void MullerGold(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 0;
            //шаг
            //float h = 0.00003F;
            //сохранение предыщего значения x
            float prevF = 0;
            //индекс массива result
            int i = 0;
            //точность
            //double eps = 0.000001;

            //массив хранения f(x) в локализации
            List<float> result = new List<float>();

            //делегат для ф-ии
            function test_function = test_function1;
            //делегат для производной
            derivative derivative = derivative1;
            //присваение ф-ии делегату
            switch (menu) {
                case 1:
                    test_function = test_function1;
                    derivative = derivative1;
                    break;
                case 2:
                    test_function = test_function2;
                    derivative = derivative2;
                    break;
                case 3:
                    test_function = test_function3;
                    derivative = derivative3;
                    break;
            }

            //локализуем и сразу считаем
            for (float f = a; f <= b; f += h, i++) {
                //вычисляем знаечение f(x)
                result.Add(test_function(f));

                //если дошли до второго f(x)
                if (i > 0) {
                    //если знак поменялся или одно из f(x) равно нулю
                    if (result[i] * result[i - 1] < 0 || result[i] == 0 || result[i - 1] == 0) {
                        //перезаписываем предыдущее заначение x
                        float A = prevF;
                        //перезаписываем текущее заначение x
                        float B = f;
                        //вычисляем x для уточнения корней
                        float xp, xp2, xi;
                        //вычисляем x для уточнения корней
                        float x;
                        float fa, fb, fx1, fx2;

                        //вычисляем x для уточнения корней
                        float x1 = B - (B - A) / Ф;
                        float x2 = A + (B - A) / Ф;

                        //вычисляем расстояние между точками
                        float check1 = Math.Abs(A - B);

                        //счиатем пока расстояние между точками
                        //больше заданной точности
                        while (check1 > eps) {
                            //вычисляем f(a)
                            fa = test_function(A);
                            //вычисляем f(b)
                            fb = test_function(B);
                            //вычисляем f(x1)
                            fx1 = test_function(x1);
                            //вычисляем f(x2)
                            fx2 = test_function(x2);
                            //если знак f(x) изменился
                            //то сдвиагем границу
                            if (x1 > x2)
                                A = fx1 * fa > 0 ? x1 : B = x1;
                            else
                                A = fx2 * fa > 0 ? x2 : B = x2;
                            //вычисляем новые значения x
                            x1 = B - (B - A) / Ф;
                            x2 = A + (B - A) / Ф;
                            //вычисляем расстояние между точками
                            check1 = Math.Abs(A - B);
                        }

                        x = (x1 + x2) / 2;
                        xp = B;
                        xp2 = (A + B) / 2;
                        xi = CalcXMuller(x, xp, xp2, test_function);
                        //вычисляем расстояние между корнями
                        float check = Math.Abs(x - xi);

                        while (check > eps) {
                            xi = CalcXMuller(x, xp, xp2, test_function);
                            check = Math.Abs(x - xi);
                            xp2 = xp;
                            xp = x;
                            x = xi;
                            ItCount++;
                        }

                        Console.WriteLine($"x{count}: " + x);
                        lines[count - 1] = Convert.ToString(x);
                        count++;
                    }
                }
                prevF = f;
            }
            //путь для ответа
            string AnswerPath = Environment.CurrentDirectory + @"\output.txt";
            //запись ответа в файл
            File.WriteAllLines($"{AnswerPath}", lines);
            Console.WriteLine("Результат работы программы записан в файл, кол-во итераций: " + ItCount);
        }

        static void Main(string[] args) {
            DateTime t1 = new DateTime();
            t1 = DateTime.Now;

            int a = -10, b = -a;
            int menu = 3;
            Console.Write("Выберите ф-ию: \n1) x^3 + 3x + 1 \n2) x + Lg(x) - 0.5 \n3) tg(0.4x + 0.4) - x^2\n>> ");
            menu = Int32.Parse(Console.ReadLine());

            Console.WriteLine(" ————————————————————————— ");
            Console.WriteLine("|  Выберите метод решения |");
            Console.WriteLine("|-------------------------|");
            Console.WriteLine("| 1 |  Ньютона            |");
            Console.WriteLine("| 4 |  Мод-ый ньютона     |");
            Console.WriteLine("| 7 |  Секущих            |");
            Console.WriteLine("|10 |  Простых итераций   |");
            Console.WriteLine("|13 |  Риддерса           |");
            Console.WriteLine("|16 |  Мюллера            |");
            Console.WriteLine(" ————————————————————————— ");
            Console.Write(">> ");
            int MainMenu;
            MainMenu = Int32.Parse(Console.ReadLine());
            switch (MainMenu) {
                case 1: NewtonHD(a, b, menu); break;
                case 2: NewtonChord(a, b, menu); break;
                case 3: NewtonGold(a, b, menu); break;
                case 4: ModNewtonHD(a, b, menu); break;
                case 5: ModNewtonChord(a, b, menu); break;
                case 6: ModNewtonGold(a, b, menu); break;
                case 7: SecantHD(a, b, menu); break;
                case 8: SecantChord(a, b, menu); break;
                case 9: SecantGold(a, b, menu); break;
                case 10: SimpleIterationHD(a, b, menu); break;
                case 11: SimpleIterationChord(a, b, menu); break;
                case 12: SimpleIterationGold(a, b, menu); break;
                case 13: RidderHD(a, b, menu); break;
                case 14: RidderChord(a, b, menu); break;
                case 15: RidderGold(a, b, menu); break;
                case 16: MullerHD(a, b, menu); break;
                case 17: MullerChord(a, b, menu); break;
                case 18: MullerGold(a, b, menu); break;

                default: Console.WriteLine("Неверное значение"); break;
            }

            DateTime t2 = new DateTime();
            t2 = DateTime.Now;
            Console.WriteLine(t2 - t1);
            Console.ReadKey();
        }
    }
}