Bitset to float or double value c++

Question

I have two IEEE754 binary representation bitsets of float(32bit) and double (64bit). How I can convert this bitsets to REAL float or double number?

Answer 1

Use bitset::to_ullong() and memcpy() the bits.

Answer 2

Here is a solution that does not rely on the C++ implementation using IEEE-754 types.

Let s be the first bit of the bitset.

Let e be the next 8 or 11 bits for 32-bit or 64-bit, respectively.

Let f be the remaining 23 or 52 bits, respectively.

Let Ebias be 127 or 1023, respectively.

Let Emax be 255 or 2047, respectively.

Let Fscale be 0x1p-23 or 0x1p-52, respectively.

Then this code returns the value of the bitset interpreted as an IEEE-754 basic binary floating-point object:

// Interpret the sign.
double S = s ? -1 : +1;

// Classify the exponent.
if (e == 0)
    // The value is zero or subnormal.
    return S * std::ldexp(f*Fscale, 1-Ebias);

else if (e < eMax)
    // The value is normal.
    return S * std::ldexp(1 + f*Fscale, e-Ebias);

else
    // The value is NaN or infinite.
    if (f == 0)
        // The value is infinite.
        return S * INFINITY;
    else
        // The value is a NaN.
        return NAN;

This does not set all the bits in the NAN (including the sign bit) to match the exact bits in the bitset. There is no portable way to do that; it would typically have to be done by copying the bits into float or double object using memcpy or other copying via a character type, and it requires that the C++ implementation be using a float or double type that is IEEE-754. And, of course, the above requires that the C++ implementation support NAN and INFINITY, and that the the floating-point type in the C++ implementation be capable of representing the value.

Answer 3

First off, one does not simply represent a IEEE 754 floating point. There is a lot that goes into such a representation. Let's say that you're given a bitset variable: param and you want to convert it to a float. To guarantee this is a valid conversion you'll need to ensure:

• param.size() == sizeof(float) * CHAR_BIT
• The endianness from which param was encoded matches endian::native
• numeric_limits<float>::is_iec559 is true
• The radix with which param was encoded matches numeric_limits<float>::radix

If all these are true then effectively these bits are in the format of your internal floating point representation, and you can convert with a simple function like this (provided that sizeof(unsigned long) == sizeof(float) and sizeof(unsigned long long) == sizeof(double)):

double foo(const bitset<sizeof(double) * CHAR_BIT>& param) {
    const auto val = param.to_ullong();
    double result;

    memcpy(&result, &val, sizeof(double));

    return result;
}

float foo(const bitset<sizeof(float) * CHAR_BIT>& param) {
    const auto val = param.to_ulong();
    float result;

    memcpy(&result, &val, sizeof(float));

    return result;
}