定义一个宏，该宏仅在指数为整数的情况下定义 pow 函数

Question

. Answers to this question are eligible for a +50 reputation bounty. youpilat13 is looking for an :

I need to have the best result from a runtime point of view since pow calls take a lot of time in my code. Moreover, I have to adapt the 2 cases when I have an integer exponent and a floating point exponent. I think I can optimize the first one but I am obliged to use the classical pow function when exponent are floating points. Any suggestion of optimization is welcome. Best regards

Following to a profiling on my C++ code, it appears that pow function is used a lot.

Some of my pow functions have integer exponent and other non integer exponent. I am only interested for the ones with integer exponent.

To gain in performance, I am looking a way to define a macro like this kind :

#define pow(x,n) ({\
    double product;\
    if (typeid(n).name() == "i") {\
    for(int i = 0; i < n-1; i++)\
        product *= x;}\
    else\
    product = pow(x,n);\
    product;\
})

But I don't get the gain expected regarding the runtime. I think this is due to the else part in my macro where I call the classical pow function.

I don't know how to determine in advance the type of exponent before macro was "written" during the pre-processing.

Ideally, I would like this macro only to be applied if exponent is an integer, but it seems my attempt is not pertinent.

Edit

From your suggestions, I tried 3 options :

First option : Just add overload inline functions with base which is integer or double :

// First option
inline int pow(int x, int n){
    // using simple mechanism for repeated multiplication
    int product = 1;
    for(int i = 0; i < n; i++){
        product *= x;
    }
    return product;
}

inline int pow(double x, int n){
    // using simple mechanism for repeated multiplication
    double product = 1;
    for(int i = 0; i < n; i++){
        product *= x;
    }
    return product;
}

Result : runtime = 1m 08s

Second option : Define a macro that calls via inline my_pow function if exponent n is not integer :

// Second option
inline double my_pow(double x, double n){
    return pow(x,n);
}

#define pow(x,n) ({\
    double product = 1;\
    if (typeid(n) == typeid(int)) {\
    for(int i = 0; i < n; i++)\
        product *= x;}\
    else product = my_pow(x,n);\
    product;\
})

Result : runtime = 51.86s

Third option : suggestion given in answer with template<typename type_t>

template<typename type_t>
inline double pow(const double x, type_t n)
{
    // this is compile time checking of types
    // don't use the rtti thing you are trying to do
    //if constexpr (is_floating_point_v<type_t>)
    if (typeid(n) != typeid(int))
    {
        return pow(x, n);
    }
    else
    {
        double value = 1;
        for (type_t i = 0; i < n; ++i) value *= x;
        return value;
    }
}

Result : runtime = 52.84s

So finally, from these first tests, the best option would be the second one where I use macro combined with a function that calls the general case of pow function (both integer and floating exponent).

Is there a more efficient solution or is the second option the best?

Answer 1

If you only need to switch between floating point types or not you can use templates instead of macros.

#include <cassert>
#include <cmath>
#include <type_traits>

namespace my_math
{
    template<typename type_t>
    inline double pow(const double x, type_t n)
    {
        // this is compile time checking of types
        // don't use the rtti thing you are trying to do 
        if constexpr (std::is_floating_point_v<type_t>)
        {
            return std::pow(x, n);
        }
        else
        {
            double value = 1;
            for (type_t i = 0; i < n; ++i) value *= x;
            return value;
        }
    };

}

int main()
{
    assert(my_math::pow(2, 0) == 1);
    assert(my_math::pow(2.0, 1) == 2.0);
    assert(my_math::pow(3.0, 2.0) == 9.0);
    assert(my_math::pow(4.0f, 3.0f) == 64.0f);

   return 0;
}

Answer 2

Instead of crafting hand-tuned solution, try using compiler optimizations -O3 -ffast-math or -O2 -ffast-math

Take a look at this answer. https://stackoverflow.com/a/2940800/1550940

and

If you are using double precision (double), std::pow(x, n) will be slower than the handcrafted equivalent unless you use -ffast-math, in which case, there is absolutely no overhead.

https://baptiste-wicht.com/posts/2017/09/cpp11-performance-tip-when-to-use-std-pow.html

Answer 3

Use the c++ standard https://www.cplusplus.com/reference/ctgmath/ for macro pow version. or use constexpr statement for a pow function instead of a macro.

Answer 4

Once you are sure your pow() is used, hereby a proposal to make your pow() function even better.

This idea might be difficult to implement, but in case you are regularly taking high powers, it might be worth-wile, let me show you an example:

You want to calculate pow(a,17) .
Using your system, you need 16 multiplications.

Now let's turn 17 into binary, you get 10001, which means that, after some calculations, you can write pow(a,17) as:

square(square(square(square(a))))*a, where square(a) = a*a

This leaves you with just 5 multiplications and might cause a performance increase. In fact, it goes from O(n) to O(log n) (where n is the exponent).