Der effizienteste Weg, um eine ganzzahlige Potenzfunktion pow (int, int) zu implementieren

Was ist der effizienteste Weg, um eine Ganzzahl auf die Potenz einer anderen Ganzzahl in C zu erhöhen?

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

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

Potenzierung durch Quadrieren.

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

    return result;
}

Dies ist die Standardmethode für die modulare Exponentiation für große Zahlen in der asymmetrischen Kryptographie.

Beachten Sie, dass die Potenzierung durch Quadrieren nicht die optimalste Methode ist. Es ist wahrscheinlich das Beste, was Sie als allgemeine Methode tun können, die für alle Exponentenwerte funktioniert, aber für einen bestimmten Exponentenwert gibt es möglicherweise eine bessere Sequenz, die weniger Multiplikationen benötigt.

Wenn Sie beispielsweise x ^ 15 berechnen möchten, erhalten Sie mit der Exponentiationsmethode durch Quadrieren:

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

Dies sind insgesamt 6 Multiplikationen.

Es stellt sich heraus, dass dies mit "nur" 5 Multiplikationen durch Potenzierung der Additionskette erfolgen kann .

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

Es gibt keine effizienten Algorithmen, um diese optimale Folge von Multiplikationen zu finden. Aus Wikipedia :

Das Problem, die kürzeste Additionskette zu finden, kann durch dynamische Programmierung nicht gelöst werden, da es die Annahme einer optimalen Unterstruktur nicht erfüllt. Das heißt, es reicht nicht aus, die Leistung in kleinere Leistungen zu zerlegen, von denen jede minimal berechnet wird, da die Additionsketten für die kleineren Leistungen in Beziehung gesetzt werden können (um Berechnungen zu teilen). Zum Beispiel muss in der kürzesten Additionskette für a¹⁵ oben das Teilproblem für a⁶ als (a³) ² berechnet werden, da a³ wiederverwendet wird (im Gegensatz zu beispielsweise a⁶ = a² (a²) ², was ebenfalls drei Multiplikationen erfordert ).

Wenn Sie 2 auf eine Potenz erhöhen müssen. Der schnellste Weg, dies zu tun, ist eine Bitverschiebung durch die Leistung.

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

Hier ist die Methode 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);
}

Wenn Sie den Wert einer Ganzzahl für 2 auf die Potenz von etwas erhöhen möchten, ist es immer besser, die Verschiebungsoption zu verwenden:

pow(2,5) kann ersetzt werden durch 1<<5

Das ist viel effizienter.

power()Funktion, die nur für Ganzzahlen funktioniert

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;

}

Komplexität = O (log (exp))

power()Funktion, um für negative exp und float base zu arbeiten .

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 
    }

} 

Komplexität = O (log (exp))

Ein äußerst spezialisierter Fall ist, wenn Sie sagen müssen 2 ^ (- x zum y), wobei x natürlich negativ ist und y zu groß ist, um auf einem int zu verschieben. Sie können immer noch 2 ^ x in konstanter Zeit ausführen, indem Sie mit einem Schwimmer schrauben.

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

Sie können mehr Potenzen von 2 erhalten, indem Sie ein Double als Basistyp verwenden. (Vielen Dank an die Kommentatoren, die geholfen haben, diesen Beitrag zu korrigieren).

Es besteht auch die Möglichkeit, dass Sie mehr über IEEE-Floats erfahren und andere Sonderfälle der Potenzierung auftreten.

Nur als Folge von Kommentaren zur Effizienz der Potenzierung durch Quadrieren.

Der Vorteil dieses Ansatzes besteht darin, dass er in log (n) -Zeit ausgeführt wird. Wenn Sie beispielsweise etwas Großes wie x ^ 1048575 (2 ^ 20 - 1) berechnen möchten, müssen Sie die Schleife nur 20 Mal durchlaufen, nicht 1 Million + mit dem naiven Ansatz.

In Bezug auf die Codekomplexität ist es auch einfacher als zu versuchen, die optimalste Folge von Multiplikationen zu finden, wie es a la Pramod vorschlägt.

Bearbeiten:

Ich denke, ich sollte klären, bevor mich jemand auf das Potenzial für einen Überlauf hinweist. Bei diesem Ansatz wird davon ausgegangen, dass Sie über eine riesige Bibliothek verfügen.

Spät zur Party:

Im Folgenden finden Sie eine Lösung, die auch y < 0so gut wie möglich funktioniert.

1. Es wird ein Ergebnis von intmax_tfür maximale Reichweite verwendet. Antworten, die nicht passen, sind nicht vorgesehen intmax_t.
2. powjii(0, 0) --> 1Das ist ein häufiges Ergebnis für diesen Fall.

3. pow(0,negative), ein weiteres undefiniertes Ergebnis, wird zurückgegeben 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;
   }

Dieser Code verwendet eine Forever-Schleife for(;;), um das endgültige base *= baseCommon in anderen Loop-Lösungen zu vermeiden . Diese Multiplikation ist 1) nicht erforderlich und 2) könnte ein int*intÜberlauf sein, der UB ist.

allgemeinere Lösung unter Berücksichtigung negativer Exponenet

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

Noch eine Implementierung (in Java). Möglicherweise nicht die effizienteste Lösung, aber die Anzahl der Iterationen entspricht der der Exponential-Lösung.

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

Ich benutze rekursiv, wenn die exp gerade ist, 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);
   }
}

Zusätzlich zu der Antwort von Elias, die bei Implementierung mit vorzeichenbehafteten Ganzzahlen undefiniertes Verhalten und bei Implementierung mit vorzeichenlosen Ganzzahlen falsche Werte für hohe Eingaben verursacht,

Hier ist eine modifizierte Version der Exponentiation durch Quadrieren, die auch mit vorzeichenbehafteten Ganzzahltypen funktioniert und keine falschen Werte angibt:

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

Überlegungen zu dieser Funktion:

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

Wenn ein Überlauf oder eine Umhüllung stattfinden soll, return 0;

Ich habe verwendet int64_t, aber jede Breite (signiert oder nicht signiert) kann mit nur geringen Änderungen verwendet werden. Wenn Sie jedoch einen nicht-feste Breite Integer - Typen verwenden müssen, werden Sie ändern müssen , SQRT_INT64_MAXum (int)sqrt(INT_MAX)(in dem Fall der Verwendung int) oder etwas ähnliches, das optimiert werden soll, aber es ist hässlicher, und kein C konstanter Ausdruck. Auch das Casting des Ergebnisses sqrt()auf ein intist aufgrund der Gleitkomma-Präzision bei einem perfekten Quadrat nicht sehr gut, aber da ich keine Implementierung kenne, bei der INT_MAX- oder das Maximum eines Typs - ein perfektes Quadrat ist, können Sie leben damit.

Ich habe einen Algorithmus implementiert, der alle berechneten Potenzen speichert und sie dann bei Bedarf verwendet. So ist zum Beispiel x ^ 13 gleich (x ^ 2) ^ 2 ^ 2 * x ^ 2 ^ 2 * x, wobei x ^ 2 ^ 2 aus der Tabelle entnommen wird, anstatt es erneut zu berechnen. Dies ist im Grunde eine Implementierung der @ Pramod-Antwort (jedoch in C #). Die Anzahl der erforderlichen Multiplikationen ist 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);
}

Mein Fall ist etwas anders, ich versuche, aus einer Kraft eine Maske zu erstellen, aber ich dachte, ich würde die Lösung teilen, die ich trotzdem gefunden habe.

Offensichtlich funktioniert es nur für Potenzen von 2.

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

Wenn Sie den Exponenten (und eine Ganzzahl) zur Kompilierungszeit kennen, können Sie die Schleife mithilfe von Vorlagen abrollen. Dies kann effizienter gestaltet werden, aber ich wollte hier das Grundprinzip demonstrieren:

#include <iostream>

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

Wir beenden die Rekursion mit einer Vorlagenspezialisierung:

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

Der Exponent muss zur Laufzeit bekannt sein.

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