Question

大家好，我正在尝试手动实现新的frexp功能。为了能够做到这一点，我使用了Union数据类型。我可以正确找到指数但我的问题是关于螳螂部分。我找不到mantisa部分的正确值。它给了我很大的数字但是什么时候。我试图转移二进制文件，但它也没有帮助我。你知道如何从这个二进制文件中找到螳螂吗？谢谢。（这是双浮动单元，我假设双是64位）

P.S。还有一件事我没有得到。为了能够找到正确的指数值，我想在理论上减少该值1023（偏差属性），但在这个例子中我需要减少1022才能找到正确的值。有什么不对吗？

typedef union {
    double f;
    struct {
        unsigned long  mantisa : 52;
        unsigned long  exponent : 11;
        unsigned long  sign : 1;
    } parts;
} double_cast;

double myfrexp(double number, int *exp)
{
    double_cast d1;
    d1.f = number;
    unsigned long dd;
    printf("\n %x \n", d1.parts.exponent);
    *exp = d1.parts.exponent - 1022;
    printf("\n%d\n\n", *exp);
    printf("\n %lf \n", (double)d1.parts.mantisa);
    return d1.parts.mantisa;
}

谢谢

Answer 1

我不记得IEEE浮点数的确切细节，但我似乎记得，结构的连续成员被放置在不断增加的地址上。这意味着，您的布局似乎假设尾数存储在最低地址。我认为如果你将双变量的地址转换为64位整数指针，并使用shift＆amp;专门掩盖。

像这样：

uint64_t bits = *((uint64_t*)&number);
uint64_t mantissa = bits & ((1<<52)-1);
unsigned exponent = (bits>>52) & 0x7FF;
unsigned sign = bits>>63;

要打印结果，您可以（忽略0.0f，NaN等）：

printf("%c1.%"PRIu64"e%u", sign?'-':'+', mantissa, exponent);

使用PRIu64时，请here

Answer 2

要减少字符串问题并且无法拥有52位int字段，请使用double和uint64_t的联合。

假设double endian-ness和integer endian-ness是相同的。大多数系统都这样做 - 但不是全部。以下内容取决于此。

您的帖子中的+1和expo + 1是因为1.0＆lt; = IEEE显着（不是尾数）＆lt; 2.0，但是frexp()：0.5＆lt; =标准化分数＆lt; 1.0。

double myfrexp(double number, int *exp) {
  static const uint64_t mantissa_mask       = 0x000FFFFFFFFFFFFFllu;
  static const uint64_t mantissa_impliedBit = 0x0010000000000000llu;
  static const uint64_t expo_mask           = 0x7FF0000000000000llu;
  static const uint64_t expo_norm           = 0x3FE0000000000000llu;
  static const uint64_t sign_mask           = 0x8000000000000000llu;
  static const int expo_NaN = 0x07FF;
  static const int expo_Bias = 1023;

  union {
    double d;
    uint64_t u;
  } x = { number };
  uint64_t mantissa = x.u & mantissa_mask;
  int expo = (x.u & expo_mask) >> 52;

  if (expo == expo_NaN) {  // Behavior for Infinity and NaN is unspecified.
    *exp = 0;
    return number;
  }
  if (expo > 0) {
    mantissa |= mantissa_impliedBit;  // This line is illustrative, not needed.
    expo -= expo_Bias;
  }
  else if (mantissa == 0) {
    *exp = 0;
    return number;  // Do not return 0.0 as that does not preserve -0.0
  }
  else {
    // de-normal or sub-normal numbers
    expo = 1 - expo_Bias;  // Bias different when biased exponent is 0
    while (mantissa < mantissa_impliedBit) {
      mantissa <<= 1;
      expo--;
    }
  }
  *exp = expo + 1;
  mantissa &= ~mantissa_impliedBit;
  x.u = (x.u & sign_mask) | expo_norm | mantissa;
  return x.d;
}

#include <limits.h>
#include <math.h>
#include <memory.h>
#include <stdio.h>
#include <float.h>

void frexp_test(double d) {
  int i1,i2;
  double d1,d2;
  d1 = frexp(d, &i1);
  d2 = myfrexp(d, &i2);
  if (memcmp(&d1,&d2,sizeof(d1)) != 0 || (i1 != i2)) {
    printf("%a  (%a %x) (%a %x)\n", d, d1, i1, d2, i2);
  }
}

int main() {
  frexp_test(1.0);
  frexp_test(0.0);
  frexp_test(-0.0);
  frexp_test(DBL_MAX);
  frexp_test(-DBL_MAX);
  frexp_test(DBL_EPSILON);
  frexp_test(DBL_MIN);
  frexp_test(DBL_MIN/1024);
  frexp_test(DBL_MIN/1024/1024);
  frexp_test(INFINITY);
  //frexp_test(DBL_TRUE_MIN);
  return 0;
}

联盟 - 二进制到双

2 个答案: