Вычисление определенного интеграла методом парабол

var values = GetFunctionValues(x => Math.Cos(x + x * x * x) / (1 + x * x), 0, 1, 25);

        delegate double Function(double x);
        static double [] GetFunctionValues(Function f, double min, double max, int count)
        {
            double[] v = new double[count + 1];
            double delta = (max - min) / count;
            for(int i = 0;min<=max;min+=delta,i++)
            {
                v[i] = f(min);
            }
            return v;
        }

        struct PointD
        {
            double X { get; set; }
            double Y { get; set; }
            public PointD(double x, double y)
            {
                X = x;
                Y = y;
            }
        }

        static PointD [] GetFunctionValues(Function f, double min, double max, int count)
        {
            PointD[] v = new PointD[count + 1];
            double delta = (max - min) / count;
            for(int i = 0;min<=max;min+=delta,i++)
            {
                v[i] = new PointD(min, f(min));
            }
            return v;
        }

        struct Polynom2
        {
            public double A { get; set; }
            public double B { get; set; }
            public double C { get; set; }
            public PointD Minimum { get; set; }
            public PointD Maximum { get; set; }
            public Polynom2(PointD p1, PointD p2, PointD p3)
            {
                Minimum = p1;
                Maximum = p3;
                A = ((p3.Y - p1.Y) * (p2.X - p1.X) - (p2.Y - p1.Y) * (p3.X - p1.X)) /
                    ((p3.X * p3.X - p1.X * p1.X) * (p2.X - p1.X) - (p2.X * p2.X - p1.X * p1.X) * (p3.X * p1.X));
 
                B = (p2.Y - p1.Y - A * (p2.X * p2.X - p1.X * p1.X)) / (p2.X - p1.X);
 
                C = p1.Y - A * p1.X * p1.X - B * p1.X;
            }
        }

            public double Integral
            {
                get
                {
                    return (Maximum.X - Minimum.X) *
                        ((Maximum.X * Maximum.X + Maximum.X * Minimum.X + Minimum.X * Minimum.X) * A / 3 + (Maximum.X + Minimum.X) * B / 2 + C);
                }
            }

        static double GetIntegralAdd(Polynom2 [] p)
        {
            double sum = 0;
            for(int i = 0;i<p.Length;i++)
            {
                sum += p[i].Integral;
            }
            return sum;
        }

        public double GetIntegralSimpson(Function f, double min, double max, int count)
        {
            var values = GetFunctionValues(f, min, max, 2*count);
            Polynom2[] pols = new Polynom2[(values.Length - 1) / 2];
            for (int i = 0, j = 0; i < values.Length - 1; j++)
            {
                pols[j] = new Polynom2(values[i++], values[i++], values[i]);
            }
            return GetIntegralAdd(pols);
        }

double res = GetIntegralSimpson(x => Math.Cos(x + x * x * x) / (1 + x * x), 0, 1, 25);

        static PointD [] GetFunctionValues(Function f, double min, double max, int count)
        {
            PointD[] v = new PointD[count + 1];
            double delta = (max - min) / count;
            for(int i = 0;i<=count;min+=delta,i++)
            {
                v[i] = new PointD(min, f(min));
            }
            return v;
        }