R.Biloti wrote:

Hi folks

I wrote the naive program to show up the unit roundoff (machine

precision) for single and double precision:

#include <stdio.h>

int main (void)

{

double x;

float y ;

x=1;

while ( (1+x) > 1 ) x = x/2;

x = 2*x;

printf("double precision epsilon: %e\n", x);

y=1;

while ( (1+y) > 1 ) y = y/2;

y = 2*y;

printf("single precision epsilon: %e\n", y);

return 0;

}

It was compiled with:

gcc -O0 epsilon.c -o epsilon

Take a look at the output on AMD64:

double precision epsilon: 2.220446e-16

single precision epsilon: 1.192093e-07

However on an Petium IV (32bit):

double precision epsilon: 1.084202e-19

single precision epsilon: 1.084202e-19

Other 32bit processors behave as pentium IV,

Am I missing something? Can anyone explain me what is going on?

At the risk of seeming to muddy the waters rather than clear them, I

have expanded your code below. If you run your test with it, you may

find that the results of the loops with the direct comparisons like

if (1 + y > 1) { /* ... */ }

give different results from those with a delayed comparison, like

yp = 1 + y;

if (yp > 1) { /* ... */ }

Think about why this might be so.

#include <stdio.h>

#include <float.h>

int main(void)

{

double x, xp;

float y, yp;

long double z, zp;

for (y = 1; 1 + y > 1; y /= 2) ;

printf("float epsilon: %e\n"

"FLT_EPSILON = %e\n", 2 * y, FLT_EPSILON);

for (y = 1, yp = 1 + y; yp > 1; y /= 2, yp = 1 + y) ;

printf("float epsilon (using temp): %e\n\n", 2 * y);

for (x = 1; 1 + x > 1; x /= 2) ;

printf("double epsilon: %e\n"

"DBL_EPSILON = %e\n", 2 * x, DBL_EPSILON);

for (x = 1, xp = 1 + x; xp > 1; x /= 2, xp = 1 + x) ;

printf("double epsilon (using temp): %e\n\n", 2 * x);

for (z = 1; 1 + z > 1; z /= 2) ;

printf("long double epsilon: %Le\n"

"LDBL_EPSILON = %Le\n", 2 * z, LDBL_EPSILON);

for (z = 1, zp = 1 + z; zp > 1; z /= 2, zp = 1 + z) ;

printf("long double epsilon (using temp): %Le\n\n", 2 * z);

return 0;

}