Question

我正在尝试实现一个函数来计算大小相同的两个数字之间的除法。我使用unsigned int的数组来存储每个数字的值（参见下面的类结构）。我希望在两者的unsigned int的数量之差不大于1的情况下实现有效的除法函数。我研究了长除法算法（如维基百科中所述），但是它太慢了。是否有任何有效的算法来处理这种特殊情况？目前，我正在处理最多100位的数字。

class BigInt {
public:
    short sign; //sign of the number
    unsigned int size; //number of unsigned int's needed to store the number
    unsigned int* values; //values of the number

    ...
}

由于

Answer 1

假设你想要一个整数结果，你应该能够相当快地完成它。

最简单的想法是以十进制的方式来考虑这一点，但开头的数字会略小一些。

让我们考虑一些较小的数字，例如：123456789/54321876。其中一个比另一个更多，所以最大可能的结果大约是10。

如果我们划分双方所以我们有（比方说）三个数字留在较大的数字和两个数字在较小的数字，我们得到123/54，这产生相同的整数结果，就像我们做了全程精确地工作。

在你的情况下，你可以做几乎相同的事情，除了十进制数字，你将在你的较大项目中基本上保持三个单词的精度，在较小的项目中保持两个单词（实际上，即使是保守的 - 2和1个单词分别可能足够，但我现在懒得证明这一点，如果你这样做，你可能需要更加小心舍入。）

所以，是的，您认为这是一种特殊情况，您可以根据几乎相同大小的数字来保存工作是正确的。

Answer 2

我相信Knuth算法D（计算机程序设计第2卷第4.3.1节）的修改版本应该在随机输入的恒定平均时间内完成这一技巧，线性时间最差 - 案件。显着的简化源于仅需要初始迭代产生的第一个商数字。

以下是我无耻地调整通用implementation from Hacker's Delight的尝试。该实现假设32位字和64位中间体/除法，但可以在更宽泛的算术可用的情况下自然扩展。

我确实担心这个功能实际上是未经测试的，所以请把它当作一个想法的细菌而不是一个完全成熟的实现。说实话，我甚至不记得为什么算法有效的细微之处。

// A helper function for finding the position of the most significant set bit.
// Please plug in your intrinsic of choice here
static unsigned int find_first_bit(uint32_t value) {
#   ifdef _MSC_VER
    unsigned long index;
    (void) _BitScanReverse(&index, value);
    return index + 1;
#   else
    unsigned int count = 0;
    for(count = 0; value; ++count)
        value >>= 1;
    return count;
#   endif
}

// Multi-word division in 32-bit big-endian segments, returning the most significant
// word of the quotient.
uint32_t divide(const uint32_t *num, const uint32_t *den, size_t len) {
    // Skip past leading zero denominator digits. The quotient must fit in a single
    // 32-bit word and so only the preceeding numerator digit needs be examined
    uint32_t norm_den;
    uint64_t norm_num = 0;
    size_t top = 0;
    while(norm_den = den[top], !norm_den)
        norm_num = num[top++];
    // Please pad the input to insure at least three denominator words counting from
    // the first non-zero digit
    assert(len >= top + 3);
    // Divide the first two digits of the numerator by the leading digit of the
    // denominator as an initial quotient digit guess, yielding an upper bound
    // for the quotient at most two steps above the true value.
    // Simultaneously normalize the denominator with the MSB in the 31st bit.
    unsigned int norm = find_first_bit(norm_den);
    norm_num = norm_num << (64 - norm);
    norm_num |= ((uint64_t) num[top + 0] << 32 | num[top + 1]) >> norm;
    norm_den = ((uint64_t) norm_den << 32 | den[top + 1]) >> norm;
    // We are using a straight 64/64 division where 64/32=32 would suffice. The latter
    // is available on e.g. x86-32 but difficult to generate short of assembly code.
    uint32_t quot = (uint32_t) (norm_num / norm_den);
    // Substitute norm_num - quot * norm_den if your optimizer is too thick-headed to
    // efficiently extract the remainder
    uint32_t rem = norm_num % norm_den;
    // Test the next word of the input, reducing the upper bound to within one step
    // of the true quotient. See Knuth for proofs of this reduction and the bounds
    // of the first guess
    norm_num = ((uint64_t) num[top + 1] << 32 | num[top + 2]) >> norm;
    norm_num = (uint64_t) rem << 32 | (uint32_t) norm_num;
    norm_den = ((uint64_t) den[top + 1] << 32 | den[top + 2]) >> norm;
    if((uint64_t) quot * norm_den > norm_num) {
        --quot;
        // There is no "add-back" step try to avoid and so there is little point
        // in looping to refine the guess further since the bound is sufficiently
        // tight already
    }
    // Compare quotient guess multiplied by the denominator to the numerator
    // across whole numbers to account for the final quotient step.
    // There is no need to bother with normalization here. Furthermore we can
    // compare from the most to the least significant and cut off early when the
    // intermediate result becomes large, yielding a constant average running
    // time for random input
    uint64_t accum = 0;
    do {
        uint64_t prod = (uint64_t) quot * *den++;
        accum = accum << 32 | *num++;
        // A negative partial result can never recover, so pick the lower
        // quotient. A separate test is required to avoid 65-bit arithmetic
        if(accum < prod)
            return --quot;
        accum -= prod;
        // Similarly a partial result which spills into the upper 32-bits can't
        // recover either, so go with the upper quotient
        if((uint64_t) accum >= 0x100000000)
            return quot;
    } while(--len);
    return quot;
}

具有大约相同大小的操作数的大整数除法

2 个答案: