मैंने इस कोड का उपयोग करके छोटे x*x*...बनाम 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(1, b)
TEST(2, b*b)
TEST(3, b*b*b)
TEST(4, b*b*b*b)
TEST(5, b*b*b*b*b)
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()
{
using std::cout;
long loops = 100000000l;
double x = 0.0;
cout << "1 ";
x += testpow<1>(rand(), loops);
x += test1(rand(), loops);
cout << "\n2 ";
x += testpow<2>(rand(), loops);
x += test2(rand(), loops);
cout << "\n3 ";
x += testpow<3>(rand(), loops);
x += test3(rand(), loops);
cout << "\n4 ";
x += testpow<4>(rand(), loops);
x += test4(rand(), loops);
cout << "\n5 ";
x += testpow<5>(rand(), loops);
x += test5(rand(), loops);
cout << "\n" << x << "\n";
}
परिणाम हैं:
1 00:00:01.126008 00:00:01.128338
2 00:00:01.125832 00:00:01.127227
3 00:00:01.125563 00:00:01.126590
4 00:00:01.126289 00:00:01.126086
5 00:00:01.126570 00:00:01.125930
2.45829e+54
ध्यान दें कि मैं यह सुनिश्चित करने के लिए कि संकलक इसे दूर का अनुकूलन नहीं करने के लिए हर पॉव गणना का परिणाम जमा करता है।
यदि मैं std::pow(double, double)संस्करण का उपयोग करता हूं , और loops = 1000000l, मुझे मिलता है:
1 00:00:00.011339 00:00:00.011262
2 00:00:00.011259 00:00:00.011254
3 00:00:00.975658 00:00:00.011254
4 00:00:00.976427 00:00:00.011254
5 00:00:00.973029 00:00:00.011254
2.45829e+52
यह उबंटू 9.10 64 बिट पर चलने वाले एक इंटेल कोर डुओ पर है। -O2 अनुकूलन के साथ gcc 4.4.1 का उपयोग करके संकलित।
इसलिए C में, हाँ x*x*xसे तेज होगा pow(x, 3), क्योंकि कोई pow(double, int)अधिभार नहीं है । C ++ में, यह लगभग एक ही होगा। (मेरे परीक्षण में कार्यप्रणाली को सही मान लेना।)
यह एक मार्क द्वारा की गई टिप्पणी के जवाब में है:
यहां तक कि अगर एक using namespace stdनिर्देश जारी किया गया था, अगर दूसरा पैरामीटर के लिए powएक है int, तो std::pow(double, int)से अधिभार <cmath>के बजाय बुलाया जाएगा ::pow(double, double)से <math.h>।
यह परीक्षण कोड उस व्यवहार की पुष्टि करता है:
#include <iostream>
namespace foo
{
double bar(double x, int i)
{
std::cout << "foo::bar\n";
return x*i;
}
}
double bar(double x, double y)
{
std::cout << "::bar\n";
return x*y;
}
using namespace foo;
int main()
{
double a = bar(1.2, 3); // Prints "foo::bar"
std::cout << a << "\n";
return 0;
}
xअभिन्न या चल बिन्दु?