将浮点二进制转换为十进制时，结果略有不准确

Question

What it should do: Input example - 101.101 output - 5.625

This is the way I wrote a floating point binary - decimal converter but there is a small error - the problem is the output is not accurate to the correct decimal point.

What my code does: Input - 101.101 Output - 5.624985

What my code does when I changed count from -16 to -32:

Input - 101.101 Output - 5.625000 This is correct.

Input - 101.111 Output - 5.875061 This is still off it should be 5.875

#include <stdio.h>

double decimal(double decpart);
long int integer(long int intpart);

int main(int argc, const char * argv[])
{

    double x;
    scanf("%lf", &x);
    long int intpart = (long int)x;
    double decpart = x-intpart;

    double finint = integer(intpart);
    double findec = decimal(decpart);

    double finnum = findec + finint;
    printf("%lf\n",finnum);

    return 0;
}

long int integer(long int intpart)
{
    double sum = 0;
    long int a, b, p= 0;

while(intpart>0)
{
    a = intpart % 10;
    b = a*(pow(2, p));
    sum = sum + b;
    p++;
    intpart = intpart / 10;
}
    return sum;
}

double decimal(double decpart)
{
    double sum = 0;
    int count = 0;
    while (decpart > 0 && count > -32)
    {
        count--;
        decpart = decpart*10;
        if (decpart >= 1)
        {
            decpart = decpart - 1;
            sum = sum + pow(2, count);
        }
    }

    return sum;
}

Answer 1

The inaccuracy is a rounding error built up from the pow function which almost always has a small error, even for integer arguments. This is because pow(x, y) is often implemented based on the mathematical identity as exp(log(x) * y) , where log and exp use the natural base 2.718281828... . Thus, even when eg the base is 2, log(2) is an approximation, so exp(log(2)) will be even more of an approximation.

In your situation, rather than using count and pow , you can have a double value field that starts off at 0.5 , and is multiplied by 0.5 after each iteration:

double decimal(double decpart)
{
    double sum = 0;
    double value = 0.5;
    while (decpart > 0 && value > 1.0e-5) // approx. 2 ^ -16
    {
        decpart = decpart*10;
        printf("%lf\n",decpart);
        if (decpart > 1)
        {
            decpart = decpart - 1;
            sum = sum + value;
        }
        value *= 0.5;
    }

    return sum;
}

In general, this will be more accurate than the pow alternative. On IEEE-754 compliant systems (most modern systems are), value should always be the exact value you want.

---

Further, as I/others have mentioned, using scanf to read in the input as a double instead of a string also leads to inaccuracies, as numbers like 0.1 often cannot be stored exactly. Instead, you should input to a char array, then parse the string.

Answer 2

The problem is -16 which is only 1 part in 65,536 or (0.0000153...). The answer you get and desire are within that range. Instead, need a more negative value like -32 or -53. (or about ln2(DBL_EPSILON) ) -

[Edit2] Values like -17, -18 , etc have additional problems. see below.

Also if (decpart > 1) --> if (decpart >= 1) .

---

[Edit]

Per the C spec with DBL_MIN_10_EXP at most -37 and typical binary floating point, a reasonable pow(2, count) will provide exact answers for count int the range -80 to +80 .

Your method of reading a decimal number and treating like a binary FP number likely breaks down once N significant digits are entered ("101.101" being 6). Expect N to be something like 1/DBL_EPSILON or at least 8 or 9 digits. To get beyond that limit, suggest @Drew McGowen advice and read and process your input as a string.

[Edit2]

Given a typical double the limit of N significant digits is about 16 or 17. Not only does this limit the input, it also limits the number of iterations in the while (decpart > 0 && count > -16) . Going much deeper than that, the string to FP conversion of "101.111" (which is more like 101.111000000000004... ) yield unexpected results, acts like 101.111000000000001111111...

(Mathematically correct 101 + 1*1/2 + 1*1/4 + 1*1/8 + 1*pow(2,-15) + 1*pow(2,-16))) ... = 5.875061

So..... Iterating decimal() more than log10(1/DBL_EPSILON) or about 15,16 times, begins to generate crap. Yet code iterating 16 times only provides a decimal precision of 1 part in 65,536 (0.000015...). Therefore to get answers better than that a new approach (like a string @Drew McGowen, inspired by @BLUEPIXY) is needed.

double BinaryFloatinPoint(const char *s) {
  double sum = 0.0;
  double power = 1.0;
  char dp = '.';  // binary radix point
  while (*s) {
    if (*s == '0' || *s == '1') {
      sum *= 2.0;
      sum += *s - '0';
      power *= 0.5;
    } else if (*s == dp) {
      dp = '0';
      power = 1.0;
    } else {
      return 0.0; // Unexpected char, maybe return NAN instead
    }
    s++;
  }
  if (dp == '0') {  // If dp found ...
    sum *= power;
  }
  return sum;
}

Answer 3

Can not be expressed exactly because the number, such as 0.1 (10) is an infinite decimal in binary.
So I suggest that you convert the input as a string.

#include <stdio.h>
#include <string.h>

double bstrtod(const char *bstr){
    double x = 0, one = 1.0;
    char *p = strchr(bstr, '.');
    if(p){
        char *fp = p;
        while(*++fp){
            one /= 2.0;
            if(*fp=='1')
                x += one;
        }
    } else {
        p = strchr(bstr, '\0');
    }
    one = 1.0;
    do{
        if(*--p == '1')
            x += one;
        one *= 2.0;
    }while(p!=bstr);

    return x;
}

int main(void){
    double x = bstrtod("101.101");
    printf("%f\n", x);//5.625000
    return 0;
}

Answer 4

This inaccuracy comes from errors during rounding off. Even if you input 8, it actually stores 7.99999... That's why the problem occurs.

Answer 5

Accurate Floating Point Binary to Decimal Converter

This code uses strings to convert a binary input to a decimal output

#include <stdio.h>
#include <string.h>

double blembo(const char *blem);

int main(void)
{
    char input[50];
    gets(input);

    int t = 0, flag = 0;
    while (input[t] != '\0')  // This whole block of code invalidates "hello" or "921" or "1.1.0" inputs
    {
        if(input[t] == '0' || input[t] == '1' || input[t] == '.')
        {
            if(input[t] == '.')
            {
                if(flag != 1)
                {
                    flag = 1;
                    t++;
                    continue;
                }
                else
                {
                    printf("\nIncorrect input\n");
                    return 0;
                }
            }
            else
            {
                t++;
                continue;
            }
        }
        else
        {
            printf("\nIncorrect input\n");
            return 0;
        }
    }

    double output = blembo(input);
    printf("%lf\n", output);
    return 0;
}

double blembo (const char *blem)
{
    double x=0, one = 1.0;
    char *p , *fp;
    p = strchr(blem, '.');
    if(p)
    {
        fp = p;
        while(*++fp)
        {
            one = one / 2.0;
            if(*fp == '1')
            {
                x = x + one;
            }
        }
    }
        else
        {
            p = strchr(blem, '\0');
        }

    one = 1.0;
    do
    {
        if(*--p == '1')
        {
            x = x + one;
        }

        one = one * 2.0;
    }
    while(p!=blem);

    return x;
}