我正在使用8位AVR芯片。 64位double没有数据类型（double只映射到32位float）。但是，我将通过串口接收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
答案 0 :(得分：5)
IEEE指定five different rounding modes，但默认使用的是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位为零。
答案 1 :(得分：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提供适当的定义。我不想破坏你所有的乐趣。 <{3}}和single precision号上的维基百科条目非常好。
如果你要修补浮点数，你应该阅读David Goldberg的double precision和 斯蒂尔和怀特"What Every Computer Scientist Should Know About Floating Point Arithmetic"。在理解浮点数如何工作时，它们是两篇内容最丰富的文章。
答案 2 :(得分：1)
http://www.google.com/search?q=c+convert+ieee+754+double+single
第一个结果之一就是：
http://www.mathworks.com/matlabcentral/fileexchange/23173
该代码显示了如何将IEEE-754 double转换为类似IEEE-754（1,5,10）的浮动格式。此代码包含大量注释，并提及您可能陷入的典型陷阱。
这不是你想要的，但它是一个很好的起点。
答案 3 :(得分：1)