Bit representation for floats?

Question

I know how to convert a float into it's binary representation using % 2 and / 2, but is there a shortcut or cleaner way of doing this? Is what I am doing even considered representing a float bitwise? Because I am supposed to be using bitwise comparison between two float numbers, but I'm not sure if that means using bitwise operations.

For example to obtain the binary representation for a number I'd store the resultant of a number like 10 % 2 into an array until the number reached 0 within a while loop and if the array were to be printed backwards it would represent the number in binary.

array[] = num % 2;
num = num / 2; 

What I did was use the method above for two float numbers, loaded them up with their own individual arrays, and compared them both through their arrays.

I have them set up in IEEE floating point format within their arrays as well.

EDIT: I have to compare two numbers of type float by using bitwise comparison and operations to see if one number is greater, less than, or if they are equal with the floats represented in biased exponent notation. The specifics are that it tests whether a floating point number number1 is less than, equal to or greater than another floating point number number2, by simply comparing their floating point representations bitwise by using bitwise comparisons from left to right, stopping as soon as the first differing bit is encountered.

Answer 1

No, it won't. Dividing a float by 2 will result in half of the number like this:

#include <stdio.h>
int main(void)
{
    float x = 5.0f;
    float y = x / 2;
    printf("%f\n", y);
}

Result:

2.50000

see? It has nothing to do with bits.

Binary representation of floating numbers consists of mantissa, exponent and a sign bit, which means that unlike for normal integers, the tricks you've mentioned won't apply here. You can learn more about this by reading an article on Wikipedia on IEEE floating points.

To make sure two floats have exactly the same bit configurations, you could compare their content using memcmp which compares things byte-by-byte, with no additional casts/arithmetic/whatever:

#include <stdio.h>
int main(void)
{
    float x = 5.0f;
    float y = 4.99999999999999f; //gets rounded up to 5.0f
    float z = 4.9f;
    printf("%d\n", memcmp(&x, &y, sizeof(float)) == 0);
    printf("%d\n", memcmp(&x, &z, sizeof(float)) == 0);
}

...will print 1 and 0 respectively. You can also inspect the individual bits this way (e.g. by operating on a *(char*)&x.

Answer 2

This compares two IEEE 32-bit floats bit by bit, returning -1, 0, or 1, and also indicating the bit at which they differ. They can be compared as sign-and-magnitude numbers. The function float_comp below first compares them bit-by-bit as uint32_t and negates the comparison if they differ in the sign bit (bit 31).

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

static int float_comp(float f1, float f2, int *bit)
{
    const uint32_t *a, *b;
    int comp = 0;

    a = (const uint32_t *)(const void *)&f1;
    b = (const uint32_t *)(const void *)&f2;
    for (*bit = 31; *bit >= 0; (*bit)--) {
        if ((*a & (UINT32_C(1) << *bit))
             && !(*b & (UINT32_C(1) << *bit))) {
            comp = 1;
            break;
        }
        if (!(*a & (UINT32_C(1) << *bit))
             && (*b & (UINT32_C(1) << *bit))) {
            comp = -1;
            break;
        }
    }
    if (*bit == 31)
        comp = -comp;   /* sign and magnitude conversion */
    return comp;
}

int main(int argc, char **argv)
{
    float f1, f2;
    int comp, bit;

    if (argc != 3) {
        fprintf(stderr, "usage: %s: float1 float2\n", argv[0]);
        return 2;
    }
    f1 = strtof(argv[1], NULL);
    f2 = strtof(argv[2], NULL);
    comp = float_comp(f1, f2, &bit);
    if (comp == 0)
        printf("%.8g = %.8g\n", f1, f2);
    else if (comp < 0)
        printf("%.8g < %.8g (differ at bit %d)\n", f1, f2, bit);
    else
        printf("%.8g > %.8g (differ at bit %d)\n", f1, f2, bit);
    return 0;
}

Answer 3

Doing what you said will not give you the bits of floating point representation. Instead use union to convert between float and integer representations and print bits as usual:

#include <stdio.h>
#include <stdint.h>

typedef union {
    uint32_t i;
    float f;
} float_conv_t;

void
int_to_bin_print(uint32_t number)
{
    char binaryNumber[33];
    int i;
    for (i = 31; i >= 0; --i)
    {
        binaryNumber[i] = (number & 1) ? '1' : '0';
        number >>= 1;
    }
    binaryNumber[32] = '\0';
    fprintf(stdout, "Number %s\n", binaryNumber);
}

int main(void) {
    float_conv_t f;
    f.f = 10.34;
    int_to_bin_print(f.i);
    f.f = -10.34;
    int_to_bin_print(f.i);
    f.f = 0.1;
    int_to_bin_print(f.i);
    f.f = 0.2;
    int_to_bin_print(f.i);
    return 0;
}

Output:

Number 01000001001001010111000010100100

Number 11000001001001010111000010100100

Number 00111101110011001100110011001101

---

My goal is to compare two floating point numbers by comparing their floating point representations bitwise.

Then you can compare raw memory using memcmp:

float f1 = 0.1;
float f2 = 0.2;
if (memcmp(&f1, &f2, sizeof(float)) == 0)
    // equal

SYNOPSIS #include

   int memcmp(const void *s1, const void *s2, size_t n);

DESCRIPTION The memcmp() function compares the first n bytes (each interpreted as unsigned char) of the memory areas s1 and s2.

RETURN VALUE The memcmp() function returns an integer less than, equal to, or greater than zero if the first n bytes of s1 is found, respectively, to be less than, to match, or be greater than the first n bytes of s2.