Round up a little detail of the round

Rounding is to get the nearest integer to a floating-point number , So-called “ rounding ” It means round .C++ Can be called std::round To achieve . It looks like a simple operation, isn't it , In fact, there are some small details .

std::round Cannot evaluate... During compilation

Compile time （compile-time） Calculation and operation period （run-time） The concept of calculation must be understood by everyone , If a function can calculate the result during compilation （ Such functions are called constant expression functions constexpr funciton）, That can save the calculation time during the operation period . In some cases, it must be required to calculate... At compile time , For example, template parameters ：

template <int N>
void printN() {
     std::cout << N << '\n'; }

int main()
{
    
    constexpr int n = std::round(0.5);
    printN<n>();
}

The above code is in MSVC and Clang Cannot be compiled in , because std::round Cannot calculate at compile time ！ It sounds incredible , Why such a simple function can only be calculated at run time ？

The answer is Error handling , When rounding fails （ Rounding result is out of integer range ） when ,std::round Store the error information in the global variable （ It's actually thread-local, That is, it can be regarded as global in a single thread , For thread safety ） math_errhandling in , So that developers can check whether there are errors .

Obviously, such an error handling mechanism is executed during operation . Like rounding ,std cmath All the mathematical functions in... Are used math_errhandling, Therefore, it cannot be calculated during compilation .

But here's the thing ,GCC Be able to calculate... During compilation std Mathematical functions , So the above code can use GCC Normal compile run . but C++ standard (c++draft) It's clear ：

An implementation shall not declare any standard library function signature as constexpr except for those where it is explicitly required.

In plain English ： The function that is not said to be a constant expression in the standard library has been changed to a constant expression ！ therefore GCC It's self assertion . For program compatibility , Try not to take advantage of GCC This feature is better .

Rounding may be slow

If you really care about computing speed ,std::round It may not be a good choice , The same reason is Error handling .

One side , Error handling itself can lead to additional time consumption （ Error judgment and error information are written to global variables ）. On the other hand ,math_errhandling The existence of this global variable leads to std::round Vectorization is not possible （ The compiler will automatically vectorize and accelerate some calculations ）.

If you want to get the ultimate computing speed , At the same time, it can ensure that the rounding result will not overflow , You can realize a rounding without error handling by yourself ：

inline static int myRound(double val)
{
    
    return (int)(val + (val >= 0 ? 0.5 : -0.5));
}

Or make use of SSE Instructions , It should be faster ：

inline static int myRound(double val)
{
    
    __m128d t = _mm_set_sd(val);
    return _mm_cvtsd_si32(t);
}

( In fact, the above two implementations come from OpenCV Of cvRound).

Rounding is not necessarily “ Five in ”

If you use OpenCV, Will find 1.5 and 2.5 adopt cvRound After rounding, it's all 2, The agreed rounding ？

This is because ,cvRound Give priority to SSE Realization , and SSE The rounding in is bankers’ rounding Strategy （ also called statistician’s rounding、Gaussian rounding）, This strategy will x.5 Round to the nearest even numbers (round half to even), In order to solve the problem of high results caused by rounding in Statistics .

By default (FE_TONEAREST) Next ,std::round It's round off ,std::rint yes bankers’ rounding.