지수 계산을 위해 `pow(x, i)` 대신 `x*x...`를 사용하는 것이 항상 더 빠릅니까?

지수화 기법의 효율성 결정

지수화 전용 함수를 사용하는 대신 숫자 자체를 곱하는 것이 효율적인 경우가 많습니다. pow() 같은 거죠. 그러나 특히 특정 지수의 경우 이 규칙에 예외가 있을 수 있습니다.

xx... 및 pow(x,i)의 성능을 테스트하려면 다음 코드를 고려하세요. 지수 'i':

#include <cstdlib>
#include <cmath>
#include <boost/date_time/posix_time/posix_time.hpp>

inline boost::posix_time::ptime now()
{
    return boost::posix_time::microsec_clock::local_time();
}

#define TEST(num, expression) \
double test##num(double b, long loops) \
{ \
    double x = 0.0; \
    boost::posix_time::ptime startTime = now(); \
    for (long i=0; i<loops; ++i) \
    { \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
        x += expression; \
    } \
    boost::posix_time::time_duration elapsed = now() - startTime; \
    std::cout << elapsed << " "; \
    return x; \
}

// Test cases for exponentiation using x*x...
TEST(1, b)
TEST(2, b*b)
TEST(3, b*b*b)
TEST(4, b*b*b*b)
TEST(5, b*b*b*b*b)

// Test cases for exponentiation using pow()
template <int exponent>
double testpow(double base, long loops)
{
    double x = 0.0;
    boost::posix_time::ptime startTime = now();
    for (long i = 0; i < loops; ++i)
    {
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
        x += std::pow(base, exponent);
    }
    boost::posix_time::time_duration elapsed = now() - startTime;
    std::cout << elapsed << " ";
    return x;
}

int main()
{
    long loops = 100000000l;
    double x = 0.0;
    std::cout << "1 ";
    x += testpow<1>(rand(), loops);
    x += test1(rand(), loops);

    std::cout << "\n2 ";
    x += testpow<2>(rand(), loops);
    x += test2(rand(), loops);

    std::cout << "\n3 ";
    x += testpow<3>(rand(), loops);
    x += test3(rand(), loops);

    std::cout << "\n4 ";
    x += testpow<4>(rand(), loops);
    x += test4(rand(), loops);

    std::cout << "\n5 ";
    x += testpow<5>(rand(), loops);
    x += test5(rand(), loops);
    std::cout << "\n" << x << "\n";
}

결과

각 지수법에 소요되는 시간을 측정한 테스트 결과는 xx... 정말 빠릅니다.

단, 몇 가지 예외가 있습니다

pow(x, 3)의 경우 컴파일러 및 최적화에 따라 결과가 달라질 수 있습니다. 플래그는 특히 "double"과 같은 부동 소수점 변수를 사용할 때 사용됩니다.

특정 상황에서는 x

xx*...가 항상 pow(x, 3)보다 빠른 것은 아닙니다. 일부 보고된 벤치마크에서 관찰되었습니다. 이는 최신 컴파일러에서 사용하는 최적화 기술 때문입니다.

결론

x

x...는 일반적으로 다음과 같은 작은 지수 값에 대해 더 빠릅니다. 1, 2 또는 3의 경우, 코드에 대한 가장 효율적인 접근 방식을 결정할 때 특정 구현 세부 사항 및 컴파일러 최적화 최적화를 고려하는 것이 필수적입니다.

위 내용은 지수 계산을 위해 `pow(x, i)` 대신 `x*x...`를 사용하는 것이 항상 더 빠릅니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!