C bug of 0.00 and -0.00 - c

Question

C program to find the rank of the matrix.
I used the Gaussian elimination to determine the rank of the matrix. This is the method which I have used.
My code in c:
#include<stdio.h>
#include<stdlib.h>
#define min(x,y) x>y?y:x
float** create_matrix(int,int);
void input(float**,int,int);
void display(float**,int,int);
void matrix_op(float**,int,int,int,float);
void row_trans(float**,int,int);
void row_swap(float**,int,int,int);
int rank(float**,int,int);
int main()
{
int row,col;
printf("Enter number of rows and columns: ");
scanf("%d %d",&row,&col);
float** matrix=create_matrix(row,col);
input(matrix,row,col);
printf("The rank of the matrix is: %d\n",rank(matrix,row,col));
return 0;
}
float** create_matrix(int r,int c)
{
int i;
float** matrix=(float**)calloc(r,sizeof(float*));
for(i=0;i<r;i++)
*(matrix+i)=(float*)calloc(c,sizeof(float));
return matrix;
}
void input(float** matrix,int r,int c)
{
int i,j;
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
scanf("%f",&matrix[i][j]);
}
}
void display(float** matrix,int r,int c)
{
int i,j;
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
printf("%.2f ",matrix[i][j]);
printf("\n");
}
}
void matrix_op(float** matrix,int c,int j,int i,float scalar)
{
int k;
for(k=0;k<c;k++)
{
matrix[j][k]+=matrix[i][k]*scalar;
}
}
void row_trans(float** matrix,int r,int i)
{
if(matrix[i][i]!=0)
{
for(int j=i+1;j<r;j++)
{
if(j==i)
continue;
if(matrix[j][i]!=0)
matrix_op(matrix,r,j,i,(-1.00)*(matrix[j][i]/matrix[i][i]));
}
}
else
{
int j=i+1;
while(j<r)
{
if(matrix[j][i]==0)
j+=1;
else
break;
}
if(j!=r)
{
row_swap(matrix,r,i,j);
row_trans(matrix,r,i);
}
}
}
void row_swap(float** matrix,int c,int i,int j)
{
for(int k=0;k<c;k++)
{
float temp=matrix[i][k];
matrix[i][k]=matrix[j][k];
matrix[j][k]=temp;
}
}
int rank(float** matrix,int r,int c)
{
int i;
int l=min(r,c);
for(i=0;i<l;i++)
{
row_trans(matrix,r,i);
display(matrix,r,c);
printf("\n");
}
i=r-1;
while(i>=0)
{
if(matrix[i][l-1]==0)
i-=1;
else
break;
}
return i+1;
}
When I input this:
Enter number of rows and columns: 5 5
3 -1 -2 3 -1
4 1 2 5 4
7 10 10 2 -3
2 -3 -6 1 -6
3 9 8 -3 -7
I get this:
3.00 -1.00 -2.00 3.00 -1.00
0.00 2.33 4.67 1.00 5.33
0.00 12.33 14.67 -5.00 -0.67
0.00 -2.33 -4.67 -1.00 -5.33
0.00 10.00 10.00 -6.00 -6.00
3.00 -1.00 -2.00 3.00 -1.00
0.00 2.33 4.67 1.00 5.33
0.00 0.00 -10.00 -10.29 -28.86
0.00 0.00 0.00 -0.00 -0.00
0.00 0.00 -10.00 -10.29 -28.86
3.00 -1.00 -2.00 3.00 -1.00
0.00 2.33 4.67 1.00 5.33
0.00 0.00 -10.00 -10.29 -28.86
0.00 0.00 0.00 -0.00 -0.00
0.00 0.00 0.00 -0.00 -0.00
3.00 -1.00 -2.00 3.00 -1.00
0.00 2.33 4.67 1.00 5.33
0.00 0.00 -10.00 -10.29 -28.86
0.00 0.00 0.00 -0.00 -0.00
0.00 0.00 0.00 0.00 0.00
3.00 -1.00 -2.00 3.00 -1.00
0.00 2.33 4.67 1.00 5.33
0.00 0.00 -10.00 -10.29 -28.86
0.00 0.00 0.00 -0.00 -0.00
0.00 0.00 0.00 0.00 0.00
The rank of the matrix is: 4
Notice that -0.00 and 0.00 are considered different.
And that is why I get rank as 4, whereas the rank should be 3.
Edit 1: In the final display we can see that, in the last column the second last row is -0.00 and the last row is 0.00. In the function rank() , the i is iterating over the zeroes of the last column and then it will return the rows- #(zeroes). But it is not considering -0.00=0.00.
Edit 2: After using double I got the same problem. After debugging I got this,
115 while(i>=0)
(gdb) p i
$4 = 3
(gdb) n
117 if(matrix[i][l-1]==0)
(gdb) p matrix[i][l-1]
$5 = 8.8817841970012523e-16
(gdb) p matrix[i][l-1]==0
$6 = 0
Edit 3:
The problem is solved after introducing precision.
double set_prec(double n)
{
return floor(pow(10,3)*n)/pow(10,3);
}
Any help will be appreciated.
Thanks in anticipation.

Answer 1

When you print a number in C using %.2f, the C implementation rounds it to two decimal places. Numbers such as 0.003… or −0.0001… will be printed as 0.00 or -0.00. So the fact that a number is printed as 0.00 does not mean it is 0. From the behavior you report, it is clear the numbers you have in your program are not 0 or −0. (IEEE 754 arithmetic has a −0 that is mathematically 0 but retains the sign as information the programmer may use. It compares equal to +0.)
Floating-point arithmetic only approximates real-number arithmetic. When you use floating-point arithmetic in an ordinary way, any computed result x is only an approximation of the result x you would get using real-number arithmetic. Since you have only computed x and not x, you do not have complete information about what x is, and therefore it is impossible, without special analysis and design, to know exactly what x is. Therefore, if some result x is near 0, you cannot know whether x is 0 or not.
In general, the difference between the floating-pount result x and the raal-number result x can range from 0 to infinity or can even be “not a number.” In the particular case of doing Gaussian elimination with small matrices of small integer inputs, it might be possible to prove that floating-point results sufficiently near 0 correspond to results that would be 0 if computed with real-number arithmetic. In that case, treating results close to 0 as if they were 0 could produce correct results.
This is not a correct solution in general, and rounding floating-point results to 0 or comparing with a tolerance should not be recommended in general. It is only useful in particlar limited circumstances.

Answer 2

Instead of comparing to 0, compare to epsilon
double epsilon = 1E-12; // tweak as you deem fit
//if (a != 0)
if (fabs(a) > epsilon)
//if (a == 0)
if (fabs(a) < epsilon)
//if (a == b)
if (fabs(a - b) < epsilon)