fast-math

I am doing some numerical optimization on a scientific application. One thing I noticed is that GCC will optimize the call pow(a,2) by compiling it into a*a , but the call pow(a,6) is not optimized and will actually call the library function pow , which greatly slows down the performance. (In contrast, Intel C++ Compiler , executable icc , will eliminate the library call for pow(a,6) .) What I am curious about is that when I replaced pow(a,6) with a*a*a*a*a*a using GCC 4.5.1 and options " -O3 -lm -funroll-loops -msse4 ", it uses 5 mulsd instructions: movapd %xmm14, %xmm13 mulsd %xmm14, %xmm13

I am compiling the following code with the -ffast-math option: #include <limits> #include <cmath> #include <iostream> int main() { std::cout << std::isnan(std::numeric_limits<double>::quiet_NaN() ) << std::endl; } I am getting 0 as output. How can my code tell whether a floating point number is NaN when it is compiled with -ffast-math ? Note: On linux, std::isnan works even with -ffast-math. Since -ffast-math instructs GCC not to handle NaN s, it is expected that isnan() has an undefined behaviour. Returning 0 is therefore valid. You can use the following fast replacement for isnan() : #if

Sample code: #include <iostream> #include <cmath> #include <stdint.h> using namespace std; static bool my_isnan(double val) { union { double f; uint64_t x; } u = { val }; return (u.x << 1) > 0x7ff0000000000000u; } int main() { cout << std::isinf(std::log(0.0)) << endl; cout << std::isnan(std::sqrt(-1.0)) << endl; cout << my_isnan(std::sqrt(-1.0)) << endl; cout << __isnan(std::sqrt(-1.0)) << endl; return 0; } Online compiler . With -ffast-math , that code prints "0, 0, 1, 1" -- without, it prints "1, 1, 1, 1". Is that correct? I thought that std::isinf / std::isnan should still work with -ffast

While writing some test cases, and some of the tests check for the result of a NaN. I tried using std::isnan but the assert failes: Assertion `std::isnan(x)' failed. After printing the value of x , it turned out it's negative NaN ( -nan ) which is totally acceptable in my case. After trying to use the fact that NaN != NaN and using assert(x == x) , the compiler does me a 'favor' and optimises the assert away. Making my own isNaN function is being optimised away as well. How can I check for both equality of NaN and -NaN? This is embarrassing. The reason the compiler (GCC in this case) was

I would like to know if any code in C or C++ using floating point arithmetic would produce bit exact results in any x86 based architecture, regardless of the complexity of the code. To my knowledge, any x86 architecture since the Intel 8087 uses a FPU unit prepared to handle IEEE-754 floating point numbers, and I cannot see any reason why the result would be different in different architectures. However, if they were different (namely due to different compiler or different optimization level), would there be some way to produce bit-exact results by just configuring the compiler? Table of