Adakah ia sentiasa lebih pantas untuk menggunakan `x*x...` dan bukannya `pow(x, i)` untuk eksponen?

Menentukan Kecekapan Teknik Eksponen

Selalunya, adalah cekap untuk mendarab nombor dengan sendirinya dan bukannya menggunakan fungsi khusus untuk eksponen, seperti pow(). Walau bagaimanapun, mungkin terdapat pengecualian kepada peraturan ini, terutamanya dengan eksponen tertentu.

Pertimbangkan kod berikut untuk menguji prestasi xx... dan pow(x,i) untuk berbeza eksponen '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";
}

Keputusan

Keputusan ujian, yang ukur masa yang diambil untuk setiap kaedah eksponen, tunjukkan bahawa xx... sememangnya lebih pantas.

Walau bagaimanapun, terdapat pengecualian tertentu

Mengenai pow(x, 3), keputusan mungkin berbeza-beza bergantung pada pengkompil dan bendera pengoptimuman, terutamanya apabila menggunakan pembolehubah titik terapung seperti "berganda".

Dalam situasi tertentu, xxx*... tidak selalunya lebih laju daripada pow(x, 3), seperti yang diperhatikan dalam beberapa penanda aras yang dilaporkan. Ini disebabkan oleh teknik pengoptimuman yang digunakan oleh penyusun moden.

Kesimpulan

Manakala xx... secara amnya kekal lebih pantas untuk nilai eksponen kecil seperti 1, 2, atau 3, adalah penting untuk mempertimbangkan butiran pelaksanaan khusus dan pengoptimuman pengoptimuman pengkompil apabila menentukan yang paling pendekatan yang cekap untuk kod anda.

Atas ialah kandungan terperinci Adakah ia sentiasa lebih pantas untuk menggunakan `x*x...` dan bukannya `pow(x, i)` untuk eksponen?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!