Java 逆模 2**64

Question

给定一个奇怪的long x，我正在寻找long y，这样它们的乘积模2**64（即使用正常的溢出算法）等于1。为了明确我的意思：可以计算几千年后这样：

for (long y=1; ; y+=2) {
    if (x*y == 1) return y;
}

我知道这可以使用扩展的欧几里得算法快速解决，但它需要能够表示所有涉及的数字（范围高达 2**64，因此即使是无符号算术也无济于事）。使用BigInteger 肯定会有所帮助，但我想知道是否有更简单的方法，可能使用为正长实现的扩展欧几里得算法。

Answer 1

与此同时，我回忆/重新发明了一个非常简单的解决方案：

public static int inverseOf(int x) {
    Preconditions.checkArgument((x&1)!=0, "Only odd numbers have an inverse, got " + x);
    int y = 1;
    for (int mask=2; mask!=0; mask<<=1) {
        final int product = x * y;
        final int delta = product & mask;
        y |= delta;
    }
    return y;
}

之所以有效，是因为两件事：

• 在每次迭代中如果product的对应位是1，那就错了，唯一的解决办法就是改变y的对应位
• y 的任何位都不会影响product 的任何次要位，因此之前的工作不会被撤消

我从int 开始，因为对于long，它也必须工作，对于int，我可以进行详尽的测试。

另一个想法：必须有一个数字n>0 使得x**n == 1，因此y == x**(n-1)。这可能应该更快，我只是想不起足够的数学来计算n。

Answer 2

这是一种方法。这使用扩展欧几里得算法来找到 abs(x) 模 2⁶² 的逆，最后将答案“扩展”到逆模 2⁶⁴ 和必要时应用符号更改：

public static long longInverse(long x) {

    if (x % 2 == 0) { throw new RuntimeException("must be odd"); }

    long power = 1L << 62;

    long a = Math.abs(x);
    long b = power;
    long sign = (x < 0) ? -1 : 1;

    long c1 = 1;
    long d1 = 0;
    long c2 = 0;
    long d2 = 1;

    // Loop invariants:
    // c1 * abs(x) + d1 * 2^62 = a
    // c2 * abs(x) + d2 * 2^62 = b 

    while (b > 0) {
        long q = a / b;
        long r = a % b;
        // r = a - qb.

        long c3 = c1 - q*c2;
        long d3 = d1 - q*d2;

        // Now c3 * abs(x) + d3 * 2^62 = r, with 0 <= r < b.

        c1 = c2;
        d1 = d2;
        c2 = c3;
        d2 = d3;
        a = b;
        b = r;
    }

    if (a != 1) { throw new RuntimeException("gcd not 1 !"); }

    // Extend from modulo 2^62 to modulo 2^64, and incorporate sign change
    // if necessary.
    for (int i = 0; i < 4; ++i) {
        long possinv = sign * (c1 + (i * power));
        if (possinv * x == 1L) { return possinv; }
    }

    throw new RuntimeException("failed");
}

我发现使用 2⁶² 比使用 2⁶³ 更容易，主要是因为它避免了使用负数的问题：2⁶³ 作为Java long 是否定的。