123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562 |
- // (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;
- }
- //---------------------------------------------------------------------------
|