[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);

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

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

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

[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 namespace qualification.
   (boost::math::isnan)(z); 
   //
   // This will cause a compiler error is isnan is a native macro:
   boost::math::isnan(z);
   // So always use (boost::math::isnan)(z); instead. 
   
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 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 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).
]
