Cara paling efisien untuk mengimplementasikan pow function power berbasis integer (int, int)

Apa cara paling efisien yang diberikan untuk menaikkan bilangan bulat ke kekuatan bilangan bulat lain di C?

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

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

Eksponen dengan mengkuadratkan.

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

    return result;
}

Ini adalah metode standar untuk melakukan eksponensial modular untuk angka besar dalam kriptografi asimetris.

Perhatikan bahwa eksponensial dengan mengkuadratkan bukan metode yang paling optimal. Ini mungkin yang terbaik yang dapat Anda lakukan sebagai metode umum yang bekerja untuk semua nilai eksponen, tetapi untuk nilai eksponen tertentu mungkin ada urutan yang lebih baik yang membutuhkan lebih sedikit perkalian.

Misalnya, jika Anda ingin menghitung x ^ 15, metode eksponensial dengan mengkuadratkan akan memberi Anda:

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

Ini adalah total 6 perkalian.

Ternyata ini bisa dilakukan dengan menggunakan "hanya" 5 perkalian melalui eksponensial rantai penjumlahan .

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

Tidak ada algoritma yang efisien untuk menemukan urutan perkalian yang optimal ini. Dari Wikipedia :

Masalah menemukan rantai penambahan terpendek tidak dapat diselesaikan dengan pemrograman dinamis, karena tidak memenuhi asumsi substruktur optimal. Artinya, tidak cukup untuk menguraikan daya menjadi kekuatan yang lebih kecil, yang masing-masing dihitung secara minimal, karena rantai tambahan untuk kekuatan yang lebih kecil mungkin terkait (untuk berbagi perhitungan). Misalnya, dalam rantai penambahan terpendek untuk a¹⁵ di atas, subproblem untuk a⁶ harus dihitung sebagai (a³) ² karena a³ digunakan kembali (sebagai lawan dari, katakanlah, a⁶ = a² (a²) ², yang juga membutuhkan tiga kali lipat ).

Jika Anda perlu meningkatkan 2 ke daya. Cara tercepat untuk melakukannya adalah dengan sedikit menggeser kekuatan.

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

Ini metode di Jawa

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

Jika Anda ingin mendapatkan nilai integer untuk 2 dengan kekuatan sesuatu, selalu lebih baik menggunakan opsi shift:

pow(2,5) dapat digantikan oleh 1<<5

Ini jauh lebih efisien.

power()berfungsi hanya untuk Integer

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;

}

Kompleksitas = O (log (exp))

power()berfungsi untuk bekerja untuk basis exp dan float negatif .

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 
    }

} 

Kompleksitas = O (log (exp))

Kasus yang sangat khusus adalah, ketika Anda perlu mengatakan 2 ^ (- x ke y), di mana x, tentu saja negatif dan y terlalu besar untuk melakukan pengalihan pada int. Anda masih dapat melakukan 2 ^ x dalam waktu konstan dengan mengacaukan float.

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

Anda bisa mendapatkan lebih banyak kekuatan 2 dengan menggunakan ganda sebagai tipe dasar. (Terima kasih banyak kepada para komentator karena telah membantu untuk memperbaiki posisi ini).

Ada juga kemungkinan bahwa mempelajari lebih lanjut tentang IEEE mengapung , kasus eksponensial khusus lainnya mungkin muncul dengan sendirinya.

Sama seperti tindak lanjut komentar tentang efisiensi eksponensial dengan mengkuadratkan.

Keuntungan dari pendekatan itu adalah berjalan dalam waktu log (n). Misalnya, jika Anda akan menghitung sesuatu yang besar, seperti x ^ 1048575 (2 ^ 20 - 1), Anda hanya perlu melalui loop 20 kali, bukan 1 juta + menggunakan pendekatan naif.

Juga, dalam hal kompleksitas kode, ini lebih sederhana daripada mencoba menemukan urutan perkalian yang paling optimal, saran ala Pramod.

Edit:

Saya kira saya harus mengklarifikasi sebelum seseorang menandai saya untuk potensi meluap. Pendekatan ini mengasumsikan bahwa Anda memiliki semacam perpustakaan bigint.

Terlambat ke pesta:

Di bawah ini adalah solusi yang juga menangani y < 0sebaik mungkin.

1. Ini menggunakan hasil intmax_tuntuk rentang maksimum. Tidak ada ketentuan untuk jawaban yang tidak cocok intmax_t.
2. powjii(0, 0) --> 1yang merupakan hasil umum untuk kasus ini.

3. pow(0,negative), hasil tidak terdefinisi lain, kembali 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;
   }

Kode ini menggunakan loop selamanya for(;;)untuk menghindari akhir base *= baseumum dalam solusi looped lainnya. Multiplikasi itu 1) tidak diperlukan dan 2) bisa int*intmeluap yaitu UB.

solusi yang lebih umum mempertimbangkan eksponen negatif

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

Satu lagi implementasi (di Jawa). Mungkin bukan solusi yang paling efisien tetapi # iterasi sama dengan solusi Eksponensial.

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

Saya menggunakan rekursif, jika exp bahkan, 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);
   }
}

Selain jawaban oleh Elias, yang menyebabkan Perilaku Tidak Terdefinisi ketika diimplementasikan dengan bilangan bulat yang ditandatangani, dan nilai yang salah untuk input tinggi ketika diimplementasikan dengan bilangan bulat yang tidak ditandatangani,

di sini adalah versi modifikasi dari Exponentiation by Squaring yang juga berfungsi dengan tipe integer yang ditandatangani, dan tidak memberikan nilai yang salah:

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

Pertimbangan untuk fungsi ini:

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

Jika terjadi overflow atau pembungkus, return 0;

Saya menggunakan int64_t, tetapi lebar apa pun (ditandatangani atau tidak ditandatangani) dapat digunakan dengan sedikit modifikasi. Namun, jika Anda perlu menggunakan tipe integer lebar tidak-tetap, Anda perlu mengubahnya SQRT_INT64_MAXdengan (int)sqrt(INT_MAX)(jika menggunakan int) atau sesuatu yang serupa, yang harus dioptimalkan, tetapi lebih jelek, dan bukan ekspresi konstan C. Juga casting hasil dari sqrt()ke inttidak terlalu baik karena precisi floating point dalam kasus kuadrat sempurna, tetapi karena saya tidak tahu implementasi apa pun di mana INT_MAX- atau maksimum jenis apa pun - adalah kuadrat sempurna, Anda dapat hidup dengan itu.

Saya telah mengimplementasikan algoritma yang menghafal semua kekuatan yang dihitung dan kemudian menggunakannya ketika dibutuhkan. Jadi misalnya x ^ 13 sama dengan (x ^ 2) ^ 2 ^ 2 * x ^ 2 ^ 2 * x di mana x ^ 2 ^ 2 diambil dari tabel alih-alih menghitungnya sekali lagi. Ini pada dasarnya adalah implementasi dari jawaban @Pramod (tetapi dalam C #). Jumlah perkalian yang dibutuhkan adalah 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);
}

Kasus saya sedikit berbeda, saya mencoba membuat topeng dari kekuatan, tapi saya pikir saya akan membagikan solusi yang saya temukan.

Jelas, itu hanya berfungsi untuk kekuatan 2.

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

Jika Anda tahu eksponen (dan bilangan bulat) pada waktu kompilasi, Anda bisa menggunakan templat untuk membuka gulungannya. Ini dapat dibuat lebih efisien, tetapi saya ingin menunjukkan prinsip dasar di sini:

#include <iostream>

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

Kami mengakhiri rekursi menggunakan spesialisasi templat:

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

Eksponen perlu diketahui saat runtime,

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