EQ2EMu/EQ2/source/depends/boost_1_72_0/libs/numeric/conversion/test/converter_test.cpp

//  (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
//  Use, modification, and distribution is 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)

//  See library home page at http://www.boost.org/libs/numeric/conversion
//
// Contact the author at: fernando_cacciola@hotmail.com
//
#include<cstdlib>
#include<iostream>
#include<iomanip>
#include<string>
#include<typeinfo>
#include<vector>
#include<algorithm>

#include "boost/config.hpp"
#include "boost/cstdint.hpp"
#include "boost/utility.hpp"

//
// Borland 5.5 lacks the following math overloads
//
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x551)
namespace std
{

inline float       ceil  (float       x) { return std::ceil  ( static_cast<double>(x)); }
inline float       floor (float       x) { return std::floor ( static_cast<double>(x)); }
inline long double ceil  (long double x) { return std::ceill (x); }
inline long double floor (long double x) { return std::floorl(x); }

} // namespace std
#endif

#include "boost/numeric/conversion/converter.hpp"
#include "boost/numeric/conversion/cast.hpp"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#include "test_helpers.cpp"
#include "test_helpers2.cpp"
#include "test_helpers3.cpp"

#include "boost/mpl/alias.hpp"

using std::cout ;

// A generic 'abs' function.
template<class N> inline N absG ( N v )
{
  return v < static_cast<N>(0) ? static_cast<N>(-v) : v ;
}
template<> inline unsigned char  absG<unsigned char>  ( unsigned char  v ) { return v ; }
template<> inline unsigned short absG<unsigned short> ( unsigned short v ) { return v ; }
template<> inline unsigned int   absG<unsigned int>   ( unsigned int   v ) { return v ; }
template<> inline unsigned long  absG<unsigned long>  ( unsigned long  v ) { return v ; }

template<class T> inline void unused_variable ( T const& ) {}
//
// The following function excersizes specific conversions that cover
// usual and boundary cases for each relevant combination.
//
void test_conversions()
{
  using namespace boost ;
  using namespace numeric ;

  // To help the test found possible bugs a random numbers are used.
#if !defined(BOOST_NO_STDC_NAMESPACE)
  using std::rand ;
#endif

  boost::int16_t v16 ;
  boost::uint16_t uv16 ;
  boost::int32_t v32 ;
  boost::uint32_t uv32 ;

  volatile float  fv ; // avoid this to be cached internally in some fpu register
  volatile double dv ; // avoid this to be cached internally in some fpu register

  //
  // sample (representative) conversions:
  //
  cout << "Testing representative conversions\n";

  // integral to integral

    // signed to signed

      // not subranged
      v16 = static_cast<boost::int16_t>(rand());
      TEST_SUCCEEDING_CONVERSION_DEF(boost::int32_t,boost::int16_t,v16,v16);

      // subranged
      v16 = static_cast<boost::int16_t>(rand());
      TEST_SUCCEEDING_CONVERSION_DEF(boost::int16_t,boost::int32_t,v16,v16);
      TEST_POS_OVERFLOW_CONVERSION_DEF(boost::int16_t,boost::int32_t,bounds<boost::int16_t>::highest() + boost::int32_t(1) ) ;
      TEST_NEG_OVERFLOW_CONVERSION_DEF(boost::int16_t,boost::int32_t,bounds<boost::int16_t>::lowest()  - boost::int32_t(1) ) ;

    // signed to unsigned

      // subranged
      v32 = absG(static_cast<boost::int32_t>(rand()));
      v16 = absG(static_cast<boost::int16_t>(rand()));
      TEST_SUCCEEDING_CONVERSION_DEF(boost::uint32_t,boost::int32_t,v32,v32);
      TEST_SUCCEEDING_CONVERSION_DEF(boost::uint16_t,boost::int32_t,v16,v16);
      TEST_POS_OVERFLOW_CONVERSION_DEF(boost::uint16_t,boost::int32_t,bounds<boost::uint16_t>::highest() + boost::int32_t(1) ) ;
      TEST_NEG_OVERFLOW_CONVERSION_DEF(boost::uint32_t,boost::int32_t,boost::int32_t(-1) ) ;

    // unsigned to signed

      // not subranged
      v32 = absG(static_cast<boost::int32_t>(rand()));
      TEST_SUCCEEDING_CONVERSION_DEF(boost::int32_t,boost::uint32_t,v32,v32);

      // subranged
      v16 = absG(static_cast<boost::int16_t>(rand()));
      TEST_SUCCEEDING_CONVERSION_DEF(boost::int16_t,boost::uint32_t,v16,v16);
      TEST_POS_OVERFLOW_CONVERSION_DEF(boost::int32_t,boost::uint32_t,bounds<boost::uint32_t>::highest() ) ;
      TEST_POS_OVERFLOW_CONVERSION_DEF(boost::int16_t,boost::uint32_t,bounds<boost::uint32_t>::highest() ) ;

    // unsigned to unsigned

      // not subranged
      uv16 = static_cast<boost::uint16_t>(rand());
      TEST_SUCCEEDING_CONVERSION_DEF(boost::uint32_t,boost::uint16_t,uv16,uv16);

      // subranged
      uv16 = static_cast<boost::uint16_t>(rand());
      TEST_SUCCEEDING_CONVERSION_DEF(boost::uint16_t,boost::uint32_t,uv16,uv16);
      TEST_POS_OVERFLOW_CONVERSION_DEF(boost::uint16_t,boost::uint32_t,bounds<boost::uint32_t>::highest() ) ;

  // integral to float

     // from signed integral
     v32 = static_cast<boost::int32_t>(rand());
     TEST_SUCCEEDING_CONVERSION_DEF(double,boost::int32_t,v32,v32);

     // from uint32_tegral
     uv32 = static_cast<boost::uint32_t>(rand());
     TEST_SUCCEEDING_CONVERSION_DEF(double,boost::uint32_t,uv32,uv32);

  // float to integral

     // to signed integral
     v32 =  static_cast<boost::int32_t>(rand());
     TEST_SUCCEEDING_CONVERSION_DEF(boost::int32_t,double,v32,v32);

     dv = static_cast<double>(bounds<boost::uint32_t>::highest()) + 1.0 ;
     TEST_POS_OVERFLOW_CONVERSION_DEF(boost::int32_t,double,dv) ;
     TEST_NEG_OVERFLOW_CONVERSION_DEF(boost::int32_t,double,-dv) ;

  // float to float

    // not subranged
    fv = static_cast<float>(rand()) / static_cast<float>(3) ;
    TEST_SUCCEEDING_CONVERSION_DEF(double,float,fv,fv);


    // subranged
    fv = static_cast<float>(rand()) / static_cast<float>(3) ;
    TEST_SUCCEEDING_CONVERSION_DEF(float,double,fv,fv);
    TEST_POS_OVERFLOW_CONVERSION_DEF(float,double,bounds<double>::highest()) ;
    TEST_NEG_OVERFLOW_CONVERSION_DEF(float,double,bounds<double>::lowest ()) ;
}

// Custom OverflowHandler
struct custom_overflow_handler
{
  void operator() ( boost::numeric::range_check_result r )
  {
    if ( r == boost::numeric::cNegOverflow )
      cout << "negative_overflow detected!\n" ;
    else if ( r == boost::numeric::cPosOverflow )
           cout << "positive_overflow detected!\n" ;
  }
} ;

template<class T, class S,class OverflowHandler>
void test_overflow_handler( MATCH_FNTPL_ARG(T), MATCH_FNTPL_ARG(S), MATCH_FNTPL_ARG(OverflowHandler),
                            PostCondition pos,
                            PostCondition neg
                          )
{
  typedef boost::numeric::conversion_traits<T,S> traits ;
  typedef boost::numeric::converter<T,S,traits,OverflowHandler> converter ;

  static const S psrc = boost::numeric::bounds<S>::highest();
  static const S nsrc = boost::numeric::bounds<S>::lowest ();

  static const T pres = static_cast<T>(psrc);
  static const T nres = static_cast<T>(nsrc);

  test_conv_base ( ConversionInstance<converter>(pres,psrc,pos) ) ;
  test_conv_base ( ConversionInstance<converter>(nres,nsrc,neg) ) ;
}

template<class T, class S>
void test_overflow_handlers( MATCH_FNTPL_ARG(T), MATCH_FNTPL_ARG(S) )
{
  cout << "Testing Silent Overflow Handler policy\n";

  test_overflow_handler( SET_FNTPL_ARG(T),
                         SET_FNTPL_ARG(S),
                         SET_FNTPL_ARG(boost::numeric::silent_overflow_handler),
                         c_converted,
                         c_converted
                       ) ;

  cout << "Testing Default Overflow Handler policy\n";

  test_overflow_handler( SET_FNTPL_ARG(T),
                         SET_FNTPL_ARG(S),
                         SET_FNTPL_ARG(boost::numeric::def_overflow_handler),
                         c_pos_overflow,
                         c_neg_overflow
                       ) ;

  cout << "Testing Custom (User-Defined) Overflow Handler policy\n";

  test_overflow_handler( SET_FNTPL_ARG(T),
                         SET_FNTPL_ARG(S),
                         SET_FNTPL_ARG(custom_overflow_handler),
                         c_converted,
                         c_converted
                       ) ;
}

// For a given float-type number 'n' of integer value (n.0), check the conversions
// within the range [n-1,n+1] taking values at: (n-1,n-0.5,n,n+0.5,n+1).
// For each sampled value there is an expected result and a PostCondition according to the
// specified round_style.
//
template<class T, class S, class Float2IntRounder>
void test_rounding_conversion ( MATCH_FNTPL_ARG(T), MATCH_FNTPL_ARG(Float2IntRounder),
                                S s,
                                PostCondition resl1,
                                PostCondition resl0,
                                PostCondition res,
                                PostCondition resr0,
                                PostCondition resr1
                              )
{
  typedef boost::numeric::conversion_traits<T,S> Traits ;

  typedef boost::numeric::converter<T,S, Traits, boost::numeric::def_overflow_handler,Float2IntRounder>
           Converter ;

  S sl1 = s - static_cast<S>(1);
  S sl0 = s - static_cast<S>(0.5);
  S sr0 = s + static_cast<S>(0.5);
  S sr1 = s + static_cast<S>(1);

  T tl1 = static_cast<T>( Converter::nearbyint(sl1) );
  T tl0 = static_cast<T>( Converter::nearbyint(sl0) );
  T t   = static_cast<T>( Converter::nearbyint(s)   );
  T tr0 = static_cast<T>( Converter::nearbyint(sr0) );
  T tr1 = static_cast<T>( Converter::nearbyint(sr1) );

  test_conv_base ( ConversionInstance<Converter>(tl1,sl1,resl1) ) ;
  test_conv_base ( ConversionInstance<Converter>(tl0,sl0,resl0) ) ;
  test_conv_base ( ConversionInstance<Converter>(t,s,res) ) ;
  test_conv_base ( ConversionInstance<Converter>(tr0,sr0,resr0) ) ;
  test_conv_base ( ConversionInstance<Converter>(tr1,sr1,resr1) ) ;
}


template<class T,class S>
void test_round_style( MATCH_FNTPL_ARG(T), MATCH_FNTPL_ARG(S) )
{
  S min = boost::numeric::bounds<T>::lowest();
  S max = boost::numeric::bounds<T>::highest();

  cout << "Testing 'Trunc' Float2IntRounder policy\n";

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::Trunc<S>),
                           min,
                           c_neg_overflow,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_converted
                          ) ;

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::Trunc<S>),
                           max,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_pos_overflow
                          ) ;

  cout << "Testing 'RoundEven' Float2IntRounder policy\n";

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::RoundEven<S>),
                           min,
                           c_neg_overflow,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_converted
                          ) ;

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::RoundEven<S>),
                           max,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_pos_overflow,
                           c_pos_overflow
                          ) ;

  cout << "Testing 'Ceil' Float2IntRounder policy\n";

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::Ceil<S>),
                           min,
                           c_neg_overflow,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_converted
                          ) ;

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::Ceil<S>),
                           max,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_pos_overflow,
                           c_pos_overflow
                          ) ;

  cout << "Testing 'Floor' Float2IntRounder policy\n" ;

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::Floor<S>),
                           min,
                           c_neg_overflow,
                           c_neg_overflow,
                           c_converted,
                           c_converted,
                           c_converted
                          ) ;

  test_rounding_conversion(SET_FNTPL_ARG(T),
                           SET_FNTPL_ARG(boost::numeric::Floor<S>),
                           max,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_converted,
                           c_pos_overflow
                          ) ;

}

void test_round_even( double n, double x )
{
  double r = boost::numeric::RoundEven<double>::nearbyint(n);
  BOOST_CHECK( r == x ) ;
}

void test_round_even()
{
  cout << "Testing 'RoundEven' tie-breaking\n";

  double min = boost::numeric::bounds<double>::lowest();
  double max = boost::numeric::bounds<double>::highest();

#if !defined(BOOST_NO_STDC_NAMESPACE)
  using std::floor ;
  using std::ceil ;
#endif
  test_round_even(min, floor(min));
  test_round_even(max, ceil (max));
  test_round_even(2.0, 2.0);
  test_round_even(2.3, 2.0);
  test_round_even(2.5, 2.0);
  test_round_even(2.7, 3.0);
  test_round_even(3.0, 3.0);
  test_round_even(3.3, 3.0);
  test_round_even(3.5, 4.0);
  test_round_even(3.7, 4.0);
}

int double_to_int ( double n ) { return static_cast<int>(n) ; }

void test_converter_as_function_object()
{
  cout << "Testing converter as function object.\n";

  // Create a sample sequence of double values.
  std::vector<double> S ;
  for ( int i = 0 ; i < 10 ; ++ i )
    S.push_back( i * ( 18.0 / 19.0 ) );

  // Create a sequence of int values from 's' using the standard conversion.
  std::vector<int> W ;
  std::transform(S.begin(),S.end(),std::back_inserter(W),double_to_int);

  // Create a sequence of int values from s using a default numeric::converter
  std::vector<int> I ;
  std::transform(S.begin(),
                 S.end(),
                 std::back_inserter(I),
                 boost::numeric::converter<int,double>()
                ) ;

  // Match 'w' and 'i' which should be equal.
  bool double_to_int_OK = std::equal(W.begin(),W.end(),I.begin()) ;
  BOOST_CHECK_MESSAGE(double_to_int_OK, "converter (int,double) as function object");

  // Create a sequence of double values from s using a default numeric::converter (which should be the trivial conv).
  std::vector<double> D ;
  std::transform(S.begin(),
                 S.end(),
                 std::back_inserter(D),
                 boost::numeric::converter<double,double>()
                ) ;

  // Match 's' and 'd' which should be equal.
  bool double_to_double_OK = std::equal(S.begin(),S.end(),D.begin()) ;
  BOOST_CHECK_MESSAGE(double_to_double_OK, "converter (double,double) as function object");
}

#if BOOST_WORKAROUND(__IBMCPP__, <= 600 ) // VCAPP6
#  define UNOPTIMIZED
#else
#  define UNOPTIMIZED volatile
#endif

void test_optimizations()
{
  using namespace boost;
  using namespace numeric;

  float fv0 = 18.0f / 19.0f ;

  // This code deosn't produce any output.
  // It is intended to show the optimization of numeric::converter<> by manual inspection
  // of the generated code.
  // Each test shows first the equivalent hand-coded version.
  // The numeric_cast<> code should be the same if full compiler optimization/inlining is used.

  //---------------------------------
  // trivial conversion.
  //
    // equivalent code:
      UNOPTIMIZED float fv1a = fv0 ;

    float fv1b = numeric_cast<float>(fv0);
    unused_variable(fv1a);
    unused_variable(fv1b);
  //
  //---------------------------------

  //---------------------------------
  // nonsubranged conversion.
  //
    // equivalent code:
      UNOPTIMIZED double dv1a = static_cast<double>(fv0);

    double dv1b = numeric_cast<double>(fv0);
    unused_variable(dv1a);
    unused_variable(dv1b);
  //
  //---------------------------------

  //------------------------------------------------------
  // subranged conversion with both-sided range checking.
  //

    // equivalent code:

      {
        double const& s = dv1b ;
        // range checking
        range_check_result r =  s < static_cast<double>(bounds<float>::lowest())
                                  ? cNegOverflow : cInRange ;
        if ( r == cInRange )
        {
          r = s > static_cast<double>(bounds<float>::highest()) ? cPosOverflow : cInRange ;
        }
        if ( r == cNegOverflow )
          throw negative_overflow() ;
        else if ( r == cPosOverflow )
               throw positive_overflow() ;
        // conversion
        UNOPTIMIZED float fv2a = static_cast<float>(s);
        unused_variable(fv2a);
      }

    float fv2b = numeric_cast<float>(dv1b);
    unused_variable(fv2b);
  //
  //---------------------------------


  //---------------------------------
  // subranged rounding conversion
  //
    // equivalent code:

      {
        double const& s = dv1b ;
        // range checking
        range_check_result r = s <= static_cast<double>(bounds<int>::lowest()) - static_cast<double>(1.0)
                                 ? cNegOverflow : cInRange ;
        if ( r == cInRange )
        {
          r = s >= static_cast<double>(bounds<int>::highest()) + static_cast<double>(1.0)
                ? cPosOverflow : cInRange ;
        }
        if ( r == cNegOverflow )
          throw negative_overflow() ;
        else if ( r == cPosOverflow )
               throw positive_overflow() ;
        // rounding

#if !defined(BOOST_NO_STDC_NAMESPACE)
        using std::floor ;
#endif

        double s1 = floor(dv1b + 0.5);

        // conversion
        UNOPTIMIZED int iv1a = static_cast<int>(s1);
        unused_variable(iv1a);
      }

    int iv1b = numeric_cast<int>(dv1b);
    unused_variable(iv1b);
  //
  //---------------------------------
}

int test_main( int, char* argv[] )
{
  std::cout << std::setprecision( std::numeric_limits<long double>::digits10 ) ;

  test_conversions();
  test_overflow_handlers( SET_FNTPL_ARG(boost::int16_t), SET_FNTPL_ARG(boost::int32_t));
  test_round_style(SET_FNTPL_ARG(boost::int32_t), SET_FNTPL_ARG(double) ) ;
  test_round_even() ;
  test_converter_as_function_object();
  test_optimizations() ;

  return 0;
}
//---------------------------------------------------------------------------