Найбільш ефективний спосіб реалізувати функцію живлення на основі цілого числа pow (int, int)

Який найефективніший спосіб дати ціле число до сили іншого цілого числа в C?

// 2^3
pow(2,3) == 8

// 5^5
pow(5,5) == 3125

Експоненція шляхом квадратування.

int ipow(int base, int exp)
{
    int result = 1;
    for (;;)
    {
        if (exp & 1)
            result *= base;
        exp >>= 1;
        if (!exp)
            break;
        base *= base;
    }

    return result;
}

Це стандартний метод проведення модульної експоненції для величезних чисел в асиметричній криптографії.

Зауважимо, що експоненціація шляхом квадратування - не найоптимальніший метод. Це, мабуть, найкраще, що ви можете зробити як загальний метод, який працює для всіх значень експонента, але для конкретного значення експонента може бути краща послідовність, яка потребує меншої множення.

Наприклад, якщо ви хочете обчислити х ^ 15, метод експоненції шляхом квадратування дасть вам:

x^15 = (x^7)*(x^7)*x 
x^7 = (x^3)*(x^3)*x 
x^3 = x*x*x

Це загалом 6 множень.

Виявляється, це можна зробити, використовуючи «просто» 5 множення за допомогою експоненції ланцюга додавання .

n*n = n^2
n^2*n = n^3
n^3*n^3 = n^6
n^6*n^6 = n^12
n^12*n^3 = n^15

Не існує ефективних алгоритмів, щоб знайти цю оптимальну послідовність множень. З Вікіпедії :

Проблема пошуку найкоротшого ланцюга додавання не може бути вирішена динамічним програмуванням, оскільки воно не задовольняє припущення про оптимальну підструктуру. Тобто недостатньо розподілити владу на менші потужності, кожна з яких обчислюється мінімально, оскільки ланцюги додавання для менших потужностей можуть бути пов'язані (для обміну обчисленнями). Наприклад, у найкоротшому ланцюжку додавання для a¹⁵ вище, підпроблема для a⁶ повинна бути обчислена як (a³) ², оскільки a³ повторно використовується (на відміну від, скажімо, a⁶ = a² (a²) ², що також вимагає трьох множень ).

Якщо вам потрібно підняти 2 до потужності. Найшвидший спосіб зробити це - трохи перемістити потужність.

2 ** 3 == 1 << 3 == 8
2 ** 30 == 1 << 30 == 1073741824 (A Gigabyte)

Ось метод на Java

private int ipow(int base, int exp)
{
    int result = 1;
    while (exp != 0)
    {
        if ((exp & 1) == 1)
            result *= base;
        exp >>= 1;
        base *= base;
    }

    return result;
}

int pow( int base, int exponent)

{   // Does not work for negative exponents. (But that would be leaving the range of int) 
    if (exponent == 0) return 1;  // base case;
    int temp = pow(base, exponent/2);
    if (exponent % 2 == 0)
        return temp * temp; 
    else
        return (base * temp * temp);
}

Якщо ви хочете отримати значення цілого числа для 2, підняте на потужність чогось, завжди краще скористатися параметром shift:

pow(2,5) можна замінити на 1<<5

Це набагато ефективніше.

power()функціонувати лише для цілих чисел

int power(int base, unsigned int exp){

    if (exp == 0)
        return 1;
    int temp = power(base, exp/2);
    if (exp%2 == 0)
        return temp*temp;
    else
        return base*temp*temp;

}

Складність = O (журнал (exp))

power()функція для роботи для негативного досвіду exp та float base .

float power(float base, int exp) {

    if( exp == 0)
       return 1;
    float temp = power(base, exp/2);       
    if (exp%2 == 0)
        return temp*temp;
    else {
        if(exp > 0)
            return base*temp*temp;
        else
            return (temp*temp)/base; //negative exponent computation 
    }

} 

Складність = O (журнал (exp))

Надзвичайно спеціалізований випадок, коли вам потрібно сказати 2 ^ (- x to y), де x, звичайно, є негативним, а y занадто великим, щоб зробити зрушення на int. Ще можна робити 2 ^ х у постійному часі, прикручуючи поплавком.

struct IeeeFloat
{

    unsigned int base : 23;
    unsigned int exponent : 8;
    unsigned int signBit : 1;
};


union IeeeFloatUnion
{
    IeeeFloat brokenOut;
    float f;
};

inline float twoToThe(char exponent)
{
    // notice how the range checking is already done on the exponent var 
    static IeeeFloatUnion u;
    u.f = 2.0;
    // Change the exponent part of the float
    u.brokenOut.exponent += (exponent - 1);
    return (u.f);
}

Ви можете отримати більше повноважень 2, використовуючи подвійний як базовий тип. (Велике спасибі коментаторам за те, що вони допомогли розмістити цю публікацію).

Існує також можливість, що дізнавшись більше про IEEE поплавці , інші особливі випадки експоненції можуть представити себе.

Так само, як продовження коментарів щодо ефективності експоненції шляхом квадратування.

Перевага такого підходу полягає в тому, що він працює в журнал (n) час. Наприклад, якщо ви збиралися обчислити щось величезне, наприклад, x ^ 1048575 (2 ^ 20 - 1), вам слід пройти цикл лише 20 разів, а не 1 мільйон +, використовуючи наївний підхід.

Крім того, з точки зору складності коду, це простіше, ніж намагатися знайти найоптимальнішу послідовність множень, пропозицію a la Pramod.

Редагувати:

Я думаю, я повинен уточнити, перш ніж хтось позначає мене на потенціал переповнення. Цей підхід передбачає, що у вас є якась бібліотека величезних кольорів.

Пізно до вечірки:

Нижче наведено рішення, яке також розглядає y < 0якнайкраще.

1. Він використовує результат intmax_tдля максимального діапазону. Немає положень для відповідей, які не підходять intmax_t.
2. powjii(0, 0) --> 1що є загальним результатом для даного випадку.

3. pow(0,negative), повертається ще один невизначений результат INTMAX_MAX

   intmax_t powjii(int x, int y) {
     if (y < 0) {
       switch (x) {
         case 0:
           return INTMAX_MAX;
         case 1:
           return 1;
         case -1:
           return y % 2 ? -1 : 1;
       }
       return 0;
     }
     intmax_t z = 1;
     intmax_t base = x;
     for (;;) {
       if (y % 2) {
         z *= base;
       }
       y /= 2;
       if (y == 0) {
         break; 
       }
       base *= base;
     }
     return z;
   }

Цей код використовує вічний цикл, for(;;)щоб уникнути остаточного base *= baseпоширеного в інших певних рішеннях. Це множення 1) не потрібно і 2) може бути int*intпереповнене, що є UB.

більш загальне рішення з огляду на негативний показник

private static int pow(int base, int exponent) {

    int result = 1;
    if (exponent == 0)
        return result; // base case;

    if (exponent < 0)
        return 1 / pow(base, -exponent);
    int temp = pow(base, exponent / 2);
    if (exponent % 2 == 0)
        return temp * temp;
    else
        return (base * temp * temp);
}

Ще одна реалізація (на Java). Можливо, це не найефективніше рішення, але # ітерацій таке ж, як і експоненціальне рішення.

public static long pow(long base, long exp){        
    if(exp ==0){
        return 1;
    }
    if(exp ==1){
        return base;
    }

    if(exp % 2 == 0){
        long half = pow(base, exp/2);
        return half * half;
    }else{
        long half = pow(base, (exp -1)/2);
        return base * half * half;
    }       
}

Я використовую рекурсивний, якщо досвід є рівним, 5 ^ 10 = 25 ^ 5.

int pow(float base,float exp){
   if (exp==0)return 1;
   else if(exp>0&&exp%2==0){
      return pow(base*base,exp/2);
   }else if (exp>0&&exp%2!=0){
      return base*pow(base,exp-1);
   }
}

На додаток до відповіді Elias, яка спричиняє не визначену поведінку при реалізації з підписаними цілими числами, і неправильні значення для високого введення, коли реалізовано з непідписаними цілими числами,

ось модифікована версія Exponentiation by Squaring, яка також працює з підписаними цілими типами і не дає неправильних значень:

#include <stdint.h>

#define SQRT_INT64_MAX (INT64_C(0xB504F333))

int64_t alx_pow_s64 (int64_t base, uint8_t exp)
{
    int_fast64_t    base_;
    int_fast64_t    result;

    base_   = base;

    if (base_ == 1)
        return  1;
    if (!exp)
        return  1;
    if (!base_)
        return  0;

    result  = 1;
    if (exp & 1)
        result *= base_;
    exp >>= 1;
    while (exp) {
        if (base_ > SQRT_INT64_MAX)
            return  0;
        base_ *= base_;
        if (exp & 1)
            result *= base_;
        exp >>= 1;
    }

    return  result;
}

Розгляд цієї функції:

(1 ** N) == 1
(N ** 0) == 1
(0 ** 0) == 1
(0 ** N) == 0

Якщо відбудеться якийсь перелив або обгортання, return 0;

Я використовував int64_t, але будь-яку ширину (з підписом або без підпису) можна використовувати з незначними змінами. Однак, якщо вам необхідно використовувати не фіксовану ширину целочисленного типу, то потрібно змінити SQRT_INT64_MAXшлях (int)sqrt(INT_MAX)(в разі використання int) або щось подібне, які повинні бути оптимізовані, але це потворніше, а не вираз константи С. Також виведення результату sqrt()на intне дуже добре через точність точок з плаваючою точкою у випадку ідеального квадрата, але, як я не знаю жодної реалізації, де INT_MAX- або максимум будь-якого типу - ідеальний квадрат, ви можете жити З цим.

Я реалізував алгоритм, який запам'ятовує всі обчислені повноваження, а потім використовує їх у разі потреби. Так, наприклад, x ^ 13 дорівнює (x ^ 2) ^ 2 ^ 2 * x ^ 2 ^ 2 * x, де x ^ 2 ^ 2 він узятий з таблиці, а не обчислювати його ще раз. Це в основному реалізація відповіді @Pramod (але в C #). Кількість потрібного множення - Ceil (Log n)

public static int Power(int base, int exp)
{
    int tab[] = new int[exp + 1];
    tab[0] = 1;
    tab[1] = base;
    return Power(base, exp, tab);
}

public static int Power(int base, int exp, int tab[])
    {
         if(exp == 0) return 1;
         if(exp == 1) return base;
         int i = 1;
         while(i < exp/2)
         {  
            if(tab[2 * i] <= 0)
                tab[2 * i] = tab[i] * tab[i];
            i = i << 1;
          }
    if(exp <=  i)
        return tab[i];
     else return tab[i] * Power(base, exp - i, tab);
}

У моєму випадку трохи інше, я намагаюся створити маску від влади, але я подумав, що все-таки поділюсь рішенням, яке знайшов.

Очевидно, він працює лише для повноважень 2.

Mask1 = 1 << (Exponent - 1);
Mask2 = Mask1 - 1;
return Mask1 + Mask2;

Якщо ви знаєте експонент (а це ціле число) під час компіляції, ви можете використовувати шаблони для розгортання циклу. Це можна зробити більш ефективним, але я хотів продемонструвати тут основний принцип:

#include <iostream>

template<unsigned long N>
unsigned long inline exp_unroll(unsigned base) {
    return base * exp_unroll<N-1>(base);
}

Ми припиняємо рекурсію за допомогою спеціалізації шаблону:

template<>
unsigned long inline exp_unroll<1>(unsigned base) {
    return base;
}

Експонент повинен бути відомий під час виконання,

int main(int argc, char * argv[]) {
    std::cout << argv[1] <<"**5= " << exp_unroll<5>(atoi(argv[1])) << ;std::endl;
}