Как вы делаете * целочисленное * возведение в степень в C #?

Довольно быстрый вариант может быть примерно таким:

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

Обратите внимание, что это не позволяет использовать отрицательные мощности. Я оставлю это вам в качестве упражнения. :)

Добавлено: О да, чуть не забыл - также добавьте проверку переполнения / потери значимости, иначе вас могут ждать несколько неприятных сюрпризов в будущем.

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);

Используя математику из ссылки в блоге Джона Кука,

    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);
    }

Как насчет:

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

Очень интересно .. в .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 мс (.net 4 = 3693 мс) ‹- в 350 раз быстрее !!!

• PowerWithSwitch (Sunsetquest): 145 мс (.net 4 = 298 мс)

• Vilx: 148 мс (.net 4 = 320 мс)

• Эван Моран - рекурсивное деление: 249 мс (.net 4 = 644 мс)

• mini-me: 288 мс (.net 4 = 194 мс)

• Чарльз Бретана (он же Cook's): 536 мс (.net 4 = 950 мс)

• Версия LINQ: 4416 мс (.net 4 = 3693 мс)

(примечания к тестированию: AMD Threadripper Gen1, .Net 4 и 5, сборка выпуска, отладчик не подключен, базы: 0–100 КБ, срок действия: 0–10)

Примечание. В приведенных выше тестах проверка точности была незначительной.

Использовать двойную версию, проверить переполнение (over max int или max long) и привести к int или long?

Мое любимое решение этой проблемы - классическое рекурсивное решение «разделяй и властвуй». Это на самом деле быстрее, чем умножение в 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.

Я передаю результат в int, например:

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

В этом случае ошибок округления нет, поскольку основание и экспонента являются целыми числами. Результат тоже будет целым.

Для короткого и быстрого однострочника.

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

Нет никаких проверок отрицательной экспоненты или переполнения.

Другой способ:

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));
}