C：将实数转换为64位浮点二进制

Question

I'm trying to write a code that converts a real number to a 64 bit floating point binary. In order to do this, the user inputs a real number (for example, 547.4242) and the program must output a 64 bit floating point binary.

My ideas:

• The sign part is easy.
• The program converts the integer part (547 for the previous example) and stores the result in an int variable. Then, the program converts the fractional part (.4242 for the previous example) and stores the result into an array (each position of the array stores '1' or '0').

This is where I'm stuck. Summarizing, I have: "Integer part = 1000100011" (type int) and "Fractional part = 0110110010011000010111110000011011110110100101000100" (array).

How can I proceed?

Answer 1

the following code is used to determine internal representation of a floating point number according to the IEEE754 notation. This code is made in Turbo c++ ide but you can easily convert for a generalised ide.

#include<conio.h>
#include<stdio.h>

void decimal_to_binary(unsigned char);

union u
{
    float f;
    char c;
};

int main()
{
    int i;
    char*ptr;
    union u a;

    clrscr();
    printf("ENTER THE FLOATING POINT NUMBER : \n");
    scanf("%f",&a.f);

    ptr=&a.c+sizeof(float);

    for(i=0;i<sizeof(float);i++)
    {
        ptr--;
        decimal_to_binary(*ptr);
    }

    getch();
    return 0;
}

void decimal_to_binary(unsigned char n)
{
    int arr[8];
    int i;
    //printf("n = %u  ",n);

    for(i=7;i>=0;i--)
    {
        if(n%2==0)
            arr[i]=0;
        else
            arr[i]=1;
        n/=2;
    }

    for(i=0;i<8;i++)
        printf("%d",arr[i]);
    printf(" ");
}

For further details visit Click here !

Answer 2

The trick is to treat the value as an integer, so read your 547.4242 as an unsigned long long (ie 64-bits or more), ie 5474242 , counting the number of digits after the '.', in this case 4. Now you have a value which is 10^4 bigger than it should be. So you float the 5474242 (as a double, or long double) and divide by 10^4.

Decimal to binary conversion is deceptively simple. When you have more bits than the float will hold, then it will have to round. More fun occurs when you have more digits than a 64-bit integer will hold -- noting that trailing zeros are special -- and you have to decide whether to round or not (and what rounding occurs when you float). Then there's dealing with an E+/-99. Then when you do the eventual division (or multiplication) by 10^n, you have (a) another potential rounding, and (b) the issue that large 10^n are not exactly represented in your floating point -- which is another source of error. (And for E+/-99 forms, you may need upto and a little beyond 10^300 for the final step.)

Enjoy !

Answer 3

In order to correctly round all possible decimal representations to the nearest double , you need big integers. Using only the basic integer types from C will leave you to re-implement big integer arithmetics. Each of these two approaches is possible, more information about each follows:

1. For the first approach, you need a big integer library: GMP is a good one. Armed with such a big integer library, you tackle an input such as the example 123.456E78 as the integer 123456 * 10 ⁷⁵ and start wondering what values M in [2 ⁵³ … 2 ⁵⁴ ) and P in [-1022 … 1023] make (M / 2 ⁵³ ) * 2 ^P closest to this number. This question can be answered with big integer operations, following the steps described in this blog post (summary: first determine P. Then use a division to compute M). A complete implementation must take care of subnormal numbers and infinities ( inf is the correct result to return for any decimal representation of a number that would have an exponent larger than +1023).

2. The second approach, if you do not want to include or implement a full general-purpose big integer library, still requires a few basic operations to be implemented on arrays of C integers representing large numbers. The function decfloat() in this implementation represents large numbers in base 10 ⁹ because that simplifies the conversion from the initial decimal representation to the internal representation as an array x of uint32_t .

Answer 4

Following is a basic conversion. Enough to get OP started.

OP's "integer part of real number" --> int is far too limiting. Better to simply convert the entire string to a large integer like uintmax_t . Note the decimal point '.' and account for overflow while scanning.

This code does not handle exponents nor negative numbers. It may be off in the the last bit or so due to limited integer ui or the the final num = ui * pow10(expo) . It handles most overflow cases.

#include <inttypes.h>

double my_atof(const char *src) {
  uintmax_t ui = 0;
  int dp = '.';
  size_t dpi;
  size_t i = 0;
  size_t toobig = 0;
  int ch;
  for (i = 0; (ch = (unsigned char) src[i]) != '\0'; i++) {
    if (ch == dp) {
      dp = '\0';  // only get 1 dp
      dpi = i;
      continue;
    }
    if (!isdigit(ch)) {
      break; // illegal character
    }
    ch -= '0';
    // detect overflow
    if (toobig || 
        (ui >= UINTMAX_MAX / 10 && 
        (ui > UINTMAX_MAX / 10 || ch > UINTMAX_MAX % 10))) {
      toobig++;
      continue;
    }
    ui = ui * 10 + ch;
  }
  intmax_t expo = toobig;
  if (dp == '\0') {
    expo -= i - dpi - 1;
  }

  double num;
  if (expo < 0) {
    // slightly more precise than: num = ui * pow10(expo);
    num = ui / pow10(-expo);
  } else {
    num = ui * pow10(expo);
  }
  return num;
}