Define a macro which defines a pow function only in the case where the exponent is an integer

Question

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

Some of my pow functions have an integer exponent and another 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:

#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.

How can I 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 the exponent is an integer, but it seems my attempt is not pertinent.

From your suggestions, I tried three 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 = 1 min 08 sec

Second option: Define a macro that calls via inline my_pow function if the exponent n is not an 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.86 sec

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.84 sec

So finally, from these first tests, the best option would be the second one where I use a macro combined with a function that calls the general case of the 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

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).

Edit

Let me show you have you can accomplish this: imagine you need to calculate the 25th power of a number n. Then, first, you need to know the amount of times you need squares, using the simple formula:

a = round_down(log(25) / log(2)) = 4

So, you need all squares, from 0 to 4, and you create following array (sqr(n) stands for the square of n):

[1, n, sqr(n), sqr(sqr(n)), sqr(sqr(sqr(n))), sqr(sqr(sqr(sqr(n))))] with meanings:
 0, 1, 2,      4,           8,                16

You need the last part (the 16th power), you are left with 9, which is larger than 8.
You need the 8, you are left with 1, which is smaller than 4. You don't need the 4.
You don't need the 2.
You need the 1, you are left with 0, and here the loop stops.

So: n^25 = n * sqr(sqr(sqr(n))) * sqr(sqr(sqr(sqr(n))))

(I admit, the explanation is not 100%, but you catch the idea)

Answer 3

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

Take a look at this answer.

What is more efficient? Using pow to square or just multiply it with itself?

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.

C++11 Performance tip: When to use std::pow?

Answer 4

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.