23

我正在使用 8 位 AVR 芯片。64 位双精度没有数据类型（双精度只映射到 32 位浮点数）。但是，我将通过串行接收 64 位双精度，并且需要通过串行输出 64 位双精度。

如何在不强制转换的情况下将 64 位双精度转换为 32 位浮点并再次返回？32 位和 64 位的格式都将遵循 IEEE 754。当然，我假设在转换为 32 位浮点数时会损失精度。

为了从 64 位转换为 32 位浮点数，我正在尝试这个：

// Script originally from http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1281990303
float convert(uint8_t *in) {
  union {
    float real;
    uint8_t base[4];
  } u;
  uint16_t expd = ((in[7] & 127) << 4) + ((in[6] & 240) >> 4);
  uint16_t expf = expd ? (expd - 1024) + 128 : 0;
  u.base[3] = (in[7] & 128) + (expf >> 1);
  u.base[2] = ((expf & 1) << 7) + ((in[6] & 15) << 3) + ((in[5] & 0xe0) >> 5);
  u.base[1] = ((in[5] & 0x1f) << 3) + ((in[4] & 0xe0) >> 5);
  u.base[0] = ((in[4] & 0x1f) << 3) + ((in[3] & 0xe0) >> 5);
  return u.real;
}

对于像 1.0 和 2.0 这样的数字，上述方法有效，但是当我测试将 1.1 作为 64 位双精度值传递时，输出稍微偏离了一点（从字面上看，不是双关语！），尽管这可能是一个问题我的测试。看：

// Comparison of bits for a float in Java and the bits for a float in C after
// converted from a 64-bit double. Last bit is different.
// Java code can be found at https://gist.github.com/912636
JAVA FLOAT:        00111111 10001100 11001100 11001101
C CONVERTED FLOAT: 00111111 10001100 11001100 11001100
4

4 回答 4

5

IEEE 指定了五种不同的舍入模式，但默认使用的一种是Round half to even。所以你有一个形式为 10001100 11001100 11001100 11001100... 的尾数，你必须将它四舍五入到 24 位。从 0（最高有效）开始对位进行编号，第 24 位为 1；但这还不足以告诉您是否将第 23 位向上舍入。如果所有剩余位均为 0，则不会四舍五入，因为位 23 为 0（偶数）。但其余位不为零，因此您在所有情况下都四舍五入。

一些例子：

10001100 11001100 11001100 10000000...（全为零）不会四舍五入，因为第 23 位已经是偶数。

10001100 11001100 11001101 10000000...（全为零）确实向上取整，因为第 23 位是奇数。

10001100 11001100 1100110x 10000000...0001 总是向上取整，因为其余位并非全为零。

10001100 11001100 1100110x 0xxxxxxx... 从不四舍五入，因为第 24 位为零。

于 2011-04-10T21:06:32.523 回答
3

以下代码似乎从单精度转换为双精度。我将把它作为练习留给读者来实现缩小版本。不过，这应该可以帮助您入门。最难的部分是在有效数字中正确地获取位位置。我包括一些评论，其中包括正在发生的事情。

double
extend_float(float f)
{
    unsigned char flt_bits[sizeof(float)];
    unsigned char dbl_bits[sizeof(double)] = {0};
    unsigned char sign_bit;
    unsigned char exponent;
    unsigned int  significand;
    double out;

    memcpy(&flt_bits[0], &f, sizeof(flt_bits));
    /// printf("---------------------------------------\n");
    /// printf("float = %f\n", f);
#if LITTLE_ENDIAN
    reverse_bytes(flt_bits, sizeof(flt_bits));
#endif
    /// dump_bits(&flt_bits[0], sizeof(flt_bits));

    /* IEEE 754 single precision
     *    1 sign bit              flt_bits[0] & 0x80
     *    8 exponent bits         flt_bits[0] & 0x7F | flt_bits[1] & 0x80
     *   23 fractional bits       flt_bits[1] & 0x7F | flt_bits[2] & 0xFF |
     *                            flt_bits[3] & 0xFF
     *
     * E = 0   & F  = 0 -> +/- zero
     * E = 0   & F != 0 -> sub-normal
     * E = 127 & F  = 0 -> +/- INF
     * E = 127 & F != 0 -> NaN
     */
    sign_bit = (flt_bits[0] & 0x80) >> 7;
    exponent = ((flt_bits[0] & 0x7F) << 1) | ((flt_bits[1] & 0x80) >> 7);
    significand = (((flt_bits[1] & 0x7F) << 16) |
                   (flt_bits[2] << 8) |
                   (flt_bits[3]));

    /* IEEE 754 double precision
     *    1 sign bit              dbl_bits[0] & 0x80
     *   11 exponent bits         dbl_bits[0] & 0x7F | dbl_bits[1] & 0xF0
     *   52 fractional bits       dbl_bits[1] & 0x0F | dbl_bits[2] & 0xFF
     *                            dbl_bits[3] & 0xFF | dbl_bits[4] & 0xFF
     *                            dbl_bits[5] & 0xFF | dbl_bits[6] & 0xFF
     *                            dbl_bits[7] & 0xFF
     *
     * E = 0    & F  = 0 -> +/- zero
     * E = 0    & F != 0 -> sub-normal
     * E = x7FF & F  = 0 -> +/- INF
     * E = x7FF & F != 0 -> NaN
     */
    dbl_bits[0] = flt_bits[0] & 0x80; /* pass the sign bit along */

    if (exponent == 0) {
        if (significand  == 0) { /* +/- zero */
            /* nothing left to do for the outgoing double */
        } else { /* sub-normal number */
            /* not sure ... pass on the significand?? */
        }
    } else if (exponent == 0xFF) { /* +/-INF and NaN */
        dbl_bits[0] |= 0x7F;
        dbl_bits[1]  = 0xF0;
        /* pass on the significand */
    } else { /* normal number */
        signed int int_exp = exponent;
        int_exp -= 127;  /* IEEE754 single precision exponent bias */
        int_exp += 1023; /* IEEE754 double precision exponent bias */
        dbl_bits[0] |= (int_exp & 0x7F0) >> 4;  /* 7 bits */
        dbl_bits[1]  = (int_exp & 0x00F) << 4;  /* 4 bits */
    }

    if (significand != 0) {
        /* pass on the significand most-significant-bit first */
        dbl_bits[1] |=  (flt_bits[1] & 0x78) >> 3;    /* 4 bits */
        dbl_bits[2] = (((flt_bits[1] & 0x07) << 5) |  /* 3 bits */
                       ((flt_bits[2] & 0xF8) >> 3));  /* 5 bits */
        dbl_bits[3] = (((flt_bits[2] & 0x07) << 5) |  /* 3 bits */
                       ((flt_bits[3] & 0xF8) >> 3));  /* 5 bits */
        dbl_bits[4] =  ((flt_bits[3] & 0x07) << 5);   /* 3 bits */
    }

    ///dump_bits(&dbl_bits[0], sizeof(dbl_bits));
#if LITTLE_ENDIAN
    reverse_bytes(&dbl_bits[0], sizeof(dbl_bits));
#endif
    memcpy(&out, &dbl_bits[0], sizeof(out));

    return out;
}

我留下了一些printf行，但在 C++ 风格的注释中注释掉了。您必须为 、 和 提供适当reverse_bytes的LITTLE_ENDIAN定义dump_bits。毕竟我不想破坏你所有的乐趣。关于单精度和双精度数字的维基百科条目非常好。

如果你要经常修改浮点数，你应该阅读David Goldberg 的 “What Every Computer Scientist Should Know About Floating Point Arithmetic”和 Steele 和 White 的“How to Print Floating Point Numbers Accurately”。在了解浮点数的工作原理时，它们是两篇信息量最大的文章。

于 2011-04-10T22:11:35.533 回答
1

据我所知，AVR的GCC中只有一个IEEE754 double的完整实现，你可以在这里找到它。

您将需要此存档，然后将存档中的avr_f64.c替换为该存档。

库占用大约 21K 闪存和 310 字节内存。

原始帖子可以在这里找到。我从原始帖子中提取了所有重要信息并在这里展示，因为我认为您需要有一个帐户才能登录论坛。

于 2011-04-11T08:40:54.913 回答
1

http://www.google.com/search?q=c+convert+ieee+754+double+single

第一个结果是这样的：

http://www.mathworks.com/matlabcentral/fileexchange/23173

该代码显示了如何将 IEEE-754 双精度转换为 IEEE-754 类 (1,5,10) 浮点格式。这段代码包含大量注释，并提到了您可能陷入的典型陷阱。

这并不完全是您想要的，但它是一个很好的起点。

于 2011-04-10T20:34:13.970 回答