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

No comments -

Functiile de prelucrare in matrice sunt acele functii care fac diferite operatii matematice, operatii de interschimbare, numarare, modificare, stergere, inlocuire asupra elementelor unei matrice modificând-o in cele mai multe cazuri.


Toate aceste functii sunt diferite intre ele, nu numai prin ceea ce fac ele, ci si prin parametrii care ii primesc sau prin valorile returnate. Totusi toate functiile din acest tutorial primesc ca date de intrare un set standard de date si anume : n numarul de linii, m numarul de coloane si matricea respectiva X sau A, matricea fiind definita static.

Urmatoarele 2 functii primesc ca date de intrare dimensiunile matricei, adica n numarul de linii si m numarul de coloane, si matricea respectiva X , definita static. Functiile sunt bubble_sort_line si bubble_sort_column si ele sorteaza o linie respectiv coloana a matricei prin metoda bulelor. Linia respectiv coloana de sortat este data functiei in interiorul ei de catre utilizator. Cum aceste doua functii nu modifica dimensiunile matricei si lucreaza doar cu valorile elementelor matricei, functiile nu returneaza nici o valoare.

Prima functie este :

void bubble_sort_line(int n,int m,int x[30][30])
{
int i,j,k,a,l,b;
//se citeste numarul linie de sortat
printf("\n The sorting line is:");
b=scanf("%d",&l);
//se sorteaza cu metoda bulelor
for (j=0;j<m-1;j++)
    for(k=j+1;k<m;k++)
	if (x[l-1][j]>x[l-1][k])
	{
	for (i=0;i<n;i++)
	    {
	    a=x[i][j];
	    x[i][j]=x[i][k];
	    x[i][k]=a;
	    }
	}
}

iar ce de-a doua functie este :

void bubble_sort_column(int n,int m,int x[30][30])
{
int i,j,k,a,c,b;
printf("\n The sorting column is:");
//se citeste numarul coloanei de sortat
b=scanf("%d",&c);
 
//se sorteaza cu metoda bulelor
for (i=0;i<n-1;i++)
    for(k=i+1;k<n;k++)
	if (x[i][c-1]>x[k][c-1])
	{
	for (j=0;j<m;j++)
	     {
	     a=x[i][j];
	     x[i][j]=x[k][j];
	     x[k][j]=a;
	     }
	}
}

Functiile void lines_sum si columns_sum afla suma elementelor matricei de pe fiecare linie, respectiv de pe fiecare coloana. Pe lânga setul standard de date de intrare (n, m, si X), functiile primesc un vector definit static cu maxim 30 de elemente, int y[30], si adresa unei variabile de tip intreg, int *v

In acel vector se vor memora sumele de pe fiecare linie, respectiv coloana, iar la adresa variabilei se va scrie dimensiunea vectorului, care este egala cu numarul de linii/coloane. Astfel la terminarea apelului functiei vom avea vectorul de sume si dimensiunea lui.

Functiile sunt :

void lines_sum(int n,int m,int x[30][30],int y[30],int *v)
{
int i,j,s;
for(i=0;i<n;i++) //se calculeaza sumele si se scriu in vector
   {
   s=0;
   for(j=0;j<m;j++)
   	s+=x[i][j];
   y[i]=s;
   }
//se retine dimensiunea vectorului
*v=n;
}

si respectiv :

void columns_sum(int n,int m,int x[30][30],int y[30],int *v)
{
int i,j,s;
for(j=0;j<m;j++)
   {
   s=0;
   for(i=0;i<n;i++)
        s+=x[i][j];
   y[j]=s;    //se calculeaza sumele si se scriu in vector
   }
*v=m; //se retine dimensiunea vectorului
}

Urmatoarea pereche de functii interchange_lines si interchange_columns interschimba doua linii, respectiv doua coloane ale matricei intre ele. Si aceste doua functii primesc dimensiunile matricei, n si m, si matricea X in care se lucreaza. Ele mai au ca date de intrare si pozitiile in matrice al celor doua linii/coloane care se interschimba. In interiorul functiilor exista validari ale acestor pozitii.

Cele doua functii sunt :

void interchange_lines(int n,int m,int x[30][30],int a,int b)
{
int i,j,var;
//validarea celor doua pozitii ale liniilor
if((a>n-1)|(a<0)|(b>n-1)|(b<0)) printf("\n Interchanging is not posible!");
   else
   {
   for(j=0;j<m;j++) //interschimbarea liniilor
	  {
	  var=x[a][j];
	  x[a][j]=x[b][j];
	  x[b][j]=var;
	  }
   }
}

si

void interchange_columns(int n,int m,int x[30][30],int a,int b)
{
int i,j,var;
//validarea celor doua pozitii ale coloanelor
if((a>m-1)|(a<0)|(b>m-1)|(b<0)) printf("\n Interchanging is not posible!");
   else
   {
   for(i=0;i<n;i++)// interschimbarea coloanelor
	  {
	  var=x[i][a];
	  x[i][a]=x[i][b];
	  x[i][b]=var;
	  }
   }
}

Cele doua functii care urmeaza column_sort si lines_sort au ca parametrii de intrare dimensiunile matricei si matricea in care se lucreaza. Functiile sorteaza coloanele, respectiv liniile matricei in functie de suma elementelor lor. Pentru a face acest lucru functiile vor apela functia care calculeaza sumele dupa care se sorteaza, adica columns_sum si lines_sort, si functia de interschimbare a doua coloane/linii.

Functiile nu returneaza nici o valoare, ci doar modifica valorile elementelor matricei.

Functiile sunt :

void column_sort(int n,int m,int x[30][30])
{
int i,j,h[30],v;
columns_sum(n,m,x,h,&v); //se calculeaza sumele pe coloane
// se sorteaza prin interschimbarea coloanelor intre ele.
for(j=0;j<m-1;j++)
    for(i=j;i<m;i++)
       if(h[i]<h[j]) interchange_columns(n,m,x,i,j);
}
 
void lines_sort(int n,int m,int x[30][30])
{
int i,j,h[30],v;
lines_sum(n,m,x,h,&v);//se calculeaza sumele pe linii
// se sorteaza prin interschimbarea liniilor intre ele.
for(i=0;i<n-1;i++)
    for(j=i;j<n;j++)
       if(h[j]<h[i]) interchange_lines(n,m,x,i,j);
}

Urmeaza o serie de functii care vor avea ca parametrii de intrare : dimensiunile matricei, m si n, matricea si adresa unei variabile de tip integer numita s. La aceasta adresa, functia va scrie suma anumitor elemente ale matricei, elemente selectate dupa o caracteristica.

Aceste functii sunt :

  • main_diag_sum care calculeaza suma elementelor din matrice care se afla pe diagonala principala.
void main_diag_sum(int n,int m,int x[30][30],int *s)
{
int i;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square!");
  else
  {
  for(i=0;i<n;i++)
	 *s+=x[i][i]; //suma elementelor de pe diagonala principala
  printf("\n The sum is %d",*s);
  }
}
  • sec_diag_sum care calculeaza suma elementelor din matrice care se afla pe diagonala secundara.
void sec_diag_sum(int n,int m,int x[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square!");
  else
  {
  for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
	       if((i+j)==(n-1)) *s+=x[i][i]; //suma elementelor de pe diagonala secundara
  printf("\n The sum is %d",*s);
  }
}
  • up_main_diag_sum care calculeaza suma elementelor din matrice aflate deasupra diagonalei principale
void up_main_diag_sum(int n,int m,int x[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square!");
   else
   {
   for(i=0;i<n;i++)
	  for(j=0;j<m;j++)
	      if(j>i) *s+=x[i][j]; //suma elementelor de deasupra diagonalei principale 
   printf("\n Above main elements sum is :%d",*s);
   }
}
  • down_main_diag_sum care calculeaza suma elementelor din matrice aflate sub diagonala principala
void down_main_diag_sum(int n,int m,int x[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square!");
   else
   {
   for(i=0;i<n;i++)
	  for(j=0;j<m;j++)
	      if(j<i) *s+=x[i][j]; //suma elementelor de sub  diagonala principala
   printf("\n Under main elements sum is:%d",*s);
   }
}
  • up_sec_diag_sum care calculeaza suma elementelor din matrice aflate deasupra diagonalei secundare
void up_sec_diag_sum(int n,int m,int x[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
   else
   {
   for(i=0;i<n;i++)
	  for(j=0;j<m;j++)
	      if((i+j)<(n-1)) *s+=x[i][j]; 
//suma elementelor de deasupra  diagonalei secundara
   printf("\n Above secondary   elements sum is %d",*s);
   }
}
  • down_sec_diag_sum care calculeaza suma elementelor din matrice aflate sub diagonala principala
void down_sec_diag_sum(int n,int m,int x[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
   else
   {
   for(i=0;i<n;i++)
	  for(j=0;j<m;j++)
	      if((i+j)>(n-1)) *s+=x[i][j]; //suma elementelor de sub diagonala secundara
   printf("\n Under secondary   elements sum is%d",*s);
   }
}
  • elem_sum care calculeaza suma tuturor elementelor din matrice
void elem_sum(int n,int m,int x[30][30],int *s)
{
int i,j;
*s=0;
for(i=0;i<n;i++)
   for(j=0;j<m;j++)
   *s+=x[i][j];// se calculeaza suma
printf("\n Matrix elements sum is %d",*s);
}
  • up_with_main_diag_sum care calculeaza suma elementelor din matrice aflate deasupra si pe diagnala secundara
void up_with_main_diag_sum(int n,int m,int a[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
       else
       {
       for(i=0;i<n;i++)
	  for(j=0;j<m;j++)
	      if(j>=i) *s+=a[i][j];//se calculeaza suma
       printf("\n The main diagonal and above it elements' sum is%d",*s);
       }
getch();
}
  • down_with_main_diag_sum care calculeaza suma elementelor din matrice aflate sub si pe diagonala principala
void down_with_main_diag_sum(int n,int m,int a[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
       else
       {
       for(i=0;i<n;i++)
	  for(j=0;j<m;j++)
	      if(j<=i) *s+=a[i][j];//se calculeaza suma
       printf("\n The main diagonal and under it elements' sum is  %d",*s);
       }
getch();
}
  • down_with_sec_diag_sum care calculeaza suma elementelor din matrice aflate sub si pe diagonala secundara
void down_with_sec_diag_sum(int n,int m,int a[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
	else
	{
	for(i=0;i<n;i++)
	    for(j=0;j<m;j++)
	        if((i+j)<=(n-1)) *s+=a[i][j];//se calculeaza suma
	printf("\n The secondary diagonal and above it elements' sum is %d",*s);
	}
getch();
}
  • up_with_sec_diag_sum care calculeaza suma elementelor din matrice aflate deasupra si pe diagonala secundara
void up_with_sec_diag_sum(int n,int m,int a[30][30],int *s)
{
int i,j;
*s=0;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
   else
   {
   for(i=0;i<n;i++)
       for(j=0;j<m;j++)
           if((i+j)>=(n-1)) *s+=a[i][j];//se calculeaza suma
   printf("\n The secondary diagonal and under it elements' sum is %d",*s);
   }
getch();
}

Asemanatoare cu functiile prezentate anterior, din punctul de vedere al parametrilor de intrare sunt si urmatoarele. Singura diferenta este aceea ca la adresa variabilei de tip integer nu se va mai scrie valoarea unei sume de elemente ale matricei ci, se va scrie valoarea unui element al matricei, cum ar fi valoarea minima sau valoarea maxima.

  • minim care gaseste valoarea minima a elementelor matricei
void minim(int n,int m,int x[30][30],int *min)
{
int i,j,i1,j1,a;
*min=x[0][0];//se initializeaza minimul cu primul element din matrice
for(i=0;i<n;i++)
   for(j=0;j<m;j++)
       if (*min>x[i][j])//se gaseste valoarea minima
       {
       *min=x[i][j];
       i1=i;
       j1=j;
       }
printf("\n The minimum element is %d and it is on line %d and column%d",*min,j1,i1);
}
  • maxim care gaseste valoarea maxima a elementelor din matrice
void maxim(int n,int m,int x[30][30],int *max)
{
int i,j,i1,j1,a;
*max=x[0][0];//se initializeaza maximul cu primul element al matricei 
 
for(i=0;i<n;i++)
   for(j=0;j<m;j++)
       if (*max<x[i][j])// se gaseste maximul
       {
       *max=x[i][j];
       i1=i;
       j1=j;
       }
printf("\n The maximum element is %d and it is on line %d and column %d",*max,j1,i1);
}
  • max_up_main care gaseste valoarea maxima a elementelor matricei aflate deasupra diagonalei principale
void max_up_main(int n,int m,int x[30][30],int *max)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
	*max=x[0][m-1];
	for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
		if (i<j) if(*max<x[i][j]) *max=x[i][j]; //gasirea maximului
	printf("\n The maximum element above main is %d",*max);
  }
}
  • min_up_main care gaseste valoarea minima a elementelor din matrice aflate deasupra diagonalei principale
void min_up_main(int n,int m,int x[30][30],int *min)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
	*min=x[0][m-1];
	for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
		if (i<j) if(*min>x[i][j]) *min=x[i][j];//se gaseste minimul
	printf("\n The minimum element above main is %d",*min);
  }
}
  • max_down_main care gaseste valoarea maxima a elementelor din matrice aflate sub diagonala principala
void max_down_main(int n,int m,int x[30][30],int *max)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
	*max=x[n-1][0];
	for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
		if (i>j) if(*max<x[i][j]) *max=x[i][j]; //se gaseste maximul
	printf("\n The maximum element under is %d",*max);
  }
}
  • min_down_main care gaseste valoarea minima a elementelor matricei aflate sub diagonala principala
void min_down_main(int n,int m,int x[30][30],int *min)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
	*min=x[n-1][0];
	for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
		if (i>j) if(*min>x[i][j]) *min=x[i][j];//se gaseste minimul
	printf("\n The minimum element under main is %d",*min);
  }
}
  • max_down_sec care gaseste valoarea maxima a elementelor matricei aflate sub diagonala secundara
void max_down_sec(int n,int m,int x[30][30],int *max)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
	*max=x[n-1][m-1];
	for(i=0;i<n;i++)
	   for(j=0;j<m;j++)
		if (i+j>n-1) if(*max<x[i][j]) *max=x[i][j];//se gaseste maximul
	printf("\n The maximum element under secondary is %d",*max);
  }
}
  • min_down_sec care gaseste valoarea minima a elementelor matricei aflate sub diagonala secundara
void min_down_sec(int n,int m,int x[30][30],int *min)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
  	*min=x[n-1][m-1];
  	for(i=0;i<n;i++)
      	    for(j=0;j<m;j++)
               if (i+j>n-1) if(*min>x[i][j]) *min=x[i][j];//se gaseste minimul
  	printf("\n The minimum element under secondary diagonal is %d",*min);
  }
}
  • min_main_diag care gaseste valoarea minima a elementelor din matrice aflate pe diagonala principala
void min_main_diag(int n,int m,int a[30][30],int *min)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if (n!=m) printf("The matrix is not a square !");
	else
	{
	*min=a[0][0];
	for(i=0;i<n;i++)
	   if (*min>a[i][i])  *min=a[i][i];//se gaseste minimul
	printf("\n Main diagonal minimum element is: %d ",*min);
	getch();
	}
}
  • max_main_diag care gaseste valoarea maxima a elementelor din matrice aflate pe diagonala principala
void max_main_diag(int n,int m,int a[30][30],int *max)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if (n!=m) printf("The matrix is not a square !");
	else
	{
	*max=a[0][0];
	for(i=0;i<n;i++)
	   if (*max<a[i][i])   *max=a[i][i];//se gaseste maximul
	printf("\n Main diagonal maximum element is  %d ",*max);
	getch();
	}
}
  • min_sec_diag care gaseste valoarea minima a elementelor din matrice aflate pe diagonala secundara
void min_sec_diag(int n,int m,int a[30][30],int *min)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if (n!=m) printf("The matrix is not a square !");
	else
	{
	*min=a[0][n-i-1];
	for(i=0;i<n;i++)
	    if (*min>a[i][n-i-1])  *min=a[i][n-i-1];//se gaseste minimul
	printf("\n Secondary diagonal minimum element is: %d ",*min);
	getch();
	}
getch();
}
  • max_sec_diag care gaseste valoarea maxima a elementelor din matrice aflate pe diagonala secundara
void max_sec_diag(int n,int m,int a[30][30],int *max)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if (n!=m) printf("The matrix is not a square !");
	else
	{
	*max=a[0][n-i-1];
	for(i=0;i<n;i++)
	   if (*max<a[i][n-i-1])    *max=a[i][n-i-1];//se gaseste maximul
	printf("\n Secondary diagonal maximum element is%d ",*max);
	getch();
	}
}
  • max_up_sec care gaseste valoarea maxima a elementelor din matrice aflate deasupra diagonalei secundare
void max_up_sec(int n,int m,int a[30][30],int *max)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
  *max=a[0][0];
  for(i=0;i<n;i++)
     for(j=0;j<m;j++)
	 if (i+j<n-1)
	    if(*max<a[i][j]) *max=a[i][j];//se gaseste maximul
  printf("\n The maximum element above secondary diagonal is %d",*max);
  }
}
  • min_up_sec care gaseste valoarea minima a elementelor din matrice aflate deasupra diagonalei secundare
void min_up_sec(int n,int m,int a[30][30],int *min)
{
int i,j;
//validare a matricei (trebuie sa fie patratica)
if(n!=m) printf("\n The matrix is not a square !");
  else
  {
  *min=a[0][0];
  for(i=0;i<n;i++)
     for(j=0;j<m;j++)
	 if (i+j>n-1)
	     if(*min>a[i][j]) *min=a[i][j];//se gaseste minimul
  printf("\n The minimum element above secondary diagonal is %d",*min);
  }
}

Functiile lines_min, lines_max si columns_min, columns_max vor afla elementele minime si maxime de pe fiecare linie, respectiv coloana si le vor scrie intr-un vector. Parametrii de intrare ale acestor functii sunt aceiasi la toate si anume : n numarul de linii al matricei, m numarul de coloane al matricei, X[ ][ ] matricea respectiva, h[ ] vectorul in care se scriu valorile minime sau maxime si adresa unei variabile intregi la care se va scrie valoarea numarului de elemente ale vectorului.

  • functia lines_min va afla minimul elementelor de pe fiecare linie.
void lines_min(int n,int m,int x[30][30],int h[30],int *l)
{
int i,j,min;
for(i=0;i<n;i++)
    {
    min=x[i][0];
    for(j=0;j<m;j++)
       if (min>x[i][j]) min=x[i][j];
    h[i]=min;//se afla minimul pe linia i
    }
*l=n;//se scrie dimensiunea vectorului
}
  • functia columns_min gaseste minimul elementelor de pe fiecare coloana
void columns_min(int n,int m,int x[30][30],int h[30],int *l)
{
int i,j,min;
for(j=0;j<m;j++)
    {
    min=x[0][j];//se initializeaza minimul
    for(i=0;i<n;i++)
       if (min>x[i][j]) min=x[i][j];
    h[j]=min;//minimul pe coloana j
    }
*l=m;//dimensiunea vectorului
}
  • functia columns_max gaseste valoarea maxima a elementelor de pe fiecare coloana
void columns_max(int n,int m,int x[30][30],int h[30],int *l)
{
int i,j,max;
for(j=0;j<m;j++)
    {
    max=x[0][j];
    for(i=0;i<n;i++)
       if (max<x[i][j]) max=x[i][j];
    h[j]=max;//maximul de pe coloana j
    }
*l=m; //dimensiunea  vectorului
}
  • functia lines_max gaseste valoarea maxima a elementelor de pe fiecare linie
void lines_max(int n,int m,int x[30][30],int h[30],int *l)
{
int i,j,max;
for(i=0;i<n;i++)
    {
    max=x[i][0];
    for(j=0;j<m;j++)
       if (max<x[i][j]) max=x[i][j];
    h[i]=max;//maximul de pe linia i
    }
*l=n;//dimensiunea vectorului 
}

Functia repl_neg inlocuieste toate elementele negative ale unei matrice. Pentru a face acest lucru ea are ca date de intrare doar dimensiunile matricei si matricea, ea nereturnând vreo valoare. De asemenea functia va afisa pe ecran numarul de elemente a caror valoare a fost modificata.

Functia nu modifica structura matricei sau adresele fizice ale elementelor sale, ci doar valoarea elementelor.

void repl_neg(int n,int m,int x[30][30])
{
int i,j,count;
count=0;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
	if(x[i][j]<0)//se gaseste elementele negative
	{
	x[i][j]=0;//se inlocuiesc cu valoarea 0
	count++;//se numara câte au fost inlocuite
	}
printf("\n %d elements have been replaced with 0",count);
}

Urmatoarele doua functii delete_line si delete_column modifica structura unei matrice, in sensul ca sterg o linie/coloana din matrice modificând astfel dimensiunea matricei. Pentru a memora noua dimensiune a matricei, pe lânga parametrii obisnuiti de intrare (n, m si X) functiile mai au ca parametru si adresa unei variabile de tip intreg unde se va scrie valoarea noului numar de linii sau coloane. Folosind acest pointer la intreg ca parametru de intrare tipul functiilor va fi void.

Ambele functii primesc pozitia liniei/coloanei de sters din matrice in interiorul lor, ele cerând acest lucru utilizatorului.

Prima functie care realizeaza stergerea unei linii este :

void delete_line(int n,int m,int x[30][30],int *n1)
{
int i,j,l,k;
//se cere linia care va fi stersa
printf("\n Line to be deleted (between 0 and %d):",n-1);
k=scanf("%d",&l);
/*stergerea se realizeaza prin interschimbarea liniilor intre ele, pâna când linia care se sterge va ajunge ultima */ 
for(i=l;i<n-1;i++)
   interchange_lines(n,m,x,i,i+1);
//se modifica numarul de linii, si astfel linia se sterge logic ea existand in matricea initiala pe ultima pozitie dar ne mai fiind citita
*n1=n-1;
}

A doua functie care sterge o coloana este :

void delete_column(int n,int m,int x[30][30],int *m1)
{
int i,j,c,k;
//se cere coloana care va fi stearsa
printf("\n Column to be deleted (between 0 and %d):",m-1);
k=scanf("%d",&c);
/*stergerea se realizeaza prin interschimbarea coloanelor intre ele, pâna când coloana care se sterge va ajunge ultima */
for(j=c;j<m-1;j++)
   interchange_columns(n,m,x,j,j+1);
/*se modifica numarul de coloane, si astfel coloana se sterge logic ea existand in matricea initiala pe ultima pozitie dar ne mai fiind citita*/
*m1=m-1;
}

Functia how_many_0 primind ca date de intrare dimensiunile unei matrice, matricea si adresa unei variabile de tip intreg va scrie la aceasta adresa numarul de elemente din matrice care au valoarea 0.

void how_many_0(int n,int m,int x[30][30],int *no)
{
int i,j;
*no=0;
for(i=0;i<n;i++)
   for(j=0;j<m;j++)
//se gasesc elementele egale cu 0 si se numara
   if(x[i][j]==0) (*no)++;
*no=((*no*100)/(n*m));
//se afiseaza procentul lor in numarul total de elemente ale matricei
printf("\n Elements with value 0 are  %d per cent of all elements",*no);
}

Functia care urmeaza modifica structura unei matrice in sensul ca adauga o noua linie la matrice. Pentru a face acest lucru ea are ca parametrii de intrare numarul de linii al matricei, n, numarul de coloane, m, matricea si doi pointeri la intregi. La cele doua adrese de variabile de tip intreg se vor scrie noile valori ale dimensiunilor matricei. La adreasa lui n1 se va scrie noul numar de linii, iar la adresa lui m1 se va scrie noul numar de coloane. Functia odata apelata ve cere utilizatorului sa introduca elementele noii linii. Noua linie va avea m elemente.

void add_line(int n,int m,int x[30][30],int *n1,int *m1)
{
int i,j,h[30],k;
/* cum matricea este definita static cu un numar maxim de 30 de linii, se verifica daca se mai pot adauga noi linii*/ 
if(n==30) printf("\n No more lines to add!");
  else
  {
//se introduc elementele noii linii
  printf("\n The new line is:");
	 for(j=0;j<m;j++)
	 {
	 printf("\n The element h[%d] is:",j);
	 k=scanf("%d",&h[j]);
	 valid_no_integer(&h[j],k);
	 }
//se adauga noua linie
for(j=0;j<m;j++)
   x[n][j]=h[j];
*n1=n+1;//noul numar de linii al matricei
*m1=m;//noul numar de coloane al matricei
  }
}

Urmatoarea serie de functii primesc ca parametrii de intrare dimensiunile matricei (n si m) si matricea A si vor returna diferite valori calculate pe baza valoruilor elementelor matricei.

  • functia pos_elem_geom_avr va returna o valoare de tip float calculata ca medie geometrica a elementelor pozitive ale matricei
float pos_elem_geom_avr(int n,int m,int  a[30][30])
{
int i;int j;
float avr=1.;int k=0;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
      if(a[i][j]>0)
      {
//se calculeaza produsul elementelor pozitive
       avr*=a[i][j];
       k++;
      }
//daca sunt elemente pozitive in matrice se calculeaza media geometrica ca fiind radical de ordinul k din produsul valorilor elementelor pozitive// 
if(k>1) avr=exp(log(avr)/k);
  else avr=-1;//daca nu sunt elemente pozitive atunci functia returneaza -1
return avr;
}
  • functia prime_elem_no returneaza un intreg ce reprezinta numarul de elemente prime din matrice
int prime_elem_no(int n,int m,int a[30][30])
{
int i;int j;
int sum=0;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
/* pentru a vedea daca un numar este prim se foloseste functia prim care se afla in biblioteca*/
      if (prim(a[i][j])) sum++;
return sum;
}
  • functia pos_elem_sum returneaza un intreg care reprezinta suma elementelor pozitive
int pos_elem_sum(int n,int m,int a[30][30])
{
int i;int j;
int sum=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(a[i][j]>0) sum+=a[i][j];
return sum;
}
  • functia pos_elem_no returneaza un intreg ce reprezinta numarul de elemente pozitive
int pos_elem_no(int n, int m,int a[30][30])
{
int i;int j;
int no=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(a[i][j]>0) no++;
return no;
}
  • functia zero_elem_no returneaza un intreg ce reprezinta numarul de elemente ale matricei egale cu 0
int zero_elem_no(int n, int m, int a[30][30])
{
int i;int j;
int no=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(a[i][j]==0) no++;
return no;
}
  • functia neg_elem_no returneaza un intreg care reprezinta numarul de elemente negative din matrice
int neg_elem_no(int n, int m, int a[30][30])
{
int i;int j;
int no=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(a[i][j]<0) no++;
return no;
}
  • functia neg_elem_sum returneaza un intreg care reprezinta suma elementelor negative din matrice
int neg_elem_sum(int n,int m,int a[30][30])
{
int i;int j;
int sum=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(a[i][j]<0) sum+=a[i][j];
return sum;
}
  • functia even_elem_no returneaza un intreg care reprezinta numarul de elemente impare din matrice
int even_elem_no(int n, int m,int a[30][30])
{
int i;int j;
int no=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(!(a[i][j] %2)) no++;
return no;
}
  • functia odd_elem_no returneaza un intreg care reprezinta numarul de elemente pare din matrice
int odd_elem_no(int n, int m, int a[30][30])
{
int i;int j;
int no=0.;
for(i=0;i<n;i++)
    for(j=0;j<m;j++)
       if(a[i][j] % 2) no++;
return no;
}
  • functia sum_module returneaza un intreg ce reprezinta suma valorilor in modul ale elementelor matricei
int sum_module(int n,int m,int x[30][30])
{
int i,j,sum;
sum=0;
for(i=0;i<n;i++)
   for(j=0;j<m;j++)
       if(x[i][j]<0) sum-=x[i][j];
//daca numarul este negativ  se face modul din valoarea sa
	 else sum+=x[i][j];
return sum;
}
  • functia abs_lines_max_sum returneaza un intreg ce reprezinta suma valorilor in modul ale maximelor de pe linii
int abs_lines_max_sum(int n,int m,int x[30][30])
{
int i,l,h[30],sum;
sum=0;
//se foloseste functia lines_max care scrie intr-un vector maximele de pe linii
lines_max(n,m,x,h,&l);
for(i=0;i<l;i++) if(h[i]<0) sum-=h[i];
			else sum+=h[i];
return sum;
}
  • functia abs_columns_max_sum returneaza un intreg care reprezinta suma valorilor in modul a maximelor de pe coloane
int abs_columns_max_sum(int n,int m,int x[30][30])
{
int i,l,h[30],sum;
sum=0;
//se foloseste functia columns_max care scrie intr-un vector maximele de pe linii
columns_max(n,m,x,h,&l);
for(i=0;i<l;i++) if(h[i]<0) sum-=h[i];
			else sum+=h[i];
return sum;
}
  • functia max_on_one_linie primeste ca date de intrare numarul de linii al matricei, n, numarul de coloane al matricei, m, matricea definita static, X, un intreg numit l care reprezinta linia pe care se lucreaza si un pointer la o variabila de tip integer, *r. Functia cauta pe linia l valoarea maxima si la adresa variabilei r va scrie numarul coloanei pe care se afla valoarea maxima a liniei respective. De asemenea functia returneaza maximul.
int max_on_one_linie(int n,int m,int x[30][30],int l,int *r)
{
int j,max;
//se verifica daca linia exista  
if ((l>30)|(l<0)|(l>n-1))
	 {
	 printf("\n Error, this line does not exist!");
	 getch();
	 exit(0);
	 }
for(j=0;j<m;j++)
//se cauta maximul pe linia l
   if (max<x[l][j])
   {
   max=x[l][j];
   *r=j;//j este coloana pe care se afla maximul
   }
return max;
}
  • functia max_on_one_column este asemanatoare cu cea precedenta, numai ca ea cauta maximul pe o coloana si la adresa variabilei l se scrie linia pe care se afla maximul din acea coloana.
int max_on_one_column(int n,int m,int x[30][30],int c,int *l)
{
int i,max;
//se verifica daca coloana exista
if ((c>30)|(c<0)|(c>m-1))
	 {
	 printf("\n Error, this column doesn't exist !");
	 getch();
	 exit(1);
	 }
for(i=0;i<n;i++)
//se cauta maximul pe coloana c
   if (max<x[i][c])
   {
   max=x[i][c];
   *l=i;//i  este linia pe care se afla maximul
   }
return max;
}
  • functia lines_max_position returneaza un vector care contine numarul coloanei pe care se afla elementele maxime de pe fiecare linie. Parametrii functiei sunt : n numarul de linii al matricei, m numarul de coloane al matricei, X matricea definita static, vectorul definit static in care se vor trece coloanele si un pointer la intreg unde se va scrie dimensiunea vectorului.
void lines_max_position(int n,int m,int x[30][30],int v[30],int *l)
{
int i,j,max;
for(i=0;i<n;i++)
    {
    max=x[i][0];//se initializeaza maximul pentru fiecare linie
    v[i]=0;
    for(j=0;j<m;j++)
       if (max<x[i][j])
       {
       v[i]=j;//odata maximul gasit se memoreaza si coloana pe care se afla
       max=x[i][j];
       }
    }
*l=n; //se memoreaza dimensiunea vectorului
}
  • functia max_on_diag pune pe diagonala principala a unei matrice patratice maximele de pe fiecare linie cu ajutorul operatiilor de interschimbare a liniilor sau coloanelor. Parametrii functiei sunt : n numarul de linii al matricei, m numarul de coloane al matricei si X matricea definita static. Functia nu face acest lucru atunci când maximele a doua sau mai multe linii se afla pe aceeasi coloana pentru ca doar cu operatiile de interschimbare aceste maxime nu pot fi puse pe diagonala.
void max_on_diag(int n,int m, int x[30][30])
{
int i,j,no,v[30],l,k;
int vb=1;
//se verifica daca matricea este patratica
if(n!=m)
	{
	printf("\n Error ! The matrix must be a square ");
	getch();
	exit(0);
	}
/*cu ajutorul functiei lines_max_position definita anterior se trec intr-un vector maximele de pe fiecare linie*/
lines_max_position(n,m,x,v,&l);
//se verifica in vectorul creat anterior daca doua maxime sunt pe aceeasi coloana
for(i=0;i<l-1;i++)
      for(j=i+1;j<l;j++)
	  if(v[i]==v[j]) vb=0;
if(vb==0)
	{
printf("\n Eroare ! Two lines have maximum elements on same column");
	getch();
	exit(0);
	}
/*se fac interschimarile de linii si coloane pentru a pune maximele pe diagonala principala */
for(i=0;i<l;i++)
   {
   interchange_columns(n,m,x,v[i],i);
   lines_max_position(n,m,x,v,&k);
   }
}
  • functia operation primeste pe langa dimensiunile matricei (n si m) si matricea respectiva, 3 intregi reprezentând numerele a 3 linii si un caracter ce este unul din operatorii matematici +, -, *. Daca cei trei intregi sunt k, i, j atunci functia calculeaza elementele liniei k ca suma/diferenta/produs dintre elementele liniilor i si j dupa formula a[k][r]=a[i][r] operator a[j][r]
void operation(int n,int m,int x[30][30],int k,int i,int j,char oper)
{
int z;
//se valideaza numerele liniilor
if ((i>30)|(i<0)|(i>n-1)|(j>30)|(j<0)|(j>n-1)|(k>30)|(k<0)|(k>n-1))
	 {
	 printf("\n Error ! One of this lines doesn't exist ! ");
	 getch();
	 exit(1);
	 }
//in functie de opeartor se creaza noua linie
switch(oper)
	{
	case '+':{ // suma
	            for(z=0;z<m;z++) x[k][z]=x[i][z]+x[j][z];
		    break;
	         }
	case '-':{ // diferenta 
	            for(z=0;z<m;z++) x[k][z]=x[i][z]-x[j][z];
		    break;
		 }
	case '*':{//produs
		    for(z=0;z<m;z++) x[k][z]=x[i][z]*x[j][z];
		    break;
		 }
	default :{
		    printf("\n Chose a operator !");
		    break;
		 }
	}
 
}

Functiile change_line si change_column modifica elementele liniei/coloanei primita ca parametru de intrare cu o valoare dorita. Valoarea este primita ca data de intrare.

Functiile sunt :

void change_line(int n,int m,int x[30][30],int line,int value)
{
int k;
for(k=0;k<m;k++) x[line][k]=value;
}

si

void change_column(int n,int m,int x[30][30],int column,int value)
{
int k;
for(k=0;k<n;k++) x[k][column]=value;
}

Functia balance_sum calculeaza elementele linie line, data ca parametru, ca suma de elementele a altor linii care formeaza la rândul lor o lista de parametrii reprezentata prin … . Primul parametru a functiei este matricea in care se lucreaza si dimensiunile ei (n si m).

Daca functia are urmatorul apel balance_sum(a, n, m, n-1,256,-1) atunci elementele liniei n-1 vor fi egale cu suma elementelor tututor liniilor din matrice. Valoarea –1 indica functiei când se termina lista de parametrii.

Daca functia are urmatorul apel balance_sum(a, n, m, n-1,2,3,-1) atunci elementele liniei n-1 vor fi egale cu suma elementelor liniilor 2 si 3 din matrice. Valoarea –1 indica functiei când se termina lista de parametrii.

void balance_sum(int a[30][30],int n,int m,int line,...)
{
int k=line,i,j;
//int b[30][30];
 
va_list lista;
change_line(n,m,a,line,0);
va_start(lista,line);
k=va_arg(lista, int);
 
while(k!=-1)
  {
  if(k==256){
	     j=0;
	     while(j!=m)
		     {
		     //a[line][j]=0;
		     for(i=0;i<n;i++) if(i!=line) a[line][j]+=a[i][j];
		     j++;
		     }
	     k=va_arg(lista, int);
  	     }
   else
   	{
   	for (j=0;j<m;j++) a[line][j]+=a[k][j];
   	k=va_arg(lista,int);
   	}
   }
va_end(lista);
}

Functiile prezentate in acest capitol apartin bibliotecii de functii matrice.h , ele fiind prezente si in clasa matrix insa sunt modificate listele de parametrii pentru a putea facilita lucrul cu obiecte de tip matrix.

Tutoriale anterioare pe aceasta tema:

,


  1. No comments yet.
(will not be published)

  1. No trackbacks yet.