Interpolacja

// Generacja opisu osi
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
//-------------------------------------

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

// Program główny
//---------------

// Przybliżenie zera
double const EPS = 0.0000000001;

int main()
{
    setlocale(LC_ALL,"");
    cout << fixed << setprecision(4);

    unsigned int n;    // Liczba działek na osi
    double vmin,vmax;  // Punkty krańcowe przedziału wartości
    double vlow,vhigh; // Wartości pierwszej i ostatniej działki
    double dv;         // Odstęp pomiędzy działkami
    double ldv,pdv,mdv,len;

    // Odczytujemy liczbę działek
    cin >> n;

    // Odczytujemy krańce przedziału
    cin >> vmin >> vmax;

    // Jeśli przedział ma zerową długość, to modyfikujemy jego końce
    if(fabs(vmin - vmax) < EPS)
    {
        vmin -= 1;
        vmax += 1;
    }

    // Obliczamy długość przedziału
    len = vmax - vmin;

    // Modyfikujemy liczbę działek
    if(n < 2) n = 2;
    
    // Obliczamy wstępną odległość pomiędzy działkami
    dv = len / ( n - 1 );

    // Modyfikujemy dv do "ładnej wartości"
    ldv = floor(log10(dv));
    pdv = pow(10,ldv);
    mdv = (int)(dv/pdv + 0.5);

    // Modyfikujemy współczynnik mdv do wartości 1, 2 lub 5
    if(mdv > 5.0)      mdv = 10.0;
    else if(mdv > 2.0) mdv = 5.0;
    else if(mdv > 1.0) mdv = 2.0;
    else               mdv = 1.0;

    // Obliczamy ostateczną odległość pomiędzy działkami
    dv = mdv * pdv;

    // Obliczmy pozycję pierwszej działki
    vlow = dv * floor(vmin / dv);

    // Obliczamy pozycję ostatniej działki
    vhigh = dv * ceil(vmax / dv);

    // Wyświetlamy wyniki
    double v;
    int i;

    cout << vlow << ", " << vhigh << endl << endl;

    i = 0;
    do
    {

        v = vlow + i * dv;
        cout << "v[" << setw(2) << i << "] = " << setw(9) << v << endl;
        i++;
    }
    while(v < vhigh);

    return 0;
}

// Procedura rysująca wykres funkcji
// (C)2020 mgr Jerzy Wałaszek
// Metody numeryczne
//----------------------------------

#include <iostream>
#include <iomanip>
#include <cmath>
#include <graphics.h>

using namespace std;

// Przybliżenie zera
double const EPS = 0.0000000001;

// Zmienne globalne
const int NX = 512;     // Liczba punktów na wykresie

double xg[NX],yg[NX];   // Współrzędne punktów wykresu, posortowane wg x
double xgs,ygs,xge,yge; // Współrzędne obszaru wykresu na płaszczyźnie

const int NV = 9;        // Przybliżona liczba działek + 2
double xvlow,xvhigh,xdv; // Zmienne do opisu osi x
double yvlow,yvhigh,ydv; // Zmienne do opisu osi y

// Funkcja, której wykres będzie tworzony
//---------------------------------------
double f(double x)
{
    return x * sin(x*x + 2) * cos(x*(x*(x+1)+1));
}

// Funkcja oblicza parametry działek
// vmin,vmax - przedział działkowany
// vlow  - pierwsza działka
// vhigh - ostatnia działka
// dv    - odstęp pomiędzy działkami
//----------------------------------
void get_v(double vmin, double vmax,
           double & vlow, double & vhigh, double & dv)
{
    double ldv,pdv,mdv,len;

    // Jeśli przedział ma zerową długość, to modyfikujemy jego końce
    if(fabs(vmin - vmax) < EPS)
    {
        vmin -= 1;
        vmax += 1;
    }

    // Obliczamy długość przedziału
    len = vmax - vmin;

    // Obliczamy wstępną odległość pomiędzy działkami
    dv = len / ( NV - 1 );

    // Modyfikujemy dv do "ładnej wartości"
    ldv = floor(log10(dv));
    pdv = pow(10,ldv);
    mdv = (int)(dv/pdv + 0.5);

    // Modyfikujemy współczynnik mdv do wartości 1, 2 lub 5
    if(mdv > 5.0)      mdv = 10.0;
    else if(mdv > 2.0) mdv = 5.0;
    else if(mdv > 1.0) mdv = 2.0;
    else               mdv = 1.0;

    // Obliczamy ostateczną odległość pomiędzy działkami
    dv = mdv * pdv;

    // Obliczmy pozycję pierwszej działki
    vlow = dv * floor(vmin / dv);

    // Obliczamy pozycję ostatniej działki
    vhigh = dv * ceil(vmax / dv);
}

// Funkcja wylicza punkty wykresu oraz ustala wstępne wartości
// współrzędnych xgs,ygs,sge,yge.
// W parametrach przekazywany jest przedział argumentów funkcji.
//--------------------------------------------------------------
void set_xy(double xp, double xk)
{
    double dx = (xk - xp) / (NX - 1); // Obliczamy odległość dwóch punktów x
    int i;

    for(i = 0; i < NX; i++)
    {
        xg[i] = xp + i * dx; // Współrzędna x punktu i-tego
        yg[i] = f(xg[i]);    // Współrzędna y punktu i-tego

        // Wyznaczamy max i min funkcji w przedziale, aby objąć ją prostokątem
        if(!i) // tzn. jeśli i == 0
            ygs = yge = yg[i];
        else
        {
            if(yg[i] > ygs) ygs = yg[i];
            if(yg[i] < yge) yge = yg[i];
        }
    }

    // Obliczamy działki na osi OX i OY

    get_v(xp,xk,xvlow,xvhigh,xdv);
    xgs = xvlow;
    xge = xvhigh;
    get_v(yge,ygs,yvlow,yvhigh,ydv);
    ygs = yvhigh;
    yge = yvlow;
}

// Funkcja rysuje wykres w zadanym przedziale
// xp,xk - początek i koniec przedziału
//-------------------------------------------
void graph2D(double xp, double xk)
{
    // Najpierw ustawiamy tablicę współrzędnych punktów wykresu wraz z danymi globalnymi
    set_xy(xp,xk);

    // Ustalamy rozmiary obszaru wykresu w oknie graficznym
    int xs = 0;
    int xe = getmaxx() - 80;
    int ys = 0;
    int ye = getmaxy() - 32;

    // Obliczamy szerokość i wysokość obszarów
    int W = xe - xs + 1;
    int H = ye - ys + 1;
    double Wg = xvhigh - xvlow;
    double Hg = yvhigh - yvlow;

    // Obszar wykresu wypełniamy kolorem białym
    setfillstyle(SOLID_FILL,WHITE);
    bar(xs,ys,xe+2,ye+2);

    // Rysujemy linie podziałkowe w kolorze jasnoniebieskim
    // Na końcach linii umieszczamy wartość podziałki

    int xd,yd;
    double x,y;

    // Pionowe
    x = xvlow;
    while(x <= xvhigh)
    {
        xd = (x - xgs) * W / Wg;
        setlinestyle(DOTTED_LINE,0,NORM_WIDTH);
        setcolor(LIGHTCYAN);
        line(xd,ys,xd,ye);
        setcolor(YELLOW);
        bgiout << x;
        outstreamxy(xd, ye+16);
        x += xdv;
    }

    // Poziome
    y = yvlow;
    while(y <= yvhigh)
    {
        yd = (ygs - y) * H / Hg;
        setlinestyle(DOTTED_LINE,0,NORM_WIDTH);
        setcolor(LIGHTCYAN);
        line(xs,yd,xe,yd);
        setcolor(LIGHTRED);
        bgiout << y;
        outstreamxy(xe+4, yd);
        y += ydv;
    }

    // Ustawiamy parametry linii osi współrzędnych
    setcolor(BLUE);
    setlinestyle(SOLID_LINE,0,NORM_WIDTH);

    // Jeśli oś wpada w obszar wykresu, to ją rysujemy
    // Najpierw oś OX
    yd = ygs * H / Hg;
    if((yd >= 0) && (yd <= ye)) line(xs,yd,xe,yd);

    // Następnie oś OY
    xd = -xgs * W / Wg;
    if((xd >= 0) && (xd <= xe)) line(xd,ys,xd,ye);

    // Ustawiamy parametry linii wykresu
    setcolor(GREEN);
    setlinestyle(SOLID_LINE,0,THICK_WIDTH);

    // Rysujemy wykres
    int i;
    for(i = 0; i < NX; i++)
    {
        // Obliczamy współrzędne ekranowe punktu wykresu
        xd = (xg[i] - xgs) * W / Wg;
        yd = (ygs - yg[i]) * H / Hg;

        // W pierwszym punkcie ustawiamy pozycję, w kolejnych rysujemy linie
        if(!i) moveto(xd,yd);
        else   lineto(xd,yd);
    }
}

//----------------
// PROGRAM GŁÓWNY
//----------------
int main()
{
   // Tworzymy okno graficzne o wybranym przez użytkownika rozmiarze
   initwindow(800, 600,"Wykres");

   // Ustawiamy parametry strumienia wyjściowego (potrzebne do opisu osi)
   bgiout << setprecision(4) << fixed;

   // Rysujemy wykres
   graph2D(-1.6,1.7);

   // Czekamy na klawisz
   getch();

   // Zamykamy okno graficzne i kończymy
   closegraph();
   return 0;
}