Multiply+Divide 仅使用 Multiply+Shift（32 位）

Question

我想知道做比例计算最快的方法，就是y = x * a / b，这里所有的值都是32位的，无符号的，a和b是固定的（初始化一次，然后不更改）但在编译时未知。结果保证不会溢出（即使中间乘法可能需要 64 位）。编程语言无关紧要，但 Java 最适合我的情况。它需要尽可能快（纳秒很重要）。我目前使用：

int result = (int) ((long) x * a / b);

但是除法很慢。我知道Perform integer division using multiplication，所以最好是一个类型的公式：

int result = (int) (((long) x * factor) >>> shift);

其中factor 和shift 可以从a 和b 计算（计算可能很慢）。

我试图简单地替换原始公式的除法部分，但它不起作用，因为两次乘法的结果不适合 64 位：

// init
int shift = 63 - Integer.numberOfLeadingZeros(b);
int factor = ((1L << shift) / b) + 1;
...
// actual calculation
int result = (int) ((long) x * a * factor) >>> shift);

在我的情况下，结果实际上不必完全准确（减一即可）。

Answer 1

怎么样

long a2 = a & 0xFFFFFFFFL;
long b2 = b & 0xFFFFFFFFL;
checkArgument(b2 > 0);
double dFactor = (double) a2 / b2;
shift = 0;
while (dFactor < 1L<<32) {
   dFactor *= 2;
   shift++;
}
factor = (long) dFactor;

准备和

int result = (int) (((x & 0xFFFFFFFFL) * factor) >>> shift);

对于快速部分？现在我们有了2**32 <= factor < 2**33，对于任何int x >= 0，产品x * factor < 2**31 * 2**33 = 2**64 正好适合unsigned long。没有比特被浪费。 dFactor 到 long 的转换向下舍入，这可能不是最理想的。

---

准备工作肯定会加快，尤其是可以通过先查看前导零来消除循环。我不会为消除 double 而烦恼，因为它使事情变得简单。

Answer 2

我认为如果使用公式(x * factor) >>> shift，不可能总是得到准确的结果：对于某些极端情况，结果要么是 1 太低，要么是 1 太高。为了总能得到正确的结果，公式需要更复杂。我找到了一个不需要浮点的解决方案，这里是一个测试用例：

static final Set<Integer> SOME_VALUES = new TreeSet<Integer>();

static {
    Set<Integer> set = SOME_VALUES;
    for (int i = 0; i < 100; i++) {
        set.add(i);
    }
    set.add(Integer.MAX_VALUE);
    set.add(Integer.MAX_VALUE - 1);
    for (int i = 1; i > 0; i += i) {
        set.add(i - 1);
        set.add(i);
        set.add(i + 1);
    }
    for (int i = 1; i > 0; i *= 3) {
        set.add(i);
    }
    Random r = new Random(1);
    for (int i = 0; i < 100; i++) {
        set.add(r.nextInt(Integer.MAX_VALUE));
    }
}

private static void testMultiplyDelete() {
    for (int a : SOME_VALUES) {
        for (int b : SOME_VALUES) {
            if (b == 0) {
                continue;
            }
            int shift = 32;
            // sometimes 1 too low
            long factor = (1L << shift) * a / b;
            // sometimes 1 too high
            // long factor = ((1L << shift) * a / b) + 1;

            // sometimes 1 too low
            // double dFactor = (double) a / b;
            // int shift = 0;
            // while (dFactor > 0 && dFactor < (1L << 32)) {
            //     dFactor *= 2;
            //     shift++;
            // }
            // long factor = (long) dFactor;

            for (int x : SOME_VALUES) {
                long expectedResult = (long) x * a / b;
                if (expectedResult < 0 ||
                        expectedResult >= Integer.MAX_VALUE) {
                    continue;
                }
                int result = (int) ((x * factor) >>> shift);
                if (Math.abs(result - expectedResult) > 1) {
                    System.out.println(x + "*" + a + "/" + b +
                            "=" + expectedResult + "; " +
                            "(" + x + "*" + factor + ")>>>" + shift + "=" + result);
                }
            }
        }
    }
}

Answer 3

由于a 和b 都是固定的，您可以只进行一次除法并重复使用结果（这可能已经在幕后自动发生）：

int c = a / b;
int y1 = x1 * c;
int y2 = x2 * c;
...

如果您确实需要优化它，请考虑在GPU 上运行它（例如使用CUDA 的java 绑定），这将允许您并行计算，尽管这更难实现。

最后，在测试时添加计时器总是一个好主意，这样您就可以运行基准测试以确保优化确实提高了性能。