你如何在 C# 中做 *integer* 幂运算？答案

【问题标题】：How do you do *integer* exponentiation in C#?你如何在 C# 中做 *integer* 幂运算？
【发布时间】：2010-09-27 20:51:42
【问题描述】：

.NET 中的内置Math.Pow() 函数将double 基数提升为double 指数并返回double 结果。

用整数做同样的事情的最好方法是什么？

补充：似乎可以将Math.Pow()结果转换为(int)，但这是否总是产生正确的数字并且没有舍入错误？

【问题讨论】：

正如其他地方所写，自 2010 年 (.NET 4.0) 以来，有 BigInteger.Pow method 进行整数求幂（需要对 System.Numerics.dll 的程序集引用）。

标签： c# math integer exponentiation

【解决方案1】：

一个相当快的可能是这样的：

int IntPow(int x, uint pow)
{
    int ret = 1;
    while ( pow != 0 )
    {
        if ( (pow & 1) == 1 )
            ret *= x;
        x *= x;
        pow >>= 1;
    }
    return ret;
}

请注意，这不允许负幂。我会把它作为练习留给你。 :)

已添加：哦，是的，差点忘了 - 还要添加上溢/下溢检查，否则您可能会遇到一些令人讨厌的惊喜。

【讨论】：

为什么需要明确的溢出检查？内置的 C# 溢出检查不适用吗？（假设你通过 /checked）
算法名称是重复平方取幂。本质上，我们反复将 x 加倍，如果 pow 在该位置有 1 位，我们将其乘/累加到返回值中。
@boost BigInteger 内置了电源
@Vilx - 确实如此。我只是在效率方面有点偏执......
@MilesB。这些天来，我的首要任务是使我的代码尽可能地可读和易于理解。没有令人难以置信的巧妙优化；没有任何可见代码隐式执行复杂事情的“魔术”构造；等等。令人着迷的是，性能问题很少见。

【解决方案2】：

使用双版本，检查溢出（超过最大 int 或最大 long）并强制转换为 int 或 long？

【讨论】：

我怎么知道这不会因为舍入错误而产生不正确的结果？
在转换为 int 之前加 0.5 以进行舍入，只要 double 的精度大于 int 或 long 的精度即可。
双精度可以表示所有整数，精确到 2^53，所以这听起来总是有效的。
除非您使用 64 位整数。

【解决方案3】：

使用约翰库克博客链接中的数学，

    public static long IntPower(int x, short power)
    {
        if (power == 0) return 1;
        if (power == 1) return x;
        // ----------------------
        int n = 15;
        while ((power <<= 1) >= 0) n--;

        long tmp = x;
        while (--n > 0)
            tmp = tmp * tmp * 
                 (((power <<= 1) < 0)? x : 1);
        return tmp;
    }

解决如果您更改电源类型，代码将无法工作的反对意见，好吧...抛开任何更改代码的人他们不理解然后在没有测试的情况下使用它...... 但是为了解决这个问题，这个版本保护了愚蠢的人免于犯那个错误......（但不是他们可能犯的无数其他人）注意：未经测试。

    public static long IntPower(int x, short power)
    {
        if (power == 0) return 1;
        if (power == 1) return x;
        // ----------------------
        int n = 
            power.GetType() == typeof(short)? 15:
            power.GetType() == typeof(int)? 31:
            power.GetType() == typeof(long)? 63: 0;  

        long tmp = x;
        while (--n > 0)
            tmp = tmp * tmp * 
                 (((power <<= 1) < 0)? x : 1);
        return tmp;
    }

也试试这个递归等价物（当然更慢）：

    public static long IntPower(long x, int power)
    {
        return (power == 0) ? x :
            ((power & 0x1) == 0 ? x : 1) *
                IntPower(x, power >> 1);
    }

【讨论】：

确保您使用它时根本不修改它。我想我会使用short 来避免投射任何东西，但如果不是，算法就不起作用。我更喜欢 Vilx 提供的更直接但性能更低的方法
黑曜石，如果将算法中的 15 改为 31，则可以使用 int
我做了一个简短的基准测试，正如我所怀疑的那样，如果您需要整数长度的幂（大约快 6 倍），Vilx 的方法会更有效。也许其他人可以验证这个结果？
注意——就像黑曜石说的那样，如果你改变电源类型，这将不起作用。对不起所有大写，但似乎真的应该叫出来。
是的，它确实...（您只需将值 15 更改为指数中使用的类型的长度。）

【解决方案4】：

对于这个问题，我最喜欢的解决方案是经典的分而治之的递归解决方案。它实际上比乘 n 次要快，因为它每次将乘法次数减少一半。

public static int Power(int x, int n)
{
  // Basis
  if (n == 0)
    return 1;
  else if (n == 1)
    return x;

  // Induction
  else if (n % 2 == 1)
    return x * Power(x*x, n/2);
  return Power(x*x, n/2);
}

注意：这不会检查溢出或负 n。

【讨论】：

这与 Vilx- 的算法相同，只是它使用更多空间（递归调用不是尾调用）。

【解决方案5】：

怎么样：

public static long IntPow(long a, long b)
{
  long result = 1;
  for (long i = 0; i < b; i++)
    result *= a;
  return result;
}

【讨论】：

很简单，虽然需要检查是否为负 b。
请注意，此代码的时间复杂度是 O(n)，其中 n 是幂，而在最佳答案中，它是 O(log(n))，这对于大幂而言要好得多。

【解决方案6】：

LINQ 有人吗？

public static int Pow(this int bas, int exp)
{
    return Enumerable
          .Repeat(bas, exp)
          .Aggregate(1, (a, b) => a * b);
}

用作扩展：

var threeToThePowerOfNine = 3.Pow(9);

【讨论】：

这是我今天看到的最搞笑的答案 - 恭喜它按预期工作：D
@ioquatix 这就是你在函数式编程语言中的做法，面无表情。
@MartinCapodici 我在写代码时总是面带微笑。在阅读其他人的代码时，或者我有时会做鬼脸。我通常不会板着脸:)

【解决方案7】：

非常有趣.. 从 .net 5.0 开始，SimplePower() 现在快了 350 倍。我会说在便携性/性能/可读性方面最好......

    public static int SimplePower(int x, int pow)
    {
        return (int)Math.Pow(x, pow);
    }

这是我过去构建的另一个速度很快的...

    public static int PowerWithSwitch(int x, int pow)
    {
        switch ((uint)pow)
        {
            case 0: return 1;
            case 1: return x;
            case 2: return x * x;
            case 3: return x * x * x;
            case 4: { int t2 = x * x; return t2 * t2; }
            case 5: { int t2 = x * x; return t2 * t2 * x; }
            case 6: { int t3 = x * x * x; return t3 * t3; }
            case 7: { int t3 = x * x * x; return t3 * t3 * x; }
            case 8: { int t3 = x * x * x; return t3 * t3 * x * x; }
            case 9: { int t3 = x * x * x; return t3 * t3 * t3; }
            case 10: { int t3 = x * x * x; return t3 * t3 * t3 * x; }
            case 11: { int t3 = x * x * x; return t3 * t3 * t3 * x * x; }
            case 12: { int t3 = x * x * x; return t3 * t3 * t3 * t3; }
            case 13: { int t3 = x * x * x; return t3 * t3 * t3 * t3 * x; }
            case 14: { int t4 = x * x * x * x; return t4 * t4 * t4 * x * x; }
            case 15: { int t4 = x * x * x * x; return t4 * t4 * t4 * x * x * x; }
            case 16: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4; }
            case 17: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * x; }
            case 18: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * x * x; }
            case 19: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * x * x * x; }
            case 20: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4; }
            case 21: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * x; }
            case 22: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * x * x; }
            case 23: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * x * x * x; }
            case 24: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * t4; }
            case 25: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * t4 * x; }
            case 26: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * t4 * x * x; }
            case 27: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * t4 * x * x * x; }
            case 28: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * t4 * t4; }
            case 29: { int t4 = x * x * x * x; return t4 * t4 * t4 * t4 * t4 * t4 * t4 * x; }
            default:
                if (x == 0)
                    return 0;
                else if (x == 1)
                    return 1;
                else
                    return (x % 1 == 0) ? int.MaxValue : int.MinValue;
        }
        return 0;
    }

性能测试 (.Net 5)

MathPow(Sunsetquest) : 11 ms (.net 4 = 3693ms )
PowerWithSwitch(Sunsetquest)：145 毫秒（.net 4 = 298 毫秒）
Vilx：148 毫秒（.net 4 = 320 毫秒）
Evan Moran 递归除法：249 毫秒（.net 4 = 644 毫秒）
迷你我：288 毫秒（.net 4 = 194 毫秒）
Charles Bretana（又名 Cook's）：536 毫秒（.net 4 = 950 毫秒）
LINQ 版本：4416 毫秒（.net 4 = 3693 毫秒）

（测试说明：AMD Threadripper Gen1、.Net 4 和 5，发布版本，未附加调试器，bases：0-100k，exp：0-10）

注意：在上述测试中几乎没有进行准确性检查。

【讨论】：

mini-me 的性能仅适用于较小的功率。但我肯定会使用您的代码来帮助解决问题 43：projecteuler.net/problem=43
对于 0 - 1M 和 Vilx- 的碱基，运行 0 - 30 的指数要快 2 倍；对于从 0 到 100 的指数，它快 4 倍。

【解决方案8】：

我将结果转换为 int，如下所示：

double exp = 3.0;
int result = (int)Math.Pow(2.0, exp);

在这种情况下，没有舍入误差，因为基数和指数都是整数。结果也是整数。

【讨论】：

试试 Math.Pow(7, 19)。有浮动相关的错误。
@N-ate 7^19 对于 Int32 来说太大了，所以如果你知道你的数字这么大，你就不会转换为 int。

【解决方案9】：

对于一个简短的快速单线。

int pow(int i, int exp) => (exp == 0) ? 1 : i * pow(i, exp-1);

没有负指数也没有溢出检查。

【讨论】：

【解决方案10】：

另一种方式是：

int Pow(int value, int pow) {
    var result = value;
    while (pow-- > 1)
        result *= value;
    return pow == 0 ? result : pow == -1 ? 1 : throw new ArgumentOutOfRangeException(nameof(pow));
}

【讨论】：