MET BISEC POL

#include <stdio.h>
#include <conio.h>
#include <math.h>
double valpol(int n,double
A[10],double x)
{
int i;
double b;
b=A[n];
for(i=n-1;i>=0;i--)
b=A[i]+x*b;
return b;
}
main()
{
int n;
double A[10];
double i,ls,ld,er,xm,*r;
printf("\neroarea:");
scanf("%lf",&er);
printf("\ngrad:");
scanf("%d",&n);
printf("\nlim st:");
scanf("%lf",&ls);
printf("\nlim dr:");
scanf("%lf",&ld);
for(i=0;i<=n;i++)
{
printf("\ndati coef[%d]:",i);
scanf("%lf",&A[i]);
printf("\nA[i]");
}
if(valpol(n,A,ls)*valpol(n,A,ld)>
0)
{
printf("err");
getche();
return 0;
}
if(valpol(n,A,ls)==0)
{
*r=ls;
return 1;
}
if(valpol(n,A,ld)==0)
{
*r=ld;
return 1;
}
xm=(ls+ld)/2;
while((fabs(ldls)>er)&&(valpol(n,A,xm)!=0))
{
xm=(ls+ld)/2;
if(valpol(n,A,xm)*valpol(n,A,ls)
<0)
ld=xm;
else ls=xm;
}
*r=xm;
printf("\nradacina:%lf",*r);
getche();
return 1;
}
MET BISEC ECT
#include<conio.h>
#include<stdio.h>
#include<math.h>
double f(double x)
{
return exp(x)-1/x;
}
double der(double x)
{
return 2*x+1.5857;
}
int bisectie(/*double(*f)
(double),*/double ls,double
ld,double err,double *sol)
{
double xm;
if(f(ls)*f(ld)>0)
return 0;
if(f(ls)==0)
{
*sol=ls;
return 1;
}
if(f(ld)==0)
{
*sol=ld;
return 1;
}
xm=(ls+ld)/2;
while((fabs(ldls)>err)&&(f(xm)!=0))
{
xm=(ls+ld)/2;
if(f(ls)*f(xm)<0)
ld=xm;
else ls=xm;
}
*sol=xm;
return 1;
}
main()
{
int e;
double ls,ld,err,*sol;
clrscr();
printf("limst:");
scanf("%lf",&ls);

printf("limdr:");
scanf("%lf",&ld);
printf("eroarea:");
scanf("%lf",&err);
e=bisectie(ls,ld,err,sol);
printf("sol:%lf",*sol);
getche();
return e;
MET APROX SUCC
#include <conio.h>
#include <math.h>
double *sol;
double fi (double x)
{
return (-x)*x+2;
}
double Derf(double x)
{
return (-2)*x;
}
/*Functia calculeaza radacina
unei ecuatii prin metoda
aproximatiilor succesive.
Functia intoarce 0 cand se
gaseste radacina cu
aproximatia dorita
1 cand nu se indeplinneste
conditia de convergenta 2 cand
nu se atinge precizia in
numarul de pasi impus*/
int AproxSuc (double ls, double
ld,
double x0, double err,double
NMax,
double *sol)
{
double xn,xn_1,pct,pas=0.001;
int iter,sem=1;
pct=ls;
do { xn=Derf(pct);
if ((Derf(pct))>=1) sem=0;
else pct+=pas;
}
while ((sem==1)&&(pct<=ld));
if (sem==0) return 1;
else xn=x0;
iter=1;
do {
xn_1=xn;
xn=fi(xn_1);
iter++;
}
while((fabs(xnxn_1)>err)&&(iter<=NMax));
*sol=xn;
if (iter<NMax) return 0;
else return 2;
}
main()
{
int i,NMax;
double ls,ld,err,x0;
clrscr();
printf("Calul solutiei unei
ecuatii date, cu metoda
aproximatiilor\ succesive.\n\n");
printf("\nIntroduceti eroarea
maxima dorita:\n\n");
scanf("%lf",&err);
printf("\nIntroduceti valoarea
de start pentru
aproximatii:\nx0= ");
scanf("%lf",&x0);
printf("\n\nIntroduceti limitele
intervalului in care se cauta
solutia:");
printf("\n\nls= ");
scanf("%lf",&ls);
printf("\nld= ");
scanf("%lf",&ld);
printf("\nIntroduceti numarul
maxim de iteratii:\nNMax= ");
scanf("%d",NMax);
printf("\n
%d",AproxSuc(ls,ld,x0,err,NMax
,sol));
printf("Radacina ecuatiei este:\t
%lf",*sol);
getch();
}
MET NW-RAP ECT
#include <conio.h>
#include <math.h>
double *sol;
double f (double x)
{
return (-x)*x+2;
}
double Derf(double x)
{
return (-2)*x;
}
/*Functia calculeaza radacina
unei ecuatii prin metoda
Newton-Raphson pentruecuatii
transcedente.
Functia intoarce 2 cand
derivata este nula 1 cand nu
pot afla radacina cu precizia
dorita 0 in caz de succes*/
int NewtonRaphsonF (double
x0,
double niter,double err,double
*sol)

{
double xn,xn_1,aux;
int cont=1;
xn=x0;
do { xn_1=xn;
if ((aux=Derf(xn_1))==0)
return 2;
xn=xn_1-f(xn_1)/aux;
cont++;
}
while ((fabs(xnxn_1)>err)&&(cont<=niter));
if (cont>=niter) return 1;
*sol=xn;
return 0;
}
main()
{
int i,NMax;
double ls,ld,err,x0;
clrscr();
printf("Calul solutiei unei
ecuatii date, cu metoda
Newton-Raphson\n\n");
printf("\nIntroduceti eroarea
maxima dorita:\n\n");
scanf("%lf",&err);
printf("\nIntroduceti valoarea
de start pentru
aproximatii:\nx0= ");
scanf("%lf",&x0);
printf("\nIntroduceti numarul
maxim de iteratii:\nNMax= ");
scanf("%d",NMax); printf("\n
%d",NewtonRaphsonF(x0,NMax
,err,sol));
printf("Radacina ecuatiei
este:\t %lf",*sol);
getch();

printf("\nIntroduceti numarul
maxim de iteratii:\nNrMax= ");
scanf("%d",NrMax);
printf("\n
%d",NewtonRaphsonP(grad,coe
f,x0,NMax,err,sol));
printf("Radacina ecuatiei
este:\t %lf",*sol);
getch();
}
TRIUNG INFER
#include <conio.h>
#include <math.h>
#define NrMax 10
double sol[NrMax+1];
/*Functia implementeaza
metoda de rezolvare a
sistemelor inferior
triunghiulare. Functia intoarce
determinantul matricei
principale. */
double TRIUNGHIINF (int
or_mat,
double
MAT[NrMax+1][NrMax+1],
double TL[],
double XX[])
{
int i,j;
double d=1;
for(i=1;i<=or_mat;i++)
d*=MAT[i][i];
if (d==0) return 0;
for(i=1;i<=or_mat;i++) {
XX[i]=TL[i];
for(j=1;j<=i-1;j++)
XX[i]=XX[i]-MAT[i][j]*XX[j];
XX[i]=XX[i]/MAT[i]
[i];
}
MET NW-RAP POL
return d;
#include <conio.h>
}
#include <math.h>
main()
#define NMax 10
{
double *sol;
int i,j,n;
/*Functia intoarce valoarea
double mat[NrMax+1]
polinomului intr-un dat */
[NrMax+1],tl[NrMax+1];
double ValPol (int grad,double
clrscr();
coef[],
double point)
printf("Calul radacinilor unui
{int i;
sistem de ecuatii inferior
double aux;
triunghiulare\n");
aux=coef[grad];
printf("\nIntroduceti
for (i=grad-1;i>=0;i--)
dimensiunea matricei patratice
aux=coef[i]+point*aux;
a sistemului:\n\nn= ");
return aux;}
scanf("%d",&n);
/*Functia intoarce valoarea
printf("Introduceti elementele
polinomului intr-un punct dat. matricei pentru sistemul
*/
inferior\
double DerPol ( int grad,double triunghiular:\n");
coef[],double point)
for(i=1;i<=n;i++)
{int i;
for(j=1;j<=i;j++) {
double aux;
printf("mat[%d]
static double B[NMax];
[%d]= ",i,j);
B[grad]=aux=coef[grad];
scanf("%lf",&mat[i]
for (i=grad-1;i>=0;i--)
[j]);
{B[i]=coef[i]+point*B[i+1];
}
aux=B[i]+point*aux;}
for (i=1;i<=n;i++) {
return aux;}
/*Functia intoarce :2 cind
printf("\nIntroduceti termenii
derivata este nula 1 cand nu
liberi ai sistemului:\n\ntl[%d]=
pot afla solutia cu precizia
",i);
dorita 0 in caz de succes*/
scanf("%lf",&tl[i]);
int NewtonRaphsonP (int
}
grad,double coef[],double
printf("Radacinile sistemului
x0,double niter,double err,
sunt:\n");
double *sol)
TRIUNGHIINF(n,mat,tl,sol);
{double xn,xn_1,aux;
for (i=1;i<=n;i++)
int cont=1;
printf("x[%d]%lf\n",i,sol[i]);
xn=x0;
getch();
do { xn_1=xn;
}
if
((aux=DerPol(grad,coef,xn_1)) GAUSS
==0) return 2;
#include <stdio.h>
xn=xn_1#include <math.h>
ValPol(grad,coef,xn_1)/aux;
#include <stdlib.h>
cont++;}
#define ordmat 5
while ((fabs(xnvoid SCHIMB( float *a, float *b)
xn_1)>err)&&(cont<=niter));
{float temp;
if (cont>=niter) return 1;
temp=*a;
*sol=xn;
*a=*b;
return 0;}
*b=temp;}
main()
float gauss(int n,float mat[]
{int i,NrMax,grad;
[ordmat],float tl[],float x[])
double coef[NMax],err,x0;
{int i,k,j,lp;
clrscr();
float m,d,max;
printf("Calul radacinii unui
d=1;
polinom, cu metoda Newtonfor (i=1;i<=n-1;i++)
Raphson\n\n");
{max=fabs(mat[i]
printf("\n\nIntroduceti gradul
[i]);
polinomului\ngrad= ");
lp=i;
scanf("%d",&grad);
for
printf("Introduceti coeficientii (k=i+1;k<=n;k++)
polinomului:\n");
if (fabs(mat[k]
for(i=0;i<=grad;i++)
[i])>max)
{printf("c[%d]= ",i);
{max=fabs(mat[k]
scanf("%lf",&coef[i]);
[i]);
printf("\nIntroduceti eroarea
lp=k;}
maxima dorita:\n\nerr= ");
if(max==0) return
scanf("%lf",&err);
0;
printf("\nIntroduceti valoarea
if (i!=lp)
de start:\nx0= ");
{for (j=1;j<=n;j+
scanf("%lf",&x0);
+) SCHIMB(&mat[i][j],&mat[lp]
[j]);

}
SCHIMB(&tl[i],&tl[lp]);
d=-d;}
for(k=i+1;k<=n;k++)
{m=mat[k]
[i]/mat[i][i];
for(j=i+1;j<=n;j+
+)mat[k][j]=mat[k][j]-m*mat[i]
[j];
tl[k]=tl[k]m*tl[i] ;}}
if (mat[n][n]==0)
return 0;
for (i=1;i<=n;i++)
d*=mat[i][i];
for(i=n;i>=1;i--)
{x[i]=tl[i];
for
(j=n;j>=i+1;j--)x[i]=x[i]-mat[i]
[j]*x[j];
x[i]=x[i]/mat[i]
[i];}
return d;}
void main(void)
{int ord,i,j;
float a[ordmat]
[ordmat],b[ordmat],xx[ordmat];
float fct;
clrscr();
printf("\nDati
ordinul sistemului:N=");
scanf("%d",&ord);
printf("\nDati
coeficientii sistemului:\n");
for(i=1;i<=ord;i+
+)
{for(j=1;j<=ord;j+
+)
{printf("\na[%d]
[%d]=",i,j);
scanf("%f",&a[i]
[j]);}}
printf("\nDati
vectorul termenilor liberi:");
for(i=1;i<=ord;i+
+)
{
printf("b[%d]=",i);
scanf("%f",&b[i]);
}
fct=gauss(ord,a,b,xx);
if(!fct) printf("\nCeva e putred
in DANEMARCA!!!");
else
{

DER 5PCT
#include<stdio.h>
#include<conio.h>
#include<math.h>
double f(double x){
return x*x*x;
}
double d5p(double x0,double
h1, double h2){
return (f(x0-2*h)-8*f(x0-h)
+8*f(x0+h)-f(x0+2*h))/(12*h);
}
void main(void){
double v0,h1,h2;
clrscr();
printf("X0=");
scanf("%lf",&v0);
printf("H1=");
scanf("%lf",&h1);
printf("H2=");
scanf("%lf",&h2);
printf("derivata prin cinci
puncte este:
%lf",d5p(v0,h1,h2));
getch();
}

CUBATUR TRAPEZ
#include <conio.h>
double f(double x,double y)
{
return (x*x+y*y);
}
/*Functia care implementeaza
metoda de cubatura a
trapezului.
Functia intoarce integrala unei
functii de doua variabile.*/
double CurbaturaTrapez(double
sx,
double dx,
double sy,
double dy,
int nx,
int ny)
{
int i,j;
double suma=0,h,k;
h=(dx-sx)/nx;
k=(dy-sy)/ny;
for(i=0;i<=nx-1;i++)
for(j=0;j<=ny-1;j++)
suma+=0.25*h*k*(f(sx+i*h,sy
printf("Determinantul
+j*k)+f(sx+i*h,sy+(j+1)*k)+
sistemului:det=%f\n",fct);
f(sx+(i+1)*h,sy+j*k)+f(sx+
for(i=ord;i>=1;i--)
(i+1)*h,sy+(j+1)*k));
printf("X[%d]=%.2f\n",i,xx[i]); return suma;
}
}
getche();
main()
}
{
double sx,dx,sy,dy,nx,ny;
DER 2PCT
clrscr();
#include <stdio.h>
printf("Introduceti limita stinga
#include<conio.h>
a intervalului de integrare pe
#include<math.h>
axa X.\
double f(double x){
\rsx= ");
return x*x;
scanf("%lf",&sx);
}
printf("Introduceti limita
double d2p(double x0,double
dreapta a inervvalului de
h){
integrare pe axa X.\
return ((f(x0+0.5*h)-f(x0\rdx= ");
0.5*h))/h);
scanf("%lf",&dx);
}
printf("Introduceti limita stinga
void main(void){
a intervalului de integrare pe
double v0,h1;
axa Y.\
clrscr();
\rsy= ");
printf("X0=");
scanf("%lf",&sy);
scanf("%lf",&v0);
printf("Introduceti limita
printf("H=");
dreapta a inervvalului de
scanf("%lf",&h1);
integrare pe axa Y.\
printf("derivata prin doua
\rdy= ");
puncte este:%lf",d2p(v0,h1));
scanf("%lf",&dy);
getch();
printf("Introduceti numarul de
}
subintervale pe axa X.\nnx= ");
DER 3PCT
scanf("%lf",&nx);
#include<stdio.h>
printf("Introduceti numarul de
#include<conio.h>
subintervale pe axa Y.\nny= ");
#include<math.h>
scanf("%lf",&ny);
double f(double x){
printf("Integrala este:
return x*x*x;
%lf\n",CurbaturaTrapez(sx,dx,s
}
y,dy,nx,ny));
double d3p(double x0,double
getch();
h1, double h2){
MET LAGRANGE
return (h1*h1*f(x0+h2)+
#include <conio.h>
(h2*h2-h1*h1)*f(x0)double f(double x)
h2*h2*f(x0-h1))/
{
(h1*h2*(h1+h2));
return (x*x);
}
}
void main(void){
/*Functia care implementeaza
double v0,h1,h2;
metoda lui Lagrange de
clrscr();
interpolare.
printf("X0=");
Functia intoarce valoarea
scanf("%lf",&v0);
interpolata. */
printf("H1=");
double Lagrange(int n,
scanf("%lf",&h1);
double x[10],
printf("H2=");
double y[10],
scanf("%lf",&h2);
double point)
printf("derivata prin trei puncte {
este:%lf",d3p(v0,h1,h2));
int i,j;
getch();
double suma=0,prod;

for(i=0;i<n;i++)
{
prod=1;
for(j=0;j<n;j++)
if(j!=i) prod*=(point-x[j])/(x[i]x[j]);
suma+=y[i]*prod;
}
return suma;
}
main()
{
int n=10,i;
double
x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,.
9},
y[10]={70,140,175,200,225,25
0,265,280,290,300},point=.45;
clrscr();
/* printf("Introduceti numaruln
de puncte.\nn= ");
scanf("%d",&n);
for(i=0;i<n;i++){
printf("Introduceti abscisa
punctului %d.\nx[%d]= ",i,i);
scanf("%lf",&x[i]);
printf("Introduceti ordonata
punctului %d.\ny[%d]= ",i,i);
scanf("%lf",&y[i]);
}
printf("Introduceti punctul in
care se calculeaza
interpolarea.\npoint= ");
scanf("%lf",&point);*/
printf("Integrala este:
%lf\n",Lagrange(n,x,y,point));
getch();
MET NEWTON 1
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza
metoda de interpolare a lui
Newton
de speta intaia.
Functia intoarce valoarea
interpolata. */
double Newton1(int n,
double vi,
double pas,
double y[10],
double point)
{
int i,j;
double suma=y[0],prod=1;
for(i=1;i<=n;i++)
{
for(j=0;j<n;j++) y[j]=y[j+1]y[j];
prod*=(point-(vi+(i-1)*pas))/
(i*pas);
suma+=y[0]*prod;
}
return suma;
}
main()
{
int n,i;
double vi,pas,
y[10]={70,140,175,200,225,25
0,265,280,290,300},point=.45;
clrscr();
printf("Introduceti numarul de
puncte.\nn= ");
scanf("%d",&n);
printf("Introduceti valoarea
abscisei primului punct
cunoscut.\nvi= ");
scanf("%lf",&vi);
printf("introduceti pasul intre
abscisele cunoscute.\npas= ");
scanf("%lf",&pas);/*
for(i=0;i<n;i++){
printf("Introduceti ordonata
punctului %d.\ny[%d]= ",i,i);
scanf("%lf",&y[i]);
}
printf("Introduceti punctul in
care se calculeaza
interpolarea.\npoint= ");
scanf("%lf",&point);*/
printf("Integrala este:
%lf\n",Newton1(n,vi,pas,y,point
));
getch();
}
MET. NEWTON 2
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza
metoda de interpolare a lui
Newton
de speta a doua.
Functia intoarce valoarea
interpolata. */
double Newton2(int n,

double vi,
double pas
double y[10],
double point)
{
int i,j;
double suma=y[n1],prod=1,vf;
vf=vi+(n-1)*pas;
for(i=1;i<=n;i++)
{
for(j=n;j>=i-1;j--) y[j]=y[j]y[j-1];
prod*=(point-(vf-(i-1)*pas))/
(i*pas);
suma+=y[n-1]*prod;
}
return suma;
}
main()
{
int n,i;
double vi,pas,

}
printf("Introduceti punctul in
care se calculeaza
interpolarea.\npoint= ");
scanf("%lf",&point);*/
printf("Integrala este:
%lf\n",NewtonDD(n,x,y,point));
getch();
}

INTERP AITKEN
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza
metoda de interpolare a lui
Aitken
de speta a doua.
Functia intoarce valoarea
interpolata. */
double Aitken(int n,
double x[],
y[10]={70,140,175,200,225,25
double y[],
0,265,280,290,300},point=.45;
double point)
clrscr();
{
printf("Introduceti numarul de
int i,j;
puncte.\nn= ");
for(i=0;i<n;i++)
scanf("%d",&n);
for(j=i;j<n;j++)
printf("Introduceti valoarea
y[j]=y[i-1]*(point-x[j])/(x[iabscisei primului punct
1]-x[j])+y[j]*(point-x[i-1])/(x[j]cunoscut.\nvi= ");
x[i-1]);
scanf("%lf",&vi);
return y[n-1];
printf("introduceti pasul intre
}
abscisele cunoscute.\npas= "); main()
scanf("%lf",&pas);
{
/* for(i=0;i<n;i++){
int n,i;
printf("Introduceti double
ordonata punctului
x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,.
%d.\ny[%d]= ",i,i);
9},
scanf("%lf",&y[i]);
}
y[10]={70,140,175,200,225,25
printf("Introduceti punctul in
0,265,280,290,300},point=.45;
care se calculeaza
clrscr();
interpolarea.\npoint= ");
printf("Introduceti numarul de
scanf("%lf",&point);*/
puncte.\nn= ");
printf("Integrala este:
scanf("%d",&n);
%lf\n",Newton2(n,vi,pas,y,point /* for(i=0;i<n;i++){
));
printf("Introduceti
getch();
abscisa punctului %d.\nx[%d]=
MET NEWT DIFER DIV
",i,i);
#include <conio.h>
scanf("%lf",&x[i]);
double f(double x)
printf("Introduceti
{
ordonata punctului
return (x*x);
%d.\ny[%d]= ",i,i);
}
scanf("%lf",&y[i]);
/*Functia care implementeaza
}
metoda de interpolare a lui
printf("Introduceti punctul in
Newton
care se calculeaza
cu diferenta divizata.
interpolarea.\npoint= ");
Functia intoarce valoarea
scanf("%lf",&point);*/
interpolata. */
/* for(i=0;i<n;i++){
double NewtonDD(int n,
printf("Introduceti
double x[],
ordonata punctului
double y[],
%d.\ny[%d]= ",i,i);
double point)
scanf("%lf",&y[i]);
{
}
int i,j;
printf("Introduceti punctul in
double sum=y[0],prod=1;
care se calculeaza
for(i=1;i<=n;i++)
interpolarea.\npoint= ");
{
scanf("%lf",&point);*/
for(j=0;j<=n-i;j++)
printf("Integrala este:
y[j]=(y[j+1]-y[j])/(x[j+1]%lf\n",Aitken(n,x,y,point));
x[j]);
getch();
prod*=(point-x[i}
1]);
INTER FCT. RERIOD
sum+=y[0]*prod; #include <conio.h>
}
#include <math.h>
return sum;
#define pi 3.141592
}
double f(double x)
main()
{
{
return sin(x);
int n,i;
}
double
/*Functia care implementeaza
x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,. metoda de interpolare a
9},
functiilor periodice.
Functia intoarce valoarea
y[10]={70,140,175,200,225,25 interpolata. */
0,265,280,290,300},point=.45; double IFPer(int n,double
clrscr();
x[],double y[], double T,double
printf("Introduceti numarul de point)
puncte.\nn= ");
{
scanf("%d",&n);
int i,j;
/* for(i=0;i<n;i++){
double sum=0,prod=1;
printf("Introduceti
for(i=0;i<n;i++)
abscisa punctului %d.\nx[%d]=
{
",i,i);
for(j=0;j<n;j++) if(j!=i)
scanf("%lf",&x[i]); prod*=sin(pi*(pointprintf("Introduceti x[j])/T)/sin(pi*(x[j])/T);
ordonata punctului
sum+=y[i]*prod;
%d.\ny[%d]= ",i,i);
}
scanf("%lf",&y[i]);
return sum;
}
}
printf("Introduceti punctul in
main()
care se calculeaza
{
interpolarea.\npoint= ");
int n,i;
scanf("%lf",&point);*/
double
/* for(i=0;i<n;i++){
x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,.
printf("Introduceti 9},
ordonata punctului
%d.\ny[%d]= ",i,i);
y[10]={70,140,175,200,225,25
scanf("%lf",&y[i]);

0,265,280,290,300},point=.45,
T;
clrscr();
printf("Introduceti numarul de
puncte.\nn= ");
scanf("%d",&n);
/* for(i=0;i<n;i++){
printf("Introduceti
abscisa punctului %d.\nx[%d]=
",i,i);
scanf("%lf",&x[i]);
printf("Introduceti
ordonata punctului
%d.\ny[%d]= ",i,i);
scanf("%lf",&y[i]);
}
printf("Introduceti punctul in
care se calculeaza
interpolarea.\npoint= ");
scanf("%lf",&point);*/
printf("Introduceti perioada
T=");
sprintf("%lf",&T);
printf("Integrala este:
%lf\n",IFPer(n,x,y,T,point));
getch();
}
MET DREPTUNGHI
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza
metoda de integrare a
dreptunghiului.
Functia intoarce valoarea
integralei.
*/
double DreptunghiF(double ls,
double ld,
double nrpas)
{
double i;
double suma=0,h;
h=(ld-ls)/nrpas;
for(i=0;i<=nrpas-1;i++)
suma+=h*f(ls+i*h);
return suma;
}
main()
{
double ls,ld,nrpas;
clrscr();
printf("Introduceti limita stinga
a inervvalului de
integrare.\nls= ");
scanf("%lf",&ls);
printf("Introduceti limita
dreapta a inervvalului de
integrare.\nld= ");
scanf("%lf",&ld);
printf("Introduceti numarul de
subintervale.\nnrpas= ");
scanf("%lf",&nrpas);
printf("Integrala este:
%lf\n",DreptunghiF(ls,ld,nrpas))
;
getch();
}
MET INTEGRARE TRAPEZ
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza
metoda de integrare a
trapezului.
Functia intoarce valoarea
integralei.
*/
double TrapezF(double ls,
double ld,
double nrpas)
{
double i;
double suma,h;
h=(ld-ls)/nrpas;
suma=0.5*h*(f(ls)+f(ld));
for(i=1;i<=nrpas-1;i++)
suma+=h*f(ls+i*h);
return suma;
}
main()
{
double ls,ld,nrpas;
clrscr();
printf("Introduceti limita stinga
a inervvalului de
integrare.\nls= ");
scanf("%lf",&ls);
printf("Introduceti limita
dreapta a inervvalului de
integrare.\nld= ");
scanf("%lf",&ld);
printf("Introduceti numarul de
subintervale.\nnrpas= ");
scanf("%lf",&nrpas);
printf("Integrala este:
%lf\n",TrapezF(ls,ld,nrpas));
getch()
}

INTEGR RICHARD
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza
metoda de integrare a lui
Richardson.
Functia intoarce valoarea
integralei.
*/
double RichardsonF(double ls,

double dx, double sy, double

dy, int nx, int ny)
{
double sum=0, h, k;
int i, j;
h=(dx-sx)/nx;
k=(dy-sy)/ny;
for(i=0;i<=nx-1;i++)
for(j=0;j<=ny-1;j++)
sum+=0.25*h*k*(f(sx+i*h,sy+j
*k)+f(sx+i*h,sy+(j+1)*k)
+f(sx+(i+1)*h,sy+j*k)+f(sx+
(i+1)*h,sy+(j+1)*k));
return sum;}
double ld,
void main(void)
{double sx, dx, sy, dy;
double nrpash,
int nx, ny;
clrscr();
double nrpask)
printf("Introduceti limita inf. a
{
domeniului x: ");
double i;
scanf("%lf",&sx);
double
printf("Introduceti limita sup. a
suma,sumah,sumak,h,k;
domeniului x: ");
h=(ld-ls)/nrpash;
scanf("%lf",&dx);
k=(ld-ls)/nrpask;
printf("Introduceti limita inf. a
sumah=0.5*h*(f(ls)+f(ld)); domeniului y: ");
sumak=0.5*k*(f(ls)+f(ld)); scanf("%lf",&sy);
for(i=1;i<=nrpash-1;i++)
printf("Introduceti limita sup. a
sumah+=h*f(ls+i*h);
domeniului y: ");
for(i=1;i<=nrpask-1;i++)
scanf("%lf",&dy);
sumak+=k*f(ls+i*k);
printf("Introduceti nr. pasilor pe
suma=sumah+(sumahdomeniului x: ");
sumak)/((k*k)/(h*h)-1);
scanf("%d",&nx);
return suma;
printf("Introduceti nr. pasilor pe
}
domeniului y: ");
main()
scanf("%d",&ny);
{
printf("Integrala este:%lf
double ls,ld,nrpash,nrpask;
",cub(f,sx,dx,sy,dy,nx,ny));
clrscr();
getch();
printf("Introduceti limita stinga }
a inervalului de integrare.\nls= CUBATURA SIMSON
");
#include<stdio.h>
scanf("%lf",&ls);
#include<conio.h>
printf("Introduceti limita
#include<math.h>
dreapta a inervalului de
double f(double x,double y)
integrare.\nld= ");
{return(x+y);
scanf("%lf",&ld);
}
printf("Introduceti numarul de double CubaturaS(double(*f)
subintervale pt.diviziunea
(double,double),
nr:1.\nnrpash= ");
double sx,
scanf("%lf",&nrpash);
double dx,
printf("Introduceti numarul de
double sy,
subintervale pt.diviziunea
double dy,
nr:2.\nnrpask= ");
int nx,
scanf("%lf",&nrpask);
int ny)
printf("Integrala este:
{ double
%lf\n",RichardsonF(ls,ld,nrpash, suma=0,h,k;
nrpask));
int i,j;
getch();
h=(dx-sx)/nx;
}
k=(dy-sy)/ny;
MET INTEGR SIMSON
for(i=1;i<=nx#include <conio.h>
1;i+=2)
double f(double x)
for(j=1;j<=ny{
1;j+=2)
return (x*x);
}
suma+=h*k*(f(sx+(i-1)*h,sy+
/*Functia care implementeaza (j-1)*k)+f(sx+(i+1)*h,sy+(jmetoda de integrare a lui
1)*k)+f(sx+(i-1)*h,sy+(j+1)*k)
Simpson.
+f(sx+(i+1)*h,sy+(j+1)*k)+
Functia intoarce valoarea
4*f(sx+i*h,sy+
integralei.
(j+1)*k)+4*f(sx+i*h,sy+(j-1)*k)
*/
+4*f(sx+(i-1)*h,sy+j*k)
double SimpsonF(double
+4*f(sx+(i+1)*h,sy+j*k)
ls,double ld,int nrpas)
+16*f(sx+i*h,sy+j*k))/9;
{
return suma;
int i;
}
double suma,h;
void main()
h=(ld-ls)/nrpas;
{
suma=h*(f(ls)+f(ld))/3.0;
double ax,bx,ay,by;
for(i=1;i<=nrpas-1;i++)
int n,m;
suma+=2*(1+i
clrscr();
%2)*h*f(ls+i*h)/3.0;
printf("Introduceti
return suma;}
limitele domeniului de
main()
integrare:\n");
{double ls,ld,nrpas;
clrscr();
printf("sx=");scanf("%lf",&ax);
printf("Introduceti limita stinga
a inervvalului de
printf("dx=");scanf("%lf",&bx);
integrare.\nls= ");
scanf("%lf",&ls);
printf("sy=");scanf("%lf",&ay);
printf("Introduceti limita
dreapta a inervvalului de
printf("dy=");scanf("%lf",&by);
integrare.\nld= ");
printf("Numarul pe
scanf("%lf",&ld);
pasi pe Ox:");scanf("%d",&n);
printf("Introduceti numarul de
printf("Numarul de
subintervale.\nnrpas= ");
pasi pe Oy:");scanf("%d",&m);
scanf("%lf",&nrpas);
printf("Valoarea
printf("Integrala este:
integralei este:
%lf\n",Simpson
%lf",CubaturaS(*f,ax,bx,ay,by,n
F(ls,ld,nrpas));
,m));
getch();
getche();
}
}
CUBATURA TRAPEZ
REGR LINIARA
#include<stdio.h>
#include <conio.h>
#include<conio.h>
/*Functia ce inplementeaza
#include<math.h>
regresia liniara */
double f(double x, double y)
void RegGeo(int nrp,
{
double x[],
return x*y;
double y[],
}
double *coef1,
double cub(double (*f)
double *coef2)
(double,double), double sx,
{

double
sx=0,sy=0,sxx=0,sxy=0;
int i;
for (i=1;i<nrp;i++)
{
sx+=log(x[i]);
sy+=log(y[i]);
sxy+=log(x[i])*log(y[i]);
sxx+=log(x[i])*log(x[i]);
}
*coef2=(nrp*sxy-sx*sy)/
(nrp*sxx-sx*sx);
*coef1=exp((sy*sxx-sx*sxy)/
(nrp*sxx-sx*sx));
}
void main()
{
int nrp,i;
double x[10],y[10],coef1,coef2;
printf("\nIntroduceti nr de
puncte:\nnrp= ");
scanf("%d",&nrp);
printf("\nIntroduceti
punctele:\n");
for(i=0;i<nrp;i++) {
RegGeo(nrp,x,y,&coef1,&coef2)
;
printf("Functia este: %lf*x*
%lf*x",coef1,coef2);
getch();
}
REG GEO
#include<stdio.h>
#include<conio.h>
#include<math.h>
#define NRMAX 10
void RegGeo(int nrp,double
x[],double y[],double *coef1,
double *coef2)
{
double sx=0,sy=0,
sxx=0,sxy=0;
int i;
for(i=1;i<=nrp;i++)
{
sx+=log(x[i]);
sy+=log(y[i]);
sxy+=log(x[i])*log(y[i]);
sxx+=log(x[i])*log(x[i]);
}
*coef2=(nrp*sxy-sx*sy)/
(nrp*sxx-sx*sx);
*coef1=exp((sy*sxx-sx*sxy)/
(nrp*sx-sx*sx));
}
void main ()
{int i, nrp;
double x[NRMAX],y[NRMAX];
double coef1, coef2;
printf("\n introduceti nrp=");
scanf("%d",&nrp);
for(i=1;i<=nrp;i++)
{printf("\n introduceti
x[%d]=",i);
scanf("%lf",&x[i]);
printf("\n introduceti
y[%d]=",i);
scanf("%lf",&y[i]);
}
RegGeo(nrp,x,y,&coef1,&coef2)
;
printf("\n coef1 este =
%lf",coef1);
printf("\n coef2 fste=
%lf",coef2);
getche();
}