Il modo più efficiente per implementare una funzione di potenza basata su numeri interi pow (int, int)

Qual è il modo più efficiente dato per elevare un numero intero alla potenza di un altro numero intero in C?

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

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

Esponenziazione per quadratura.

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

    return result;
}

Questo è il metodo standard per eseguire esponenziazione modulare per grandi numeri nella crittografia asimmetrica.

Si noti che l' esponenziazione mediante quadratura non è il metodo più ottimale. È probabilmente il meglio che puoi fare come metodo generale che funziona per tutti i valori di esponente, ma per un valore di esponente specifico potrebbe esserci una sequenza migliore che richiede meno moltiplicazioni.

Ad esempio, se vuoi calcolare x ^ 15, il metodo di esponenziazione mediante quadratura ti darà:

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

Questo è un totale di 6 moltiplicazioni.

Si scopre che ciò può essere fatto usando "solo" 5 moltiplicazioni tramite esponenziazione della catena di addizione .

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

Non ci sono algoritmi efficienti per trovare questa sequenza ottimale di moltiplicazioni. Da Wikipedia :

Il problema di trovare la catena di addizione più breve non può essere risolto dalla programmazione dinamica, poiché non soddisfa il presupposto di una sottostruttura ottimale. Cioè, non è sufficiente scomporre il potere in poteri più piccoli, ognuno dei quali è calcolato minimamente, poiché le catene di addizione per i poteri più piccoli possono essere correlate (per condividere i calcoli). Ad esempio, nella catena di addizione più breve per a¹⁵ sopra, il sottoproblema di a⁶ deve essere calcolato come (a³) ² poiché a³ viene riutilizzato (al contrario, diciamo, a⁶ = a² (a²) ², che richiede anche tre moltiplicazioni ).

Se hai bisogno di aumentare 2 a una potenza. Il modo più veloce per farlo è spostarsi un po 'dal potere.

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

Ecco il metodo in 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);
}

Se vuoi ottenere il valore di un numero intero per 2 elevato alla potenza di qualcosa, è sempre meglio usare l'opzione shift:

pow(2,5) può essere sostituito da 1<<5

Questo è molto più efficiente.

power()funzione per funzionare solo per numeri interi

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;

}

Complessità = O (log (exp))

power()funzione per lavorare con exp negativo e 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 
    }

} 

Complessità = O (log (exp))

Un caso estremamente specializzato è, quando hai bisogno di dire 2 ^ (- x a y), dove x, ovviamente, è negativo e y è troppo grande per fare lo spostamento su un int. Puoi ancora fare 2 ^ x in tempo costante avvitando con un galleggiante.

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

Puoi ottenere più poteri di 2 usando un doppio come tipo base. (Grazie mille ai commentatori per aver contribuito a far quadrare questo post).

C'è anche la possibilità che apprendendo di più sui galleggianti IEEE , possano presentarsi altri casi speciali di esponenziazione.

Proprio come seguito ai commenti sull'efficienza dell'espiazione mediante quadratura.

Il vantaggio di questo approccio è che viene eseguito in log (n) time. Ad esempio, se stavi per calcolare qualcosa di enorme, come x ^ 1048575 (2 ^ 20 - 1), devi solo passare attraverso il ciclo 20 volte, non 1 milione + utilizzando l'approccio ingenuo.

Inoltre, in termini di complessità del codice, è più semplice che cercare di trovare la sequenza ottimale di moltiplicazioni, come suggerisce la Pramod.

Modificare:

Immagino che dovrei chiarire prima che qualcuno mi tagghi per il potenziale di overflow. Questo approccio presuppone che tu abbia una sorta di libreria vastissima.

In ritardo alla festa:

Di seguito è una soluzione che si occupa anche y < 0il meglio possibile.

1. Utilizza un risultato di intmax_tper la portata massima. Non sono previste risposte che non rientrano intmax_t.
2. powjii(0, 0) --> 1che è un risultato comune per questo caso.

3. pow(0,negative), un altro risultato indefinito, ritorna 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;
   }

Questo codice utilizza un ciclo for(;;)per sempre per evitare il base *= basecomune finale in altre soluzioni in loop. Quella moltiplicazione è 1) non necessaria e 2) potrebbe essere un int*intoverflow che è UB.

soluzione più generica considerando exponenet negativo

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

Un'altra implementazione (in Java). Potrebbe non essere la soluzione più efficiente ma il numero di iterazioni è uguale a quello della soluzione esponenziale.

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

Uso ricorsivo, se exp è pari, 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);
   }
}

Oltre alla risposta di Elias, che causa un comportamento indefinito quando implementato con numeri interi con segno e valori errati per input elevati se implementato con numeri interi senza segno,

ecco una versione modificata di Exponentiation by Squaring che funziona anche con tipi interi con segno e non fornisce valori errati:

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

Considerazioni per questa funzione:

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

In caso di overflow o avvolgimento, return 0;

Ho usato int64_t, ma qualsiasi larghezza (con o senza segno) può essere usata con poche modifiche. Tuttavia, se è necessario utilizzare un tipo intero non-larghezza fissa, sarà necessario cambiamento SQRT_INT64_MAXda (int)sqrt(INT_MAX)(in caso di utilizzo int) o qualcosa di simile, che dovrebbe essere ottimizzato, ma è brutto, e non un'espressione C costante. Anche il cast del risultato su sqrt()an intnon è molto buono a causa della precisione in virgola mobile nel caso di un quadrato perfetto, ma poiché non conosco alcuna implementazione in cui INT_MAXil massimo di qualsiasi tipo sia un quadrato perfetto, puoi vivere con quello.

Ho implementato un algoritmo che memorizza tutti i poteri calcolati e li usa quando necessario. Ad esempio, x ^ 13 è uguale a (x ^ 2) ^ 2 ^ 2 * x ^ 2 ^ 2 * x dove x ^ 2 ^ 2 ha preso dalla tabella invece di calcolarlo di nuovo. Questa è sostanzialmente l'implementazione della risposta @Pramod (ma in C #). Il numero di moltiplicazioni necessarie è 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);
}

Il mio caso è un po 'diverso, sto provando a creare una maschera da un potere, ma ho pensato di condividere comunque la soluzione che ho trovato.

Ovviamente, funziona solo per potenze di 2.

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

Se conosci l'esponente (ed è un numero intero) in fase di compilazione, puoi utilizzare i modelli per srotolare il ciclo. Questo può essere reso più efficiente, ma volevo dimostrare qui il principio di base:

#include <iostream>

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

Terminiamo la ricorsione usando una specializzazione template:

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

L'esponente deve essere conosciuto in fase di esecuzione,

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