Convert string to float, C++ implementation

Question

VS minimum double value = 2.2250738585072014e-308. atof function converts string to double value such as when you look at this value in the debugger you get original string representation.

double d = atof("2.2250738585072014e-308");    // debugger will show 2.2250738585072014e-308

As we can see, double value is not denormalized (there is no DEN)

I try to achieve the same precision when converting string to double. Here is the code:

double my_atof(char* digits, int digits_length, int ep)
{
int idot = digits_length;

for (int i = 0; i < digits_length; i++)
{
    if (digits[i] == '.')
    {
        idot = i;
        break;
    }
}

double accum = 0.0;
int power = ep + idot - 1;

for (int i = 0; i < digits_length; i++)
{
    if (digits[i] != '.')
    {
        if (digits[i] != '0')
        {
            double base_in_power = 1.0;

            if (power >= 0)
            {
                for (int k = 0; k < power; k++) base_in_power *= 10.0;
            }
            else if (power < 0)
            {
                for (int k = 0; k < -power; k++) base_in_power *= 0.1;
            }

            accum += (digits[i] - '0') * base_in_power;
        }
        power--;
    }
    else power = ep - 1;
}

return accum;
}

Now, let's try:

char* float_str = "2.2250738585072014";
int float_length = strlen(float_str);

double d = my_atof(float_str, float_length, -308);

Debugger shows that d = 2.2250738585072379e-308. I tried to substitute

for (int k = 0; k < -power; k++) base_in_power *= 0.1;

with

for (int k = 0; k < -power; k++) base_in_power /= 10.0;

but it results in denormalized value. How to achieve the same precision as VS does, such that debugger will show the same number?

The debugger is just showing a representation. Depending on the debugger you can change this. Perhaps if you are so concerned you can just look at the bit patterns — Ed Heal, Jul 11 '15 at 11:44
Why *= 0.1 and /= 10.0 gives different results while they should be identical? — igntec, Jul 11 '15 at 11:50
@igntec Because they are not identical in finite precision binary arithmetic. Read [this](http://stackoverflow.com/questions/588004/is-floating-point-math-broken). — Baum mit Augen, Jul 11 '15 at 11:53
http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html et al. — Ed Heal, Jul 11 '15 at 11:55
You can't convert using IEEE arithmetic and expect a correct answer; you need higher precision arithmetic. See my article http://www.exploringbinary.com/decimal-to-floating-point-needs-arbitrary-precision/ . — Rick Regan, Jul 11 '15 at 22:13

Sergey Kalinichenko · Answer 1 · 2018-12-08T13:19:07.997

The problem is with double representation of the 0.1 constant, or the division by 10.0, which produces exactly the same result: negative powers of ten have no exact representation in floating-point numbers, because they have no exact representation as a sum of negative powers of 2.

When you compute negative powers of ten by repeated multiplication, you accumulate the error. First few negative powers come out right, but after about 0.000001 the difference becomes visible. Run this program to see what is happening:

double p10[] = {
    0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001, 0.00000001, 0.000000001, 0.0000000001
};

int main(void) {
    double a = 1;
    for (int i = 0 ; i != 10 ; i++) {
        double aa = a * 0.1;
        double d = aa - p10[i];
        printf("%d %.30lf\n", aa == p10[i], d);
        a = aa;
    }
    return 0;
}

The output looks like this:

1 0.000000000000000000000000000000
1 0.000000000000000000000000000000
1 0.000000000000000000000000000000
1 0.000000000000000000000000000000
1 0.000000000000000000000000000000
0 0.000000000000000000000211758237
0 0.000000000000000000000026469780
0 0.000000000000000000000001654361
0 0.000000000000000000000000206795
0 0.000000000000000000000000025849

Demo.

The first few powers match exactly, but then some differences start appearing. When you use powers that you compute to compose the number during your string-to-float conversion, the accumulated errors make it into the final result. If the library function uses a look-up table (see this implementation for an example), the result that you get would be different from result that they get.

You can fix your implementation by hard-coding a table of negative powers of ten, and referencing this table instead of computing the powers manually. Alternatively you could construct a positive power of ten by consecutive multiplications, and then do a single division 1 / pow10 to construct the corresponding negative power (demo).

Couldn't you also divide by increasing powers of 10 i.e. 10, 100, 1000 etc. to get accurate results? — Mark Ransom, Dec 08 '18 at 06:17
@MarkRansom Right, that would also work, because multiplications to compute a positive power of ten would be exact, and then a single division would make the corresponding negative power without accumulating errors. I edited the answer and linked an additional demo. Thank you very much! — Sergey Kalinichenko, Dec 08 '18 at 13:20

Convert string to float, C++ implementation

1 Answers1