[section:fpclass Floating-Point Classification: Infinities and NaN's]

[h4 Synopsis]

   #define FP_ZERO        /* implementation specific value */
   #define FP_NORMAL      /* implementation specific value */
   #define FP_INFINITE    /* implementation specific value */
   #define FP_NAN         /* implementation specific value */
   #define FP_SUBNORMAL   /* implementation specific value */

   template <class T>
   int fpclassify(T t);

   template <class T>
   bool isfinite(T z); // Neither infinity nor NaN.

   template <class T>
   bool isinf(T t); // Infinity (+ or -).

   template <class T>
   bool isnan(T t); // NaN.

   template <class T>
   bool isnormal(T t); // isfinite and not denormalised.
   
   #include <boost\math\special_functions\fpclassify.hpp>

to use these functions.

[h4 Description]

These functions provide the same functionality as the macros with the same
name in C99, indeed if the C99 macros are available, then these functions
are implemented in terms of them, otherwise they rely on std::numeric_limits<>
to function.

Note that the definition of these functions ['does not suppress the definition
of these names as macros by math.h] on those platforms that already provide
these as macros.  That mean that the following have differing meanings:

   using namespace boost::math;
   
   // This might call a global macro if defined,
   // but might not work if the type of z is unsupported 
   // by the std lib macro:
   isnan(z);
   //
   // This calls the Boost version
   // (found via the "using namespace boost::math" declaration)
   // it works for any type that has numeric_limits support for type z:
   (isnan)(z); 
   //
   // As above but with explicit namespace qualification.
   (boost::math::isnan)(z); 
   //
   // This will cause a compiler error if isnan is a native macro:
   boost::math::isnan(z);
   // So always use instead:
   (boost::math::isnan)(z);
   //
   // You can also add a using statement,
   // globally to a .cpp file, or to a local function in a .hpp file.
   using boost::math::isnan;
   // so you can write the shorter and less cluttered
   (isnan)(z)
   // But, as above, if isnan is a native macro, this causes a compiler error,
   // because the macro always 'gets' the name first, unless enclosed in () brackets.
   
Detailed descriptions for each of these functions follows: 

   template <class T>
   int fpclassify(T t);
   
Returns an integer value that classifies the value /t/:

[table
[[fpclassify value] [class of t.]]
[[FP_ZERO] [If /t/ is zero.]]
[[FP_NORMAL] [If /t/ is a non-zero, non-denormalised finite value.]]
[[FP_INFINITE] [If /t/ is plus or minus infinity.]]
[[FP_NAN] [If /t/ is a NaN.]]
[[FP_SUBNORMAL] [If /t/ is a denormalised number.]]
]

   template <class T>
   bool isfinite(T z);

Returns true only if /z/ is not an infinity or a NaN.

   template <class T>
   bool isinf(T t);

Returns true only if /z/ is plus or minus infinity.

   template <class T>
   bool isnan(T t);

Returns true only if /z/ is a [@http://en.wikipedia.org/wiki/NaN NaN].

   template <class T>
   bool isnormal(T t);

Returns true only if /z/ is a normal number (not zero, infinite, NaN, or denormalised).

[endsect] [/section:fpclass Floating Point Classification: Infinities and NaN's]

[/ 
  Copyright 2006, 2008 John Maddock and Paul A. Bristow.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]