Interpreter binárního formátu #

static float float_from_parts(uint8_t sign_bit, uint32_t mantissa_bits, uint32_t exponent_bits) {
    // Add implied top bit
    uint32_t mantissa = (1u << 23) | mantissa_bits;
    int32_t signed_mantissa = sign_bit ? -((int32_t)mantissa) : (int32_t)mantissa;
    int exponent = (int)exponent_bits - 127;
    // -23 is to normalize mantissa from 1xxxx to 1.xxxx
    return ldexpf((float)signed_mantissa, exponent - 23);
}

static double double_from_parts(uint8_t sign_bit, uint64_t mantissa_bits, uint64_t exponent_bits) {
    // Add implied top bit
    uint64_t mantissa = (1ull << 52) | mantissa_bits;
    int64_t signed_mantissa = sign_bit ? -((int64_t)mantissa) : (int64_t)mantissa;
    int exponent = (int)exponent_bits - 1023;
    // -52 is to normalize mantissa from 1xxxx to 1.xxxx
    return ldexp((double)signed_mantissa, exponent - 52);
}

int main() {
    int descriptor;
    
    while ((descriptor = getchar()) != EOF) {
        if (/* TODO: is integer */) {
            // TODO: extract value based on descriptor

            if (/* TODO: is signed */) {
                switch (size) {
                    case 1:
                        printf("%d\n", (int)(int8_t)value);
                        break;
                    case 2:
                        printf("%d\n", (int)(int16_t)value);
                        break;
                    case 4:
                        printf("%d\n", (int)(int32_t)value);
                        break;
                    case 8:
                        printf("%lld\n", (long long)(int64_t)value);
                        break;
                    default: /* unreachable */
                        break;
                }
            } else {
                switch (size) {
                    case 1:
                        printf("%u\n", (unsigned)(uint8_t)value);
                        break;
                    case 2:
                        printf("%u\n", (unsigned)(uint16_t)value);
                        break;
                    case 4:
                        printf("%u\n", (unsigned)(uint32_t)value);
                        break;
                    case 8:
                        printf("%llu\n", (unsigned long long)(uint64_t)value);
                        break;
                    default:
                        break;
                }
            }
        } else { /* is any floating point number */
            if (/* TODO: is float */) {
                // TODO: extract value based on descriptor

                if (exponent_bits == 0 && mantissa_bits == 0) {
                    // Requirement: both +0.0 and -0.0 must be printed as 0 (no leading -0)
                    // Always print positive zero with the required format.
                    printf("%.8g\n", 0.0f);
                } else {
                    printf("%.8g\n", float_from_parts(sign_bit, mantissa_bits, exponent_bits));
                }
            } else {
                // TODO: extract value based on descriptor

                if (exponent_bits == 0 && mantissa_bits == 0) {
                    // Requirement: both +0.0 and -0.0 must be printed as 0 (no leading -0)
                    printf("%.17g\n", 0.0);
                } else {
                    printf("%.17g\n", double_from_parts(sign_bit, mantissa_bits, exponent_bits));
                }
            }
        }
    }
    
    return 0;
}

#include <stdint.h>
#include <math.h>

/// Reconstruct float from parts of IEEE 754 in a platform independent way
/// that follows the C standard, where float memory layout is not specified.
///
/// Note that this is not very performant.
///
/// @param sign_bit      `0|1`
/// @param mantissa_bits 23 bits of mantissa with top bit implied one (not
///                      considering denormals)
/// @param exponent_bits 8 bits of exponent (with offset signed number format)
static float float_from_parts(uint8_t sign_bit, uint32_t mantissa_bits, uint32_t exponent_bits) {
    // Add implied top bit
    uint32_t mantissa = (1u << 23) | mantissa_bits;
    int32_t signed_mantissa = sign_bit ? -((int32_t)mantissa) : (int32_t)mantissa;
    int exponent = (int)exponent_bits - 127;
    // -23 is to normalize mantissa from 1xxxx to 1.xxxx
    return ldexpf((float)signed_mantissa, exponent - 23);
}

/// Reconstruct double from parts of IEEE 754 in a platform independent way
/// that follows the C standard, where double memory layout is not specified.
///
/// Note that this is not very performant.
///
/// @param sign_bit      `0|1`
/// @param mantissa_bits 52 bits of mantissa with top bit implied one (not
///                      considering denormals)
/// @param exponent_bits 11 bits of exponent (with offset signed number format)
static double double_from_parts(uint8_t sign_bit, uint64_t mantissa_bits, uint64_t exponent_bits)
{
    // Add implied top bit
    uint64_t mantissa = (1ull << 52) | mantissa_bits;
    int64_t signed_mantissa = sign_bit ? -((int64_t)mantissa) : (int64_t)mantissa;
    int exponent = (int)exponent_bits - 1023;
    // -52 is to normalize mantissa from 1xxxx to 1.xxxx
    return ldexp((double)signed_mantissa, exponent - 52);
}

if (exponent_bits == 0 && mantissa_bits == 0) {
    return sign_bit ? -0.0f : 0.0f;  // nebo -0.0 : 0.0 pro double
}