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

using System;
using System.Collections.Generic;
using System.IO;

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 void Newton(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 1;
            //шаг
            float h = 0.00001F;
            //сохранение предыщего значения 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;
                        x = test_function(A) * SecondDerivative(A, menu) > 0 ? 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 ModNewton (int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 1;
            //шаг
            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;
                        //вычисляем начальное приближение x0
                        float x;
                        x = test_function(A) * SecondDerivative(A, menu) > 0 ? 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 Secant (int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 1;
            //шаг
            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;

                        if (test_function(A) * SecondDerivative(A, menu) > 0) {
                            //xk
                            x = A;
                            //xk-1
                            xp = x + (float)eps;
                        }

                        else {
                            //xk
                            x = B;
                            //xk-1
                            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 SimpleIteration(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 1;
            //шаг
            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;
                        x = 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 Ridder(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 1;
            //шаг
            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 = 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 Muller(int a, int b, int menu) {
            //массив для ответов
            string[] lines = new string[20];
            //счётчик корней
            int count = 1;
            //счётчик итераций
            int ItCount = 1;
            //шаг
            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, xp2, xi;
                        x = A;
                        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 = 0;
            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("| 2 |  Мод-ый ньютона     |");
            Console.WriteLine("| 3 |  Секущих            |");
            Console.WriteLine("| 4 |  Простых итераций   |");
            Console.WriteLine("| 5 |  Риддерса           |");
            Console.WriteLine("| 6 |  Мюллера            |");
            Console.WriteLine(" ————————————————————————— ");
            Console.Write(">> ");
            int MainMenu;
            MainMenu = Int32.Parse(Console.ReadLine());
            switch (MainMenu) {
                case 1: Newton(a, b, menu); break;
                case 2: ModNewton(a, b, menu); break;
                case 3: Secant(a, b, menu); break;
                case 4: SimpleIteration(a, b, menu); break;
                case 5: Ridder(a, b, menu); break;
                case 6: Muller(a, b, menu); break;
                default: Console.WriteLine("Неверное значение"); break;
            }

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