How do you check for infinite and indeterminate values in C++?
Solution 1
For Visual Studio I would use _isnan
and _finite
, or perhaps _fpclass
.
But if you have access to a C++11-able standard library and compiler you could use std::isnan
and std::isinf
.
Solution 2
Although C++03 doesn't provide C99's isnan and isinf macros, C++11 standardizes them by providing them as functions. If you can use C++11, instead of strict C++03, then these would be cleaner options, by avoiding macros, compiler built-ins and platform-dependant functions.
C++11's std::isfinite
returns true
for all values except inf
and nan
; so !isfinite
should check for infinite and indeterminate values in one shot.
Solution 3
You may also use these as a strict C++-only solution. They don't really offer more than the OP's solution except added security through use of type traits and perhaps the tiniest speed boost in the case of is_inf
.
template <bool> struct static_assert;
template <> struct static_assert<true> { };
template<typename T>
inline bool is_NaN(T const& x) {
static_cast<void>(sizeof(static_assert<std::numeric_limits<T>::has_quiet_NaN>));
return std::numeric_limits<T>::has_quiet_NaN and (x != x);
}
template <typename T>
inline bool is_inf(T const& x) {
static_cast<void>(sizeof(static_assert<std::numeric_limits<T>::has_infinity>));
return x == std::numeric_limits<T>::infinity() or x == -std::numeric_limits<T>::infinity();
}
(beware of self-made static_assert
)
Solution 4
Although not strictly a part of C++03, if your compiler provides some of the new C99 features of the standard <math.h> header file, then you may have access to the following "function-like macros": isfinite
, isinf
, isnan
. If so, these would be the easiest and safest way to perform these checks.
Solution 5
There's isfinite
from C99 or POSIX or something I think.
One hackish way to do it is to test x-x == 0
; if x
is infinite or NaN, then x-x
is NaN so the comparison fails, while if x
is finite, then x-x
is 0
and the comparison succeeds. I'd recommend using isfinite
, though, or packaging this test into a function/macro called something like isfinite
so you can get rid of it all when the time comes.
Samil
I developed desktop, web, mobile and IOT applications with the following: Java (using Netbeans & Android Studio) C# (using Visual Studio) NodeJS, JavaScript & HTML (using Visual Studio Code) Matlab, Simulink C (using Visual Studio & Arduino IDE) C++ (using Visual Studio) Ada (using GPS) Delphi
Updated on February 15, 2020Comments
-
Samil over 4 years
In my programs infinity usually arises when a value is divided by zero. I get indeterminate when I divide zero by zero. How do you check for infinite and indeterminate values in C++?
In C++, infinity is represented by 1.#INF. Indeterminate is represented by -1.#IND. The problem is how to test if a variable is infinite or indeterminate. Checking infinity is relatively straightforward: You find the infinity definition in your particular C++. For my case (VS2003), it is std::numeric_limits::infinity(). You have to include "limits" in order to use it. You can assign this infinite value to a variable and you can compare it to some value in order to check if that value is infinite.
Indeterminate is a little tricky, because you cannot compare an indeterminate value to some other value. Any comparison returns false. You can use this property to detect an indeterminate value by comparing it to itself. Let's say you have a double variable called aVal. Under normal conditions, aVal != aVal returns false. But if the value is indeterminate, aIndVal != aIndVal returns true. This weird situation is not present for infinite values, i.e. aInfVal != aInfVal always returns false.
Here are two functions that can be used to check for indeterminate and infinite values:
#include "limits.h" #include "math.h" bool isIndeterminate(const double pV) { return (pV != pV); } bool isInfinite(const double pV) { return (fabs(pV) == std::numeric_limits::infinity()) }
Are there better ways for these checks, am I missing anything?