Тейлор и Монте-Карло C#

/* ЗДАРОВА, ГОРЕ ПРОГЕРЫ ИЗ ВОДНИКА РАБОТАЕТ ЭТО ВСЁ АБЫ КАК, НО ЖИЛА ПРИНИМАЕТ. ВСЕ ОШИБКИ СКИДЫВАЕМ НА ПОГРЕШНОСТЬ И ГГ*/


using System;

namespace Integration3 {
    class Program {

        //"а"
        #region
        //Изначальная ф-ия
        static float Af(float x) {
            return 1 / MathF.Pow(MathF.Cosh(x), 2);
        }

        //Первая производная
        static float Adef1(float x) {
            return -2 * MathF.Sinh(x) / MathF.Pow(MathF.Cosh(x), 3);
        }

        //Вторая производная
        static float Adef2(float x) {
            float chisl = 6 * MathF.Pow(MathF.Sinh(x), 2) - 2 * MathF.Pow(MathF.Cosh(x), 2);
            float znam = MathF.Pow(MathF.Cosh(x), 4);
            return chisl / znam;
        }
        #endregion

        //"б"
        #region
        //Изначальная ф-ия "б"
        static float Bf(float x) {
            return (float)Math.Sqrt(x + 1);
        }

        //Первая и вторая производные ф-ии "б"

        static float Bdef1(float x) {
            float srt = MathF.Sqrt(x + 1);
            return 1/(2*srt);
        }

        static float Bdef2(float x) {
            float znam = 4 * MathF.Sqrt(x + 1) * (x + 1);
            return - 1 / znam;
        }
        #endregion

        //Метод аппроксимации рядом Тейлора
        static float ART(float min, float max, float n, int menu) {
            //Память под результат
            float integral = 0.0f;
            //Вычисляем шаг
            float step = (max - min) / n;
            if (menu == 1) {
                //"Шагаем" по иксам
                for (float x = min; x < max - step; x += step) {
                    //Считаем по формуле, используя две производные
                    integral += Af(x) * step + Adef1(x) / 2 * MathF.Pow(step, 2) + Adef2(x) / 6 * MathF.Pow(step, 3);
                }
                Console.WriteLine($"Интеграл равен: {integral}");
            }

            else if (menu == 2) {
                //"Шагаем" по иксам
                for (float x = min; x < max - step; x += step) {
                    //Считаем по формуле, используя две производные
                    integral += Bf(x) * step + Bdef1(x) / 2 * MathF.Pow(step, 2) + Bdef2(x) / 6 * MathF.Pow(step, 3);
                }
                return integral;
            }

            return 0;
        }

        //Метод Монте-Карло
        static float MonteCarlo(float n, int menu) {
            //Создаём генератор псевдослучайных чисел
            Random rnd = new Random();
            //Память под ответ
            float integral = 0.0f;
            //Память под пределы интегрирования
            float min = 0, max = 0;

            //Функция "а"
            if (menu == 1) {
                min = MathF.Log(2); max = MathF.Log(3);
                //Рандомим n чисел
                for (int i = 0; i < n; i++) {
                    //Рандомим число на отрезке [min,max]
                    float u = rnd.Next(693, 1098);
                    u = u / 1000;
                    //Суммируем значение функции в случайной точке
                    integral += Af(u);
                }

                //Вычисляем значение интеграла,
                //Домножив сумму на b-a/n
                integral *= (max - min) / n;
                Console.WriteLine(integral);
            }

            //Функция "б"
            else if (menu == 2) {
                min = 1; max = 3;
                //Рандомим n числел
                for (int i = 0; i < n; i++) {
                    //Рандомим число на отрезке [min, max]
                    float u = rnd.Next(1, 4);
                    //Суммируем значение функции в случайной точке
                    integral += Bf(u);
                }

                //Вычисляем значение интеграла,
                //Домножив сумму на b-a/n
                return integral *= (max - min) / n;
            }

            return 0;
        }

        static void Main(string[] args) {
            int menu = 0;
            Console.WriteLine("Выберите функцию:");
            Console.WriteLine("\t1)1/cosh(x)^2\n\t2)sqrt(x+1)");
            menu = Int32.Parse(Console.ReadLine());
            float min = 0, max = 0;
            switch (menu) {
                case 1:
                    min = MathF.Log(2);
                    max = MathF.Log(3);
                    break;
                case 2:
                    min = 1;
                    max = 3;
                    break;
                default:
                    Console.WriteLine("Ошибка");
                    break;
            }

            //Для задания "а" считаем разным разбиением
            if (menu == 1) {
                Console.WriteLine("Аппроксимация методом Тейлора");
                ART(min, max, 5, menu);
                ART(min, max, 10, menu);
                ART(min, max, 100, menu);

                Console.WriteLine("Метод Монте-Карло");
                MonteCarlo(5, menu);
                MonteCarlo(10, menu);
                MonteCarlo(100, menu);
            }

            else if (menu == 2) {
                //Ответ полученный по формуле Нютона-Лейбница
                float answer = 3.448f;
                //Желаемая точность вычислений
                float eps = 0.1f;
                //Память под результат вычислений
                float integral = 0;
                //Количество разбиений промоежутка интегрирования
                float i = 0;
                Console.WriteLine("Аппроксимация методом Тейлора");
                while(MathF.Abs(answer-integral) > eps) {
                    i++;
                    integral = ART(min, max, i, menu);

                }
                Console.WriteLine($"Интеграл равен: {integral}. Количество итераций: {i}");

                i = 0; integral = 0;

                Console.WriteLine("Метод Монте-Карло");
                while (MathF.Abs(answer - integral) > eps) {
                    i++;
                    integral = MonteCarlo(i, menu);
                }
                Console.WriteLine($"Интеграл равен: {integral}. Количество итераций: {i}");
            }
        }
    }
}