# C and C++ library of functions and procedures for matrix (bidimensional arrays) – Comparison functions

The comparison functions used for matrix processing are needed for finding more information about a matrix or group of matrices from the point of view of: the matrix type, its elements type or the apparition number of a key in the matrix.

The function symmet checks if a matrix is a square or a symmetrical one. It gets as entry parameters the matrix’ lines and columns numbers, which are n and m, and the matrix X. The matrix is defined static. The function returns the address of an integer variable, *er, where it writes 1 if the matrix is symmetrical or 0 if the matrix isn’t symmetrical. Also it verifies if the matrix is a square one and it writes 0 at the integer variable’ address if the condition isn’t fulfilled.

The function is:

```void symmet(int n,int m,int x[30][30],int *er)
{
int i,j;
//checks if the matrix is a square one
if(n!=m) printf("\n The matrix must be a square !");
else
{
*er=1;
for(i=0;i

The function check_unit verifies if a matrix is or not the unit matrix. Its parameters are the variables m and n, which are representing the dimensions of the static defined matrix X, and the address of an integer variable, *er. If the matrix isn't the unit matrix or if isn't square the variable er takes the value 0. In opposite case the variable takes the value 1.

The function is:

void check_unit(int n,int m,int x[30][30],int *er)
{
int i,j;
// checks if the matrix is a square one
if(n!=m) printf("\n The matrix must be a square !");
else
{
*er=1;
for(i=0;i

The function check_no verifies if a user' number is or not in the matrix. The function' parameters are the variables n and m, representing the matrix dimensions, and the matrix X, which is defined static. The search result is known by using the integer variable eror, which address is also entry parameter of the function. The variable error has the value 1 if the number is found inside the matrix and the value 0 otherwise. The number to be found is read inside the function.

The function is:

void check_no(int n,int m,int x[30][30],int *eror)
{
int i,j,k,z;
// the number to be searched for is read from the keyboard
printf("\n The searched number is::");
*eror=0;
k=scanf("%d",&z);
//the number’ validation
valid_no_integer(&z,k);

for(i=0;i

The function check_line_column gets as entry parameters the dimensions of a static defined matrix, the matrix and the address of an integer variable. All those variables are: n for the lines number, m for the columns number, X for the matrix, and int* eror for the address. The function gets from the keyboard an array and checks if that array is representing or not a matrix column. If this is true the variable takes the value 1 and if is false takes the value 0.

When the array' elements are read, they are validated by the function valid_no_integer.

The function is:

void check_line_column(int n,int m,int x[30][30],int *eror)
{
int i,j,h[30],k;
//the array is created from the keyboard
printf("\n The line to be checked is :");
//its dimension
for(i=0;i

The function check_line_line verifies if an array created from the console is representing a matrix line. This function parameters are: n representing the matrix lines number, m representing the matrix columns number, X representing the static defined matrix and int*eror representing the address of an integer variable. If the array is a line of the matrix then the variable eror takes the value 1. Else it takes the value 0.

When the array' components are read from the keyboard, they are validated by the function valid_no_integer.

The function is:

void check_line_line(int n,int m,int x[30][30],int *eror)
{
int i,j,h[30],k;
//the array is created
printf("\n The line to be checked is:");
//the array dimension is m
for(j=0;j

The following two functions check_columns and check_lines verify if a matrix has or not lines or columns which are equal between them. Both functions have the next parameters:  the matrix lines number, n, the matrix columns number, m, the static defined matrix, X, and the address of the integer variable eror, int* eror. The result of this search is given with the help of the variable eror. In case the matrix has equal lines or columns, the variable takes the value 1. Else it takes the value 0.

The basic principle of these two functions is that every line or column is compared with all the others, and when are found two lines or columns equal they are displayed.

The functions are:

void check_columns(int n,int m,int x[30][30],int *eror)
{
int i,j,k,l;
*eror=1;
l=0;
// every column is selected
for(j=0;j

And the second function is:

void check_lines(int n,int m,int x[30][30],int *eror)
{
int i,j,k,l;
*eror=1;
l=0;
//each line is selected
for(i=0;i

The function key_appar_no has the same parameters as the previous described functions. It gets a number from the keyboard and it checks if that number is in the matrix X. Also it counts that number apparitions and it writes the final value at the integer variable' address.

Using the function valid_no_integer validates the number read from the console.

The function is:

void key_appar_no(int n,int m,int x[30][30],int *v)
{
int i,j,k,c,l;
clrscr();
//the number is read and validated
printf("\n Type the key:");
l=scanf("%d",&c);
valid_no_integer(&c,l);

k=0;
//its apparitions in the matrix are counted
for (i=0;(i

The next two functions key_appar_no_line and key_appar_no_column check how many times a number given by the user appears in a line of the matrix or in a column, also indicated by the user. These functions parameters are: the matrix lines number, n, the matrix columns number, m, the static defined matrix, X, and the address of the integer variable v, int* v. The result of this search is given with the help of the variable v.

The number and the column or the line in which the search took place, are read by the function from the keyboard. If the number isn't in the line or the column the variable v takes the value 0.

The functions are:

void key_appar_no_line(int n,int m,int a[30][30],int *v)
{
int i,j,k,c,q,l;
clrscr();
//the number is read and validated
printf("\n Type the key:");
l=scanf("%d",&c);
valid_no_integer(&c,l);

// the line in which the number is searched
printf("\n Type the line :\t");
scanf("%d",&q);
k=0;
//the number’ apparitions are counted
for (j=0;j

and the second one:

void key_appar_no_column(int n,int m,int a[30][30],int *v)
{
int i,j,k,c,q,l;
clrscr();

// the number is read and validated
printf("Type the key:");
scanf("%d",&c);
valid_no_integer(&c,l);

// the column in which the number is searched, is indicated
printf("\n Type the column:\t");
scanf("%d",&q);
k=0;
// the number’ apparitions are counted
for (i=0;i

Besides these functions from the library matrix.h, inside the class matrix have been overloaded the following operators: % and = =, for comparing objects of type matrix. The operator %
does the same thing as the function symmet, which is checking if a matrix is a symmetrical one.

The operator = = sees if two objects of type matrix are equal, that is, if two matrices are equal. Its parameter is the address of the comparing object and it returns 0 if the objects are not equal or 1 if they are equal.

This function code sequence is:

int matrix::operator ==(matrix &b)
{
int k=0;
//the objects dimensions are verified first
if ((n==b.n)&&(m==b.m))
{
//if they have the same dimensions, their  elements are compared
for(i=0;i

The functions from this chapter, which are from the library matrice.h, are present in the class matrix too, but they don't have any parameters and they return integer values.

int check_line_column();

int check_line_line();

int check_columns();

int check_lines();

int check_unit();

int key_appar_no(int);

int key_appar_no_line(int,int);

int key_appar_no_column(int,int);

These are the only differences between the two versions of each function, because their algorithms are the same in both cases

Other posts on this topic:

C and C++ library of functions and procedures for matrix (bidimensional arrays) processing – Introduction (contains the C/C++ library source code)

C and C++ library of functions and procedures for matrix (bidimensional arrays) processing – Read and Write functions

C and C++ library of functions and procedures for matrix (bidimensional arrays) – Mathematical functions

Data Structures
Programming

Tags: Data Structures, Matrix

```