Question

Exponentiation by squaring是一种快速计算ⁿ的算法，其中a和n是有符号整数。（它在O（log n）乘法中这样做。）

是否有类似的算法，而是计算（a / b）ⁿ，其中a，b和n都是无符号整数？显而易见的方法（即计算ⁿ / b ⁿ）的问题在于，由于中间值上的整数溢出，它将返回错误的结果。

我没有宿主语言的浮点数，只有整数。

我很满意答案。

Answer 1

如果你想要（a / b）^ n的值具有极好的精度，其中a，b和n是无符号整数，并且你没有可用的浮点运算 - 使用扩展精度整数计算来查找^ n和b ^ n，然后将两者分开。

某些语言（如Python）内置了扩展精度整数运算。如果您的语言没有，请查找实现它的包。如果你不能这样做，那就做个自己的包。这并不难 - 这个包在当天的第二学期计算机科学课上是一项任务。乘法和幂是相当简单的;最困难的部分是分裂，即使你只想要商和余数。但“最困难”并不意味着“非常困难”，你可能会这样做。第二个必须困难的例程是将扩展整数打印成十进制格式。

基本思想是将每个整数存储在一个数组或常规无符号整数列表中，其中整数是算术中具有大基数的“数字”。您希望能够处理任意两位数的乘积，因此如果您的机器具有32位整数并且您无法处理64位整数，则存储每位16位的“数字”。 “数字”越大，计算越快。如果您的计算很少并且您的打印到十进制频繁，请为每个“数字”使用10的幂，例如10000。

询问您是否需要更多细节。

Answer 2

这是基于费曼的对数算法的固定点的pow实现。它很快，有点脏; C库倾向于使用多项式近似，但这种方法更复杂，我不确定它将如何转换为定点。

// powFraction approximates (a/b)**n.
func powFraction(a uint64, b uint64, n uint64) uint64 {
    if a == 0 || b == 0 || a < b {
        panic("powFraction")
    }
    return expFixed((logFixed(a) - logFixed(b)) * n)
}

// logFixed approximates 2**58 * log2(x). [Feynman]
func logFixed(x uint64) uint64 {
    if x == 0 {
        panic("logFixed")
    }
    // Normalize x into [2**63, 2**64).
    n := numberOfLeadingZeros(x)
    x <<= n
    p := uint64(1 << 63)
    y := uint64(0)
    for k := uint(1); k <= 63; k++ {
        // Warning: if q > x-p, then p + q may overflow.
        if q := p >> k; q <= x-p {
            p += q
            y += table[k-1]
        }
    }
    return uint64(63-n)<<58 + y>>6
}

// expFixed approximately inverts logFixed.
func expFixed(y uint64) uint64 {
    n := 63 - uint(y>>58)
    y <<= 6
    p := uint64(1 << 63)
    for k := uint(1); k <= 63; k++ {
        if z := table[k-1]; z <= y {
            p += p >> k
            y -= z
        }
    }
    return p >> n
}

// numberOfLeadingZeros returns the number of leading zeros in the word x.
// [Hacker's Delight]
func numberOfLeadingZeros(x uint64) uint {
    n := uint(64)
    if y := x >> 32; y != 0 {
        x = y
        n = 32
    }
    if y := x >> 16; y != 0 {
        x = y
        n -= 16
    }
    if y := x >> 8; y != 0 {
        x = y
        n -= 8
    }
    if y := x >> 4; y != 0 {
        x = y
        n -= 4
    }
    if y := x >> 2; y != 0 {
        x = y
        n -= 2
    }
    if x>>1 != 0 {
        return n - 2
    }
    return n - uint(x)
}

// table[k-1] approximates 2**64 * log2(1 + 2**-k). [MPFR]
var table = [...]uint64{
    10790653543520307104, // 1
    5938525176524057593,  // 2
    3134563013331062591,  // 3
    1613404648504497789,  // 4
    818926958183105433,   // 5
    412613322424486499,   // 6
    207106307442936368,   // 7
    103754619509458805,   // 8
    51927872466823974,    // 9
    25976601570169168,    // 10
    12991470209511302,    // 11
    6496527847636937,     // 12
    3248462157916594,     // 13
    1624280643531991,     // 14
    812152713665686,      // 15
    406079454902306,      // 16
    203040501980337,      // 17
    101520444623942,      // 18
    50760270720599,       // 19
    25380147462480,       // 20
    12690076756788,       // 21
    6345039134781,        // 22
    3172519756487,        // 23
    1586259925518,        // 24
    793129974578,         // 25
    396564990243,         // 26
    198282495860,         // 27
    99141248115,          // 28
    49570624104,          // 29
    24785312063,          // 30
    12392656035,          // 31
    6196328018,           // 32
    3098164009,           // 33
    1549082005,           // 34
    774541002,            // 35
    387270501,            // 36
    193635251,            // 37
    96817625,             // 38
    48408813,             // 39
    24204406,             // 40
    12102203,             // 41
    6051102,              // 42
    3025551,              // 43
    1512775,              // 44
    756388,               // 45
    378194,               // 46
    189097,               // 47
    94548,                // 48
    47274,                // 49
    23637,                // 50
    11819,                // 51
    5909,                 // 52
    2955,                 // 53
    1477,                 // 54
    739,                  // 55
    369,                  // 56
    185,                  // 57
    92,                   // 58
    46,                   // 59
    23,                   // 60
    12,                   // 61
    6,                    // 62
    3,                    // 63
}

Answer 3

万一有人正在寻找恒定空间解决方案，我已经解决了二项式扩展的问题，这是一个不错的近似。我使用以下代码：

// Computes `k * (1+1/q) ^ N`, with precision `p`. The higher
// the precision, the higher the gas cost. It should be
// something around the log of `n`. When `p == n`, the
// precision is absolute (sans possible integer overflows).
// Much smaller values are sufficient to get a great approximation.
function fracExp(uint k, uint q, uint n, uint p) returns (uint) {
  uint s = 0;
  uint N = 1;
  uint B = 1;
  for (uint i = 0; i < p; ++i){
    s += k * N / B / (q**i);
    N  = N * (n-i);
    B  = B * (i+1);
  }
  return s;
}

这只是计算p的二项式展开的(1 + r)^N个第一项，其中r是一个小的正实数。我在Ethereum Stack Exchange发布了一个更周到的解释。

有没有一种有效的方法来近似（a / b）^ n，其中a，b和n是无符号整数？

3 个答案: