小编典典

您可以使用Float.intBitsToFloat()和Float.floatToIntBits()在原始浮点值之间进行转换。如果您可以采用截断的精度(而不是舍入)，那么只需少量的移位就可以实现转换。

我现在付出了更多的努力，结果却没有一开始就那么简单。现在，该版本已经在我能想到的各个方面进行了测试和验证，我非常有信心它可以为所有可能的输入值产生准确的结果。它支持任一方向上的精确舍入和次正规转换。

// ignores the higher 16 bits

public static float toFloat( int hbits )

{

int mant = hbits & 0x03ff; // 10 bits mantissa

int exp = hbits & 0x7c00; // 5 bits exponent

if( exp == 0x7c00 ) // NaN/Inf

exp = 0x3fc00; // -> NaN/Inf

else if( exp != 0 ) // normalized value

{

exp += 0x1c000; // exp - 15 + 127

if( mant == 0 && exp > 0x1c400 ) // smooth transition

return Float.intBitsToFloat( ( hbits & 0x8000 ) << 16

| exp << 13 | 0x3ff );

}

else if( mant != 0 ) // && exp==0 -> subnormal

{

exp = 0x1c400; // make it normal

do {

mant <<= 1; // mantissa * 2

exp -= 0x400; // decrease exp by 1

} while( ( mant & 0x400 ) == 0 ); // while not normal

mant &= 0x3ff; // discard subnormal bit

} // else +/-0 -> +/-0

return Float.intBitsToFloat( // combine all parts

( hbits & 0x8000 ) << 16 // sign << ( 31 - 15 )

| ( exp | mant ) << 13 ); // value << ( 23 - 10 )

}

// returns all higher 16 bits as 0 for all results

public static int fromFloat( float fval )

{

int fbits = Float.floatToIntBits( fval );

int sign = fbits >>> 16 & 0x8000; // sign only

int val = ( fbits & 0x7fffffff ) + 0x1000; // rounded value

if( val >= 0x47800000 ) // might be or become NaN/Inf

{ // avoid Inf due to rounding

if( ( fbits & 0x7fffffff ) >= 0x47800000 )

{ // is or must become NaN/Inf

if( val < 0x7f800000 ) // was value but too large

return sign | 0x7c00; // make it +/-Inf

return sign | 0x7c00 | // remains +/-Inf or NaN

( fbits & 0x007fffff ) >>> 13; // keep NaN (and Inf) bits

}

return sign | 0x7bff; // unrounded not quite Inf

}

if( val >= 0x38800000 ) // remains normalized value

return sign | val - 0x38000000 >>> 13; // exp - 127 + 15

if( val < 0x33000000 ) // too small for subnormal

return sign; // becomes +/-0

val = ( fbits & 0x7fffffff ) >>> 23; // tmp exp for subnormal calc

return sign | ( ( fbits & 0x7fffff | 0x800000 ) // add subnormal bit

+ ( 0x800000 >>> val - 102 ) // round depending on cut off

>>> 126 - val ); // div by 2^(1-(exp-127+15)) and >> 13 | exp=0

}

与 本书

相比，我实现了两个小的扩展，因为16位浮点的通用精度相当低，与较大的浮点类型(通常由于精度高而通常不会注意到)相比，这可能使浮点格式的固有异常在视觉上可以感知。

第一个是toFloat()函数中的这两行：

if( mant == 0 && exp > 0x1c400 ) // smooth transition

return Float.intBitsToFloat( ( hbits & 0x8000 ) << 16 | exp << 13 | 0x3ff );

字体大小的正常范围内的浮点数采用指数，因此采用数值大小的精度。但这并不是一个平稳的采用，它是分步进行的：切换到下一个更高的指数将导致一半的精度。现在，对于尾数的所有值，精度都保持不变，直到下一次跳转到下一个更高的指数为止。上面的扩展代码通过返回此特定的半浮点值在覆盖的32位浮点范围的地理中心的值，使这些过渡更加平滑。每个正常的半浮点值都精确映射到8192个32位浮点值。返回值应该恰好在这些值的中间。但是在半浮点指数的过渡处，较低的4096值的精度是较高的4096值的两倍，因此覆盖的数字空间仅为另一侧的一半。所有这8192个32位浮点值都映射到相同的半浮点值，因此，无论将8192中的哪一个转换为32位，然后将其转换回32位，都将产生相同的半浮点值

选择了中间的 32位值。扩展现在导致在过渡像更平滑的半一步SQRT(2)的一个因素，因为在正确的显示 图象 下面而左 画面

应该以可视化的尖锐步骤由两个因素不用抗混叠。您可以安全地从代码中删除这两行以获得标准行为。

covered number space on either side of the returned value:

6.0E-8 ####### ##########

4.5E-8 | #

3.0E-8 ######### ########

第二个扩展是在fromFloat()函数中：

{ // avoid Inf due to rounding

if( ( fbits & 0x7fffffff ) >= 0x47800000 )

...

return sign | 0x7bff; // unrounded not quite Inf

}

此扩展通过保存一些32位值形式(提升为Infinity)来稍微扩展半浮点格式的数字范围。受影响的值为那些没有四舍五入而小于Infinity的值，仅由于四舍五入而变为Infinity的值。如果您不需要此扩展名，则可以安全地删除上面显示的行。

我试图尽可能地优化fromFloat()函数中正常值的路径，由于使用了预先计算和未移位的常量，因此使其可读性降低了。我没有在’toFloat()’上投入过多的精力，因为无论如何它都不会超出查找表的性能。因此，如果速度真的很重要，则可以toFloat()仅使用该函数填充0x10000个元素的静态查找表，然后使用该表进行实际转换。对于当前的x64服务器VM，这大约快3倍，对于x86客户端VM，这大约快5倍。

我在此将代码放入公共领域。

2020-10-18