정수 기반의 전력 함수를 구현하는 가장 효율적인 방법 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;
}

이것은 비대칭 암호화에서 많은 수의 모듈 식 지수를 수행하는 표준 방법입니다.

참고 제곱에 의해 지수가 가장 최적의 방법은 아닙니다. 모든 지수 값에 대해 작동하는 일반적인 방법으로 수행하는 것이 가장 좋을 수도 있지만 특정 지수 값의 경우 곱셈이 덜 필요한 더 나은 시퀀스가있을 수 있습니다.

예를 들어, x ^ 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¹ for에 대한 가장 짧은 덧셈 체인에서, 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 (log (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 (log (exp))

매우 특수한 경우는 2 ^ (-x to y)라고 말하면 x는 음수이고 y는 너무 커서 int에서 시프트하기가 어렵습니다. 플로트로 나사를 조여 일정 시간에 2 ^ x를 수행 할 수 있습니다.

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

기본 유형으로 double을 사용하면 2의 거듭 제곱을 얻을 수 있습니다. (이 게시물을 제곱하는 데 도움을 주신 의견을 주신 분들께 감사드립니다).

IEEE float 에 대해 더 많이 배우 면 다른 특별한 지수화 사례가 나타날 수도 있습니다.

제곱에 의한 지수의 효율성에 대한 언급에 대한 후속 조치와 같습니다.

이 방법의 장점은 log (n) 시간에 실행된다는 것입니다. 예를 들어, x ^ 1048575 (2 ^ 20-1)와 같이 거대한 것을 계산하려는 경우 순진한 접근 방식을 사용하면 1 백만이 아니라 루프를 20 회만 이동하면됩니다.

또한 코드의 복잡성 측면에서 라프 라모 (La Pramod)의 제안 인 가장 최적의 곱셈 시퀀스를 찾는 것보다 간단합니다.

편집하다:

누군가가 오버플로 가능성을 태그하기 전에 명확히해야한다고 생각합니다. 이 접근법은 일종의 hugeint 라이브러리가 있다고 가정합니다.

파티에 늦게 :

아래는 가능한 한 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*intUB 인 오버플로가 될 수 있습니다 .

부정적인 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);
}

하나 더 구현 (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;
    }       
}

exp가 짝수이면 재귀를 사용합니다 .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의 답변 외에도 부호있는 정수로 구현하면 정의되지 않은 동작이 발생하고 부호없는 정수로 구현하면 높은 입력 값이 잘못됩니다.

다음은 부호있는 정수 유형에서도 작동하며 잘못된 값을 제공하지 않는 Squaing에 의한 지수의 수정 된 버전입니다.

#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또는 최적화되어야 비슷한), 그러나 그것은 C 상수 표현 이보다이며, 없습니다. 또한 결과 주조 sqrt()가 int있기 때문에 완벽한 정사각형의 경우 포인트 precission 부동의 매우 좋지 않다,하지만 난 어떤 구현을 알고하지 않는 한 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;
}