.NET 4.x Математичеса либа(нахождения производной для функции,заданной точками) - C#

Формулировка задачи:

Нужна математическая библиотека(или либа(дотнета) с помощью которой можно сделать это) Есть график он строиться по точкам, те (х1,у1)(х2,у2)(х3,у3)(х4,у4). То есть нет точно определенной ф-ии. Надо построить график(а для этого надо найти (х1,у1`)(х2,у2`)(х`,у3`)(х4,у4`)), который был бы производной того что я прикрепил. С помощью какой либы можно такое сделать?

Решение задачи: «.NET 4.x Математичеса либа(нахождения производной для функции,заданной точками)»

textual
                            Листинг программы 
                        

                            #region using
 
using System;
using System.Linq;
using System.Drawing;
using System.Windows.Forms;
 
#endregion
 
namespace WindowsFormsApplicationTest
{
    public partial class UserInterface : Form
    {
        private const int NUM = 30;
        private const int SCALE = 20;
 
        private double[] _doublesX;
        private double[] _doublesY;
        private PointF[] _pointList;
 
        public UserInterface()
        {
            InitializeComponent();
        }
 
        private void ButtonDrawClick(object sender, EventArgs e)
        {
            var bitmap = new Bitmap(400, 400);
            var graphics = Graphics.FromImage(bitmap);
 
            const double MAX = 2*Math.PI;
            const double MIN = -2*Math.PI;
            
            // Исходный массив.
            _pointList = new PointF[NUM + 1];
 
            for (var i = 0; i <= NUM; i++)
            {
                var x = MIN + (MAX - MIN)*i/NUM;
                _pointList[i] = new PointF(
                    (float) x,
                    (float) (Math.Sin(x)*x)); // Функция Sin(x)*x
            }
 
            // Выводим исходный график чёрным
            var pen = new Pen(Color.Black);
            graphics.DrawLines(pen, _pointList
                                        .Select(p => new PointF(
                                                         (float) (bitmap.Width)/2 + p.X*SCALE,
                                                         (float) (bitmap.Height)/2 - p.Y*SCALE
                                                         )
                                        )
                                        .ToArray());
 
            // Интерполяция
            _doublesX = _pointList.Select(p => (double) p.X).ToArray();
            _doublesY = _pointList.Select(p => (double) p.Y).ToArray();
 
            const double DX = 0.01;
            var interp = _pointList.Select(
                p => new PointF(
                         p.X,
                         (float) ((NewtonInterpolator(p.X + DX) - p.Y)/DX)
                         )
                );
 
            // Выводим график производных красным.
            pen = new Pen(Color.Red);
            graphics.DrawLines(pen, interp
                                        .Select(p => new PointF(
                                                         (float) (bitmap.Width)/2 + p.X*SCALE,
                                                         (float) (bitmap.Height)/2 - p.Y*SCALE
                                                         )
                                        )
                                        .Where(p =>
                                               p.X <= bitmap.Width && p.X >= 0 &&
                                               p.Y <= bitmap.Height && p.Y >= 0)
                                        .ToArray());
            pictureBox.Image = bitmap;
        }
 
        // Интерполяция Ньютона.
        private double NewtonInterpolator(double inputX)
        {
            double F, outputY, XX, X = 1;
            int i, j, k;
            for (i = 1, outputY = _doublesY[0]; i < NUM; i++)
            {
                X *= (inputX - _doublesX[i - 1]);
                for (j = 0, F = 0; j <= i; j++)
                {
                    for (k = 0, XX = 1; k <= i; k++)
                        if (k != j)
                            XX *= _doublesX[j] - _doublesX[k];
                    F += _doublesY[j]/XX;
                }
                outputY += X*F;
            }
            return outputY;
        }
    }
}
                        