Java 无符号除法不转换为长？

Question

I have written an interpreter that requires me to perform 32-bit division of unsigned integers. In Java, I can do this as:

reg[a] = (int) ((reg[b] & 0xFFFFFFFFL) / (reg[c] & 0xFFFFFFFFL));

But I would like to avoid the conversion to long and back to int. Java already gives the unsigned right shift operator >>> for that special case, so maybe there is a clever way to do unsigned division in the same way.

Note that add and multiply work fine, since two's compliment numbers just work.

Is there a better way in Java to do this?

Answer 1

Well, if you shift down by one bit, you could divide the resulting two numbers, then shift up twice (because the resulting number would be 4 times smaller). But that would only work on even numbers, since you would lose the least significant bit.

I don't really think it would save you any time to check for that condition. (or check for numbers smaller then 2 ³¹ )

Answer 2

在 Java 8 及更高版本中， Integer对 unsigned int s 有一个完整的操作集合

reg[a] = Integer.divideUnsigned(reg[b], reg[c]);

Answer 3

Other people have mentioned simple and clearly correct approaches like casting to long , or using Integer.divideUnsigned() (Java SE 8+), or using BigInteger .

Practically speaking, Integer.divideUnsigned() is the clearest and most performant way to do it, because the JVM probably intrinsifies this function call into a native unsigned division machine instruction, making it run as fast as the language-level signed division operator / .

But for the sake of completeness, here is how to emulate uint32 / uint32 in pure Java (no C or assembly) in a relatively efficient manner, without using wider types like long or BigInteger :

int divideUint32(int x, int y) {
    if (y < 0) {  // i.e. 2^31 <= unsigned y < 2^32
        // Do unsigned comparison
        return (x ^ 0x8000_0000) >= (y ^ 0x8000_0000) ? 1 : 0;
    }
    else if (x >= 0 || y == 0) {
        assert y >= 0;
        return x / y;  // Straightforward or division by zero
    }
    else {  // The hard case: signed x < 0 && signed y > 0
        assert x < 0 && y > 0;
        // In other words, 2^31 <= unsigned x < 2^32 && 0 < unsigned y < 2^31
        int shift = Integer.numberOfLeadingZeros(y);
        assert shift > 0;
        assert (y << shift) < 0;
        // Do one step of long division
        if (x < (y << shift))
            shift--;
        return (1 << shift) | (x - (y << shift)) / y;
    }
}

I have checked this code on millions of random test cases over the full range of int values. In case anyone is wondering about adapting the code to work wing long , it is easy to do so by following the implicit patterns in the logic.

Answer 4

You could always used BigInteger , which works on arbitrary sized integers, but that would be a lot more expensive than promoting to long and cast back as int . Is your intention to improve performance (hence you want a "pure integer" solution to avoid the time for casts) or to improve how readable/understandable the code is (in which case BigInteger might be neater)?