缩放（长）整数时防止溢出并保持精度

Question

假设我在给定的范围中有一个位置pos，这样：

  0 pos 范围

范围内的这个位置可以包含在两种不同的上下文中，一种是范围是整数值，即 pos range 31 sup>，另一个范围是长整数，即最大 pos range 63。如果我想在这些上下文之间移动，我需要将位置缩放到新范围，以便正确地向下舍入到最接近的（长）整数值。所以，从技术上讲，我想做的就是：

   pos _new = floor( pos _old * range_新的 / 范围_旧的 )

不幸的是，这种直截了当的方法并不能解决问题，因为它要么溢出（如 pos _old * range _new 可以大到 ~2⁹⁴) 如果我先做乘法或如果我先做除法会给我舍入错误。使用浮点值进行数学运算通常也无济于事，因为它们不能提供足够的精度位，因此也可能导致不正确的舍入（我只有双精度可用）。

我找到了一种从整数范围正确缩放到长整数范围的方法：

public long scaleUp(int oldPos, int oldRange, long newRange) {
    return (newRange / oldRange) * oldPos + 
           (newRange % oldRange) * oldPos / oldRange;
}

这可确保计算在任何时候都不会超出长整数的限制，也不会因过早舍入而降低精度（模数捕获在第一次除法中舍入丢失的部分）。

我现在想弄清楚的是一种反向缩放的方法：

public int scaleDown(long oldPos, long oldRange, int newRange) {
    return ??? ;
}

不确定这是否应该比其他功能更困难，但不知何故我没有看到它。

几点说明：

• 我想避免使用浮点运算，因为我总是很难说服自己，由于四舍五入，在某些极不常见的情况下，给定公式确实不可能产生意外结果
• 我宁愿不使用 BigInteger 库
• 虽然这里的代码示例是 Java，但这确实是一个与语言无关的问题

Answer 1

我找到了一个不是 100% 完整的答案，但涵盖了我的程序中出现的所有特殊情况。您可以在我在数学 StackExchange 上发布的相应问题的答案中找到推导的详细信息：https://math.stackexchange.com/q/433729/84557

这是粗略的大纲：

public int scaleDown(long oldPos, long oldRange, int newRange) {
    if (oldPos <= Long.MAX_VALUE/newRange)
        return (int) (oldPos*newRange/oldRange);
    assert oldRange >= newRange*newRange : "Case not supported yet"; // Never happens in my code
    int newPos = (int) (oldPos / (oldRange/newRange));
    if (!isOk(newPos)) newPos--; // Check might be implementation specific
    return newPos;
}

不完整，但也许对某人有用。

Answer 2

我参加这个聚会非常非常晚，但我遇到了完全相同的问题。

请注意，我一直使用术语 x 表示您的 pos，y 表示您的 oldRange，并使用 w 表示您的 newRange，即求解方程 @987654330 中的 z @。

以下是我考虑过的解决方案：

我可以使用浮点数，但是对于 64 位整数，精度是否可以接受完全取决于平台是否支持尾数至少为 64 位的浮点数。 （许多平台没有。）

我可以将输入域重新定义为比输出范围小不超过一半的域，然后按比例放大 - 即q = y / w; scaleUp(x / q / 2, y / q / 2, w);，在最坏的情况下，最低位将完全丢失，并且在最好的情况是根本不会丢失任何信息，但无论如何我都不想丢失低位。

我可以使用一种二进制搜索来查找要从 x / (y / w) 中减去的值，以补偿错误，但我认为使用循环或递归对性能的影响是不可接受的。

现在我想出的最好的方法是通常计算 x / (y / w) - (y % w) * x / y 并且当乘法溢出时——当然，这应该只适用于相对较小的输入域（当然输入比仅仅计算 @ 少987654334@) - 使用诸如this one之类的算法来捕获乘积的高位。

但我仍然觉得有必须有一个更简单的方法来做到这一点。

Answer 3

编辑：此解决方案不正确，请参阅 cmets 中的讨论。

我有一个没有特殊情况的解决方案。我没有正确性的证明，但它看起来很合理，我找不到反例。

int scaleDown2(long longPos, long longRange, int shortRange) {
    int p = longPos / (longRange / shortRange);
    return p - ((p * (longRange % shortRange)) / longRange);
}