Ist es immer schneller, „x*x...' anstelle von „pow(x, i)' zur Potenzierung zu verwenden?

Bestimmung der Effizienz von Potenzierungstechniken

Oft ist es effizient, eine Zahl mit sich selbst zu multiplizieren, anstatt eine Funktion zur Potenzierung zu verwenden. wie pow(). Es kann jedoch Ausnahmen von dieser Regel geben, insbesondere bei bestimmten Exponenten.

Betrachten Sie den folgenden Code, um die Leistung von xx... und pow(x,i) für verschiedene zu testen Exponenten '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";
}

Ergebnisse

Die Testergebnisse, die die für jede Potenzierungsmethode benötigte Zeit messen, zeigen, dass xx... ist tatsächlich schneller.

Es gibt jedoch bestimmte Ausnahmen

Bezüglich pow(x, 3) können die Ergebnisse je nach Compiler und Optimierung variieren Flags, insbesondere bei Verwendung von Gleitkommavariablen wie „double“.

In bestimmten Situationen ist xxx*... nicht immer schneller als pow(x, 3), as in einigen gemeldeten Benchmarks beobachtet. Dies ist auf Optimierungstechniken zurückzuführen, die von modernen Compilern verwendet werden.

Schlussfolgerung

Während xx... im Allgemeinen schneller bleibt für kleine Exponentenwerte wie 1, 2 oder 3 ist es wichtig, spezifische Implementierungsdetails und Compiler-Optimierungsoptimierungen zu berücksichtigen, wenn Sie den effizientesten Ansatz für Ihren Code bestimmen.

Das obige ist der detaillierte Inhalt vonIst es immer schneller, „x*x...' anstelle von „pow(x, i)' zur Potenzierung zu verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!