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