Ministerul Educatiei al Republicii Moldova

Universitatea Tehnica a Moldovei

Facultatea Calculatoare,Informatica si Microelectronica

Raport
la Lucrarea de laborator nr.3

Disciplina: Metode numerice

Tema: Polinomul de interpolare Lagrange

A Indeplinit: st.gr.CR-182 Mardari Ion

A Verificat : prof.unive. Istrati Daniela

Chisinau-2019
 Scopul lucrării:

1. Implementarea algoritmului de găsire a polinomului de interpolare

Lagrange.

Introducere:
În analiză numerică, interpolarea polinomială este o tehnică de interpolare a
unui set de date sau a unei funcții printr-un polinom. Cu alte cuvinte, dat este un
set de puncte (obținut, de exemplu, ca urmare a unui experiment), vom căuta un
polinom care trece prin toate aceste puncte, și, eventual, verifica pentru alte
condiții, dacă este posibil, gradul cel mai mic.
Una dintre cele mai vechi și generale formule de interpolare este cea datorită
lui Lagrange. Mai mult decât în utilizarea practică directă, importanța ei constă în
consecințele teoretice. O întreagă clăsă de formule de integrare numerică are la
bază aproximarea funcțiilor prin polinomul de interpolare al lui Lagrange. Pe de
altă parte, plecând de la acest interpolant pot fi construite scheme de derivare
numerică cu diferite ordine de precizie.
 Polinomul Lagrange.
Formula de interpolare Lagrange este: dacă y = f(x) ia valori y 0, y1 ... yn în
corespondență cu x = x0, x1 ... xn.

Listingul programului folosit pentru calcularea polinomului în punctul dat:

1. #include<iostream>  
2. #include <math.h>  
3. #include <iomanip>  
4. using namespace std;  
5.   
6. struct Point{  
7.     int x;  
8.     int y;  
9. };  
10.   
11. double lagrangeInterpolation(Point f[], int value, int n);  
12. int fun(int value);  
13.   
14. int main(){  
15.     int numberOfRecords, point;  
16.   
17.     cout << "How many records you will be enter: ";  
18.     cin >> numberOfRecords;  
19.   
20.     struct Point *records = (Point *) malloc(sizeof(struct Point) * numberOfRecords);  
21.   
22.     for (int i = 0; i < numberOfRecords; ++i) {  
23.         cout << "   Enter value of x"<<i<<": ";  
24.         cin >> records[i].x;  
25.         records[i].y = fun(records[i].x);  
26.     }  
27.   
 28.     for (int i = 0; i < numberOfRecords; ++i) {  
29.         cout << "X: " << setw(2) << records[i].x << setw(5) << "Y: " << records[i].y << 
endl;  
30.     }  
31.   
32.     cout << "Enter value of x: ";  
33.     cin >> point;  
34.   
35.     cout << "Value of f(1) = " << lagrangeInterpolation(records, point, numberOfRecords
);  
36.     return 0;  
37. }  
38.   
39. int fun(int value){  
40.     return pow(value, 2);  
41. }  
42.   
43. double lagrangeInterpolation(Point f[], int value, int n){  
44.     double result = 0;  
45.     for (int i = 0; i < n; ++i) {  
46.         double term = f[i].y;  
47.         for (int j = 0; j < n; ++j) {  
48.             if(i!=j){  
49.                 term = term * (value - f[j].x) / double(f[i].x - f[j].x);  
50.             }  
51.         }  
52.         result += term;  
53.     }  
54.     return result;  
55. }  

Rezultatul execuției:

Figura 1. Rezultatul execuției algoritmului pentru interpolarea

Lagrange.

Listingul programului folosit pentru aflării polinomului de interpolare

Lagrange și calcularea valorii în punctul dat:
1. import sympy  
2.   
3. def evaluateExpression(value, function):  
4.     x = value  
5.     return eval(function)  
6.   
7. def Lagrange(Lx, Ly):  
8.     X = sympy.symbols('x')  
9.     if len(Lx) != len(Ly):  
10.         print "ERROR"  
11.         return 1  
12.     y = 0  
13.     for k in range (len(Lx)):  
14.         t = 1  
 15.         for j in range (len(Lx)):  
16.             if j != k:  
17.                 t = t * ((X-Lx[j]) / (Lx[k]-Lx[j]))  
18.         y += t * Ly[k]  
19.     return y  
20.   
21. n = int(raw_input("Number of coeficients: "))  
22. x = []  
23. fx = []  
24.   
25. for i in range(n):  
26.     a, b = (raw_input("Value of x and f(x): ")).split()  
27.     x.append(int(a))  
28.     fx.append(int(b))  
29.   
30.   
31. point = int(raw_input("Point value: "))  
32.   
33. formula = ((Lagrange(x,fx).conjugate().conjugate())).simplify()  
34. print ("Lagrange polynom-> %s" % formula)  
35. print ("Polynom value in point-> " + str(point) + " is = " + str(evaluateExpression(2, 
str(formula))))  

Rezultatul execuției:

Figura 2. Rezultatul execuției algortimului ce permite

aflarea polinomului de interpolare Lagrange și calcularea valoriia cestuia în
punctul dat.

Concluzie: Elaborând această lucrare de laborator am utilizat polinomul Lagrange

pentru interpolarea în noduri echidistanțate. În urma analizei metodei putem
evidenția următoarele dezavantaje ale interpolării Lagrange:
1. Un număr mare de calcule.
2. Modificarea valorii x pentru care se face interpolarea implică de fiecare dată
același număr de calcule – deoarece nu se pot utiliza rezultatele parțiale de la
interpolările anterioare.
3. Modificarea numărului de noduri necesită reluarea calculelor.
4. Evaluarea dificilă a erorii.