Question

我正在将BigInt课程作为编程练习。它在base-65536中使用2的补码有符号整数向量（因此32位乘法不会溢出。一旦我完全工作，我将增加基数。）

所有基本的数学运算都经过编码，但有一个问题：使用我能够创建的基本算法，除法是痛苦慢。（对于商的每个数字，它有点像二进制除法......除非有人想看到它，否则我不会发布它。）

我想使用Newton-Raphson找到（移位）倒数然后乘以（和移位），而不是我的慢速算法。我想我已经掌握了基础知识：你给出了公式（x1 = x0（2 - x0 * divisor））一个很好的初始猜测，然后在经过一些迭代后，x收敛到倒数。这部分似乎很容易......但是当我尝试将这个公式应用于大整数时，我遇到了一些问题：

问题1：

因为我正在使用整数......好吧......我不能使用分数。这似乎导致x总是发散（x0 *除数必须<2似乎？）。我的直觉告诉我应该对方程进行一些修改，使其能够整数运算（达到一定的精度），但我真的很难找出它是什么。（我缺乏数学技能在这里打败了我......）我想我需要找到一些等效的等式而不是 d 有 d * [base ^ somePower] ？可以使用像（x1 = x0（2 - x0 * d））这样的等式来处理整数吗？

问题2：

当我使用牛顿的公式来找到某些数字的倒数时，结果最终只是一个小部分，低于答案应该是...... ex。当试图找到4的倒数（十进制）时：

x0 = 0.3
x1 = 0.24
x2 = 0.2496
x3 = 0.24999936
x4 = 0.2499999999983616
x5 = 0.24999999999999999999998926258176

如果我代表基数为10的数字，我希望得到25的结果（并记住右移产品2）。使用一些倒数（例如1/3），您可以在知道足够的准确度后截断结果。但是我如何从上述结果中得出正确的倒数？

对不起，如果这太模糊或者我要求太多了。我查看了维基百科和我在谷歌上可以找到的所有研究论文，但我觉得我正在撞墙。我感谢任何人都能给我的帮助！

...

编辑：算法运行，虽然它比我预期的要慢得多。与我的旧算法相比，我实际上失去了很多速度，即使是数千位的数字......我仍然缺少一些东西。这不是乘法的问题，这是非常快的。（我确实使用Karatsuba的算法）。

对于任何感兴趣的人，这是我目前对Newton-Raphson算法的迭代：

bigint operator/(const bigint& lhs, const bigint& rhs) {
    if (rhs == 0) throw overflow_error("Divide by zero exception");
    bigint dividend = lhs;
    bigint divisor = rhs;

    bool negative = 0;
    if (dividend < 0) {
        negative = !negative;
        dividend.invert();
    }
    if (divisor < 0) {
        negative = !negative;
        divisor.invert();
    }

    int k = dividend.numBits() + divisor.numBits();
    bigint pow2 = 1;
    pow2 <<= k + 1;

    bigint x = dividend - divisor;
    bigint lastx = 0;
    bigint lastlastx = 0;
    while (1) {
        x = (x * (pow2 - x * divisor)) >> k;
        if (x == lastx || x == lastlastx) break;
        lastlastx = lastx;
        lastx = x;
    }
    bigint quotient = dividend * x >> k;
    if (dividend - (quotient * divisor) >= divisor) quotient++;
    if (negative)quotient.invert();
    return quotient;
}

这是我的（非常丑陋）旧算法更快：

bigint operator/(const bigint& lhs, const bigint & rhs) {
    if (rhs == 0) throw overflow_error("Divide by zero exception");
    bigint dividend = lhs;
    bigint divisor = rhs;

    bool negative = 0;
    if (dividend < 0) {
        negative = !negative;
        dividend.invert();
    }
    if (divisor < 0) {
        negative = !negative;
        divisor.invert();
    }

    bigint remainder = 0;
    bigint quotient = 0;
    while (dividend.value.size() > 0) {
        remainder.value.insert(remainder.value.begin(), dividend.value.at(dividend.value.size() - 1));
        remainder.value.push_back(0);
        remainder.unPad();
        dividend.value.pop_back();

        if (divisor > remainder) {
            quotient.value.push_back(0);
        } else {
            int count = 0;
            int i = MSB;
            bigint value = 0;
            while (i > 0) {
                bigint increase = divisor * i;
                bigint next = value + increase;
                if (next <= remainder) {
                    value = next;
                    count += i;
                }
                i >>= 1;
            }
            quotient.value.push_back(count);
            remainder -= value;
        }
    }

    for (int i = 0; i < quotient.value.size() / 2; i++) {
        int swap = quotient.value.at(i);
        quotient.value.at(i) = quotient.value.at((quotient.value.size() - 1) - i);
        quotient.value.at(quotient.value.size() - 1 - i) = swap;
    }

    if (negative)quotient.invert();
    quotient.unPad();
    return quotient;
}

Answer 1

首先，你可以实现时间O(n^2)的划分并且具有合理的常数，因此它不会比天真的乘法慢得多。但是，如果您使用Karatsuba - 类似算法，甚至基于FFT的乘法算法，那么您确实可以使用Newton-Raphson加速划分算法。

用于计算x的倒数的Newton-Raphson迭代是q[n+1]=q[n]*(2-q[n]*x)。

假设我们想要计算floor(2^k/B)，其中B是一个正整数。 WLOG，B≤2^k;否则，商为0。 x=B/2^k的Newton-Raphson迭代产生q[n+1]=q[n]*(2-q[n]*B/2^k)。我们可以将其重新排列为

q[n+1]=q[n]*(2^(k+1)-q[n]*B) >> k

这种迭代只需要整数乘法和位移。它会收敛到floor(2^k/B)吗？不必要。但是，在最坏的情况下，它最终会在floor(2^k/B)和ceiling(2^k/B)之间交替出现（证明它！）。因此，您可以使用一些不那么聪明的测试来查看您是否处于这种情况，并提取floor(2^k/B)。（这个＆＃34;不那么聪明的测试＆＃34;应该比每次迭代中的乘法更快;但是，优化这个东西会很好。）

确实，计算floor(2^k/B)足以计算任何正整数floor(A/B)的{{1}}。取A,B k，然后验证A*B≤2^k。

最后，这种方法的一个简单但重要的优化是在Newton-Raphson方法的早期迭代中截断乘法（即仅计算乘积的较高位）。这样做的原因是，早期迭代的结果远非商，并且不正确地执行它们并不重要。（优化这个论点，并表明如果你适当地做这件事，你可以在时间floor(A/B)=A*ceiling(2^k/B) >> k中划分两个≤n - 位整数，假设你可以及时乘以两个O(M(2n))位整数{ {1}}，而≤k是一个增加凸函数。）

Answer 2

如果我看到这一点，那么主要的改进就是为x选择一个良好的起始值。知道除数的位数，你知道逆的最高位必须在哪里，如

1/x = pow(2,log2(1/x))
1/x = pow(2,-log2(x))
1/x >= pow(2,-floor(log2(x)))

floor（log2（x））只是最高位集的索引。

Answer 3

Newton-Raphson是一种近似算法 - 不适合用于整数数学。您将得到舍入错误，这将导致您遇到的问题。您可以使用浮点数来解决问题，然后查看是否得到一个整数，精确到指定的位数（参见下一段）

关于第二个问题，选择精确度（小数位数）以获得精确度并舍入到该精度。如果你在问题中选择了二十位数的精度，你将舍入到0.25。您只需要迭代直到所需的精度数字稳定。通常，在计算机上表示无理数字通常会导致不精确。

Newton-Raphson分部与大整数

3 个答案: