//  Copyright Daniel James 2005-2006. Use, modification, and distribution are

 //  subject to 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)

 /*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 */

 #if !defined(BOOST_FUNCTIONAL_DETAIL_FLOAT_FUNCTIONS_HPP)

 #define BOOST_FUNCTIONAL_DETAIL_FLOAT_FUNCTIONS_HPP

 #include <cmath>

 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

 # pragma once

 #endif

 // The C++ standard requires that the C float functions are overloarded

 // for float, double and long double in the std namespace, but some of the older

 // library implementations don't support this. On some that don't, the C99

 // float functions (frexpf, frexpl, etc.) are available.

 //

 // Some of this is based on guess work. If I don't know any better I assume that

 // the standard C++ overloaded functions are available. If they're not then this

 // means that the argument is cast to a double and back, which is inefficient

 // and will give pretty bad results for long doubles - so if you know better

 // let me know.

 // STLport:

 #if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)

 #  if (defined(__GNUC__) && __GNUC__ < 3 && (defined(linux) || defined(__linux) || defined(__linux__))) || defined(__DMC__)

 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS

 #  elif defined(BOOST_MSVC) && BOOST_MSVC < 1300

 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS

 #  else

 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 #  endif

 // Roguewave:

 //

 // On borland 5.51, with roguewave 2.1.1 the standard C++ overloads aren't

 // defined, but for the same version of roguewave on sunpro they are.

 #elif defined(_RWSTD_VER)

 #  if defined(__BORLANDC__)

 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS

 #    define BOOST_HASH_C99_NO_FLOAT_FUNCS

 #  elif defined(__DECCXX)

 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS

 #  else

 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 #  endif

 // libstdc++ (gcc 3.0 onwards, I think)

 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)

 #  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 // SGI:

 #elif defined(__STL_CONFIG_H)

 #  if defined(linux) || defined(__linux) || defined(__linux__)

 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS

 #  else

 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 #  endif

 // Dinkumware.

 #elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)

 // Overloaded float functions were probably introduced in an earlier version

 // than this.

 #  if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 402)

 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 #  else

 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS

 #  endif

 // Digital Mars

 #elif defined(__DMC__)

 #  define BOOST_HASH_USE_C99_FLOAT_FUNCS

 // Use overloaded float functions by default.

 #else

 #  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 #endif

 namespace boost

 {

     namespace hash_detail

     {

         inline float call_ldexp(float v, int exp)

         {

             using namespace std;

 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS) || \

     defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)

             return ldexp(v, exp);

 #else

             return ldexpf(v, exp);

 #endif

         }

         inline double call_ldexp(double v, int exp)

         {

             using namespace std;

             return ldexp(v, exp);

         }

 #ifndef __SYMBIAN32__

         inline long double call_ldexp(long double v, int exp)

         {

             using namespace std;

 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)

             return ldexp(v, exp);

 #else

             return ldexpl(v, exp);

 #endif

         }

 #endif

         inline float call_frexp(float v, int* exp)

         {

             using namespace std;

 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS) || \

     defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)

             return frexp(v, exp);

 #else

             return frexpf(v, exp);

 #endif

         }

         inline double call_frexp(double v, int* exp)

         {

             using namespace std;

             return frexp(v, exp);

         }

 #ifndef __SYMBIAN32__

         inline long double call_frexp(long double v, int* exp)

         {

             using namespace std;

 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)

             return frexp(v, exp);

 #else

             return frexpl(v, exp);

 #endif

         }

 #endif        

     }

 }

 #if defined(BOOST_HASH_USE_C99_FLOAT_FUNCS)

 #undef BOOST_HASH_USE_C99_FLOAT_FUNCS

 #endif

 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)

 #undef BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS

 #endif

 #if defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)

 #undef BOOST_HASH_C99_NO_FLOAT_FUNCS

 #endif

 #endif