提取位并在C中重构

Question

For a class project I'm trying to extract 3 bit fields from an IEEE floating point number, multiply it by 0.5, and reconstruct the number. I've gotten extraction mostly working by pushing them into unsigned integers:

x = 5.5
x: 1000000101100000000000000000000 (1085276160, 0x40b00000)
extracted sign: 0 (0, 0x0)
extracted exp: 10000001 (129, 0x81)
extracted sig: 01100000000000000000000 (1610612736, 0x60000000)

My two questions are:

a) How do I put these bits back to form the original input? I tried:

return sign ^ exp ^ sig

and did not get the correct result.

b) How do I multiply the number by 0.5? Do I multiply sig or exp?

Answer 1

a) you can "but these bits back" together with a combination of shifting with ands (to mask) and ors (to stick them back together). Playing with a programmers' calculator should suffice to understand how it works.

For example (pseudo-C):

unsigned int sign = ...;
unsigned int exp  = ...;
unsigned int sig  = ...;

See: float format

unsigned int out;
out = ((sign & 1)<<31)|((exp & 0xff)<<23)|(sig & 0x7fffff);

Where the significance of the & 1, & 0xff and & 0x07fffff is that they each have respectively 1, 8 and 23 bits set.

b) either would work, but if you move the exponent by +-1 it is the same as multiplying/dividing by two. This would not reduce the "precision" because the significand stays the same. If the exponent is already at the minimum the only way to do it would then be to start reducing the signifcand, which would be denormalization.

Note: there is an implicit high order 1 bit to the significand that is not stored. In other words, unless the exponent is zero, there is a 24th one bit that is not stored and is assumed to be one.

Answer 2

a) How do I put these bits back to form the original input?

To re-form the 32-bit representation of the float , use | , not ^ .

#include <stdint.h>

#define FLT_SIGN_SFT 31
#define FLT_EXP_SFT  23
#define FLT_SIG_SFT  0
#define FLT_SIGN_MSK 1
#define FLT_EXP_MSK  0xFF
#define FLT_SIG_MSK  0x7FFFFF
#define FLT_SIG_IMPLIED_BIT  (0x7FFFFF + 1)

float float_form(uint32_t sign, uint32_t exp, uint32_t sig) {
  union {
    uint32_t u32;
    float f;
  } u;
  u.u32 = sign << FLT_SIGN_SFT | exp << FLT_EXP_SFT | sig << FLT_SIG_SFT;
  return u.f;
}

Endian concerns: As long as both the float and uint32_t are of the same endian, this works. Else adjustments are needed.

How do I multiply the number by 0.5? Do I multiply sig or exp?

This is tricky. If x is a NaN or Infinty, do nothing. If x in a normal number, decrement the exponent (special case: if value is now a sub-normal). If x is a sub-normal, shift the significand. If a 1 bit was shifted out, consider rounding. If rounding caused change in exponent, adjust.

float float_div2(float f) {
  union {
    uint32_t u32;
    float f;
  } u;
  u.f = f;
  uint32_t sign = (u.u32 >> FLT_SIGN_SFT) & FLT_SIGN_MSK;
  uint32_t exp = (u.u32 >> FLT_EXP_SFT) & FLT_EXP_MSK;
  uint32_t sig = (u.u32 >> FLT_SIG_SFT) & FLT_SIG_MSK;
  if (exp < FLT_EXP_MSK) {
    unsigned shift_out = 0;
    if (exp > 0) {
      exp--;
      if (exp == 0) {
        sig += FLT_SIG_IMPLIED_BIT;
        shift_out = sig % 2u;
        sig /= 2;
      }
    } else {
      shift_out = sig % 2u;
      sig /= 2;
    }
    if (shift_out > 0) {
      assert(exp == 0);
      // Assume round to even
      if (sig % 2) {
        sig++;
        if (sig >= FLT_SIG_IMPLIED_BIT) {
          sig -= FLT_SIG_IMPLIED_BIT;
          exp++;
        }
      } // end if (sig % 2)
    } // end if (exp > 0)
  } // end if (exp < FLT_EXP_MSK)
  return float_form(sign, exp, sig);
}

Test code. Tested successfully against all float .

void float_div2_test(float x) {
  float y = x / 2.0f;
  float z = float_div2(x);
  if (memcmp(&y, &z, sizeof z)) {
    printf("%.10e %.10e %.10e\n", x, y, z);
    printf("%a %a %a\n", x, y, z);
    exit(1);
  }
}

void float_div2_tests() {
  union {
    uint32_t u32;
    float f;
  } u;
  u.u32 = 0;
  do {
    u.u32--;
    float_div2_test(u.f);
  } while (u.u32);
  puts("Success!");
}