Comparing floating point values converted from strings with literals

Question

This is not a duplicate of the famous Is floating point math broken, even if it looks like one at first sight.

I'm reading a double from a text file using fscanf(file, "%lf", &value); and comparing it with the == operator against a double literal. If the string is the same as the literal, will the comparision using == be true in all cases?

Example

Text file content:

7.7

Code snippet:

double value;
fscanf(file, "%lf", &value);     // reading "7.7" from file into value

if (value == 7.7)
   printf("strictly equal\n");

The expected and actual output is

strictly equal

But this supposes that the compiler converts the double literal 7.7 into a double exactly the same way as does the fscanf function, but the compiler may or may not use the same library for converting strings to double.

Or asked otherwise: does the conversion from string to double result in a unique binary representation or may there be slight implementation dependent differences?

Live demonstration

Answer 1

From the c++ standard:

[lex.fcon]

... If the scaled value is in the range of representable values for its type, the result is the scaled value if representable, else the larger or smaller representable value nearest the scaled value, chosen in an implementation-defined manner...

emphasis mine.

So you can only rely on equality if the value is strictly representable by a double.

Answer 2

About C++, from cppreference one can read:

[lex.fcon] (§6.4.4.2)

The result of evaluating a floating constant is either the nearest representable value or the larger or smaller representable value immediately adjacent to the nearest representable value, chosen in an implementation-defined manner (in other words, default rounding direction during translation is implementation-defined).

Since the representation of a floating literal is unspecified, I guess you cannot conclude about its comparison with a scanf result.

---

About C11 (standard ISO/IEC 9899:2011):

[lex.fcon] (§6.4.4.2)

Recommended practice

7 The translation-time conversion of floating constants should match the execution-time conversion of character strings by library functions, such as strtod, given matching inputs suitable for both conversions, the same result format, and default execution-time rounding.

So clearly for C11, this is not guaranteed to match.

Answer 3

If the string is the same as the literal, will the comparison using == be true in all cases?

A common consideration not yet explored: FLT_EVAL_METHOD

#include <float.h>
...
printf("%d\n", FLT_EVAL_METHOD);

2 evaluate all operations and constants to the range and precision of the long double type.

If this returns 2, then the math used in value == 7.7 is long double and 7.7 treated as 7.7L. In OP's case, this may evaluate to false.

To account for this wider precision, assign values which will removes all extra range and precision.

scanf(file, "%lf", &value);
double seven_seven = 7.7;
if (value == seven_seven)
  printf("strictly equal\n");

IMO, this is a more likely occurring problem than variant rounding modes or variations in library/compiler conversions.

---

Note that this case is akin to the below, a well known issue.

float value;
fscanf(file, "%f", &value);
if (value == 7.7)
   printf("strictly equal\n");

---

Demonstration

#include <stdio.h>
#include <float.h>
int main() {
  printf("%d\n", FLT_EVAL_METHOD);
  double value;
  sscanf("7.7", "%lf", &value);
  double seven_seven = 7.7;
  if (value == seven_seven) {
    printf("value == seven_seven\n");
  } else {
    printf("value != seven_seven\n");
  }
  if (value == 7.7) {
    printf("value == 7.7\n");
  } else {
    printf("value != 7.7\n");
  }
  return 0;
}

Output

2
value == seven_seven
value != 7.7

---

Alternative Compare

To compare 2 double that are "near" each other, we need a definition of "near". A useful approach is to consider all the finite double values sorted into a ascending sequence and then compare their sequence numbers from each other. double_distance(x, nextafter(x, 2*x) --> 1

Following code makes various assumptions about double layout and size.

#include <assert.h>

unsigned long long double_order(double x) {
  union {
    double d;
    unsigned long long ull;
  } u;
  assert(sizeof(double) == sizeof(unsigned long long));
  u.d = x;
  if (u.ull & 0x8000000000000000) {
    u.ull ^= 0x8000000000000000;
    return 0x8000000000000000 - u.ull;
  }
  return u.ull + 0x8000000000000000;
}

unsigned long long double_distance(double x, double y) {
  unsigned long long ullx = double_order(x);
  unsigned long long ully = double_order(y);
  if (x > y) return ullx - ully;
  return ully - ullx;
}

....
printf("%llu\n", double_distance(value, 7.7));                       // 0
printf("%llu\n", double_distance(value, nextafter(value,value*2)));  // 1
printf("%llu\n", double_distance(value, nextafter(value,value/2)));  // 1

Or just use

if (nextafter(7.7, -INF) <= value && value <= nextafter(7.7, +INF)) {
  puts("Close enough");
}

Answer 4

There's no guarantee.

You can hope that the compiler uses a high quality algorithm for the conversion of literals, and that the standard library implementation uses a high quality conversion as well, and two high quality algorithms should agree quite often.

It's also possible that both use the exact same algorithm (for example, the compiler converts the literal by putting the characters into a char array and calling sscanf.

BTW. I had one bug caused by the fact that a compiler didn't convert the literal 999999999.5 exactly. Replaced it with 9999999995 / 10.0 and everything was fine.