Интерполяция полиномами Лагранжа

using System;
 
namespace ConsoleApp
{
    class Program
    {
        static void Main()
        {
            const int size = 10;
            var xValues = new double[size];
            var yValues = new double[size];
 
            for (int i = 0; i < size; i++)
            {
                xValues[i] = i; 
                yValues[i] = TestF(i);
            }
 
            Console.WriteLine(InterpolateLagrangePolynomial(13.6, xValues, yValues, size));
        }
 
        static double InterpolateLagrangePolynomial (double x, double[] xValues, double[] yValues, int size)
        {
            double lagrangePol = 0;
 
            for (int i = 0; i < size; i++)
            {
                    double basicsPol = 1;
                    for (int j = 0; j < size; j++)
                    {
                        if (j != i)
                        {
                            basicsPol *= (x - xValues[j])/(xValues[i] - xValues[j]);
                        }
                    }
                    lagrangePol += basicsPol * yValues[i];
            }
 
            return lagrangePol;
        }
 
        static double TestF(double x)
        {
            return  x*x*x + 3*x*x + 3*x + 1; // for example
        }
    }
}

    class Approximator
    {
        //Points and function values
        readonly double[] _p;
        readonly double[] _fp;
 
        //Coefficients for Lagrange polynomial
        readonly double[] _l;
 
        //Delegates for needed parameters
        public delegate double Function(double x);
        delegate double Operation(int x);
 
        //Constructor
        public Approximator(double begin, double incr, int number, Function func)
        {
            _p = new double[number];
            _fp = new double[number];
            _l = new double[number];
            for (int i = 0; i < number; i++)
            {
                _p[i] = begin + incr * i;
                _fp[i] = func(_p[i]);
            }
            for (int i = 0; i < number; i++)
                _l[i] = _fp[i] / Product(Enumerable.Range(0, _p.Length).
                    Where(j => j != i), j => _p[i] - _p[j]);
        }
 
        //Lagrange's formula
        public double Lp(double x)
        {
            return Enumerable.Range(0, _p.Length).Sum( i => _l[i]
                * Product(Enumerable.Range(0, _p.Length).
                Where(j => j != i), j => x - _p[j]));
        }
 
        //Auxiliary functions
        static double Product(IEnumerable<int> values, Operation oper)
        {
            return values.Aggregate(1D, (current, v) => current * oper(v));
        }
    }