Całka

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Calka
{
    public interface Methods
    {
       void showMethod(double result, double steps);
       double calculateResult(ref double k, double a, double b);
    }

    public static class MathFunctions
    {
        public static readonly double M_E = 2.71828182845904523536;

        public static double f(double x) => (Math.Pow(M_E, x) + 1) / (Math.Pow(x, 2) + 1);

        public static double h(double k, double a, double b) => ((b - a) / Math.Pow(2, k));

        public static double x(double i, double k, double a, double b) => (a + i * h(k, a, b));

        public static double y(double i, double k, double a, double b) => (f(x(i, k, a, b)));
    }

    public static class SumFunctions
    {
       public static double sum1(double k, double a, double b)
        {
            double sum = 0;
            for (int i = 1; i < Math.Pow(2, k); i++)
            {
                sum += MathFunctions.y(i, k, a, b);
            }
            return sum;
        }

        public static double sum2(double k, double a, double b)
        {
            double sum = 0;
            for (int i = 1; i < Math.Pow(2, k); i += 2)
            {
                sum += MathFunctions.y(i, k, a, b);
            }
            return sum;
        }

        public static double sum3(double k, double a, double b)
        {
            double sum = 0;

            for (int i = 2; i < Math.Pow(2, k) - 1; i += 2)
            {
                sum += MathFunctions.y(i, k, a, b);
            }
            return sum;
        }

       public static double sum4(double k, double a, double b)
        {
            double sum = 0;
            for (int i = 1; i <= Math.Pow(2, k - 1) - 1; i++)
            {
                sum += MathFunctions.f(a + ((2 * i) - 1) * MathFunctions.h(k, a, b));
            }
            return sum;
        }
    }

    public static class MathMethods
    {
        public static double T(double k, double a, double b) => (MathFunctions.h(k, a, b) / 2) * (MathFunctions.f(a) + MathFunctions.f(b) + 2 * SumFunctions.sum1(k, a, b));

        public static double S(double k, double a, double b) => (MathFunctions.h(k, a, b) / 3) * (MathFunctions.y(0, k, a, b) + MathFunctions.y(Math.Pow(2, k), k, a, b) + 4 * SumFunctions.sum2(k, a, b) + 2 * SumFunctions.sum3(k, a, b));

        public static double R(double k, double a, double b)
        {
            if (k == 0)
                return ((MathFunctions.f(a) + MathFunctions.f(b)) / 2) * (b - a);
            else
                return (1 / 2 * R(k - 1, a, b)) + (MathFunctions.h(k, a, b) * SumFunctions.sum4(k, a, b));
        }
    }

    public static class ExecuteMethods
    {
        public static readonly double eps = 10e-4;

        public static double R(ref double kr,double a, double b)
        {
            double R1 = 0, R2 = 0;
            do
            {
                kr++;
                R2 = R1;
                R1 = MathMethods.R(kr,a,b);

            } while (Math.Abs(R1 - R2) > eps);
            return R1;
        }

        public static double S(ref double ks,double a, double b)
        {
            double S1 = 0, S2 = 0;
            do
            {
                ks++;
                S2 = S1;
                S1 = MathMethods.S(ks, a, b);

            } while (Math.Abs(S1 - S2) > eps);
            return S1;
        }

        public static double T(ref double kt,double a, double b)
        {
            double T1=0,T2 = 0;
            do
            {
                kt++;
                T2 = T1;
                T1 = MathMethods.T(kt, a, b);
            } while (Math.Abs(T1 - T2) > eps);

            return T1;
        }
    }

    public class ShowResultsT : Methods
    {
        public double calculateResult(ref double k, double a, double b)
        {
            return ExecuteMethods.T(ref k, a, b);
        }

        public void showMethod(double result, double steps)
        {
            Console.WriteLine($"Metoda trapezów:");
            Console.WriteLine($" wynik: {result}");
            Console.WriteLine($" kroki: {steps}");
            Console.WriteLine();
        }
    }

    public class ShowResultsS : Methods
    {
        public double calculateResult(ref double k, double a, double b)
        {
            return ExecuteMethods.S(ref k, a, b);
        }

        public void showMethod(double result, double steps)
        {
            Console.WriteLine($"Metoda parabol:");
            Console.WriteLine($" wynik: {result}");
            Console.WriteLine($" kroki: {steps}");
            Console.WriteLine();
        }
    }

    public class ShowResultsR : Methods
    {
        public double calculateResult(ref double k, double a, double b)
        {
            return ExecuteMethods.R(ref k,a,b);
        }

        public void showMethod(double result, double steps)
        {
            Console.WriteLine($"Metoda na r:");
            Console.WriteLine($" wynik: {result}");
            Console.WriteLine($" kroki: {steps}");
            Console.WriteLine();
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            #region user variables
            double a = -2;
            double b = 0;
            #endregion

            #region program variables
            double steps=1;
            var methods = from t in Assembly.GetExecutingAssembly().GetTypes()
                            where t.GetInterfaces().Contains(typeof(Methods))
                                     && t.GetConstructor(Type.EmptyTypes) != null
                            select Activator.CreateInstance(t) as Methods;
            #endregion

            #region execute
            foreach (var method in methods)
            {
                method.showMethod(method.calculateResult(ref steps,a,b),steps);
            }
            #endregion
        }
    }
}