什么更有效率? 使用pow来平方或只是乘以它自己?

这两种方法在C中更有效率? 以及如何:

pow(x,3) 

 x*x*x // etc? 

我testing了x*x*...pow(x,i)之间的性能差异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 

请注意,我累积了每个pow计算的结果,以确保编译器不会优化它。

如果我使用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 

这是运行Ubuntu 9.10 64位的英特尔酷睿双核。 使用gcc 4.4.1编译使用-o2优化。

所以在C中,是x*x*x会比pow(x, 3)更快,因为没有pow(double, int)过载。 在C ++中,它将大致相同。 (假设我testing的方法是正确的。)


这是针对安马克所做的评论:

即使using namespace std指令,如果pow的第二个参数是int ,那么来自<cmath>std::pow(double, int)重载将被调用,而不是::pow(double, double) <math.h>

这个testing代码证实了这个行为:

 #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; } 

这是一个错误的问题。 正确的问题是:“我的代码的读者更容易理解哪一个?”

如果速度很重要(以后),不要问,而是测量。 (在此之前,测量是否优化这实际上会造成任何明显的差异。)在此之前,写代码,以便它是最容易阅读。

编辑
为了说明这一点(虽然它本来应该是这样):突破性的加速通常来自于使用更好的algorithm改善数据的局部性减lessdynamic内存的使用预计 结果等等。 它们很less来自微- 优化单个函数调用 ,以及他们在哪里执行,他们在很less的地方这样做,这只能通过仔细 (耗时)的分析来发现,而不是从来不会通过做非直观的事情来加速(比如插入noop语句),一个平台的优化有时候是另一个平台的问题(这就是为什么你需要测量,而不是问,因为我们不完全知道/有你的环境)。

让我再次强调这一点:即使在less数应用程序中这些事情很重要,在大多数使用它们的地方并不重要,通过查看代码,您很难find他们所关注的地方。 你确实需要首先确定热点 ,否则优化代码只是浪费时间

即使单个操作(如计算某个值的平方)占用了应用程序执行时间的10% (该IME非常less见),即使优化该操作也可节省该操作所需时间的50% (即IME为甚至更less见),但您仍然需要less5%的时间
您的用户将需要秒表甚至注意到。 (我想在大多数情况下,对于大多数用户来说,加速20%以下的东西是不会被注意到的, 就是你需要find的四个这样的地方。)

x x或x x x将比p​​ow更快,因为pow必须处理一般情况,而x x是特定的。 此外,你可以ellide函数调用等。

但是,如果您发现自己像这样进行微型优化,则需要获取一个分析器并进行一些严格的分析。 压倒性的概率是你永远不会注意到两者之间的任何区别。

我也想知道性能问题,并希望这将被编译器优化,基于@EmileCormier的答案。 然而,我担心他所显示的testing代码仍然允许编译器优化掉std :: pow()调用,因为每次调用时都使用相同的值,这将允许编译器存储结果,在循环中重新使用它 – 这将解释所有情况下几乎相同的运行时间。 所以我也看了一下。

这里是我使用的代码(test_pow.cpp):

 #include <iostream> #include <cmath> #include <chrono> class Timer { public: explicit Timer () : from (std::chrono::high_resolution_clock::now()) { } void start () { from = std::chrono::high_resolution_clock::now(); } double elapsed() const { return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - from).count() * 1.0e-6; } private: std::chrono::high_resolution_clock::time_point from; }; int main (int argc, char* argv[]) { double total; Timer timer; total = 0.0; timer.start(); for (double i = 0.0; i < 1.0; i += 1e-8) total += std::pow (i,2); std::cout << "std::pow(i,2): " << timer.elapsed() << "s (result = " << total << ")\n"; total = 0.0; timer.start(); for (double i = 0.0; i < 1.0; i += 1e-8) total += i*i; std::cout << "i*i: " << timer.elapsed() << "s (result = " << total << ")\n"; std::cout << "\n"; total = 0.0; timer.start(); for (double i = 0.0; i < 1.0; i += 1e-8) total += std::pow (i,3); std::cout << "std::pow(i,3): " << timer.elapsed() << "s (result = " << total << ")\n"; total = 0.0; timer.start(); for (double i = 0.0; i < 1.0; i += 1e-8) total += i*i*i; std::cout << "i*i*i: " << timer.elapsed() << "s (result = " << total << ")\n"; return 0; } 

这是编译使用:

 g++ -std=c++11 [-O2] test_pow.cpp -o test_pow 

基本上,差异是std :: pow()是循环计数器的参数。 正如我担心的那样,performance的差异是显而易见的。 如果没有-O2标志,我系统(Arch Linux 64位,g ++ 4.9.1,Intel i7-4930)上的结果是:

 std::pow(i,2): 0.001105s (result = 3.33333e+07) i*i: 0.000352s (result = 3.33333e+07) std::pow(i,3): 0.006034s (result = 2.5e+07) i*i*i: 0.000328s (result = 2.5e+07) 

通过优化,结果同样显着:

 std::pow(i,2): 0.000155s (result = 3.33333e+07) i*i: 0.000106s (result = 3.33333e+07) std::pow(i,3): 0.006066s (result = 2.5e+07) i*i*i: 9.7e-05s (result = 2.5e+07) 

所以它看起来像编译器至less试图优化std :: pow(x,2)的情况下,而不是std :: pow(x,3)的情况下(它需要约40倍的时间比std :: pow (x,2)情况)。 在所有情况下,手动扩展效果都更好 – 但是对于功率3的情况尤其如此(快60倍)。 这是绝对值得注意的是,如果在一个严格的循环中运行整数次幂大于2的std :: pow()…

最有效的方法是考虑乘法的指数增长。 检查这个代码p ^ q:

 template <typename T> T expt(T p, unsigned q){ T r =1; while (q != 0) { if (q % 2 == 1) { // if q is odd r *= p; q--; } p *= p; q /= 2; } return r; } 

如果指数恒定而小,则将其展开,最小化乘法的次数。 (例如, x^4不是最优的x*x*x*x ,而是y*y ,其中y=x*xx^5y*y*x ,其中y=x*x等等。 )对于常数整数指数,只需写出已优化的表格; 用小的指数,这是一个标准的优化,应该执行代码是否被分析或不。 优化后的表格在如此大比例的情况下会更快,因此基本上总是值得的。

(如果使用Visual C ++, std::pow(float,int)会执行我提到的优化,其中操作的顺序与指数的位模式有关,我不保证编译器将循环展开你呢,所以还是值得的。)

顺便说一句, pow在分析器的结果上有一个(不)令人惊讶的倾向。 如果你不是绝对需要它(即指数很大或者不是一个常数),并且你对性能感到担心,那么最好写出最优的代码,然后等待分析器告诉你它(令人惊讶的是)在进一步思考之前浪费时间。 (另一种方法是调用pow并让分析器告诉你这是浪费时间(不出所料) – 你正在智能化地去掉这一步。)