Sunteți pe pagina 1din 10

MINISTERUL EDUCAIEI AL REPUBLICII MOLDOVA

UNIVERSITATEA TEHNIC A MOLDOVEI


Facultatea Calculatoare, Informatic i Microelectronic
Catedra Calculatoare

Raport
Lucrare de laborator nr.1
La disciplina
Metode Numerice
Tema:Rezolvarea numeric a ecuaiilor algebrice transcendente.

A efectuat:

st.gr. ISBM-121 Bizga Alexei

Nebelciuc Vitalic

A verificat:

Chiinu 2013

Scopul lucrarii:
1.Sa se separe toate radacinile reale ale ecuaiei f(x)=0 unde y=f(x) este o funcie real de variabil real.
2.S se determine o rdcina real a ecuatiei date cu ajutorul metodei injumatatirii intervalului cu o eroare
mai mica decit =0.01.
3.Sa se precizeze radacina obtinuta cu exactitatea =10-6,utilizind:
-Metoda aproximatiilor successive;
-Metoda tangentelor(Newton);
-Metoda secantelor.
4.Ecuaiile propuse spre rezolvare: I. ln ( x+ 1 )4 x=0
II.

2x +3 x0.5=0

Partea teoretic:
Separarea radacinilor se poate realiza prin diferite metode. Cele mai des utilizate metode in practica sunt
urmatoarele doua metode de separare:
Metoda grafica
De multe ori ecuatia f(x)=0 poate fi adusa la forma echivalenta h(x)=g(x). Radacinile acestei ecuatii sunt
abscisele punctelor de intersectie ale curbelor y=h(x) si y=g(x).
I. ln ( x+ 1 )4 x=0

II.

2x +3 x0.5=0

Metoda sirurilor lui Rolle


Metodele analitice de separare a solutiilor unei ecuatii neliniare sunt bazate pe urmatoarele doua teoreme:
Teorema Boltzano-Cauchy
Daca functia f(x) este continua pe [a;b] si primeste la capetele intervalului valori de semn opus, atunci pe
intervalul dat functia are cel putin o radacina.
Teorema Rolle

Daca functia f(x)este continua pe [a;b], diferentiabila pe acest interval si f(a)=f(b), atunci exista un asa punct
care aprtine (a;b) pentru care derivate functiei f(x) in punctul l se anuleaza.
Metodele de rezolvare a ecuatiilor neliniare pot fi divizate in doua grupe:
- metodele directe
- metode iterative
Metodele directe permit determinarea solutiilor ecuatiilor cu ajutorul unei formule. Asa formule avem
pentru ecuatiile patratice, trigonometrice, logaritmice, etc.
Deseori in practica putem intilni ecuatii care nu pot fi rezolvate prin metodele directe si pentru rezolvare
se folosesc metodele iterative. Algoritmul determinarii solutiei ecuatiei neliniare f(x)=0 cu ajutorul
metodelor iterative implica parcurgerea a doua etape:
1.Separarea radacinilor, care consta in determinarea unui asa interval [a;b] in care este situata o radacina
reala a ecuatiei
2.Calculul aproximativ al fiecarei radacini si evaluarea erorii care s-a comis considerind ca separarea daja
s-a efectuat.

Rezultatul:

Concluzie:
La aceast lucrare de laborator am obinut deprinderi practice n domeniul rezolvrii numerice a ecuaiilor
algebrice i transcendente care sunt foarte eficiente i uor aplicabile. Aceste metode sunt deseori utilizate n
practic deoarece majoritatea proceselor care se studiaz n tehnic, tiin i economie sunt neliniare.
Am introdus intervalul [-2;-1] si prin metoda injumatatirii am obtinut solutia initiala pentru ecuaie -1.43101
prin 22 iteratii, prin metoda aproximatiilor successive obtinem rezultatul -1.43102 cu un numar de 8
iteratii, prin metoda newton solutia este -1.43102 prin 6 iteratii,prin metoda secantelor -1.43101cu 5
iteratii,respective cea mai buna metoda este metoda secantelor .

Anexa:
Am rezolvat numai prima ecuatie, a doua fiind similara
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define e 2.7
int n;
float f(float x)
{
return(ln(x+1)-4*x);
}
//*****************************************************************
float f1(float x)
{
return(1/(x+1)-4);
}
//*****************************************************************
float f2(float x)
{
return(6*x);
}
//*****************************************************************
float Newton1(float a,float b,float eroarea)
{
float x,x0,z,xi;
if (f(a)*f(b)>0)
{
textcolor(6);
cprintf("\r\nIntroduceti Intervalul de cautare !\n");
return 0;
}
if ((f(a)*f2(a))>0)
xi=x0=a;
else
xi=x0=b;
x=x0;
do
{
n++;
x0=x;
x=x0-f(x0)/f1(xi);
}
while(fabs(x-x0)>eroarea*eroarea);
return x;
}
//*****************************************************************
void Newton()
{
clrscr();
int i,m;
float a,b,r,eroarea;
textcolor(18);
cprintf("\r\n
Metoda Newton");
textcolor(12);
cprintf("\r \nIntroduceti eroarea: ");

scanf("%f",&eroarea);
n=0;
textcolor(12);
cprintf("\r\n Introduceti Intervalul:\n");
cprintf("\r\n a= ");
scanf("%f",&a);
cprintf("\r\n b= ");
scanf("%f",&b);
r=Newton1(a,b,eroarea);
clrscr();
textcolor(12);
cprintf("\r\n
Metoda Newton");
printf("\n");
printf("\n");
cprintf("\r\n 1) Radacina pe intervalul dat este: %.5f\n",r);
printf("\n");
cprintf("\r\n 2) Valoarea functiei in aceasta radacina este: %.10f\n",f(r));
printf("\n");
cprintf("\r\n 3) Numarul de pasi este: %d\n\n",n);
getch();
}
//*****************************************************************
float M(float x)
{
return(x*x*x-30*x-40);
}
//*****************************************************************
void Metoda_Injumatatirii()
{
clrscr();
float eroarea,a,b,c;
int k=0,Nmax;
textcolor(18);
cprintf("\r\n
Metoda Injumatatirii Intervalului:\n\n");
printf("\n");
printf("\n");
textcolor(13);
cprintf("\r\n Introduceti eroarea:");
scanf("%f",&eroarea);
cprintf("\r\n Introdu extremele intervalului:");
cprintf("\r\n
<< a >>=");
scanf("%f",&a);
cprintf("\r\n
<< b >>=");
scanf("%f",&b);
if (M(a)*M(b)>0)
{
textcolor(6);
cprintf("\r\n
Radacina pe acest inerval nu exista");
getch();
exit(1);
}
while (fabs(a-b)>eroarea)
{
k++;
c=a+(b-a)/2;
if (M(c)==0)
{

textcolor(18);
cprintf("\r\n
Radacina este %f",c);
getch();
exit(0);
}
if (M(a)*M(c)<0) {b=c;a=a;}
else
{a=c;b=b;}
}
clrscr();
textcolor(18);
cprintf("\r\n
Metoda Injumatatirii Intervalului:");
printf("\n");
cprintf("\r\n Radacina pe acest inerval %f",a);
printf("\n");
cprintf("\r\n F(x)=%f",M(a));
printf("\n");
cprintf("\r\n Numarul de iteratii %d",k);
getch();
return ;
}
//****************************************************************
float Met_sec1(float x)
{
return ((x*x*x-30*x-40));
}
//****************************************************************
float Met_sec2(float x)
{
return (3*x*x-30);
}
//*****************************************************************
void Metoda_secantelor()
{
clrscr();
float eroarea, x0, x;
int k=0;
textcolor(18);
cprintf("\r\n
Metoda Secantelor:\n\n");
printf("\n");
printf("\n");
textcolor(13);
cprintf("\r\n Introduceti eroarea:");
scanf("%f",&eroarea);
cprintf("\r\n Introdu valoarea initiala :");
cprintf("\r\n
<< x0 >>=");
scanf("%f",&x0);
x=x0-Met_sec1(x0)/Met_sec2(x0);
while (fabs(x-x0)>eroarea)
{
k++;
x0=x;
x=x0-Met_sec1(x0)/Met_sec2(x0);
}
clrscr();
textcolor(18);
cprintf("\r\n
Metoda Secantelor:\n\n");
printf("\n");

printf("\n");
textcolor(6);
cprintf("\r\n Radacina pe acest inerval %f",x);
printf("\n");
cprintf("\r\n F(x)=%f",Met_sec1(x));
printf("\n");
cprintf("\r\n Numarul de iteratii %d",k);
getch();
}
//*****************************************************************
void main()
{
textbackground(1);
clrscr();
int m,n,i,g;
m=1;
while(m)
{
clrscr();
textcolor(4);
cprintf("\r\n
<<<<<<<<<<<<<<<<< MENU >>>>>>>>>>>>>>");
printf("\n");
printf("\n");
textcolor(18);
cprintf("\r\n Metoda Newton -------------------------- 1");
cprintf("\r\n *************");
printf("\n");
cprintf("\r\n Metoda Secantelor ---------------------- 2");
cprintf("\r\n *****************");
printf("\n");
cprintf("\r\n Metoda Injumatatirii Intervalului ------ 3");
cprintf("\r\n *********************************");
printf("\n");
cprintf("\r\n Exit ---------------------------------- 4");
cprintf("\r\n ****");
printf("\n");
textcolor(13);
cprintf("\r\n Introdu metoda dorita");
scanf("%d",&g);
switch(g)
{
case 1:{Newton();break;}
case 2:{Metoda_secantelor();break;}
case 3:{Metoda_Injumatatirii();break;}
case 4:{exit(0);}
}
}
getch();
}