如何将压缩整数 (16.16) 定点转换为浮点数？

Question

如何将“32位有符号定点数（16.16）”转换为浮点数？

(fixed >> 16) + (fixed & 0xffff) / 65536.0 可以吗？ -2.5呢？还有-0.5？

或者 fixed / 65536.0 是正确的方法吗？

（PS：有符号定点“-0.5”在内存中是什么样子的？）

Answer 1

我假设 32 位整数的补码和运算符的工作方式与 C# 中一样。

如何进行转换？

fixed / 65536.0

是正确且容易理解的。

---

(fixed >> 16) + (fixed & 0xffff) / 65536.0

与上面的正整数等效，但速度较慢且难以阅读。您基本上使用分配律将单个部分分成两个部分，并使用位移位写入第一个部分。

对于负整数fixed & 0xffff 不会提供小数位，因此对于负数来说它是不正确的。

查看原始整数 -1，它应映射到 -1/65536。此代码改为返回 65535/65536。

---

根据您的编译器，它可能会更快：

fixed * (1/65536.0)

但我假设大多数现代编译器已经进行了这种优化。

有符号定点“-0.5”在内存中是什么样子的？

反转转换给我们：

RoundToInt(float*65536)

设置 float=-0.5 给我们：-32768。

Answer 2

class FixedPointUtils {
  public static final int ONE = 0x10000;

  /**
   * Convert an array of floats to 16.16 fixed-point
   * @param arr The array
   * @return A newly allocated array of fixed-point values.
   */
  public static int[] toFixed(float[] arr) {
    int[] res = new int[arr.length];
    toFixed(arr, res);
    return res;
  }

  /**
   * Convert a float to  16.16 fixed-point representation
   * @param val The value to convert
   * @return The resulting fixed-point representation
   */
  public static int toFixed(float val) {
    return (int)(val * 65536F);
  }

  /**
   * Convert an array of floats to 16.16 fixed-point
   * @param arr The array of floats
   * @param storage The location to store the fixed-point values.
   */
  public static void toFixed(float[] arr, int[] storage)
  {
    for (int i=0;i<storage.length;i++) {
      storage[i] = toFixed(arr[i]);
    }
  }

  /**
   * Convert a 16.16 fixed-point value to floating point
   * @param val The fixed-point value
   * @return The equivalent floating-point value.
   */
  public static float toFloat(int val) {
    return ((float)val)/65536.0f;
  }

  /**
   * Convert an array of 16.16 fixed-point values to floating point
   * @param arr The array to convert
   * @return A newly allocated array of floats.
   */
  public static float[] toFloat(int[] arr) {
    float[] res = new float[arr.length];
    toFloat(arr, res);
    return res;
  }

  /**
   * Convert an array of 16.16 fixed-point values to floating point
   * @param arr The array to convert
   * @param storage Pre-allocated storage for the result.
   */
  public static void toFloat(int[] arr, float[] storage)
  {
    for (int i=0;i<storage.length;i++) {
      storage[i] = toFloat(arr[i]);
    }
  }

}

Answer 3

阅读 CodesInChaos 的答案后，我编写了一个 C++ 函数模板，非常方便。您可以传递小数部分的长度（例如，BMP 文件格式使用 2.30 定点数）。如果省略小数部分长度，则函数假设小数部分和整数部分具有相同的长度

#include <math.h> // for NaN
#include <limits.h> // for CHAR_BIT = 8

template<class T> inline double fixed_point2double(const T& x, int frac_digits = (CHAR_BIT * sizeof(T)) / 2 )
{
  if (frac_digits >= CHAR_BIT * sizeof(T)) return NAN;
  return double(x) / double( T(1) << frac_digits) );
}

如果你想从内存中读取这样的数字，我写了一个函数模板

#include <math.h> // for NaN
#include <limits.h> // for CHAR_BIT = 8

template<class T> inline double read_little_endian_fixed_point(const unsigned char *x, int frac_digits = (CHAR_BIT * sizeof(T)) / 2)
// ! do not use for single byte types 'T'
{
  if (frac_digits >= CHAR_BIT * sizeof(T)) return NAN;

  T res = 0;

  for (int i = 0, shift = 0; i < sizeof(T); ++i, shift += CHAR_BIT)
    res |= ((T)x[i]) << shift;

  return double(res) / double( T(1) << frac_digits) );
}

Answer 4

CodesInChaos 实际上是错误的，说这

(fixed >> 16) + (fixed & 0xffff) / 65536.0

不起作用。
如果固定是一个 32 位有符号整数，那么对于负数，它实际上是从 0 减去的值，或者说 0x1_0000_0000，即 33 位数字。这就是二进制补码的工作原理。因此，这些小数位需要从下一个较小的整数中添加才能读取正确的值！

因此，整数 -1 的 (fixed >> 16) 将生成浮点数 -1，并添加 (fixed & 0xffff) / 65536.0 = 65535 /65536 到 -1 将产生正确的值 -1/65536，因为 -65536/65536 + 65535/65536 = -1/65536