Metoda elimin[rii (Gauss)

/**************************************************************************
Metoda eliminarii (Gauss)
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#define N 100

// Numarul de necunoscute

float a[N][N];
float b[N];
float x[N];

// Matricea coeficientilor
// Termenii liberi
// Vectorul necunoscutelor

/**************************************************************************
Prototipuri
**************************************************************************/
void CitSis(float a[][N], float b[], int n);
void ScrieSis(float a[][N], float b[], int n);
void ScrieSol(float x[], int n);
int Gauss(float a[][N], float b[], float x[], int n);
int GaussP(float a[][N], float b[], float x[], int n);
void Schimba(float a[][N], float b[], int n, int i, int j);
/**************************************************************************
Functia main
**************************************************************************/
void main(void)
{
int n,i,j;
clrscr();
printf("Metoda Gauss\r\n");
printf("============\r\n\r\n");
fflush(stdin);
printf("Numar necunoscute: n="); scanf("%d",&n);
CitSis(a,b,n);
ScrieSis(a,b,n);
if(GaussP(a,b,x,n))
{
printf("\r\nSistem incompatibil sau nedeterminat\r\n");
}
else ScrieSol(x,n);
printf("Apasa o tasta !\r\n"); getch();
}// end main

/**************************************************************************
Functii utilizator
**************************************************************************/
void CitSis(float a[][N], float b[], int n)
/**************************************************************************
Citeste coeficientii
**************************************************************************/
{
int i,j;
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
printf("a(%d,%d)=",i+1,j+1); scanf("%f",&a[i][j]);
}// end for j
printf("b(%d)=",i+1); scanf("%f",&b[i]);
}// end for i
}// end CitSis
void ScrieSis(float a[][N], float b[], int n)
/**************************************************************************
Afiseaza sistemul
**************************************************************************/
{
int i,j;
printf("\r\nSistemul:\r\n");
for(i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
printf("%8.3f ",a[i][j]);
}// end for j
printf("%8.3f\r\n",b[i]);
}// end for i
}// end ScrieSis
void ScrieSol(float x[], int n)
/**************************************************************************
Afiseaza solutia
**************************************************************************/
{
int i;
printf("\r\nSolutia:\r\n");
for(i=0; i<n; i++)
{
printf("%8.3f ",x[i]);
}// end for i
printf("\r\n");
}// end ScrieSol

int GaussP(float a[][N], float b[], float x[], int n)

/**************************************************************************
Metoda eliminarii cu pivotare partiala
Valoare returnata:
0 - sistem compatibil
1 - sistem nedeterminat sau incompatibil
**************************************************************************/
{
int i,j,k;
float t;
for(i=0; i<n-1; i++)
{
for(j=i+1; j<n; j++) if(fabs(a[i][i])<fabs(a[j][i])) Schimba(a,b,n,i,j);
for(j=i+1; j<n; j++)
{
if(a[i][i]==0) return 1;
t=a[j][i]/a[i][i];
for(k=i+1; k<n; k++) a[j][k]=a[j][k]-t*a[i][k];
b[j]=b[j]-t*b[i]; a[j][i]=0;
}// end for j
}// end for i
if(a[n-1][n-1]==0) return 1;
x[n-1]=b[n-1]/a[n-1][n-1];
for(i=n-2; i>=0; i--)
{
t=0; for(k=i+1; k<n; k++) t=t+a[i][k]*x[k];
x[i]=(b[i]-t)/a[i][i];
}// end for i
return 0;
}// end GaussP
int Gauss(float a[][N], float b[], float x[], int n)
/**************************************************************************
Metoda eliminarii fara pivotare
Valoare returnata:
0 - sistem compatibil
1 - sistem nedeterminat sau incompatibil
**************************************************************************/
{
int i,j,k;
float t;
for(i=0; i<n-1; i++)
{
for(j=i+1; j<n; j++)
{
if(a[i][i]==0) return 1;
// Semnaleaza eroarea
t=a[j][i]/a[i][i];
for(k=i+1; k<n; k++) a[j][k]=a[j][k]-t*a[i][k];
b[j]=b[j]-t*b[i];
a[j][i]=0;
}// end for j
}// end for i
if(a[n-1][n-1]==0) return 1;
// Semnaleaza eroarea
x[n-1]=b[n-1]/a[n-1][n-1];
for(i=n-2; i>=0; i--)
{
t=0; for(k=i+1; k<n; k++) t=t+a[i][k]*x[k];
x[i]=(b[i]-t)/a[i][i];
}// end for i
return 0;
// Sistem compatibil
}// end Gauss

void Schimba(float a[][N], float b[], int n, int i, int j)

/**************************************************************************
Schimba linia i cu linia j
**************************************************************************/
{
float t;
int k;
for(k=0; k<n; k++)
{
t=a[i][k];
a[i][k]=a[j][k];
a[j][k]=t;
}// end for k
t=b[i];
b[i]=b[j];
b[j]=t;
}// end Schimba

Polinomul Lagrange
/**************************************************************************
Aproximare cu polinim Lagrange
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#define N 10

// Gradul max. al polinomului

float x[N],y[N];

// Date distributie

/**************************************************************************
Prototipuri
**************************************************************************/
void CitDate(float x[], float y[], int n);
void ScrieDate(float x[], float y[], int n);
float Lagrange(float x[], float y[], float p, int n);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int n;
float p,v;
clrscr();
printf("Aproximare cu polinom Lagrange\r\n");
printf("==============================\r\n\r\n");
fflush(stdin);
printf("Gradul polinomului: n="); scanf("%d",&n);
CitDate(x,y,n);
ScrieDate(x,y,n);
printf("Apasa CTRL+C pentru terminare\r\n\r\n");
while(1)
{
fflush(stdin);
printf("x="); scanf("%f",&p);
v=Lagrange(x,y,p,n);
printf("y(%.3f)=%.3f\r\n",p,v);
}// end while
}// end main

/**************************************************************************
Functii utilizator
**************************************************************************/
float Lagrange(float x[], float y[], float p, int n)
/**************************************************************************
Calculeaza polinomul Lagrange
**************************************************************************/
{
int i,j;
float t,u;
u=0;
for(i=0; i<=n; i++)
{
t=y[i];
for(j=0; j<=n; j++) if(j!=i) t=t*(p-x[j])/(x[i]-x[j]);
u=u+t;
}// end for i
return u;
}// end Lagrange
void CitDate(float x[], float y[], int n)
/**************************************************************************
Citeste date distributie
**************************************************************************/
{
int i;
printf("Introduceti datele distributiei:\r\n");
for(i=0; i<=n; i++)
{
printf("x(%d)=",i); scanf("%f",&x[i]);
printf("y(%d)=",i); scanf("%f",&y[i]);
}// end for i
}// end CitDate
void ScrieDate(float x[], float y[], int n)
/**************************************************************************
Afiseaza date distributie
**************************************************************************/
{
int i;
printf("\r\nDate distributie:\r\n");
printf(" i
x
y\r\n");
printf("====================\r\n");
for(i=0; i<=n; i++)
{
printf("%02d %8.3f %8.3f\r\n",i,x[i],y[i]);
}// end for i
}// end ScrieDate

Regresie polinomial[
/**************************************************************************
Regresie polinomiala
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#define M 10
#define N 5

// Numar max. de puncte

// Grad maxim polinom

float
float
float
float

//
//
//
//

x[M],y[M];
s[N][N];
t[N];
a[N];

Date distributie
Coeficienti sistem normal
Termeni liberi
Coeficienti polinom

/**************************************************************************
Prototipuri
**************************************************************************/
void CitData(float x[], float y[], int m);
void GenSis(float x[], float y[], float s[][N], float t[], int m, int n);
float Pwr(float x, int n);
int
Gauss(float a[][N], float b[], float x[], int n);
int
GaussP(float a[][N], float b[], float x[], int n);
void Schimba(float a[][N], float b[], int n, int i, int j);
void ScrieSis(float a[][N], float b[], int n);
void ScrieSol(float x[], int n);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int n;
// Grad polinom
int m;
// Numar de puncte
clrscr();
printf("Regresie polinomiala\r\n");
printf("====================\r\n\r\n");
printf("Numar de puncte: m="); scanf("%d",&m);
printf("Gradul polinomului: n="); scanf("%d",&n);
printf("Introduceti coordonatele punctelor:\r\n");
CitData(x,y,m);
GenSis(x,y,s,t,m,n);
printf("Sistemul normal:\r\n");
ScrieSis(s,t,n);
GaussP(s,t,a,n);
printf("Coeficientii polinomului:\r\n");
ScrieSol(a,n);
getch();
}// end main

/**************************************************************************
Functii utilizator
**************************************************************************/
void GenSis(float x[], float y[], float s[][N], float t[], int m, int n)
/**************************************************************************
Genereaza sistemul normal
**************************************************************************/
{
int i,j,k;
for(i=0; i<=n; i++)
{
for(j=0; j<=n; j++)
{
s[i][j]=0;
for(k=0; k<=m; k++) s[i][j]=s[i][j]+Pwr(x[k],i+j);
}// end for j
t[i]=0;
for(k=0; k<=m; k++) t[i]=t[i]+y[k]*Pwr(x[k],i);
}// end for i
}// end GenSis
float Pwr(float x, int n)
/**************************************************************************
Calculeaza x^n
**************************************************************************/
{
float t;
int i;
t=1.0;
if(n) for(i=1; i<=n; i++) t=t*x;
return t;
}// end Pwr
void CitData(float x[], float y[], int m)
/**************************************************************************
Citeste date distributie
**************************************************************************/
{
int i;
for(i=0; i<=m; i++)
{
printf("x(%d)=",i); scanf("%f",&x[i]);
printf("y(%d)=",i); scanf("%f",&y[i]);
}// end for
}// end CitData
void ScrieSis(float a[][N], float b[], int n)
/**************************************************************************
Afiseaza sistemul
**************************************************************************/
{
int i,j;
for(i=0; i<=n; i++)
{
for(j=0; j<=n; j++)
{
printf("%8.3f ",a[i][j]);
}// end for j
printf("%8.3f\r\n",b[i]);
}// end for i
}// end ScrieSis

void ScrieSol(float x[], int n)

/**************************************************************************
Afiseaza solutia
**************************************************************************/
{
int i;
for(i=0; i<=n; i++)
{
printf("%8.3f ",x[i]);
}// end for i
}// end ScrieSol
int GaussP(float a[][N], float b[], float x[], int n)
/**************************************************************************
Rezolva sistemul a.x=b prin metoda eliminarii cu pivotare partiala
Valoare returnata:
0 - sistem compatibil
1 - sistem nedeterminat sau incompatibil
**************************************************************************/
{
int i,j,k;
float t;
for(i=0; i<n; i++)
{
for(j=i+1; j<=n; j++)
if(fabs(a[i][i])<fabs(a[j][i])) Schimba(a,b,n,i,j);
for(j=i+1; j<=n; j++)
{
if(a[i][i]==0) return 1;
t=a[j][i]/a[i][i];
for(k=i+1; k<=n; k++) a[j][k]=a[j][k]-t*a[i][k];
b[j]=b[j]-t*b[i]; a[j][i]=0;
}// end for j
}// end for i
if(a[n][n]==0) return 1;
x[n]=b[n]/a[n][n];
for(i=n-1; i>=0; i--)
{
t=0; for(k=i+1; k<=n; k++) t=t+a[i][k]*x[k];
x[i]=(b[i]-t)/a[i][i];
}// end for i
return 0;
}// end GaussP
void Schimba(float a[][N], float b[], int n, int i, int j)
/**************************************************************************
Schimba linia i cu linia j
**************************************************************************/
{
float t;
int k;
for(k=0; k<=n; k++)
{
t=a[i][k];
a[i][k]=a[j][k];
a[j][k]=t;
}// end for k
t=b[i]; b[i]=b[j]; b[j]=t;
}// end Schimba

Metoda itera\iilor
/**************************************************************************
Rezolvarea ecuatiei x=1/x-1 prin iteratii
Numarul de aur
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
/**************************************************************************
Prototipuri
**************************************************************************/
float f(float x);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int i;
float x,xp;
float eps;
clrscr();
fflush(stdin);
x=1; xp=2; eps=1e-8;
for (i=0; ((fabs(x-xp)>eps) && (i<40)); i++)
{
xp=x;
x=f(x);
printf("i=%02d x=%9.6f |x-xp|=%E\r\n",i,x,fabs(x-xp));
}// end for
getch();
}// end main
/**************************************************************************
Functii utilizator
**************************************************************************/
float f(float x)
{
return 1.0/x+1.0;
}// end f(x)

10

Schema lui Horner

/*********************************************************
Schema lui Horner
*********************************************************/
#include <stdio.h>
#include <conio.h>
float x,y;
float a[10];
int
n,i;
/*********************************************************
Prototipuri
*********************************************************/
float Horner(float a[], int i, float x);
/*********************************************************
Functia main
*********************************************************/
void main(void)
{
clrscr();
printf("Schema lui Horner\r\n");
printf("=================\r\n\r\n");
fflush(stdin);
printf("Grad polinom: n="); scanf("%d",&n);
printf("Introduceti coeficientii:\r\n");
for (i=n; i>=0; i--)
{
printf("a(%d)=",i); scanf("%f",&a[i]);
}// end for
printf("Apasati CTRL+C pentru terminare\r\n\r\n");
while(1)
{
printf("x="); scanf("%f",&x);
fflush(stdin);
y=Horner(a,n,x);
printf("P(%.3f)=%f\r\n",x,y);
}// end while
}// end main
/*********************************************************
Functii utilizator
*********************************************************/
float Horner(float a[],
// Coeficientii polinomului
int n,
// Gradul polinomului
float x)
// Argumentul
{
float y;
int i;
y=a[n];
for (i=n-1; i>=0; i--) y=y*x+a[i];
return y;
}// end Horner

11

Regresie liniar[
/**************************************************************************
Regresie liniara
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define N 100

// Nr. max. de puncte

float x[N],y[N];

// Date distributie

/**************************************************************************
Prototipuri
**************************************************************************/
void CitDate(float x[], float y[], int n);
void ScrieDate(float x[], float y[], int n);
void RegLin(float x[], float y[], int n, float *a, float *b);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int n;
float p,v;
float a,b;
clrscr();
printf("Regresie liniara\r\n");
printf("================\r\n\r\n");
fflush(stdin);
printf("Numar de puncte: n="); scanf("%d",&n);
CitDate(x,y,n);
ScrieDate(x,y,n);
RegLin(x,y,n,&a,&b);
printf("\nCoeficientii dreptei de regresie:\n");
printf("a=%f b=%f\n\n",a,b);
printf("Apasa CTRL+C pentru terminare\r\n\r\n");
while(1)
{
fflush(stdin);
printf("x="); scanf("%f",&p);
v=a*p+b;
printf("y(%.3f)=%.3f\n\n",p,v);
}// end while
}// end main

12

/**************************************************************************
Functii utilizator
**************************************************************************/
void RegLin(float x[], float y[], int n, float *a, float *b)
/**************************************************************************
Calculeaza coeficientii dreptei de regresie
**************************************************************************/
{
int i;
float sx,sxx,sy,sxy;
sx=0; sxx=0; sy=0; sxy=0;
for(i=0; i<n; i++)
{
sx=sx+x[i]; sxx=sxx+x[i]*x[i];
sy=sy+y[i]; sxy=sxy+x[i]*y[i];
}// end for i
*a=(sx*sy-n*sxy)/(sx*sx-n*sxx);
*b=(sx*sxy-sxx*sy)/(sx*sx-n*sxx);
}// end RegLin
void CitDate(float x[], float y[], int n)
/**************************************************************************
Citeste date distributie
**************************************************************************/
{
int i;
printf("Introduceti datele distributiei:\r\n");
for(i=0; i<n; i++)
{
printf("x(%d)=",i); scanf("%f",&x[i]);
printf("y(%d)=",i); scanf("%f",&y[i]);
}// end for i
}// end CitDate
void ScrieDate(float x[], float y[], int n)
/**************************************************************************
Afiseaza date distributie
**************************************************************************/
{
int i;
printf("\r\nDate distributie:\r\n");
printf(" i
x
y\r\n");
printf("====================\r\n");
for(i=0; i<n; i++)
{
printf("%02d %8.3f %8.3f\r\n",i,x[i],y[i]);
}// end for i
}// end ScrieDate

13

Estimarea parametrilor

Distribu\ia teoretic[: R[] = e T[ K ]

Distribu\ia experimental[ (fi=ierul Data.txt):
Nr. crt. T[C] R[]
1
52
151.8
2
53
146.2
3
54
141.5
4
55
136.7
5
56
132.1
6
57
127.4
7
58
123.1
8
59
119.2
9
60
115.5
10
61
111.5
11
62
107.7
12
63
104.5
13
64
101.0
14
65
97.8
15
66
94.8
16
67
91.7
17
68
89.0
18
71
81.4
19
75
73.2
20
77
71.2
Solu\ia:

0.00266 3556.118
/**************************************************************************
Estimarea parametrilor
Caracteristica unui termistor: R(T)=alfa*Exp(beta/T[K])
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define N 100
float r[N],t[N];
float x[N],y[N];
int n;
float m=1.0E+3;

//
//
//
//
//

Nr. max. de puncte

Date distributie
Date liniarizate
Numar de puncte distributie
Factor scalare

/**************************************************************************
Prototipuri
**************************************************************************/
void CitDate(void);
void ScrieDate(void);
void RegLin(float x[], float y[], int n, float *a, float *b);
void main(void)

14

/**************************************************************************
Functia main
**************************************************************************/
{
float a,b;
float alfa,beta;
clrscr();
printf("Caracteristica unui termistor\r\n");
printf("=============================\r\n\r\n");
CitDate();
ScrieDate();
RegLin(x,y,n,&a,&b);
alfa=exp(b);
beta=m*a;
printf("\nParametrii distributiei teoretice:\n");
printf("alfa=%f beta=%f\n\n",alfa,beta);
printf("Apasa o tasta\n");
getch();
}// end main
/**************************************************************************
Functii utilizator
**************************************************************************/
void RegLin(float x[], float y[], int n, float *a, float *b)
/**************************************************************************
Calculeaza coeficientii dreptei de regresie
**************************************************************************/
{
int i;
float sx,sxx,sy,sxy;
sx=0; sxx=0; sy=0; sxy=0;
for(i=0; i<n; i++)
{
sx=sx+x[i]; sxx=sxx+x[i]*x[i];
sy=sy+y[i]; sxy=sxy+x[i]*y[i];
}// end for i
*a=(sx*sy-n*sxy)/(sx*sx-n*sxx);
*b=(sx*sxy-sxx*sy)/(sx*sx-n*sxx);
}// end RegLin

15

void CitDate(void)
/**************************************************************************
Citeste date distributie din fisierul Data.txt
Liniarizeaza datele distributiei
**************************************************************************/
{
FILE *fis;
int i;
float xf,yf;
if(!(fis=fopen("Data.txt","rt")))
{
printf("Eroare deschidere fisier\n");
return;
}// end if
do
{
fscanf(fis,"%d %f %f",&i,&xf,&yf);
t[i-1]=xf; r[i-1]=yf;
x[i-1]=m/(273.0+xf); y[i-1]=log(yf);
} while(!feof(fis));
n=i;
fclose(fis);
}// end CitDate
void ScrieDate(void)
/**************************************************************************
Afiseaza date distributie
**************************************************************************/
{
int i;
printf("\r\nDate distributie:\n");
printf("n=%d\n\n",n);
printf(" i
t
r
x
y\n");
printf("======================================\n");
for(i=0; i<n; i++)
{
printf("%02d %8.3f %8.3f %8.3f %8.3f\r\n",i,t[i],r[i],x[i],y[i]);
}// end for i
}// end ScrieDate

16

Calculul valorii inverse prin itera\ii

Calculeaz[ x =

1
, a R , a > 0 prin metoda itera\iilor: x n +1 = x n (2 a x n ) , n N .
a

Aproxima\ia ini\ial[ se calculeaz[ astfel: x 0 = 2 [log2 a ] .

/**************************************************************************
Calculul valorii inverse prin metoda iteratiilor
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int i,m;
float a,eps,x,xp;
clrscr();
printf("Calculul inversului prin iteratii\n");
printf("=================================\n");
printf("Precizia="); scanf("%f",&eps);
printf("Apasa CTRL+C pentru terminare\n\n");
while(1)
{
printf("a="); scanf("%f",&a);
m=-floor(log(a)/log(2.0));
x=pow(2,m);
printf("Aproximatia initiala=%f\n\n",x);
i=0;
do
{
xp=x;
x=xp*(2.0-a*xp);
i++;
printf("i=%02d x=%f |x-xp|=%E\n",i,x,fabs(x-xp));
} while ((fabs(x-xp)>eps) && (i<=40));
printf("\nValoarea exacta 1/a= %f\n",1.0/a);
printf("Eroarea absoluta= %E\n\n",1.0/a-x);
}// end while
}// end main

17

Calculul r[d[cinii p[trate prin metoda lui Heron

Calculeaz[ x = a , a R , a > 0 prin metoda lui Heron: x n +1 =

1
a
x n +
2
xn

, n N cu x 0 = 1 .

/**************************************************************************
Calculul radicalului prin metoda iteratiilor (Heron)
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int i;
float a,eps,x,xp;
clrscr();
printf("Calculul radicalului prin iteratii\n");
printf("==================================\n");
printf("Precizia="); scanf("%f",&eps);
printf("Apasa CTRL+C pentru terminare\n\n");
while(1)
{
printf("a="); scanf("%f",&a);
i=0; x=1;
do
{
xp=x;
x=0.5*(xp+a/xp);
i++;
printf("i=%02d x=%f |x-xp|=%E\n",i,x,fabs(x-xp));
} while((fabs(x-xp)>eps) && (i<=40));
printf("\nValoarea exacta= %f\n",sqrt(a));
printf("Eroarea absoluta= %E\n\n",sqrt(a)-x);
}// end while
}// end main

18

Calculul r[d[cinii p[trate prin itera\ii

Calculeaz[ x = a , a R , a > 0 prin itera\ii: x n +1 =
Aproxima\ia ini\ial[ se alege astfel: x 0 = 2

log 2 a
2

xn
x2
3 n , n N .
2
a

/**************************************************************************
Calculul radicalului prin metoda iteratiilor
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int i,m;
float a,eps,x,xp;
clrscr();
printf("Calculul radicalului prin iteratii\n");
printf("==================================\n");
printf("Precizia="); scanf("%f",&eps);
printf("Apasa CTRL+C pentru terminare\n\n");
while(1)
{
printf("a="); scanf("%f",&a);
m=floor(log(a)/log(2.0)/2);
x=pow(2,m);
printf("Aproximatia initiala=%f\n\n",x);
i=0;
do
{
xp=x;
x=0.5*xp*(3.0-xp*xp/a);
i++;
printf("i=%02d x=%f |x-xp|=%E\n",i,x,fabs(x-xp));
} while((fabs(x-xp)>eps) && (i<=40));
printf("\nValoarea exacta= %f\n",sqrt(a));
printf("Eroarea absoluta= %E\n\n",sqrt(a)-x);
}// end while
}// end main

19

Calculul r[d[cinii cubice prin itera\ii

1
a
Calculeaz[ x = 3 a , a R , a > 0 prin itera\ii: x n +1 = 2 x n + 2 , n N .
3
xn

Aproxima\ia ini\ial[ se alege astfel: x 0 = 2

log 2 a
3

/**************************************************************************
Calculul radacinii cubice prin metoda iteratiilor
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
int i,m;
float a,eps,x,xp,xe;
clrscr();
printf("Calculul radacinii cubice\n");
printf("=========================\n");
printf("Precizia="); scanf("%f",&eps);
printf("Apasa CTRL+C pentru terminare\n\n");
while(1)
{
printf("a="); scanf("%f",&a);
m=floor(log(a)/log(2.0)/3);
x=pow(2,m);
printf("Aproximatia initiala=%f\n\n",x);
i=0;
do
{
xp=x;
x=(2.0*xp+a/xp/xp)/3.0;
i++;
printf("i=%02d x=%f |x-xp|=%E\n",i,x,fabs(x-xp));
} while((fabs(x-xp)>eps) && (i<=40));
printf("\nValoarea exacta= %f\n",pow(a,(float)1/3));
printf("Eroarea absoluta= %E\n\n",pow(a,(float)1/3)-x);
}// end while
}// end main

20

Metoda biparti\iei
/**************************************************************************
Metoda bipartitiei
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
/**************************************************************************
Variabile globale
**************************************************************************/
float a,b,eps,x;
int i;
/**************************************************************************
Prototipuri functii
**************************************************************************/
float f(float x);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
clrscr();
printf("Metoda bipartitiei\n");
printf("==================\n\n");
printf("a="); scanf("%f",&a);
printf("b="); scanf("%f",&b);
printf("Precizia="); scanf("%f",&eps);
i=0;
do
{
x=(a+b)/2.0;
if (f(a)*f(x)<0) b=x; else a=x;
i++;
} while (fabs(b-a)>eps);
printf("x=%8.6f\n",x);
printf("Iteratii=%d\n",i);
getch();
}
/**************************************************************************
Functii utilizator
**************************************************************************/
float f(float x)
{
return x*x*x+3*x-1;
}// end f

21

Metoda coardei
/**************************************************************************
Metoda coardei
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
/**************************************************************************
Variabile globale
**************************************************************************/
float a,b,eps,x,xp;
int i;
/**************************************************************************
Prototipuri functii
**************************************************************************/
float f(float x);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
clrscr();
printf("Metoda coardei\n");
printf("==============\n\n");
printf("a="); scanf("%f",&a);
printf("b="); scanf("%f",&b);
printf("Precizia="); scanf("%f",&eps);
i=0; x=a;
do
{
xp=x;
x=a-f(a)*(b-a)/(f(b)-f(a));
if (f(a)*f(x)<0) b=x; else a=x;
i++;
} while (fabs(x-xp)>eps);
printf("x=%8.6f\n",x);
printf("Iteratii=%d\n",i);
getch();
}
/**************************************************************************
Functii utilizator
**************************************************************************/
float f(float x)
{
return x*x*x+3*x-1;
}// end f

22

Metoda Newton
/**************************************************************************
Metoda Newton
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
/**************************************************************************
Variabile globale
**************************************************************************/
float a,b,eps,x,xp;
int i;
/**************************************************************************
Prototipuri functii
**************************************************************************/
float f(float x);
float df(float x);
float ddf(float x);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
clrscr();
printf("Metoda Newton\n");
printf("=============\n\n");
printf("a="); scanf("%f",&a);
printf("b="); scanf("%f",&b);
printf("Precizia="); scanf("%f",&eps);
i=0;
if (f(a)*ddf(a)>0) x=a; else x=b;
do
{
xp=x;
x=x-f(x)/df(x);
i++;
} while (fabs(x-xp)>eps);
printf("x=%8.6f\n",x);
printf("Iteratii=%d\n",i);
getch();

// Alegerea aproximatiei initiale

}
/**************************************************************************
Functii utilizator
**************************************************************************/
float f(float x)
{ return x*x*x+3*x-1;}// end f
float df(float x)
{ return 3*(x*x+1);}// end df
float ddf(float x)
{ return 6*x;}// end ddf

23

Metoda Newton modificat[

/**************************************************************************
Metoda Newton modificata
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
/**************************************************************************
Variabile globale
**************************************************************************/
float a,b,eps,x,xp,df0;
int i;
/**************************************************************************
Prototipuri functii
**************************************************************************/
float f(float x);
float df(float x);
float ddf(float x);
void main(void)
/**************************************************************************
Functia main
**************************************************************************/
{
clrscr();
printf("Metoda Newton modificata\n");
printf("========================\n\n");
printf("a="); scanf("%f",&a);
printf("b="); scanf("%f",&b);
printf("Precizia="); scanf("%f",&eps);
i=0;
if (f(a)*ddf(a)>0) x=a; else x=b;
df0=df(x);
do
{
xp=x;
x=x-f(x)/df0;
i++;
} while (fabs(x-xp)>eps);
printf("x=%8.6f\n",x);
printf("Iteratii=%d\n",i);
getch();

// Alegerea aproximatiei initiale

}
/**************************************************************************
Functii utilizator
**************************************************************************/
float f(float x)
{ return x*x*x+3*x-1;}// end f
float df(float x)
{ return 3*(x*x+1);}// end df
float ddf(float x)
{ return 6*x;}// end ddf

24

Rezolvarea sistemelor tridiagonale

/**************************************************************************
Rezolvarea sistemelor tridiagonale
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define N 100
// Numarul max. de necunoscute
/**************************************************************************
Variabile globale
**************************************************************************/
int
n;
// Ordinul sistemului
float a[N];
// Coeficientii sistemului
float b[N];
float c[N];
float d[N];
// Termenii liberi
float x[N];
// Vectorul necunoscutelor
/**************************************************************************
Prototipuri
**************************************************************************/
void TriDiag(float a[], float b[], float c[], float d[], float x[], int n);
void Date1(float a[], float b[], float c[], float d[], int n);
void CitSis(float a[], float b[], float c[], float d[], int n);
void ScrieVec(float x[], int n);
/**************************************************************************
Functia main
**************************************************************************/
void main(void)
{
printf("Rezolvarea sistemelor tridiagonale\n");
printf("==================================\n");
printf("n="); scanf("%d",&n);
Date1(a,b,c,d,n);
TriDiag(a,b,c,d,x,n);
printf("Solutia:\n");
ScrieVec(x,n);
getch();
}// end main
/**************************************************************************
Functii utilizator
**************************************************************************/
void TriDiag(float a[], float b[], float c[], float d[], float x[], int n)
/**************************************************************************
Rezolva sistemul tridiagonal
**************************************************************************/
{
int i;
for (i=1; i<n; i++)
{
b[i]=b[i]-a[i]*c[i-1]/b[i-1];
d[i]=d[i]-a[i]*d[i-1]/b[i-1];
}// end for i
x[n-1]=d[n-1]/b[n-1];
for (i=n-2; i>=0; i--) x[i]=(d[i]-c[i]*x[i+1])/b[i];
}// end TriDiag

25

void Date1(float a[], float b[], float c[], float d[], int n)
/**************************************************************************
Genereaza sistem demo (tridiagonal)
**************************************************************************/
{
int i;
a[0]=0.0; b[0]=2.0; c[0]=1.0; d[0]=1.0;
a[n-1]=1.0; b[n-1]=2.0; c[n-1]=0.0; d[n-1]=n;
for (i=1; i<n-1; i++)
{
a[i]=1.0; b[i]=2.0; c[i]=1.0; d[i]=i+1;
}// end for i
}// end Date1
void CitSis(float a[], float b[], float c[], float d[], int n)
/**************************************************************************
Citeste coeficientii
**************************************************************************/
{
int i,j;
fflush(stdin);
for(i=0; i<n; i++)
{
printf("a(%d)=",i+1);
printf("b(%d)=",i+1);
printf("c(%d)=",i+1);
printf("d(%d)=",i+1);
}// end for i
}// end CitSis

scanf("%f",&a[i]);
scanf("%f",&b[i]);
scanf("%f",&c[i]);
scanf("%f",&d[i]);

void ScrieVec(float x[], int n)

/**************************************************************************
Afiseaza vectorul
**************************************************************************/
{
int i;
for(i=0; i<n; i++) printf("%8.3E ",x[i]);
printf("\n");
}// end ScrieVec

26

Factorizarea LR (Crout)
/**************************************************************************
Metoda factorizarii (Crout)
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define N 100
/**************************************************************************
Variabile globale
**************************************************************************/
double
double
double
double
double
double
int

a[N][N];
b[N];
x[N];
L[N][N];
R[N][N];
y[N];
n;

//
//
//
//
//
//
//

Matricea coeficientilor
Termenii liberi
Vectorul necunoscutelor
Factor stanga
Factor dreapta
Vector auxiliar
Ordinul sistemului

/**************************************************************************
Prototipuri
**************************************************************************/
int
Crout(double a[][N], double L[][N], double R[][N], int n);
void
DSub(double L[][N], double y[], double b[], int n);
void
BSub(double R[][N], double x[], double y[], int n);
double
double
void
void
void
void

ProdErr(double a[][N], double L[][N], double R[][N], int n);

SolErr(double x[], int n);
Date(double a[][N], double b[], int n);
DateRand(double a[][N], double b[], int n);
ScrieMat(double a[][N], int n);
ScrieVec(double x[], int n);

/**************************************************************************
Functia main
**************************************************************************/
void main(void)
{
int ret;
double p,eps;
clrscr();
printf("Metoda factorizarii\n");
printf("===================\n\n");
fflush(stdin);
printf("Numar necunoscute: n="); scanf("%d",&n);
DateRand(a,b,n);
printf("\nMatricea coeficientilor:\n");
ScrieMat(a,n);
printf("\nTermenii liberi:\n");
ScrieVec(b,n);
ret=Crout(a,L,R,n);
if (ret)
{
printf("Eroare factorizare in linia %d\n",ret);
getch();
}
else

27

{
printf("\nMatricea L:\n");
ScrieMat(L,n);
printf("\nMatricea R:\n");
ScrieMat(R,n);
p=ProdErr(a,L,R,n);
printf("\n||A-L.R||=%E\n",p);
DSub(L,y,b,n);
BSub(R,x,y,n);
eps=SolErr(x,n);
printf("\nVectorul y:\n");
ScrieVec(y,n);
printf("\nSolutia sistemului:\n");
ScrieVec(x,n);
printf("\nNorma erorii=%E\n",eps);
getch();
}// end if Crout
}
/**************************************************************************
Functii utilizator
**************************************************************************/
int Crout(double a[][N], double L[][N], double R[][N], int n)
/**************************************************************************
Factorizare Crout A=L.R cu L[i,i]=1
Valoarea returnata:
0 - factorizare reusite
1 - eroare factorizare
**************************************************************************/
{
int i,j,k;
double temp;
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++)
{
if (i==j) L[i][j]=1;
else if (i<j) L[i][j]=0; else R[i][j]=0;
}// end for j
}// end for i
for (j=1; j<=n; j++)
{
i=1;
do
{
if (i==1) R[i][j]=a[i][j];
else
{
temp=0; for (k=1; k<=i-1; k++) temp=temp+L[i][k]*R[k][j];
R[i][j]=a[i][j]-temp;
}
i++;
} while(i<=j);
if (R[j][j]==0) return j;
i=j+1;
do
{
if (j==1) L[i][j]=a[i][j]/R[j][j];
else

28

{
temp=0; for (k=1; k<=j-1; k++) temp=temp+L[i][k]*R[k][j];
L[i][j]=(a[i][j]-temp)/R[j][j];
}
i++;
} while(i<=n);
}// end for j
return 0;
}// end Crout
void DSub(double L[][N], double y[], double b[], int n)
/**************************************************************************
Rezolva L.Y=B in cascada directa
**************************************************************************/
{
int i,k;
double t;
y[1]=b[1];
for (i=2; i<=n; i++)
{
t=0; for (k=1; k<i; k++) t=t+L[i][k]*y[k];
y[i]=b[i]-t;
}// end for i
}// end DSub
void BSub(double R[][N], double x[], double y[], int n)
/**************************************************************************
Rezolva R.X=Y in cascada inversa
**************************************************************************/
{
int i,k;
double t;
x[n]=y[n]/R[n][n];
for (i=n-1; i>0; i--)
{
t=0; for (k=i+1; k<=n; k++) t=t+R[i][k]*x[k];
x[i]=(y[i]-t)/R[i][i];
}// end for i
}// end BSub
double ProdErr(double a[][N], double L[][N], double R[][N], int n)
/**************************************************************************
Calculeaza ||A-L.R||
**************************************************************************/
{
int i,j,k;
double t,w;
w=0;
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++)
{
t=0; for (k=1; k<=n; k++) t=t+L[i][k]*R[k][j];
w=w+(a[i][j]-t)*(a[i][j]-t);
}// end for j
}// end for i
return sqrt(w);
}// end ProdErr

29

double SolErr(double x[], int n)

/**************************************************************************
Calculeaza norma erorii solutiei
NOTA: Solutia exacta a sistemului este x[i]=1
**************************************************************************/
{
int i;
double t;
t=0;
for (i=1; i<=n; i++) t=t+(x[i]-1.0)*(x[i]-1.0);
return sqrt(t);
}// end SolErr
void Date(double a[][N], double b[], int n)
/**************************************************************************
Genereaza sistemul
**************************************************************************/
{
int i,j;
for (i=1; i<=n; i++)
{
b[i]=0;
for (j=1; j<=n; j++)
{
a[i][j]=((double)n)/((double)(n+i+j));
b[i]=b[i]+a[i][j];
}// end for j
}// end for i
}// end Date
void DateRand(double a[][N], double b[], int n)
/**************************************************************************
Genereaza sistemul
**************************************************************************/
{
int i,j;
randomize();
for (i=1; i<=n; i++)
{
b[i]=0;
for (j=1; j<=n; j++)
{
a[i][j]=0.5-(double)rand()/(double)RAND_MAX;
b[i]=b[i]+a[i][j];
}// end for j
}// end for i
}// end DateRand
void ScrieMat(double a[][N], int n)
/**************************************************************************
Afiseaza elementele unei matrici
**************************************************************************/
{
int i,j;
for (i=1; i<=n; i++)
{
for (j=1; j<=n; j++) printf("%10.3E ",a[i][j]);
printf("\n");
}// end for i
}// end ScrieMat

30

void ScrieVec(double x[], int n)

/**************************************************************************
Afiseaza elementele unui vector
**************************************************************************/
{
int i;
for (i=1; i<=n; i++) printf("%10.3E ",x[i]);
printf("\n");
}// end ScrieVec

31

Metoda r[d[cinii p[trate

/**************************************************************************
Metoda radacinii patrate
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
/**************************************************************************
Variabile globale
**************************************************************************/
#define N 100
// Numar max de necunoscute
float a[N][N];
// Matricea coeficientilor
float b[N];
// Termenii liberi
float x[N];
// Vectorul necunoscutelor
float R[N][N];
// Factorul drept
float L[N][N];
// Factorul stang L=R'
float y[N];
// Vector auxiliar
int
n;
// Ordinul sistemului
float w[N][N];
/**************************************************************************
Prototipuri
**************************************************************************/
void Radical(float a[][N], float R[][N], int n);
void DSub(float a[][N], float b[], float x[], int n);
void BSub(float a[][N], float b[], float x[], int n);
float ProdErr(float a[][N], float L[][N], float R[][N], float w[][N], int n);
void Date(float a[][N], float b[], int n);
void Date1(float a[][N], float b[], int n);
void DateRand(float a[][N], float b[], int n);
void ScrieMat(float a[][N], int n);
void ScrieVec(float x[], int n);
/**************************************************************************
Functia main
**************************************************************************/
void main(void)
{
clrscr();
printf("Metoda radacinii patrate\n");
printf("========================\n\n");
fflush(stdin);
printf("Numar necunoscute: n="); scanf("%d",&n);
Date1(a,b,n);
printf("Matricea coeficientilor:\n");
ScrieMat(a,n);
printf("Termenii liberi:\n");
ScrieVec(b,n);
Radical(a,R,n);
printf("\nMatricea R:\n");
ScrieMat(R,n);
printf("\nEroarea de factorizare ||A-R'.R||=%E\n",ProdErr(a,L,R,w,n));
DSub(L,y,b,n);
BSub(R,x,y,n);
printf("\nSolutia:\n");
ScrieVec(x,n);
getch();
}

32

/**************************************************************************
Functii utilizator
**************************************************************************/
void Radical(float a[][N], float R[][N], int n)
/**************************************************************************
Factorizare A=L.R cu L=R'
**************************************************************************/
{
int i,j,k;
float t;
for (i=0; i<n; i++) for (j=0; j<n; j++) R[i][j]=0.0;
R[0][0]=sqrt(a[0][0]); for (j=1; j<n; j++) R[0][j]=a[0][j]/R[0][0];
for (i=1; i<n; i++)
{
t=0.0;
for (k=0; k<i; k++) t=t+R[k][i]*R[k][i];
R[i][i]=sqrt(a[i][i]-t);
if (i<n-1)
{
for (j=i+1;j<n; j++)
{
t=0.0;
for (k=0; k<i; k++) t=t+R[k][i]*R[k][j];
R[i][j]=(a[i][j]-t)/R[i][i];
}// end for j
}// end if
}// end for i
for (i=0; i<n; i++) for (j=0; j<n; j++) L[j][i]=R[i][j];
}// end Radical
void DSub(float L[][N], float y[], float b[], int n)
/**************************************************************************
Rezolva L.Y=B in cascada directa cu L=R'
**************************************************************************/
{
int i,k;
float t;
y[0]=b[0]/L[0][0];
for (i=1; i<n; i++)
{
t=0; for (k=0; k<i; k++) t=t+L[i][k]*y[k];
y[i]=(b[i]-t)/L[i][i];
}// end for i
}// end DSub
void BSub(float R[][N], float x[], float y[], int n)
/**************************************************************************
Rezolva R.X=Y in cascada inversa
**************************************************************************/
{
int i,k;
float t;
x[n-1]=y[n-1]/R[n-1][n-1];
for (i=n-2; i>=0; i--)
{
t=0; for (k=i+1; k<n; k++) t=t+R[i][k]*x[k];
x[i]=(y[i]-t)/R[i][i];
}// end for i
}// end BSub

33

float ProdErr(float a[][N], float L[][N], float R[][N], float w[][N], int n)
/**************************************************************************
Calculeaza w=L.R si ||A-L.R|| cu L=R'
**************************************************************************/
{
int i,j,k;
float v;
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
{
w[i][j]=0.0;
for (k=0; k<n; k++) w[i][j]=w[i][j]+L[i][k]*R[k][j];
}// end for j
}// end for i
v=0.0;
for (i=0; i<n; i++)
for (j=0; j<n; j++) v=v+(a[i][j]-w[i][j])*(a[i][j]-w[i][j]);
return sqrt(v);
}// end ProdErr
void Date(float a[][N], float b[], int n)
/**************************************************************************
Genereaza sistemul
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++)
{
b[i]=0;
for (j=0; j<n; j++)
{
a[i][j]=((float)n)/((float)(n+i+j+2));
b[i]=b[i]+a[i][j];
}// end for j
}// end for i
}// end Date
void Date1(float a[][N], float b[], int n)
/**************************************************************************
Genereaza sistem demo (tridiagonal)
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
{
if (i==j) a[i][j]=2.0;
else if ((j==i-1)||(j==i+1)) a[i][j]=1.0;
else a[i][j]=0;
}// end for j
if ((i==0)||(i==n-1)) b[i]=3.0;
else b[i]=4.0;
}// end for i
}// end Date1

34

void DateRand(float a[][N], float b[], int n)

/**************************************************************************
Genereaza sistemul
**************************************************************************/
{
int i,j,k;
randomize();
for (i=0; i<n; i++)
{
for (j=0; j<=i; j++)
{
a[i][j]=(float)rand()/(float)RAND_MAX;
a[j][i]=a[i][j];
}// end for j
b[i]=0; for (j=0; j<n; j++) b[i]=b[i]+a[i][j];
}// end for i
}// end DateRand
void ScrieMat(float a[][N], int n)
/**************************************************************************
Afiseaza elementele unei matrici
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
{
printf("%12.6E ",a[i][j]);
}// end for j
printf("\n");
}// end for i
}// end ScrieMat
void ScrieVec(float x[], int n)
/**************************************************************************
Afiseaza elementele unui vector
**************************************************************************/
{
int i;
for (i=0; i<n; i++) printf("%12.6E ",x[i]);
printf("\n");
}// end ScrieVec

35

Metoda itera\iilor
/**************************************************************************
Metoda iteratiilor
**************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define N 100

// Numarul max. de necunoscute

float
float
float
float
float
float
int
float
int

// Matricea coeficientilor
// C=A-Diag(A)
// Termenii liberi

a[N][N];
c[N][N];
b[N];
d[N];
x[N];
xp[N];
n;
eps;
nit;

//
//
//
//
//

Vectorul necunoscutelor
Aproximatia precedenta
Ordinul sistemului
Precizia de aproximare
Contor iteratii

/**************************************************************************
Prototipuri
**************************************************************************/
void Iter(float c[][N], float d[], float x[], float xp[], int n);
void Siedel(float c[][N], float d[], float x[], float xp[], int n);
float SolErr(float x[], float xp[], int n);
void Date1(float a[][N], float c[][N], float b[], float d[], int n);
void Date2(float a[][N], float c[][N], float b[], float d[], int& n);
void Date3(float a[][N], float c[][N], float b[], float d[], int n);
void DateRand(float a[][N], float c[][N], float b[], float d[], int n);
void ScrieMat(float a[][N], int n);
void ScrieVec(float x[], int n);
/**************************************************************************
Functia main
**************************************************************************/
void main(void)
{
clrscr();
printf("Metoda iteratiilor\n");
printf("==================\n\n");
fflush(stdin);
printf("Numar necunoscute: n="); scanf("%d",&n);
printf("Precizia: eps="); scanf("%f",&eps);
Date2(a,c,b,d,n);
printf("\nSistemul:\n");
ScrieMat(a,n);
nit=0;
do
{
Iter(c,d,x,xp,n);
//
Siedel(c,d,x,xp,n);
nit++;
printf("Iteratia %d, err=%E:\n",nit, SolErr(x,xp,n));
ScrieVec(x,n);
} while((SolErr(x,xp,n)>eps) && (nit<40));
getch();
}

36

/**************************************************************************
Functii utilizator
**************************************************************************/
void Iter(float c[][N], float d[], float x[], float xp[], int n)
/**************************************************************************
Calculeaza aproximatia X=D+C.Xp
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++) xp[i]=x[i];
// Salveaza aproximatia precedenta
for (i=0; i<n; i++)
{
x[i]=d[i];
for (j=0; j<n; j++) x[i]=x[i]+c[i][j]*xp[j];
}// end for i
}// end Iter
void Siedel(float c[][N], float d[], float x[], float xp[], int n)
/**************************************************************************
Calculeaza aproximatia X=D+C.Xp
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++) xp[i]=x[i];
// Salveaza aproximatia precedenta
for (i=0; i<n; i++)
{
x[i]=d[i];
if (i==0) {for (j=0; j<n; j++) x[i]=x[i]+c[i][j]*xp[j];}
else
{
for (j=0; j<i; j++) x[i]=x[i]+c[i][j]*x[j];
for (j=i; j<n; j++) x[i]=x[i]+c[i][j]*xp[j];
}
}// end for i
}// end Iter
void DateRand(float a[][N], float c[][N], float b[], float d[], int n)
/**************************************************************************
Genereaza sistemul si aproximatia initiala:
X=D+C.X si X=D
**************************************************************************/
{
int i,j;
randomize();
for (i=0; i<n; i++)
{
b[i]=0;
for (j=0; j<n; j++)
{
a[i][j]=0.5-(float)rand()/(float)RAND_MAX;
b[i]=b[i]+a[i][j];
}// end for j
}// end for i
for (i=0; i<n; i++)
{
d[i]=b[i]/a[i][i];
x[i]=d[i];
for (j=0; j<n; j++)
{
if (i==j) c[i][j]=0; else c[i][j]=-a[i][j]/a[i][i];

37

}// end for j

}// end for i
}// end DateRand
void Date1(float a[][N], float c[][N], float b[], float d[], int n)
/**************************************************************************
Genereaza sistemul si aproximatia initiala:
X=D+C.X si X=D
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++)
{
b[i]=0;
for (j=0; j<n; j++)
{
a[i][j]=((float)n)/((float)(n+i+j+2));
b[i]=b[i]+a[i][j];
}// end for j
}// end for i
for (i=0; i<n; i++)
{
d[i]=b[i]/a[i][i];
x[i]=d[i];
for (j=0; j<n; j++)
{
if (i==j) c[i][j]=0; else c[i][j]=-a[i][j]/a[i][i];
}// end for j
}// end for i
}// end Date1
void Date2(float a[][N], float c[][N], float b[], float d[], int& n)
/**************************************************************************
Genereaza sistemul si aproximatia initiala:
X=D+C.X si X=D
**************************************************************************/
{
int i,j;
n=3;
a[0][0]=4.0; a[0][1]=0.24; a[0][2]=-0.08; b[0]=8.0;
a[1][0]=0.09; a[1][1]=3.0;
a[1][2]=-0.15; b[1]=9.0;
a[2][0]=0.04; a[2][1]=-0.08; a[2][2]=4.0 ; b[2]=20.0;
for (i=0; i<n; i++)
{
d[i]=b[i]/a[i][i];
x[i]=d[i];
for (j=0; j<n; j++)
{
if (i==j) c[i][j]=0; else c[i][j]=-a[i][j]/a[i][i];
}// end for j
}// end for i
}// end Date2

38

void Date3(float a[][N], float c[][N], float b[], float d[], int n)
/**************************************************************************
Genereaza sistemul A.X=B x[i-1]+3.x[i]+x[i+1]=i
Formeaza sistemul pentru iteratii X=D+C.X
Alege aproximatia initiala: X=D
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++)
for (j=0; j<n; j++) a[i][j]=0.0;
a[0][0]=3.0; a[0][1]=1.0; b[0]=1.0;
a[n-1][n-2]=1.0; a[n-1][n-1]=3.0; b[n-1]=n;
for (i=1; i<n-1; i++)
{
a[i][i-1]=1.0; a[i][i]=3.0; a[i][i+1]=1.0;
b[i]=i+1;
}// end for i
for (i=0; i<n; i++)
{
d[i]=b[i]/a[i][i];
x[i]=d[i];
for (j=0; j<n; j++)
{
if (i==j) c[i][j]=0; else c[i][j]=-a[i][j]/a[i][i];
}// end for j
}// end for i
}// end Date3

void ScrieMat(float a[][N], int n)

/**************************************************************************
Afiseaza elementele unei matrici
**************************************************************************/
{
int i,j;
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
{
printf("%8.6f ",a[i][j]);
}// end for j
printf("\n");
}// end for i
}// end ScrieMat
void ScrieVec(float x[], int n)
/**************************************************************************
Afiseaza elementele unui vector
**************************************************************************/
{
int i;
for (i=0; i<n; i++) printf("%8.6f ",x[i]);
printf("\n");
}// end ScrieVec

39

float SolErr(float x[], float xp[], int n)

/**************************************************************************
Calculeaza norma erorii ||x-xp||
**************************************************************************/
{
int i;
float t;
t=0; for (i=0; i<n; i++) t=t+(x[i]-xp[i])*(x[i]-xp[i]);
return sqrt(t);
}// end SolErr

40