Parse and convert denorm numbers? - c++

Question

In C++, we can store denorm numbers into variables without problems:
double x = std::numeric_limits<double>::denorm_min();
Then, we can print this variable without problems:
std::cout<<std::setprecision(std::numeric_limits<double>::max_digits10)
std::cout<<std::scientific;
std::cout<<x;
std::cout<<std::endl;
And it will print:
4.94065645841246544e-324
But a problem occurs when one tries to parse this number. Imagine that this number is stored inside a file, and read as a string. The problem is that:
std::string str = "4.94065645841246544e-324";
double x = std::stod(str);
will throw an std::out_of_range exception.
So my question is: how to convert a denorm value stored in a string?

Answer 1

I'm not sure I have understood the problem, but using std::istringstream like this:
std::string str = "4.94065645841246544e-324";
double x;
std::istringstream iss(str);
iss >> x;
std::cout << std::setprecision(std::numeric_limits<double>::max_digits10);
std::cout << std::scientific;
std::cout << x << std::endl;
...gives me:
4.94065645841246544e-324

Answer 2

Apparently, you can use the strtod (or the older atof) interface from cstdlib. I doubt whether this is guaranteed or portable.

Answer 3

I'm not sure if it will make a difference, but you are actually printing:
(std::numeric_limits<double>::max_digits10 + 1) = 18 decimal digits.
e.g., an IEEE-754 64-bit double with round-trip precision is "1.16" in scientific notation. Perhaps this is introducing some ULP / rounding that interferes with the conversion?

Answer 4

The problem with denormals and std::stod is that the latter is defined in terms of std::strtod, which may set errno=ERANGE on underflow (it's implementation-defined whether it'll do, and in glibc it does). As reminded by gcc developers, in such a case std::stod is defined by the standard to throw std::out_of_range.
So your proper workaround is to use std::strtod directly, ignoring ERANGE when the value it returns is finite and nonzero, like here:
double stringToDouble(const char* str, std::size_t* pos=nullptr)
{
errno=0;
char* end;
const auto x=std::strtod(str, &end);
if(errno==ERANGE)
{
// Ignore it for denormals
if(x!=0 && x>-HUGE_VAL && x<HUGE_VAL)
return x;
throw std::out_of_range("strtod: ERANGE");
}
else if(errno)
throw std::invalid_argument("strtod failed");
if(pos)
*pos=end-str;
return x;
}
Note that, unlike std::istringstream approach suggested in another answer, this will work for hexfloats too.