Est-il toujours plus rapide d'utiliser `x*x...` au lieu de `pow(x, i)` pour l'exponentiation ?

Détermination de l'efficacité des techniques d'exponentiation

Souvent, il est efficace de multiplier un nombre par lui-même au lieu d'utiliser une fonction dédiée à l'exponentiation, comme pow(). Cependant, il peut y avoir des exceptions à cette règle, notamment avec certains exposants.

Considérez le code suivant pour tester les performances de xx... et pow(x,i) pour différents exposants '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";
}

Résultats

Le test Les résultats, qui mesurent le temps nécessaire pour chaque méthode d'exponentiation, démontrent que xx... est effectivement plus rapide.

Cependant, il existe certaines exceptions

Concernant pow(x, 3), les résultats peuvent varier en fonction du compilateur et des indicateurs d'optimisation, notamment lors de l'utilisation de variables à virgule flottante comme "double".

Dans certaines situations, xxx*... n'est pas toujours plus rapide que pow(x, 3), comme observé dans certains benchmarks rapportés. Cela est dû aux techniques d'optimisation utilisées par les compilateurs modernes.

Conclusion

Alors que xx... reste généralement plus rapide pour les petites valeurs d'exposant comme 1, 2 ou 3, il est essentiel de prendre en compte les détails d'implémentation spécifiques et les optimisations d'optimisation du compilateur lors de la détermination de l'approche la plus efficace pour votre code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!