What operations and functions on +0.0 and -0.0 give different arithmetic results?

by

There are a few standard operations and functions that form numerically different answers between f(+0.0) and f(-0.0).

Different rounding modes or other floating point implementations may give different results.

#include <math.h>

double inverse(double x) { return 1/x; }

double atan2m1(double y) { return atan2(y, -1.0); }

double sprintf_d(double x) {
  char buf[20];
  // sprintf(buf, "%+f", x);   Changed to e
  sprintf(buf, "%+e", x);
  return buf[0];  // returns `+` or `-`
}

double copysign_1(double x) { return copysign(1.0, x); }

double signbit_d(double x) {
  int sign = signbit(x);  // my compile returns 0 or INT_MIN
  return sign;
}

double pow_m1(double x) { return pow(x, -1.0); }

void zero_test(const char *name, double (*f)(double)) {
  double fzp = (f)(+0.0);
  double fzn = (f)(-0.0);
  int differ = fzp != fzn;
  if (fzp != fzp && fzn != fzn) differ = 0;  // if both NAN
  printf("%-15s  f(+0):%-+15e %s  f(-0):%-+15e\n", 
      name, fzp, differ ? "!=" : "==", fzn);
}

void zero_tests(void) {
  zero_test("1/x",             inverse);
  zero_test("atan2(x,-1)",     atan2m1);
  zero_test("printf(\"%+e\")", sprintf_d);
  zero_test("copysign(x,1)",   copysign_1);
  zero_test("signbit()",       signbit_d);
  zero_test("pow(x,-odd)",     pow_m1);;  // @Pascal Cuoq
  zero_test("tgamma(x)",       tgamma);  // @vinc17 @Pascal Cuoq
}

Output:
1/x              f(+0):+inf             !=  f(-0):-inf           
atan2(x,-1)      f(+0):+3.141593e+00    !=  f(-0):-3.141593e+00  
printf("%+e")    f(+0):+4.300000e+01    !=  f(-0):+4.500000e+01   
copysign(x,1)    f(+0):+1.000000e+00    !=  f(-0):-1.000000e+00  
signbit()        f(+0):+0.000000e+00    !=  f(-0):-2.147484e+09 
pow(x,-odd)      f(+0):+inf             !=  f(-0):-inf           
tgamma(x)        f(+0):+inf             !=  f(-0):+inf

Notes:
tgamma(x) came up == on my gcc 4.8.2 machine, but correctly != on others.

rsqrt(), AKA 1/sqrt() is a maybe future C standard function. May/may not also work.

double zero = +0.0; memcpy(&zero, &x, sizeof x) can show x is a different bit pattern than +0.0 but x could still be a +0.0. I think some FP formats have many bit patterns that are +0.0 and -0.0. TBD.

This is a self-answer as provided by https://stackoverflow.com/help/self-answer.

More Related Contents:

  1. Printf width specifier to maintain precision of floating-point value
  2. ‘float’ vs. ‘double’ precision
  3. How are floating point numbers stored in memory?
  4. How to generate random float number in C
  5. When does appending an ‘f’ change the value of a floating constant when assigned to a `float`?
  6. What’s the use of suffix `f` on float value
  7. Simd matmul program gives different numerical results
  8. How to convert string to float?
  9. How do you print the EXACT value of a floating point number?
  10. How to extract the decimal part from a floating point number in C?
  11. C- Floating point precision
  12. Why doesn’t C have unsigned floats?
  13. C: printf a float value
  14. C: Casting minimum 32-bit integer (-2147483648) to float gives positive number (2147483648.0)
  15. Convert double/float to string
  16. pow() seems to be out by one here
  17. Ranges of floating point datatype in C?
  18. Precision in C floats
  19. How to enable linking floating point library in TurboC?
  20. My floating point number has extra digits when I print it
  21. Is there a function to round a float in C or do I need to write my own?
  22. C: How to wrap a float to the interval [-pi, pi)
  23. sin, cos, tan and rounding error
  24. What precisely does the %g printf specifier mean?
  25. Is there a document describing how Clang handles excess floating-point precision?
  26. Why do you need an explicit `-lm` compiler option? [duplicate]
  27. clang 14.0.0 floating point optimizations
  28. Conditional tests in primality by trial division
  29. C fundamentals: double variable not equal to double expression?
  30. How can floating point calculations be made deterministic?

Leave a Comment