Librarie de functii si proceduri pentru lucru cu matrici (masive bidimensionale) in limbajul C si C++ – Citire si Afisare

1 comment - This post in english

Pentru realizarea calculului matriceal este necesara existenta matricei sau matricelor. Crearea necorespunzatoare a obiectului de lucru, si anume matricea, duce la efecte total neasteptate. De aceea, pentru a fi lipsiti de neplaceri, atentia acordata acestor functii este maxima.

In calculul matriceal sunt incluse si functii de intrare si iesire. Aceste functii realizeaza:

  • crearea matricei, fie de la consola ca in cazul bibliotecii matrice.h, fie initializata cu zero ca in cazul clasei matrix( constructorul cu parametrii);
  • afisarea matricei pe ecran.

Cum in biblioteca de functii matrice.h se lucreaza cu o matrice de dimensiuni constante, iar in clasa matrix se utilizeaza o variabila de tip pointer, deci dinamic, sunt prezentate ambele moduri de creare( dinamic si static).

In continuare se prezinta functiile care realizeaza creare matricei. In practica se observa, ca pe langa matricea dorita, sunt folosite o serie de matrice ajutatoare cum ar fi matricea unitate, matricea booleana, matricea cu 1 pe o linie si in rest zero etc.. Functiile de creare a acestor matrice sunt functii de intrare, iar afisarea lor este realizata tot cu functii de iesire.

Matricea este creata in modul de lucru static de la consola folosind functia din cadrul bibliotecii matrice.h :

void creation(int *n, int *m, int x[30][30])

Dupa cum se observa tipul functiei este void. Functia primeste ca parametrii urmatoarele variabile:

  • int x[30][30]- variabila de tip pointer constant( se aloca memorie pentru 30 de linii si 30 de coloane, fig.1) la intreg. Aceasta reprezinta matricea care este citita de la tastatura.
  • int *n- parametru de iesire, numarul de linii a matricei, care este citit de la tastatura. Transferul se realizeaza prin valoare.
  • int *m- parametru de iesire, numarul de coloane a matricei, care este citit de la tastatura. Transferul se realizeaza prin valoare.

Declarand matricea de dimensiuni constante se aloca de fiecare data un tablou cu 30 de linii si 30 de coloane, chiar daca este necesar de exemplu decat o matrice de doua linii si doua coloane.

Continutul functiei creation este urmatorul :

void creation(int *n,int *m,int x[30][30])
{
int i,j,k;
clrscr();
printf("\n Matrix lines number:");
scanf("%d",n);
valid_l_c(n);
printf("\n Matrix columns number:");
scanf("%d",m);
valid_l_c(m);
printf("\n The matrix is:");
for(i=0;i<*n;i++)
for(j=0;j<*m;j++)
   {
   printf("\n The element x[%d][%d] is:",i,j);
   k=scanf("%d",&x[i][j]);
   valid_no_integer(&x[i][j],k);
   }
}

Se citeste numarul de linii si de coloane ale matricei, urmand introducerea elementelor matricei. Dupa cum se observa fiecare citire este urmata de o validare. Validarea asigura ca nu sunt introduse date eronate( caractere in loc de intregi, float in loc de intreg, numarul de linii sau de coloane depaseste 30, sau este mai mic sau egal cu zero). Validarea se realizeaza cu ajutorul a doua functii:

void valid_no_integer(int *l, int k)

void valid_l_c(int *l)

void valid_l_c(int *l)- realizeaza validarea numarului de linii si de coloane introduse de la tastatura. Functia primeste ca parametru(atat de intrare cat si de iesire) un intreg int *l, care este transferat catre alte functii prin valoare. Continutul acestei functii este urmatorul:

void valid_l_c(int *l)
{
int i,j;
char lines[100],*endptr;
 
clrscr();
if((*l<1)||(*l>30))
			do
			{
			printf("\n Error !");
			gets(lines);
			*l=strtod(lines,&endptr);
			clrscr();
			}
			while ((*l<1)||(*l>30)||(*endptr>9));
}

Aceasta validare este foarte puternica deoarece nu permite si introducerea cifrelor urmate de caractere. Numarul introdus de la tastatura este citit ca un sir de caractere. Se realizeaza conversia de la sir de caractere la intreg cu ajutorul functiei int strtod(char, & char*) din cadrul bibliotecii stdlib.h. In caz de introducere necorespunzatoare se afiseaza mesajul Error.

void valid_no_integer(int *l, int k)- realizeaza validarea introducerii unui intreg de la tastatura. Este folosita in cadrul functiei de creare a matricei in mod static atunci cand sunt introduse de la tastatura elementele matricei. Functia primeste ca parametrii doua variabile de tip intreg si anume:

  • int k- parametru de intrare; functia scanf intoarce valoare 0 daca citirea este incorecta sau 1 in cazul citirii corecte. Aceasta valoare este primita de functia valid_no_integer prin intermediul parametrului k. Daca k este egal cu 0 se afiseaza mesajul Error si se cere o noua introducere a elementului.
  • int *l- reprezinta valoarea introdusa care indeplineste toate conditiile de validitate. Transferul parametrului de iesire se realizeaza prin valoare.

Continutul acestei functii este urmatorul:

void valid_no_integer(int *l,int k)
{
if (k==0)
   {
fflush(stdin);
	    do
	    {
	    k=1;
	    printf("\n Error ! :");
	    k=scanf("%d",l);
	    fflush(stdin);
	    }
	    while(k==0);
   }
}

Spre deosebire de functia de validare precedenta, aceasta nu este la fel de puternica deoarece permite introducerea numerelor urmate de caractere.

Asadar aceasta a fost functia de creare de la tastatura a unei matrice in mod static. In continuare se prezinta modul de creare de la consola a unei matrice alocate dinamic. Lucrul cu matrice alocate dinamic este implementat in clasa matrix. Crearea de la tastatura a unei matrice se realizeaza in cadrul constructorului implicit al clasei matrix, precum si cu operatorul de shiftare la dreapta.

Clasa matrix are implementata doi constructori. Unul este implicit fara parametri si realizeaza introducerea matricei de la tastatura, iar cel de-al doilea primeste ca parametrii numarul de linii si de coloane si creaza matricea cu elementele zero.

Constructorul implicit are urmatoarea configuratie:

matrix::matrix()
{
cout<<"\n Matrix lines number:";
cin>>n;
////clrscr();
cout<<"\n Matrix columns number:";
cin>>m;
a=aloc_mat(n,m);
cout<<"The matrix is:";
for(int i=0;i<n;i++)
     for(int j=0;j<m;j++)
	     {
	     cout<<"\n a["<<i<<"]["<<j<<"]=";
	     cin>>a[i][j];
	     }
}

Declararea unei matrice cuprinde tipul de data asociat elementului, numele masivului si numarul de dimensiuni ale acestuia, adica [ ][ ] ,sau putem declara un pointer la o matrice de forma int
**x.

Folosind a doua metoda de declarare a unei matrice folosim atat spatiu cat ne trebuie, alocandu-l dinamic in functie de cate linii si coloane avem.

Alocarea dinamica presupune utilizarea memoriei intr-un mult mai eficient si anume se aloca memorie exact cat este necesar pentru memorarea matricei. Pentru a realiza aceasta se foloseste functia membru int** aloc_mat(int, int). Dupa cum se observa din secventa prezentata mai sus alocarea memoriei necesare matricei se realizeaza dupa introducerea numarului de linii si coloane. Este foarte important sa nu se omita acest pas, altfel rezultatele obtinute fiind cu totul altele. Functia de alocarea a matricei are ca drept de acces private.

Continutul ei este urmatorul:

int ** matrix::aloc_mat(int n,int m)
	    {
	    int **pmat;
	    pmat=(int **)malloc(n*sizeof(int*));
	    for (int i=0;i<n;i++) pmat[i]=(int*)malloc(m*sizeof(int));
	    return pmat;
}

Functia primeste ca date de intrare numarul de linii n si numarul de coloane m al matricei si intoarce un pointer la aceasta.

Matricea X de dimensiuni n=4 si m=3,

Matrix example

Matrix example

, unde n este numarul de linii si m este numarul de coloane, este alocata in memorie ca in figura .

Dynamic memory allocation for a matrix

Dynamic memory allocation for a matrix

La inceput este alocata zona de memorie pentru un vector de pointeri, care reprezinta inceputul fiecarei linii a matricei. Vectorul contine n componente. Urmeaza alocarea zonei de memorie pentru fiecare linie a matricei. Linia matricei este alcatuita din m elemente. Dupa alocarea spatiului necesar memorarii matricei se continua cu introducerea elementelor matricei.

O alta functie de intrare este functia de supraancarcare a operatorului de shiftare la dreapta “>>“. Aceasta este declarata ca functie prietena si are urmatoarea forma:

istream &operator>>(istream &c,matrix &a)
		    {
		    //clrscr();
			cout<<"The matrix is:";
			for(int i=0;i<a.n;i++)
			      for(int j=0;j<a.m;j++)
				 {
				 cout<<"\n a["<<i<<"]["<<j<<"]=";
				 c>>a.a[i][j];
				 }
			  return c;
	 }

Operatorul “>>” realizeaza introducerea elementelor matricei, deoarece citirea unei matrice de la tastatura este realizata atunci cand este apelat constructorul cu parametrii, adica constructorul care initializeaza numarul de linii si de coloane ale matricei cu datele dorite, precum si elementele matricei cu zero. Daca este apelat constructorul implicit acesta realizeaza citirea numarului de linii, numarului de coloane si elementele matricei. Deci recitirea numarului de linii si de coloane este inutila. A se retine insa faptul ca operatorul de shiftare la dreapta este asociat unor obiecte create cu constructorul cu parametrii.

Constructorul cu parametrii amintit mai sus are structura urmatoare:

                     matrix::matrix(int k,int l)
		              {
		               n=k;
		               m=l;
		               a=aloc_mat(n,m);
		              for(i=0;i<n;i++)
		                      for (j=0;j<m;j++) a[i][j]=0;
		                }

Asadar au fost prezentate functiile de intrare de la consola la nivel de matrice. Au fost prezentate in paralel modul de alocare static si varianta dinamica.

In continuare sunt prezentate functiile care creaza matricele speciale. Prezentarea este facuta in paralel( static si dinamic).

Revenim la biblioteca matrice.h pentru prezentarea functiei de creare a matricei unitate. Acesta este realizata cu functia void creating_unit(int *n,int *m, int x[30][30]). Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea unitate.

Secventa care realizeaza crearea matricei unitate este urmatoarea:

void creating_unit(int *m,int *n,int x[30][30])
{
int i,j;
printf("\n Matrix is square,so lines number = columns numbers");
printf("\n Lines and columns number:");
 
scanf("%d",n);
valid_l_c(n);
*m=*n;
 
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
    if(i==j) x[i][j]=1;
       else x[i][j]=0;
}

Matricea unitate presupune o matrice patratica si de aceea numarul de coloane si linii este citit in aceeasi secventa.

In clasa matrix matricea unitate este creata cu ajutorul functiei membru void creating_unit() . Desi se lucreaza cu o matrice alocata dinamic nu mai este necesara alocarea spatiului de memorie deoarece acesta a fost pus la dispozitie in momentul apelarii constructorului cu parametrii. De retinut ca toate functiile de creare a matricelor speciale sunt asociate obiectelor create cu constructorul cu parametrii. Secventa care realizeaza aceasta este urmatoarea:

void matrix::creating_unit()
{
////clrscr();
for (i=0;i<n;i++)
    for(j=0;j<=i;j++)
		     if (i==j) a[i][j]=1;
			      else a[i][j]=a[j][i]=0;
}

Deci, singura diferenta dintre functia creating_unit din matrice.h si functia creating_unit din clasa matrix este aceea ca in functia membra clasei citirea numarul de linii si de coloane nu mai este necesara. Numarul este cunoscut, n si m fiind membrii in clasa si sunt initializati prin apelarea constructorului cu parametrii.

Functia void creating_column_1(int *n,int *m, int x[30][30]) creaza matricea cu valoarea 1 pe o coloana dorita, care se introduce de la tastatura, si in rest elementele matricei vor fi zero. Functia primeste urmatorii parametrii:

  • int *n- parametru de iesire si reprezinta numarul de linii;
  • int *m- parametru de iesire si reprezinta numarul de coloane;
  • int x[30][30]-parametru de iesire si reprezinta matricea ce este obtinuta prin apelarea acestei functii.

Secventa care realizeaza crearea matricei cu valoarea 1 pe o coloana dorita este urmatoarea:

void creating_column_1(int *m,int *n,int x[30][30])
{
int i,j,c,k;
 
printf("\n The matrix lines number:");
scanf("%d",n);
valid_l_c(n);
 
printf("\n The matrix columns number:");
scanf("%d",m);
valid_l_c(m);
 
printf("\n The column with elements one is:");
k=scanf("%d",&c);
 
if ((c<1)|(k==0)|(c>*m))
	{
	fflush(stdin);
	do
	   {
	   k=1;
	   printf("\n Eror, retype the column number(between 1 and %d):");
	   k=scanf("%d",&c);
	   if((c<1)|(c>*m)) k=0;
	   fflush(stdin);
	   }
	   while(k==0);
	}
c--;
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
   {
    if(j==c) x[i][c]=1;
       else x[i][j]=0;
   }
}

In clasa matrix matricea cu 1 pe coloana dorita este realizata cu functia membra void creating_column_1(int c). Acesta are ca parametru de intrare int c care reprezinta coloana cu elementele 1. Secventa care realizeaza crearea matricei este urmatoarea:

void matrix::creating_column_1(int c)
{
if (c<m)
   for (i=0;i<n;i++)
	for (j=0;j<m;j++)
		  if (j==c) a[i][c]=1;
			 else a[i][j]=0;
       else cout<<"Column doesn't exist!";
}

In clasa, coloana dorita a fi 1 este primita ca parametru in timp ce in functia din biblioteca matrice.h este citita de la tastatura.

Functia void creating_line_1(int *n,int *m, int x[30][30]) creaza matricea cu valoarea 1 pe o linie dorita, care se introduce de la tastatura, si in rest elementele matricei vor fi zero. Functia primeste urmatorii parametrii:

  • int *n- parametru de iesire si reprezinta numarul de linii;
  • int *m- parametru de iesire si reprezinta numarul de coloane;
  • int x[30][30]-parametru de iesire si reprezinta matricea ce este obtinuta prin apelarea acestei functii.

Secventa care realizeaza crearea matricei cu valoarea 1 pe o linie dorita este urmatoarea:

void creating_line_1(int *m,int *n,int x[30][30])
{
int i,j,k,l;
 
printf("\n The matrix lines number:");
scanf("%d",n);
valid_l_c(n);
 
printf("\n The matrix columns number:");
scanf("%d",m);
valid_l_c(m);
 
printf("\n The line with elements one is:");
k=scanf("%d",&l);
 
if ((k==0)|(l<1)|(l>*n))
	{
	fflush(stdin);
	do
	   {
	   k=1;
	   printf("\n Eror, retype the line number(between 1 and %d):");
	   k=scanf("%d",&l);
	   if((l<1)|(l>*n)) k=0;
	   fflush(stdin);
	   }
	   while(k==0);
	}
l--;
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
   {
    if(i==l) x[i][j]=1;
       else x[i][j]=0;
   }
}

In clasa matrix matricea cu 1 pe linia dorita este realizata cu functia membra void creating_line_1(int l). Acesta are ca parametru de intrare int l care reprezinta linia cu elementele 1. Secventa care realizeaza crearea matricei este urmatoarea:

void matrix::creating_line_1(int l)
{
if (l<n)
   for (i=0;i<n;i++)
	for (j=0;j<m;j++)
		  if (i==l) a[l][j]=1;
			 else a[i][j]=0;
       else cout<<"Line doesn't exist!";
}

In clasa linia dorita a fi 1 este primita ca parametru in timp ce in functia din biblioteca matrice.h este citita de la tastatura.

Functia void creating_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 1 pe diagonala secundara, restul elementelor matricei avand valoarea 0. Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 1 pe diagonala secundara.

Secventa care realizeaza crearea matricei cu 1 pe diagonala secundara este urmatoarea:

void creating_sec_diag(int *n,int *m,int a[30][30])
{
int i,j,k;
clrscr();
 
printf("\n Matrix lines number:");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix columns number:");
scanf("%d",m);
valid_square(m,*n);
 
for (i=0;i<*n;i++)
    for(j=0;j<*n;j++)
		 if (j==((*n)-i-1)) a[i][j]=1;
			    else a[i][j]=0;
}

Matricea cu valoarea 1 pe diagonala secundara presupune matricea patratica si de aceea este folosita functia de validare valid_square(m,*n). Ea verifica daca numarul liniilor si cel al coloanelor este egal. In cazul in care sunt diferite este afisat mesajul Error si se cere o noua introducere a numarului de coloane.

In clasa matrix matricea cu 1 pe diagonala secundara este creata cu ajutorul functiei membru void creating_sec_diag(). Secventa care realizeaza aceasta este urmatoarea:

void matrix::creating_sec_diag()
{
////clrscr();
for (i=0;i<n;i++)
    for(j=0;j<n;j++)
		  if (j==((n)-i-1)) a[i][j]=1;
			      else a[i][j]=a[j][i]=0;
}

Numarul de linii si de coloane este cunoscut, n si m fiind membrii in clasa si sunt initializati prin apelarea constructorului cu parametrii.

Functia void creating_0_up_main_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 deasupra diagonalei principale, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 deasupra diagonalei principale.

Secventa care realizeaza crearea matricei cu 0 deasupra diagonalei principale este urmatoarea:

void creating_0_up_main_diag(int *n,int *m,int a[30][30])
{
int i,j,k,l;
clrscr();
 
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix column number :");
scanf("%d",m);
valid_square(m,*n);
clrscr();
 
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
     if	 (i>=j)
     {
     printf("\n a[%d][%d]=",i,j);
     l=scanf("%d",&a[i][j]);
     valid_no_integer(&a[i][j],l);
     }
        else a[i][j]=0;
}

and the class method

void matrix::creating_0_up_main_diag()
{
////clrscr();
cout<<"\nThe matrix is :\n";
if (n==m)
    for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
		    if	 (i>=j){
			  cout<<"\n a["<<i<<"]["<<j<<"]=";
			  cin>>a[i][j];
				 }
			   else a[i][j]=0;
    else { cout<<"The matrix must be a square!";
	  return;}
}

Dinamic, adica in clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_up_main_diag(). Continutul functiei este acelasi cu cel al functie de mai sus. Cum se lucreaza cu obiecte nu mai este necesara citirea numarului de linii si de coloane.

Functia void creating_0_main_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 pe diagonala principala, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 pe diagonala principala.

Secventa care realizeaza crearea matricei cu 0 pe diagonala principala este urmatoarea:

void creating_0_main_diag(int *n,int *m,int a[30][30])
{
int i,j,k,l;
clrscr();
 
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix column number:");
scanf("%d",m);
valid_square(m,*n);
clrscr();
 
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
     if	 (i!=j)
     {
     printf("\n a[%d][%d]=",i,j);
     l=scanf("%d",&a[i][j]);
     valid_no_integer(&a[i][j],l);
     }
       else a[i][j]=0;
}

In clasa matrix, functia care realizeaza aceasta operatie se numeste creating_0_main_diag(). Functia este declarata ca functie membra fara tip. Continutul functiei este acelasi cu cel al functie de mai sus. Cum se lucreaza cu obiecte nu mai este necesara citirea numarului de linii si de coloane.

Functia void creating_0_under_main_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 sub diagonala principala, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:

int *n- parametru de iesire si reprezinta liniile matricei x;

int *m- parametru de iesire si reprezinta coloanele matricei x;

int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 sub diagonala principala.

Secventa care realizeaza crearea matricei cu 0 sub diagonala principala este urmatoarea:

void creating_0_under_main_diag(int *n,int *m,int a[30][30])
{
int i,j,k,l;
clrscr();
 
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix columns number :");
scanf("%d",m);
valid_square(m,*n);
clrscr();
 
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
     if	 (i<=j)
     {
     printf("\n a[%d][%d]=",i,j);
     l=scanf("%d",&a[i][j]);
     valid_no_integer(&a[i][j],l);
     }
	 else a[i][j]=0;
}

Dinamic, adica in clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_under_main_diag().

Functia creating_0_under_main_diag() este functie membra fara tip si are acelasi continut cu functia creating_0_under_main_diag() din biblioteca matrice.h, mai putin citirea numarului de linii si de coloane. Initializarea lor este realizata prin apelarea constructorului cu parametrii.

Functia void creating_0_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 pe diagonala secundara, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 pe diagonala secundara.

Secventa care realizeaza crearea matricei cu 0 pe diagonala secundara este urmatoarea:

void creating_0_sec_diag(int *n,int *m,int a[30][30])
{
int i,j,k,l;
clrscr();
 
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix columns number :");
scanf("%d",m);                       
valid_square(m,*n);
clrscr();
 
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
     if	 (j!=*n-i-1)
     {
     printf("\n a[%d][%d]=",i,j);
     l=scanf("%d",&a[i][j]);
     valid_no_integer(&a[i][j],l);
     }
	 else a[i][j]=0;
}

In clasa matrix, functia care realizeaza aceasta operatie se numeste creating_0_sec_diag(). Functia este declarata ca functie membra fara tip. Continutul functiei este acelasi cu cel al functie de mai sus, mai putin citirea numarului de linii si de coloane care sunt initializate in momentul apelarii constructorului cu parametrii.

Functia void creating_0_up_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 deasupra diagonalei secundare, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 deasupra diagonalei secundare.

Secventa care realizeaza crearea matricei cu 0 deasupra diagonalei secundare este urmatoarea:

void creating_0_up_sec_diag(int *n,int *m,int a[30][30])
{
int i,j,k,l;
clrscr();
 
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix columns number :");
scanf("%d",m);
valid_square(m,*n);
clrscr();
 
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
     if	 (i+j>=*n-1)
     {
     printf("\n a[%d][%d]=",i,j);
     l=scanf("%d",&a[i][j]);
     valid_no_integer(&a[i][j],l);
     }
	 else a[i][j]=0;
}

Dinamic, adica in clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_up_sec_diag(). Continutul functiei este acelasi cu cel al functie de mai sus, mai putin citirea numarului de linii si de coloane deoarece se lucreaza cu obiecte si nu mai este necesara citirea lor.

Functia void creating_0_under_sec_diag(int *n, int *m, int x[30][30]) creaza matricea cu 0 sub diagonala secundara, restul elementelor matricei fiind citite de la tastatura. Functia primeste ca parametrii urmatoarele variabile:

  • int *n- parametru de iesire si reprezinta liniile matricei x;
  • int *m- parametru de iesire si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de iesire si reprezinta matricea care are valoarea 0 sub diagonala secundara.

Secventa care realizeaza crearea matricei cu 0 sub diagonala secundara este urmatoarea:

void creating_0_under_sec_diag(int *n,int *m,int a[30][30])
{
int i,j,k,l;
clrscr();
 
printf("\n Matrix lines number :");
scanf("%d",n);
valid_l_c(n);
clrscr();
 
printf("\n Matrix columns number :");
scanf("%d",m);
valid_square(m,*n);
clrscr();
 
printf("\n The matrix is:\n");
for(i=0;i<*n;i++)
   for(j=0;j<*m;j++)
     if	 (i+j<=*n-1)
     	{
	printf("\n a[%d][%d]=",i,j);
	l=scanf("%d",&a[i][j]);
	valid_no_integer(&a[i][j],l);
	}
	 else a[i][j]=0;
}

Dinamic, adica in clasa matrix , functia care realizeaza aceasta operatie se numeste creating_0_under_sec_diag().Functia creating_0_under_sec_diag() este functie membra fara tip si are acelasi continut cu functia creating_0_under_sec_diag() din biblioteca matrice.h, mai putin citirea numarului de linii si de coloane. Initializarea este realizata prin apelarea constructorului cu parametrii.

Functia void creating_bool_matrix(int n, int m, int x[30][30], int b[30][30]) creaza matricea booleana. Matricea booleana este matricea ale carei elemente pot lua valori in multimea {0,1}. Matricea booleana este de obicei asociata intotdeauna unei alte matrice.

Functia primeste ca parametrii urmatoarele variabile:

  • int n- parametru de intrare si reprezinta liniile matricei x;
  • int m- parametru de intrare si reprezinta coloanele matricei x;
  • int x[30][30]- parametru de intrare si reprezinta matricea careia i se asociaza matricea booleana;
  • int b[30][30]- parametru de iesire si reprezinta matricea booleana asociata matricei x.

Secventa care realizeaza crearea matricei booleane este urmatoarea:

void creating_bool_matrix(int n,int m,int a[30][30],int b[30][30])
{
int i,j;
for (i=0;i<n;i++)
     for(j=0;j<m;j++)
	     if (a[i][j]==0)  b[i][j]=0;
			else b[i][j]=1;
}

In clasa matrix matricea booleana este obtinuta cu ajutorul functiei membre fara tip creating_bool_matrix(matrix &). Functia primeste ca parametru de iesire un obiect de tip matrix care se transfera prin referinta. Parametrul de intrare este reprezentat de pionterul this caruia i se asociaza obiectul de tip matrix , matrice booleana. Functia este urmatoarea :

void matrix::creating_bool_matrix(matrix &b)
{
for (i=0;i<n;i++)
      for (j=0;j<m;j++) if (a[i][j]==0) b.a[i][j]=0;
				   else b.a[i][j]=1;
}

Dupa efectuarea operatiilor este foarte important sa vizualizam efectele create. Acesta se realizeaza cu ajutorul functiilor de iesire. In cazul de fata sunt realizate numai functii de iesire catre monitor. Exista functii de iesire care transmit informatia unei imprimante, unui fisier sau mai multor fisiere etc.

Afisarea pe ecran este obtinuta in cazul lucrului in mod static cu ajutorul functiei void show_matrix(int n,int m,int x[30][30]), in timp ce in modul de lucru dinamic( implementat in clasa matrix) este realizat prin supraancarcarea operatorului de shiftare la stanga “<<”, care lucreaza acum la nivel de obiecte de tip matrix.

Functia show_matrix(n,m,x) afiseaza pe ecran matricea x. Ea are ca parametrii de intrare :

  • int n- numarul de linii;
  • int m- numarul de coloane;
  • int x[30][30]-matricea care este afisata.

Functia este urmatoarea:

void show_matrix(int n,int m,int x[30][30])
{
int i,j;
printf("\n The matrix is:\n");
for (i=0;i<n;i++)
{for (j=0;j<m;j++)
	printf(" %3d ",x[i][j]);
	printf("\n");}
}

Daca avem de exemplu matricea de 3 linii si 3 coloane, care are elementele 1,2,3,4,5,6,7,8,9 dupa apelul acestei functii pe ecran sunt afisate urmatoarele:

The matrix is:
1   2   3
4   5   6
7   8   9

Operatorul de shiftare la stanga “<<” are ca efect exact acelasi mesaj ca si functia show_matrix. El a fost supraancarcat ca functie prietena astfel:

ostream &operator<<(ostream &c,matrix &a)
{
int i,j;
if((a.n!=0)&&(a.m!=0))
		{
	      cout<<"\n The matrix is : \n";
	      for (i=0;i<a.n;i++) {
			     cout<<"\n\t";
			     for (j=0;j<a.m;j++)
				      c<<"\t"<<a.a[i][j];
				  }
		 }
      else cout<<"\nNothing to list !!!";
return c;
}

Functii prezentate in acest capitol fac parte din grupul procedurilor de calcul care sunt utilizate in capitolele urmatoarea pentru exemplificarea aplicabilitatii calculului matriceal.

Datorita necesitatilor ulterioare sunt incluse in biblioteca matrice.h si functiile creation_float(&n,&m,x), creating_unit_float(n,m,x) si show_matrix_float(n,m,x). Diferenta dintre aceste functii si functiile prezentate in acest capitol consta in tipul elementelor matricei. Matricea este declarata astfel:

float x[30][30];

Asadar comentariile pentru aceste functii sunt identice cu cele corespondente functiilor prezentate in acest capitol, care au ca parametru de intrare un masiv bidimensionl cu elemente intregi.

Calculul matriceal presupune existenta matricelor. Aceasta problema este rezolvata cu ajutorul functiilor de intrare. Pentru monitorizarea efectelor obtinute in urma operatiilor realizate sunt foarte necesare functiile de iesire. De aceea functiile de intrare si iesire trebuie tratate cu toata seriozitatea de catre programatori.

,