Вычислить и вывести на экран в виде таблицы значения функции arcsin(x), заданной с помощью ряда Тейлора

static void Main(string[] args)
        {
            int x = 1;
            int n = 5;
            double sum = 0;
            for (int i = 0; i < n; i++)
                sum += rec(2 * i) / (Math.Pow(4, i) * Math.Pow(rec(i), 2) * (2 * i + 1)) * Math.Pow(x, (2 * i + 1));
        }
        static int rec(int n)//вычисление факториала
        {
            if (n == 1 || n == 0)
                return 1;
            else
                return n * rec(n - 1);
        }

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        { Console.Write("Введите начальное значение аргумента: ");
            double Xn = double.Parse(Console.ReadLine());
            Console.Write("Введите конечное значение аргумента: ");
            double Xk = double.Parse(Console.ReadLine());
            Console.Write("Введите шаг dx: ");
            double dx = double.Parse(Console.ReadLine());
            Console.Write("Введите точность: ");
            double eps = double.Parse(Console.ReadLine());
            int n, ch, zn;
            double result;
            double x = Xn;
            Console.WriteLine("Аргумент\tФункция\t\tКоличество слагаемых");
            Console.WriteLine();
            while (x <= Xk + dx)
                {
                n = 1;
                result =0;
                for (int i = 1; i < n; i++) ;
                ch = 2 * n - 1;
                zn = 2 * n;
 
                while (ch*(Math.Pow(x,2*n+1))/zn*(2*n+1)  > eps)
                {
                   result += (ch*(Math.Pow(x,2*n+1))/zn*(2*n+1));
                    n++;
                }
                Console.WriteLine("{0:f8}\t{1:f8}\t{2}", x, result, n);
                x += dx;
                }
            Console.ReadKey();
 
        }
    }
}

using System;
 
namespace TaylorTemplate
{
    internal class Program
    {
        private static void Main()
        {
            var func = new Taylor(new FunctionData(0, 0.9, 0.1, 0.00001, "Arth"), StartsWith, Multipler, Arth);
            foreach (string s in func.CalculateFunction())
                Console.WriteLine(s);
            Console.WriteLine("\n\nПрограмма завершена. Для выхода нажмите любую клавишу");
            Console.ReadKey();
        }
 
 
        private static double Multipler(double x, int n)
        {
            return x * x * (2 * n + 1) / (2 * n + 3);
        }
 
 
        private static double Arth(double x)
        {
            return Math.Log((1 + x) / (1 - x)) / 2;
        }
 
 
        private static double StartsWith(double x)
        {
            return x;
        }
    }
}

using System;
using System.Collections.Generic;
 
namespace TaylorTemplate
{
    public struct FunctionData
    {
        public readonly double Epsilon;
        public readonly double Dx;
        public readonly double Start;
        public readonly double End;
        public readonly string Name;
 
 
        public FunctionData(double start, double end, double delta, double epsilon, string name)
        {
            if (start >= end)
                throw new ArgumentOutOfRangeException("end");
            if (delta >= (end - start))
                throw new ArgumentOutOfRangeException("delta");
            Start = start;
            End = end;
            Dx = delta;
            Epsilon = epsilon;
            Name = name;
        }
    }
 
 
    public class Taylor
    {
        private readonly FunctionData functionData;
        private readonly Func<double, int, double> multipler;
        private readonly Func<double, double> etalon;
        private readonly Func<double, double> startsWith;
 
 
        public Taylor(FunctionData functionData, Func<double, double> startsWith, Func<double, int, double> multipler,
                      Func<double, double> etalon)
        {
            this.functionData = functionData;
            this.startsWith = startsWith;
            this.multipler = multipler;
            this.etalon = etalon;
        }
 
 
        public IEnumerable<string> CalculateFunction()
        {
            int iters;
            yield return string.Format("Рассчет функции: {0}\nС точностью {1} и шагом {2}\nВ диапазоне [{3},{4}]\n\n",
                                       functionData.Name,
                                       functionData.Epsilon,
                                       functionData.Dx,
                                       functionData.Start,
                                       functionData.End);
            yield return string.Format("Приближенное значение\t\tТочное значение\t\t\tСлагаемых");
            for (double x = functionData.Start; x < functionData.End; x += functionData.Dx)
                yield return
                    string.Format("{0,-25}\t{1,-25}\t{2}", F(x, functionData.Epsilon, out iters), etalon(x), iters);
        }
 
 
        private double F(double x, double eps, out int i)
        {
            if (Math.Abs(x) >= 1) throw new ArgumentOutOfRangeException("x");
            i = 0;
            double result = 0, lastresult = double.MinValue, summand = startsWith(x);
            for (; Math.Abs(result - lastresult) >= eps; i++)
            {
                lastresult = result;
                result += summand;
                summand *= multipler(x, i);
            }
            return result;
        }
    }
}

using System;
 
namespace TaylorTemplate
{
    internal class Program
    {
        private static void Main()
        {
            var func = new Taylor(new FunctionData(0, 0.9, 0.1, 0.00001, "Asin"), StartsWith, Multipler, Arth);
            foreach (string s in func.CalculateFunction())
                Console.WriteLine(s);
            Console.WriteLine("\n\nПрограмма завершена. Для выхода нажмите любую клавишу");
            Console.ReadKey();
        }
 
 
        private static double Multipler(double x, int n)
        {
            return ((1 + 2 * n) * x * x) / (4 * (1 + n) * (3 + 2 * n));
        }
 
 
        private static double Arth(double x)
        {
            return Math.Asin(x);
        }
 
 
        private static double StartsWith(double x)
        {
            return x;
        }
    }
}

        private static double Multipler(double x, int n)
        {
            return (4 - 2.0 / (n + 1)) * (x * x) * (2.0 * n + 1) / (4 * (2 * n + 3));
        }