Całki numeryczne problem

Witam

muszę napisać program który zgodnie z tym wzorem poniżej będzie rysował wykres funkcji w(x)...

Teoretycznie (chyba) wiem jak to policzyć ale w praktyce jest gorzej...ba napisałem już nawet próbny algorytm ale dziwne te wyniki wychodzą...
Poza tym co jeśli w mianowniku z którymkolwiek z nawiasów wyjdzie 0 ? Wtedy cały ułamek dla danego "i" będzie równy 0 ?

Czy mógłby mi ktoś pomóc policzyć to jeden jedyny raz dla obojętnie jakich danych ? Był bym bardzo wdzięczny...

Aha i nie wiem czy dobrze rozumiem :
Xi oraz Xj - są to współrzędne punktów podanych przez użytkownika (czyli np. przykładowa tabelka)
X to też współrzędna dla której szukamy Y (Y = wynik tego co liczmy)
n to liczba punktów - 1
i to tj. numer kroku sumy który właśnie wykonujemy.
j = 0, j != i jeśli "j" jest różne i to przeskakujemy do kolejnego punktu - czyli zwiększamy "i"

Dziwnie ci wychodzi, bo ten wzór, który podałeś, jest bezsensu.
Ten wzór tylko przypomina wzór na wielomian Lagrange'a, wyznaczany na podstawie znanych punktów.

Nom tak to ten wzór (swój przepisywałem z notatek...)

Ale nie wiem jak się za to zabrać...poza sumą (czyli w sumie pętlą liczącą ułamek od Xo do Xn), mnożeniem tego ułamka co każde "i" przez Ai oraz zasadą zachowania j!=i co trzeba tutaj rozumieć ?

Niestety w matematyce nie jestem orłem:) Tyle mi się udaje z tego wyczytać.

Π oznacza iloczyn wszystkich elementów, które są indeksowane po j od 1 do n z pominięciem wartości j równej i (by nie było dzielenia przez zero).

@k4myk czegoś nie rozumiem...
Jaki jest wg Ciebie współczynnik korelacji pomiędzy całkowaniem numerycznym a interpolacją??

@nemomemo szczerze to nie wiem, zabrałem się za ten temat wczoraj i jestem zielony...

a w kodzie jak by to wyglądało ?

licząc dla jakiegoś już podanego w(x) mamy dwie pętle :
pierwszą od i do n
drugą od j do n

w drugiej liczymy licznik (x - Xj) dla Xj róznego od Xi (jeśli i == j to przeskakujemy na kolejny Xj)
to samo z mianownikiem (Xi - Xj)

licznik i mianownik zapisujemy dla przykładu
licznik *= licznik z obecnej pętli
licznik i mianownik wcześniej ustawiamy na 1 aby przy pierwszym obiegu pętli wynik się nie zmienił.

po wyjściu z drugiej pętli do pierwszej
robimy wynik += Yi * (licznik / mianownik)
i mianownik na początku wynosi 0

czyli w skrócie pętla najbardziej w głąb liczy pojedynczy nawias z licznika i mianownika i mnoży przez siebie wcześniejsze wyniki
pętla druga liczy już cały ułamek i mnoży przez Yi (czyli f(Xi)), stopniowo dodając wszystko do ogólnego wyniku...

Nie zdążę już napisać programu przed wyjściem...motam się trochę z indeksami, dla Xj indeksem będzie to co w najgłębszej pętli ? od j do n ? a dla Xi indeksem będzie to co w poprzedzającej pętli ?

Aha @MarekR22 piszesz że wszystkich elementów od 1 do n... ale w trzymając punkty w tablicy w pętli robimy od j = 0 do j < n ?

@k4myk nie rozumiem kolejnej kwestii...
Próbujesz zrobić coś o czym nie masz pojęcia(to akurat do pewnego stopnia jest akceptowalne),
lecz nie jesteś w stanie podać poprawnie treści zadania/tematu (a to już jest troszeczkę nie fair).

Chyba trzeba by założyć kolejny dział, coś w stylu pytania do wróżek i/lub wróżbitów...

Nie wiem co tutaj nie jasnego - fakt może temat nie jest odpowiedni (konkretne całki numeryczne to kolejna część zadania z do których potrzebny jest wykres)
Ale w treści podałem wzór i to czego nie rozumiem i to co muszę zrobić...

Teraz konkretnie
muszę napisać algorytm obliczający http://pl.wikipedia.org/wiki/Posta%C4%87_Lagrange%27a_wielomianu

Tyle co udało mi się zrobić :

#include <iostream>
#include <vector>
#include <iomanip>

using namespace std;

float licz();

vector<int> x;
vector<int> y;
int n = 0;
int wx = 0;

int main()
{
    cout << fixed;
    cout << setprecision (1);

    cout << "Ile punktow wprowadzic : ";
    cin  >> n;

    for (int i = 0; i < n; i++)
    {
        int tmp;
        cout << "Podaj X " << i << " : ";
        cin  >> tmp;
        x.push_back(tmp);

        cout << "Podaj Y " << i << " : ";
        cin  >> tmp;
        y.push_back(tmp);

        cout << "\n";
    }

    cout << "w(x) gdzie x = ";
    cin  >> wx;

    cout << "\n";
    cout << "n = " << n << "\n";
    for (int i = 0; i < n; i++)
    {
        cout << x[i] << "," << y[i] << "\n";
    }
    cout << "\n";

    cout << licz();

    return 0;
}

float licz()
{
    float   licznik = 1,
            mianownik = 1;
    float   wynik = 1;
    int     index = 0;

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (i == index) index++;
            if (index >= n){ index = 0; cout << "przkroczenie indeksu\n"; }

            mianownik *= (wx - x[index]);
            licznik *= (x[i] - x[index]);
        }
        wynik += y[i] * (licznik / mianownik);
    }
    return wynik;
}

ciężko mi powiedzieć czy algorytm działa poprawnie...

No i super, że pokazałeś, że nie jesteś leniem i coś zrobiłeś. Od razu trzeba było od tego zacząć, szczególnie, że nie jest bardzo źle.

double LagrangePoly(double xx) {
    double result = 0;
    for (int i=0; i<x.size(); ++i) {
        double product = 1.0;
        for (int j=0; j<x.size(); ++j) {
              if (i==j)
                  continue; // pomiń człon
              product *= (xx-x[j])/(double)(x[i]-x[j]); // x i y powinny być raczej typu vector<double> a nie vector<int>!
        }
        result += product * y[i];
    }
    return result;
}

x i y powinny być raczej typu vector<double>, a nie vector<int>, pewnie to jest główna przyczyna twoich dziwnych wyników!

@MarekR22 dzięki nie pierwszy raz mi pomagasz :)

w sumie myślałem że jak zostawię inty to Od razu nie będę się musiał bawić bardzo z rysowaniem wykresu (umieszczanie niecałkowitych liczb)

W sumie to widzę że miałem problem z pomijaniem tego kroku gdzie i == j (nie potrzebnie dałem dodatkowy indeks)

Dzięki jeszcze raz, chociaż program przetestuje dopiero wieczorem.