How to be precise in converting floats into binary - c

Question

I'm coding a C function that allows me to transform any float or double into a string containing 32 bits of 0s and 1s (according to IEEE754 standard). I'm not going to make use of printf as the objective is to understand the way it works and be able to store the string.
I took the calculus method from this video: https://www.youtube.com/watch?v=8afbTaA-gOQ. It enabled me to deconstruct the floats into 1 bit for the sign, 8 bits for the exponent and 23 bits for the mantissa.
I'm getting some pretty good results, but my converter is still not accurate, and my mantissa is often wrong in the last bits. The method I use to calculate the mantissa is (where strnew is just a malloc of the appropriate length):
char *ft_double_decimals(double n, int len)
{
char *decimals;
int i;
if (!(decimals = ft_strnew(len)))
return (NULL);
i = 0;
while (i < len)
{
n = n * 2;
decimals[i++] = (n >= 1) ? '1' : '0';
n = n - (int)n;
}
return (decimals);
}
For a float such as 0.1 I get this mantissa: 1001 1001 1001 1001 1001 100 where I should get 1001 1001 1001 1001 1001 101. This is so frustrating! I'm obviously missing something here, and I guess it has something to do with a wrong approximation of the decimals, so if someone knows what method I should use instead of the one I'm using I'll be very grateful!

Answer 1

my mantissa is often wrong in the last bits.
When the conversion is incomplete, results should be rounded. #Eric Postpischil
The below rounds half-way cases away from zero.
char *ft_double_decimals(double n, int len) {
char *decimals;
int i;
if (!(decimals = ft_strnew(len)))
return (NULL);
i = 0;
while (i < len) {
n = n * 2;
decimals[i++] = (n >= 1) ? '1' : '0';
n = n - (int) n;
}
// Add rounding code
if (n >= 0.5) {
int carry = 1;
while (i > 0) {
i--;
int sum = decimals[i] - '0' + carry;
decimals[i] = sum % 2 + '0';
carry = sum / 2;
}
if (i == 0 && carry > 0) {
// Rounding into the "one's" digit"
// TBD code to indicate to the caller that event
}
}
return (decimals);
}
int main(void) {
printf("%s\n", ft_double_decimals(0.1f, 23)); // --> 00011001100110011001101
return 0;
}
A more common rounding: round half-way cases to nearest even.
if (n >= 0.5 && (n > 0.5 || ((i > 0) && decimals[i-1] > '0'))) {
Further, calling code needs to be informed when the rounded result is "1.00000..."