Формулы Ньютона-Котеса

using System;

namespace Integration {
    class Program {

        //Делегат для упрощённого выбора
        delegate float func(float x);

        //Исходная функция задания а
        static float Afunc(float x) {
            return 1 / (float)(Math.Pow(Math.Cosh(x),2));
        }

        //Исходная функция задания б
        static float Bfunc(float x) {
            return (float)Math.Sqrt(x + 1);
        }

        //Метод правых квадратов
        static float right_rectangles(func func, float mim_lim, float max_lim, float n) {
            //Выделяем память под ответ
            float integral = 0.0f;
            //Вычисление шага
            float step = (max_lim - mim_lim) / n;
            //Вычисляем сумму площадей в установленных границах
            //x меняется на шаг
            for (float x = mim_lim; x < max_lim - step; x += step)
                integral += step * func(x + step);
            //Выводим численное значение интеграла
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        //Метод левых прямоугольников
        //Работает по аналогии с правыми, но x+step
        static float left_rectangle(func func, float mim_lim, float max_lim, float n) {
            float integral = 0.0f;
            float step = (max_lim - mim_lim) / n;
            for (float x = mim_lim; x < max_lim - step; x += step)
                integral += step * func(x);
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        //Метод средних прямоугольников
        //Работает как и остальные прямоугольники, но x + step/2
        static float middle_rectangles(func func, float mim_lim, float max_lim, float n) {
            float integral = 0.0f;
            float step = (max_lim - mim_lim) / n;
            for (float x = mim_lim; x < max_lim - step; x+=step)
                integral += step * func(x + step / 2);
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        //Метод Трапеций
        static float trapezium(func func, float mim_lim, float max_lim, float n) {
            //Память под результат
            float integral = 0.0f;
            //Шаг
            float step = (max_lim - mim_lim) / n;
            //Вычисляем сумму площадей в установленных границах
            //x меняется на шаг
            for (float x = mim_lim; x < max_lim - step; x += step)
                integral += step * ( (func(x) + func(x+step))/2 );
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        //Метод Симпсона
        static float simpson(func func, float mim_lim, float max_lim, float n) {
            //Выделяем память под ответ
            float integral = 0.0f;
            //Шаг
            float step = (max_lim - mim_lim) / n;
            //Вычисляем сумму площадей в установленных границах
            //x меняется на шаг
            for (float x = mim_lim; x < max_lim - step; x += step)
                integral += step/6 * (func(x) + 4 * func(x + step/2) + func(x+step));
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        //Правило Симпсона 3/8
        //Сложная формула Ньютона-Котеса с m=3
        static float simpson38(func func, float min_lim, float max_lim, float n) {
            //шаг
            float step = (max_lim - min_lim) / n;
            //Вычисляем слагаемые без множителей
            float integral = func(min_lim) + func(max_lim);

            //Вычисляет значение до y без множителя
            for (int i = 1; i < n; i++) {
                //Если элемент третий в триаде, то домножаем на 2
                if (i % 3 == 0)
                    integral = integral + 2 * func(min_lim + i * step);
                //Если 1-ый или 2-ой в триаде то на 3
                else
                    integral = integral + 3 * func(min_lim + i * step);
            }
            //Вычисляем значение интеграла домножив 3/8 и шаг
            integral =  (3 * step / 8) * integral;
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        //Правило Симпсона 2/45
        //Сложная Формула Ньютона-Котеса с m=4
        static float simpson245(func func, float min_lim, float max_lim, float n) {
            //Шаг
            float step = (max_lim - min_lim) / n;
            //Вычисляем сумму первого и последнего слагаемых
            float integral = 7*func(min_lim) + 7*func(max_lim);
            //Костыль для 12 и 14
            Boolean flag = false;

            //ВЫчисляем до последнего слагаемого
            for (int i = 1; i < n; i++) {
                //Если элемент нечётный, то множитель 32
                if (i % 2 != 0) {
                    integral = integral + 32 * func(min_lim + i * step);
                }

                //Иначе 12 или 14 по очереди
                else if (!flag) {
                    integral = integral + 12 * func(min_lim + i * step);
                    flag = true;
                }

                else if (flag) {
                    integral = integral + 14 * func(min_lim + i * step);
                    flag = false;
                }
            }
            //Вычисляем значение интеграла домножив сумму на 2/45 и шаг
            integral = (2 * step / 45) * integral;
            if (func != Bfunc)
                Console.WriteLine($"Интеграл равен: {integral}");
            return integral;
        }

        static void Main(string[] args) {
            //Память под пределы интегрирования
            float min = 0, max = 0;
            //Выделяем память под делегат
            func function = Afunc;

            int menu = 0;
            Console.WriteLine("Выберите функцию:");
            Console.WriteLine("\t1) 1/cosh^2(x) \n\t2) Sqrt(x+1)");
            menu = Int32.Parse(Console.ReadLine());

            switch(menu) {
                case 1:
                    function = Afunc;
                    min = (float)Math.Log(2);
                    max = (float)Math.Log(3);
                    break;
                case 2:
                    function = Bfunc;
                    min = 1;
                    max = 3;
                    break;
                default:
                    Console.WriteLine("Ошибка ввода");
                    break;
            }

            if (function == Afunc) {
                Console.WriteLine("Метод средних прямоугольников:");
                middle_rectangles(function, min, max, 5);
                middle_rectangles(function, min, max, 10);
                middle_rectangles(function, min, max, 100);

                Console.WriteLine();
                Console.WriteLine("Метод левых прямоугольников:");
                left_rectangle(function, min, max, 5);
                left_rectangle(function, min, max, 10);
                left_rectangle(function, min, max, 100);

                Console.WriteLine();
                Console.WriteLine("Метод правых прямоугольников:");
                right_rectangles(function, min, max, 5);
                right_rectangles(function, min, max, 10);
                right_rectangles(function, min, max, 100);

                Console.WriteLine();
                Console.WriteLine("Метод трапеций:");
                trapezium(function, min, max, 5);
                trapezium(function, min, max, 10);
                trapezium(function, min, max, 100);

                Console.WriteLine();
                Console.WriteLine("Метод Симпсона:");
                simpson(function, min, max, 5);
                simpson(function, min, max, 10);
                simpson(function, min, max, 100);

                Console.WriteLine();
                Console.WriteLine("Правило Симпсона 3/8:");
                simpson38(function, min, max, 5);
                simpson38(function, min, max, 10);
                simpson38(function, min, max, 100);

                Console.WriteLine();
                Console.WriteLine("Правило Симпсона 2/45:");
                simpson245(function, min, max, 5);
                simpson245(function, min, max, 10);
                simpson245(function, min, max, 100);
            }

            else {
                //Погрешность
                const float eps = 0.001f;
                //Решение, полученное аналитическим путём
                const float answer = 3.44772f;
                //Память под результат вычислений
                float integral = 0;
                //Количество делений для задания 2
                int i = 0;

                Console.WriteLine("Метод средних прямоугольников:");
                i = 0;
                integral = 0;
                while(Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = middle_rectangles(function, min, max, i);
                }
                Console.WriteLine ($"Интеграл равен: {integral}. Кол-во итераций: {i}");

                Console.WriteLine();
                Console.WriteLine("Метод правых прямоугольников:");
                i = 0;
                integral = 0;
                while (Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = right_rectangles(function, min, max, i);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Кол-во итераций: {i}");

                Console.WriteLine();
                Console.WriteLine("Метод левых прямоугольников:");
                i = 0;
                integral = 0;
                while (Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = left_rectangle(function, min, max, i);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Кол-во итераций: {i}");

                Console.WriteLine();
                Console.WriteLine("Метод трапеций:");
                i = 0;
                integral = 0;
                while (Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = trapezium(function, min, max, i);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Кол-во итераций: {i}");

                Console.WriteLine();
                Console.WriteLine("Метод Симпсона:");
                i = 0;
                integral = 0;
                while (Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = simpson(function, min, max, i);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Кол-во итераций: {i}");

                Console.WriteLine();
                Console.WriteLine("Правило Симпсона 3/8:");
                i = 0;
                integral = 0;
                while (Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = simpson38(function, min, max, i);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Кол-во итераций: {i}");

                Console.WriteLine();
                Console.WriteLine("Правило Симпсона 2/45:");
                i = 0;
                integral = 0;
                while (Math.Abs((answer - integral)) > eps) {
                    i++;
                    integral = simpson245(function, min, max, i);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Кол-во итераций: {i}");
            }
        }
    }
}