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(ld-ls)>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();
}

MET NW-RAP POL

#include <conio.h>
#include <math.h>
#define NMax 10
double *sol;
/*Functia intoarce valoarea polinomului
intr-un dat */
double ValPol (int grad,double coef[],
double point)
{int i;
double aux;
aux=coef[grad];
for (i=grad-1;i>=0;i--) aux=coef[i]
+point*aux;
return aux;}
/*Functia intoarce valoarea polinomului
intr-un punct dat. */
double DerPol ( int grad,double
coef[],double point)
{int i;
double aux;
static double B[NMax];
B[grad]=aux=coef[grad];
for (i=grad-1;i>=0;i--)
{B[i]=coef[i]+point*B[i+1];
aux=B[i]+point*aux;}
return aux;}
/*Functia intoarce :2 cind derivata este
nula 1 cand nu pot afla solutia cu precizia
dorita 0 in caz de succes*/
int NewtonRaphsonP (int grad,double
coef[],double x0,double niter,double err,
double *sol)
{double xn,xn_1,aux;
int cont=1;
xn=x0;
do { xn_1=xn;
if ((aux=DerPol(grad,coef,xn_1))==0)
return 2;
xn=xn_1-ValPol(grad,coef,xn_1)/aux;
cont++;}
while ((fabs(xnxn_1)>err)&&(cont<=niter));
if (cont>=niter) return 1;
*sol=xn;
return 0;}
main()
{int i,NrMax,grad;
double coef[NMax],err,x0;
clrscr();
printf("Calul radacinii unui polinom, cu
metoda Newton-Raphson\n\n");
printf("\n\nIntroduceti gradul
polinomului\ngrad= ");
scanf("%d",&grad);
printf("Introduceti coeficientii
polinomului:\n");
for(i=0;i<=grad;i++)
{printf("c[%d]= ",i);
scanf("%lf",&coef[i]);
printf("\nIntroduceti eroarea maxima
dorita:\n\nerr= ");
scanf("%lf",&err);
printf("\nIntroduceti valoarea de
start:\nx0= ");
scanf("%lf",&x0);
printf("\nIntroduceti numarul maxim de
iteratii:\nNrMax= ");
scanf("%d",NrMax);
printf("\n
%d",NewtonRaphsonP(grad,coef,x0,NMa
x,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];
}
return d;
}
main()
{
int i,j,n;
double mat[NrMax+1]
[NrMax+1],tl[NrMax+1];
clrscr();
printf("Calul radacinilor unui sistem de
ecuatii inferior triunghiulare\n");
printf("\nIntroduceti dimensiunea
matricei patratice a sistemului:\n\nn= ");
scanf("%d",&n);
printf("Introduceti elementele matricei
pentru sistemul inferior\
triunghiular:\n");
for(i=1;i<=n;i++)
for(j=1;j<=i;j++) {
printf("mat[%d][%d]= ",i,j);
scanf("%lf",&mat[i][j]);
}
for (i=1;i<=n;i++) {
printf("\nIntroduceti termenii
liberi ai sistemului:\n\ntl[%d]= ",i);
scanf("%lf",&tl[i]);
}
printf("Radacinile sistemului sunt:\n");
TRIUNGHIINF(n,mat,tl,sol);
for (i=1;i<=n;i++)
printf("x[%d]%lf\n",i,sol[i]);
getch();
}

GAUSS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define ordmat 5
void SCHIMB( float *a, float *b)
{float temp;
temp=*a;
*a=*b;
*b=temp;}
float gauss(int n,float mat[][ordmat],float
tl[],float x[])
{int i,k,j,lp;
float m,d,max;
d=1;
for (i=1;i<=n-1;i++)
{max=fabs(mat[i][i]);
lp=i;
for (k=i+1;k<=n;k++)
if (fabs(mat[k][i])>max)
{max=fabs(mat[k][i]);
lp=k;}
if(max==0) return 0;
if (i!=lp)
{for (j=1;j<=n;j++)
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
{
printf("Determinantul
sistemului:det=%f\n",fct);
for(i=ord;i>=1;i--)
printf("X[%d]=%.2f\n",i,xx[i]);
}
getche();
}

DER 2PCT
#include <stdio.h>
#include<conio.h>
#include<math.h>
double f(double x){
return x*x;
}
double d2p(double x0,double h){
return ((f(x0+0.5*h)-f(x0-0.5*h))/h);
}
void main(void){
double v0,h1;
clrscr();
printf("X0=");
scanf("%lf",&v0);
printf("H=");
scanf("%lf",&h1);
printf("derivata prin doua puncte este:
%lf",d2p(v0,h1));
getch();
}
DER 3PCT
#include<stdio.h>
#include<conio.h>
#include<math.h>
double f(double x){
return x*x*x;
}
double d3p(double x0,double h1, double
h2){
return (h1*h1*f(x0+h2)+(h2*h2h1*h1)*f(x0)-h2*h2*f(x0-h1))/
(h1*h2*(h1+h2));
}
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 trei puncte este:
%lf",d3p(v0,h1,h2));
getch();
}
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+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 suma;
}
main()
{
double sx,dx,sy,dy,nx,ny;
clrscr();
printf("Introduceti limita stinga a
intervalului de integrare pe axa X.\
\rsx= ");
scanf("%lf",&sx);
printf("Introduceti limita dreapta a
inervvalului de integrare pe axa X.\
\rdx= ");
scanf("%lf",&dx);
printf("Introduceti limita stinga a
intervalului de integrare pe axa Y.\
\rsy= ");
scanf("%lf",&sy);
printf("Introduceti limita dreapta a
inervvalului de integrare pe axa Y.\
\rdy= ");
scanf("%lf",&dy);
printf("Introduceti numarul de
subintervale pe axa X.\nnx= ");
scanf("%lf",&nx);
printf("Introduceti numarul de
subintervale pe axa Y.\nny= ");
scanf("%lf",&ny);
printf("Integrala este:
%lf\n",CurbaturaTrapez(sx,dx,sy,dy,nx,ny
));
getch();
}

MET LAGRANGE
#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza metoda lui
Lagrange de interpolare.
Functia intoarce valoarea interpolata. */
double Lagrange(int n,
double x[10],
double y[10],
double point)
{
int i,j;
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,250,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,250,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[n-1],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,
y[10]={70,140,175,200,225,250,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",Newton2(n,vi,pas,y,point));
getch();
}

MET NEWT DIFER DIV

#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza metoda de
interpolare a lui Newton
cu diferenta divizata.
Functia intoarce valoarea interpolata. */
double NewtonDD(int n,
double x[],
double y[],
double point)
{
int i,j;
double sum=y[0],prod=1;
for(i=1;i<=n;i++)
{
for(j=0;j<=n-i;j++)
y[j]=(y[j+1]-y[j])/(x[j+1]-x[j]);
prod*=(point-x[i-1]);
sum+=y[0]*prod;
}
return sum;
}
main()
{
int n,i;
double x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,.9},
y[10]={70,140,175,200,225,250,265,280,
290,300},point=.45;
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);*/
/* 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",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[],
double y[],
double point)
{
int i,j;
for(i=0;i<n;i++)
for(j=i;j<n;j++)
y[j]=y[i-1]*(point-x[j])/(x[i-1]-x[j])
+y[j]*(point-x[i-1])/(x[j]-x[i-1]);
return y[n-1];
}
main()
{
int n,i;
double x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,.9},
y[10]={70,140,175,200,225,250,265,280,
290,300},point=.45;
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);*/
/* 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",Aitken(n,x,y,point));
getch();
}

INTER FCT. RERIOD

#include <conio.h>
#include <math.h>
#define pi 3.141592
double f(double x)
{
return sin(x);
}
/*Functia care implementeaza metoda de
interpolare a functiilor periodice.
Functia intoarce valoarea interpolata. */
double IFPer(int n,double x[],double y[],
double T,double point)
{
int i,j;
double sum=0,prod=1;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++) if(j!=i)
prod*=sin(pi*(pointx[j])/T)/sin(pi*(x[j])/T);
sum+=y[i]*prod;
}
return sum;
}
main()
{
int n,i;
double x[10]={0,.1,.2,.3,.4,.5,.6,.7,.8,.9},
y[10]={70,140,175,200,225,250,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 ld,
double nrpash,
double nrpask)
{
double i;
double suma,sumah,sumak,h,k;
h=(ld-ls)/nrpash;
k=(ld-ls)/nrpask;
sumah=0.5*h*(f(ls)+f(ld));
sumak=0.5*k*(f(ls)+f(ld));
for(i=1;i<=nrpash-1;i++)
sumah+=h*f(ls+i*h);
for(i=1;i<=nrpask-1;i++)
sumak+=k*f(ls+i*k);
suma=sumah+(sumah-sumak)/((k*k)/
(h*h)-1);
return suma;
}
main()
{
double ls,ld,nrpash,nrpask;
clrscr();
printf("Introduceti limita stinga a
inervalului de integrare.\nls= ");
scanf("%lf",&ls);
printf("Introduceti limita dreapta a
inervalului de integrare.\nld= ");
scanf("%lf",&ld);
printf("Introduceti numarul de
subintervale pt.diviziunea nr:1.\nnrpash=
");
scanf("%lf",&nrpash);
printf("Introduceti numarul de
subintervale pt.diviziunea nr:2.\nnrpask=
");
scanf("%lf",&nrpask);
printf("Integrala este:
%lf\n",RichardsonF(ls,ld,nrpash,nrpask));
getch();
}

MET INTEGR SIMSON

#include <conio.h>
double f(double x)
{
return (x*x);
}
/*Functia care implementeaza metoda de
integrare a lui Simpson.
Functia intoarce valoarea integralei.
*/
double SimpsonF(double ls,double ld,int
nrpas)
{
int i;
double suma,h;
h=(ld-ls)/nrpas;
suma=h*(f(ls)+f(ld))/3.0;
for(i=1;i<=nrpas-1;i++)
suma+=2*(1+i%2)*h*f(ls+i*h)/3.0;
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",Simpson
F(ls,ld,nrpas));
getch();
}

CUBATURA TRAPEZ
#include<stdio.h>
#include<conio.h>
#include<math.h>
double f(double x, double y)
{
return x*y;
}
double cub(double (*f)(double,double),
double sx, 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;}
void main(void)
{double sx, dx, sy, dy;
int nx, ny;
clrscr();
printf("Introduceti limita inf. a domeniului
x: ");
scanf("%lf",&sx);
printf("Introduceti limita sup. a
domeniului x: ");
scanf("%lf",&dx);
printf("Introduceti limita inf. a domeniului
y: ");
scanf("%lf",&sy);
printf("Introduceti limita sup. a
domeniului y: ");
scanf("%lf",&dy);
printf("Introduceti nr. pasilor pe
domeniului x: ");
scanf("%d",&nx);
printf("Introduceti nr. pasilor pe
domeniului y: ");
scanf("%d",&ny);
printf("Integrala este:%lf
",cub(f,sx,dx,sy,dy,nx,ny));
getch();
}

CUBATURA SIMSON
#include<stdio.h>
#include<conio.h>
#include<math.h>
double f(double x,double y)
{return(x+y);
}
double CubaturaS(double(*f)
(double,double),
double sx,
double dx,
double sy,
double dy,
int nx,
int ny)
{ double suma=0,h,k;
int i,j;
h=(dx-sx)/nx;
k=(dy-sy)/ny;
for(i=1;i<=nx-1;i+=2)
for(j=1;j<=ny-1;j+=2)
suma+=h*k*(f(sx+(i1)*h,sy+(j-1)*k)+f(sx+(i+1)*h,sy+(j1)*k)+f(sx+(i-1)*h,sy+(j+1)*k)+f(sx+
(i+1)*h,sy+(j+1)*k)+
4*f(sx+i*h,sy+(j+1)*k)
+4*f(sx+i*h,sy+(j-1)*k)+4*f(sx+(i1)*h,sy+j*k)+4*f(sx+(i+1)*h,sy+j*k)
+16*f(sx+i*h,sy+j*k))/9;
return suma;
}
void main()
{
double ax,bx,ay,by;
int n,m;
clrscr();
printf("Introduceti limitele
domeniului de integrare:\n");
printf("sx=");scanf("%lf",&ax);
printf("dx=");scanf("%lf",&bx);
printf("sy=");scanf("%lf",&ay);
printf("dy=");scanf("%lf",&by);
printf("Numarul pe pasi pe
Ox:");scanf("%d",&n);
printf("Numarul de pasi pe
Oy:");scanf("%d",&m);
printf("Valoarea integralei
este:
%lf",CubaturaS(*f,ax,bx,ay,by,n,m));
getche();
}

printf("\n coef2 fste=%lf",coef2);

getche();
}
REGR LINIARA
#include <conio.h>
/*Functia ce inplementeaza regresia
liniara */
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*sxxsx*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*sxsx*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);

REG HYP
#include <conio.h>
/*Functia ce inplementeaza regresia
liniara */
void RegHip(int nrp,
double *x,
double *y,
double *coef1,
double *coef2)
{
double sx=0,sy=0,sxx=0,sxy=0;
int i;
for (i=0;i<nrp;i++)
{
sx+=x[i];
sy+=1/y[i];
sxy+=x[i]/y[i];
sxx+=x[i]*x[i];
}
*coef1=(nrp*sxy-sx*sy)/(nrp*sxx-sx*sx);
*coef2=(sy*sxx-sx*sxy)/(nrp*sxx-sx*sx);

printf("Functia este: %lf*x*

%lf*x",coef1,coef2);
getch();
}
REGR TRIGONOM
#include <conio.h>
#include <math.h>
#define pi 3.141592
/*Regresia trigonometrica*/
/*Functia ce inplementeaza regresia
trigonometrica*/
void RegTrig(int n,
double x[],
double y[],
double w,
double *coef1,
double *coef2)
{
double sx=0,sy=0,sxx=0,sxy=0;
int i;
for (i=0;i<n;i++)
{
sx+=cos(w*x[i]);
sy+=y[i];
sxy+=cos(w*x[i])*y[i];

}
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++) {
RegHip(nrp,x,y,&coef1,&coef2);
printf("Functia este: %lf*x+
%lf",coef1,coef2);
getch();
}
REGR EXPON
#include <conio.h>
/*Functia ce inplementeaza regresia
liniara */
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*sxxsx*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);

sxx+=cos(w*x[i])*cos(w*x[i]);
}
*coef2=(n*sxy-sx*sy)/(n*sxx-sx*sx);
*coef1=(sy*sxx-sx*sxy)/(n*sxx-sx*sx);
}
void main()
{
int nrp,i;
double x[10]={0,pi/6,pi/4,pi/3,pi/2,2*pi},
y[10],
coef1,coef2,w=1;
y[0]=2; y[1]=1+sqrt(3)/2;
y[2]=1+sqrt(2)/2; y[3]=3/2; y[4]=1;
y[5]=2;
printf("\nIntroduceti nr de puncte:\nnrp=
");
scanf("%d",&nrp);
printf("\nIntroduceti punctele:\n");
//for(i=0;i<nrp;i++) {
}
RegTrig(nrp,x,y,w,&coef1,&coef2);
printf("A este: %lf",coef1);
printf(" B este: %lf",coef2);
getch();
}

RK 4
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define max 100
double solutie(double x)
{
return exp(0.5*(x*x-1));
}
double f(double x , double y)
{
return x*y;
}
void RK4(double (*f)(double,double),
double x0,
double y0,
double pas,
int nrp,
double sol[])
{
int i;
double k1,k2,k3,k4;
sol[0]=y0;
for(i=1;i<nrp;i++)
{
k1=f(x0+(i-1)*pas,sol[i-1]);
k2=f(x0+(i1)*pas+0.5*pas,sol[i-1]+0.5*pas*k1);
k3=f(x0+(i1)*pas+0.5*pas,sol[i-1]+0.5*pas*k2);
k4=f(x0+i*pas,sol[i1]+pas*k3);
sol[i]=sol[i1]+pas*(k1+2*k2+2*k3+k4)/6;
}
}
void main(void)
{
int nrp,i;
double x0,y0,pas, sol[max];
clrscr();
printf("Dati conditia initiala:\n ");
printf("x0=");
scanf("%lf",&x0);
printf("y0=");
scanf("%lf",&y0);
printf("Dati numarul de puncte de
calcul:");
scanf("%d",&nrp);
printf("Dati pasul de calcul: ");
scanf("%lf",&pas);
RK4(f,x0,y0,pas,nrp,sol);
for(i=0;i<nrp;i++)
{
printf("\n%lf
%lf",sol[i],solutie(x0));
x0+=pas;
}
getch();
}

EULER IMBUNAT
#include<stdio.h>
#include<conio.h>
#include<math.h>
#define MAX 10
double f(double x,double y)
{
return y/x;
}
void eulerimb(double(*f)(double x,double
y),double x0,double y0,double h,int
n,double y[MAX])
{
int i;
float x[MAX];
y[0]=y0;
x[0]=x0;
for(i=1;i<n;i++)
{
x[i]=x[i-1]+i*h;
y[i]=y[i-1]+h*(f(x[i1]+0.5*h,y[i-1])+0.5*h*f(x[i-1],y[i-1]));
}
}
void main()
{
int i,n;
double x0,y0,p,h;
double y[MAX];
clrscr();
printf("Introduceti x0:");
scanf("%lf",&x0);
printf("\nIntroduceti y0:");
scanf("%lf",&y0);
printf("\ndati pasul:");
scanf("%lf",&h);
printf("\n nr. de pasi:");
scanf("%d",&n);
eulerimb(f,x0,y0,h,n,y);
printf("\nsolutia este");
for(i=0;i<n;i++)
printf("\ny[%d]= %lf",i,y[i]);
getch();
}

EULER MODIF
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define max 100
double solutie(double x)
{
return exp(0.5*(x*x-1));
}
double f(double x , double y)
{
return x*y;
}
void eulmod(double (*f)(double,double),
double x0, double y0, double
pas, int nrp, double sol[])
{
int i;
sol[0]=y0;
for(i=1;i<nrp;i++)
{
sol[i]=sol[i-1]+pas*f(x0+(i1)*pas+0.5*pas,sol[i-1]+
0.5*pas*f(x0+(i-1)*pas,sol[i1]));
}
}
void main(void)
{
int nrp,i;
double x0,y0,pas, sol[max];
clrscr();
printf("Dati conditia initiala:\n ");
printf("x0=");
scanf("%lf",&x0);
printf("y0=");
scanf("%lf",&y0);
printf("Dati numarul de puncte de
calcul:");
scanf("%d",&nrp);
printf("Dati pasul de calcul: ");
scanf("%lf",&pas);
eulmod(f,x0,y0,pas,nrp,sol);
for(i=0;i<nrp;i++)
{
printf("\n%lf
%lf",sol[i],solutie(x0));
x0+=pas;
}
getch();
}