如何保持 int64_t = int64_t * float 的精度？

Question

我想通过[0.01..1.2] 范围内的因子对int64_t 执行校正，精度约为0.01。天真的实现是：

int64_t apply_correction(int64_t y, float32_t factor)
{
    return y * factor;
}

不幸的是，如果我将factor 转换为int32 或将y 转换为float，我将失去精度。

但是，如果我可以确保y 的最大值低于1<<56，我可以使用这个技巧：

(1<<8) * (y / (int32_t)(factor * (1<<8)))

如果我的输入值可以大于1<<56，我该如何解决这个问题？

情节转折：

我在 32 位架构上运行，其中 int64_t 是一种模拟类型，并且我不支持双精度。该架构是 Analog Devices 的 SHARC。

Answer 1

如果您计算((int64_t)1 << 57) * 100 或* 256，您将有一个有符号整数溢出，这将导致您的代码具有未定义的行为。相反，如果您使用 uint64_t 和值，那么您的代码将是定义良好但行为不端的。

---

但是，对于几乎高达 (1 << 63 / 1.2) 的数字，也可以使用此功能。

如果 y 是 uint64_t，您可以将原始数字拆分为最高有效 32 位，右移 32 位，最低有效 32 位，乘以 (int32_t)(factor * (1 << 8))。

那么在乘法之后你不会将最高有效位右移 8 位，而是左移 24 位；然后加起来：

uint64_t apply_uint64_correction(uint64_t y, float32_t factor)
{
    uint64_t most_significant = (y >> 32) * (uint32_t)(factor * (1 << 8));
    uint64_t least_significant = (y & 0xFFFFFFFFULL) * (uint32_t)(factor * (1 << 8));     
    return (most_significant << 24) + (least_significant >> 8);
}

现在，apply_uint64_correction(1000000000000, 1.2) 将生成 1199218750000，apply_uint64_correction(1000000000000, 1.25) 将生成 1250000000000。

---

其实如果你能保证factor的范围，你可以做的更精准：

uint64_t apply_uint64_correction(uint64_t y, float32_t factor)
{
    uint64_t most_significant = (y >> 32) * (uint32_t)(factor * (1 << 24));
    uint64_t least_significant = (y & 0xFFFFFFFFULL) * (uint32_t)(factor * (1 << 24));     
    return (most_significant << 8) + (least_significant >> 24);
}

apply_uint64_correction(1000000000000, 1.2) 会在我的电脑上提供1200000047683；如果 float32_t 具有 24 位尾数，这也是您可以获得的最大精度。

---

上述算法也适用于有符号正数，但由于负数的有符号移位是一个灰色区域，我会记下符号，然后将值转换为uint64_t，进行便携式计算，并且如果原始符号为负，则取反。

int64_t apply_correction(int64_t y, float32_t factor) {
    int negative_result = 0;
    uint64_t positive_y = y;
    if (y < 0) {
        negative_result = 1;
        positive_y = -y;
    }

    uint64_t result = apply_uint64_correction(positive_y, factor);
    return negative_result ? -(int64_t)result : result;
}

Answer 2

在整数空间里做怎么样？

/* factor precision is two decimal places */
int64_t apply_correction(int64_t y, float32_t factor)
{
    return y * (int32_t)(factor * 100) / 100;
}

这确实假设 y 不是很接近最大值，但它让你比 56 位更接近一点。

Answer 3

只是不要使用浮点数。

int64_t apply_correction(int64_t y, float32_t factor)
{
  int64_t factor_i64 = factor * 100f;

  return (y * factor_i64) / 100ll;
}

这是假设y * factor_i64 * 100 不会溢出。