Mam problemy interpolujące plik danych, które konwertowałem z .csv na tablicę X i tablicę Y, gdzie X [0] odpowiada na przykład punktowi Y [0].

Muszę interpolować między wartościami, aby dać mi gładki plik na końcu. Używam Picoskopu do wyprowadzania funkcji, co oznacza, że ​​każda linia jest równo rozmieszczona w czasie, więc tylko przy użyciu wartości Y, dlatego staram się to robić w dziwny sposób, gdy widzisz mój kod.

Rodzaj wartości, którymi musi się zająć, to:

X     Y
0     0
2.5   0
2.5   12000
7.5   12000
7.5   3000
10    3000
10    6000
11    6625.254
12    7095.154

Więc gdzie 2 wartości Y obok siebie są takie same, to linia prosta między nimi, ale kiedy zmieniają się jak od X = 10 na osłonach, w tym przykładzie staje się falą sinusoidalną.

Patrzyłem na równania dla interpolacji itp. I innych postów tutaj, ale nie robiłem tego rodzaju matematyki od lat i niestety nie mogę już tego rozgryźć, ponieważ są 2 niewiadome i nie mogę myśleć jak zaprogramować to na c #.

Mam to:

int a = 0, d = 0, q = 0;
bool up = false;
double times = 0, change = 0, points = 0, pointchange = 0; 
double[] newy = new double[8192];
while (a < sizeoffile-1 && d < 8192)
{
    Console.Write("...");
    if (Y[a] == Y[a+1])//if the 2 values are the same add correct number of lines in to make it last the correct time
    {
        times = (X[a] - X[a + 1]);//number of repetitions
        if ((X[a + 1] - X[a]) > times)//if that was a negative number try the other way around
            times = (X[a + 1] - X[a]);//number of repetitions 
        do
        {
            newy[d] = Y[a];//add the values to the newy array which replaces y later on in the program
            d++;//increment newy position
            q++;//reduce number of reps in this loop
        }
        while (q < times + 1 && d < 8192);
        q = 0;//reset reps
    }
    else if (Y[a] != Y[a + 1])//if the 2 values are not the same interpolate between them
    {
        change = (Y[a] - Y[a + 1]);//work out difference between the values
        up = true;//the waveform is increasing
        if ((Y[a + 1] - Y[a]) > change)//if that number was a negative try the other way around
        {
            change = (Y[a + 1] - Y[a]);//work out difference bwteen values
            up = false;//the waveform is decreasing
        }
        points = (X[a] - X[a + 1]);//work out amount of time between given points
        if ((X[a + 1] - X[a]) > points)//if that was a negative try other way around
            points = (X[a + 1] - X[a]);///work out amount of time between given points
        pointchange = (change / points);//calculate the amount per point in time the value changes by
        if (points > 1)//any lower and the values cause errors
        {
            newy[d] = Y[a];//load first point
            d++;
            do
            {
                if (up == true)//
                    newy[d] = ((newy[d - 1]) + pointchange);
                else if (up == false)
                    newy[d] = ((newy[d - 1]) - pointchange);
                d++;
                q++;
            }
            while (q < points + 1 && d < 8192);
            q = 0;
        }
        else if (points != 0 && points > 0)
        {
            newy[d] = Y[a];//load first point
            d++;
        }
    }
    a++;
}

a to tworzy bliski przebieg, ale wciąż jest bardzo skokowy.

Czy więc ktoś może zobaczyć, dlaczego nie jest to bardzo dokładne? Jak poprawić dokładność? Lub inny sposób robienia tego za pomocą tablic?

Dzięki za szukanie :)