libs/rational/test/rational_test.cpp
/* * A test program for boost/rational.hpp. * Change the typedef at the beginning of run_tests() to try out different * integer types. (These tests are designed only for signed integer * types. They should work for short, int and long.) * * (C) Copyright Stephen Silver, 2001. Permission to copy, use, modify, sell * and distribute this software is granted provided this copyright notice * appears in all copies. This software is provided "as is" without express or * implied warranty, and with no claim as to its suitability for any purpose. * * Incorporated into the boost rational number library, and modified and * extended, by Paul Moore, with permission. */ // boostinspect:nolicense (don't complain about the lack of a Boost license) // (Stephen Silver hasn't been contacted yet for permission to change the // license. If Paul Moore's permission is also needed, then that's a problem // since he hasn't been in contact for years.) // Revision History // 30 Aug 13 Add bug-test of assignments holding the basic and/or strong // guarantees (Daryle Walker) // 27 Aug 13 Add test for cross-version constructor template (Daryle Walker) // 23 Aug 13 Add bug-test of narrowing conversions during order comparison; // spell logical-negation in it as "!" because MSVC won't accept // "not" (Daryle Walker) // 05 Nov 06 Add testing of zero-valued denominators & divisors; casting with // types that are not implicitly convertible (Daryle Walker) // 04 Nov 06 Resolve GCD issue with depreciation (Daryle Walker) // 02 Nov 06 Add testing for operator<(int_type) w/ unsigneds (Daryle Walker) // 31 Oct 06 Add testing for operator<(rational) overflow (Daryle Walker) // 18 Oct 06 Various fixes for old compilers (Joaquín M López Muñoz) // 27 Dec 05 Add testing for Boolean conversion operator (Daryle Walker) // 24 Dec 05 Change code to use Boost.Test (Daryle Walker) // 04 Mar 01 Patches for Intel C++ and GCC (David Abrahams) #define BOOST_TEST_MAIN "Boost::Rational unit tests" #include <boost/config.hpp> #include <boost/limits.hpp> #include <boost/mpl/list.hpp> #include <boost/operators.hpp> #include <boost/preprocessor/stringize.hpp> #include <boost/integer/common_factor_rt.hpp> #include <boost/cstdint.hpp> #include <boost/rational.hpp> #include <boost/test/unit_test.hpp> #include <climits> #include <iomanip> #include <ios> #include <iostream> #include <istream> #include <ostream> #include <sstream> #include <stdexcept> #include <string> #ifdef _MSC_VER #pragma warning(disable:4146) #endif // We can override this on the compile, as -DINT_TYPE=short or whatever. // The default test is against rational<long>. #ifndef INT_TYPE #define INT_TYPE long #endif namespace { class MyOverflowingUnsigned; // This is a trivial user-defined wrapper around the built in int type. // It can be used as a test type for rational<> class MyInt : boost::operators<MyInt> { friend class MyOverflowingUnsigned; int val; public: MyInt(int n = 0) : val(n) {} friend MyInt operator+ (const MyInt&); friend MyInt operator- (const MyInt&); MyInt& operator+= (const MyInt& rhs) { val += rhs.val; return *this; } MyInt& operator-= (const MyInt& rhs) { val -= rhs.val; return *this; } MyInt& operator*= (const MyInt& rhs) { val *= rhs.val; return *this; } MyInt& operator/= (const MyInt& rhs) { val /= rhs.val; return *this; } MyInt& operator%= (const MyInt& rhs) { val %= rhs.val; return *this; } MyInt& operator|= (const MyInt& rhs) { val |= rhs.val; return *this; } MyInt& operator&= (const MyInt& rhs) { val &= rhs.val; return *this; } MyInt& operator^= (const MyInt& rhs) { val ^= rhs.val; return *this; } const MyInt& operator++() { ++val; return *this; } const MyInt& operator--() { --val; return *this; } bool operator< (const MyInt& rhs) const { return val < rhs.val; } bool operator== (const MyInt& rhs) const { return val == rhs.val; } bool operator! () const { return !val; } friend std::istream& operator>>(std::istream&, MyInt&); friend std::ostream& operator<<(std::ostream&, const MyInt&); }; inline MyInt operator+(const MyInt& rhs) { return rhs; } inline MyInt operator-(const MyInt& rhs) { return MyInt(-rhs.val); } inline std::istream& operator>>(std::istream& is, MyInt& i) { is >> i.val; return is; } inline std::ostream& operator<<(std::ostream& os, const MyInt& i) { os << i.val; return os; } inline MyInt abs(MyInt rhs) { if (rhs < MyInt()) rhs = -rhs; return rhs; } // This is an "unsigned" wrapper, that throws on overflow. It can be used to // test rational<> when an operation goes out of bounds. class MyOverflowingUnsigned : private boost::unit_steppable<MyOverflowingUnsigned> , private boost::ordered_euclidian_ring_operators1<MyOverflowingUnsigned> { // Helper type-aliases typedef MyOverflowingUnsigned self_type; typedef unsigned self_type::* bool_type; // Member data unsigned v_; public: // Exception base class class exception_base { protected: virtual ~exception_base() throw() {} }; // Divide-by-zero exception class class divide_by_0_error : public virtual exception_base , public std::domain_error { public: explicit divide_by_0_error( std::string const &w ) : std::domain_error( w ) {} virtual ~divide_by_0_error() throw() {} }; // Overflow exception class class overflowing_error : public virtual exception_base , public std::overflow_error { public: explicit overflowing_error( std::string const &w ) : std::overflow_error( w ) {} virtual ~overflowing_error() throw() {} }; // Lifetime management (use automatic dtr & copy-ctr) MyOverflowingUnsigned( unsigned v = 0 ) : v_( v ) {} explicit MyOverflowingUnsigned( MyInt const &m ) : v_( m.val ) {} // Operators (use automatic copy-assignment); arithmetic & comparison only self_type & operator ++() { if ( this->v_ == UINT_MAX ) throw overflowing_error( "increment" ); else ++this->v_; return *this; } self_type & operator --() { if ( !this->v_ ) throw overflowing_error( "decrement" ); else --this->v_; return *this; } operator bool_type() const { return this->v_ ? &self_type::v_ : 0; } bool operator !() const { return !this->v_; } self_type operator +() const { return self_type( +this->v_ ); } self_type operator -() const { return self_type( -this->v_ ); } bool operator <(self_type const &r) const { return this->v_ < r.v_; } bool operator ==(self_type const &r) const { return this->v_ == r.v_; } self_type & operator *=( self_type const &r ) { if ( r.v_ && this->v_ > UINT_MAX / r.v_ ) { throw overflowing_error( "oversized factors" ); } this->v_ *= r.v_; return *this; } self_type & operator /=( self_type const &r ) { if ( !r.v_ ) throw divide_by_0_error( "division" ); this->v_ /= r.v_; return *this; } self_type & operator %=( self_type const &r ) { if ( !r.v_ ) throw divide_by_0_error( "modulus" ); this->v_ %= r.v_; return *this; } self_type & operator +=( self_type const &r ) { if ( this->v_ > UINT_MAX - r.v_ ) { throw overflowing_error( "oversized addends" ); } this->v_ += r.v_; return *this; } self_type & operator -=( self_type const &r ) { if ( this->v_ < r.v_ ) { throw overflowing_error( "oversized subtrahend" ); } this->v_ -= r.v_; return *this; } // Input & output template < typename Ch, class Tr > friend std::basic_istream<Ch, Tr> & operator >>( std::basic_istream<Ch, Tr> &i, self_type &x ) { return i >> x.v_; } template < typename Ch, class Tr > friend std::basic_ostream<Ch, Tr> & operator <<( std::basic_ostream<Ch, Tr> &o, self_type const &x ) { return o << x.v_; } }; // MyOverflowingUnsigned inline MyOverflowingUnsigned abs( MyOverflowingUnsigned const &x ) { return x; } } // namespace // Specialize numeric_limits for the custom types namespace std { template < > class numeric_limits< MyInt > { typedef numeric_limits<int> limits_type; public: static const bool is_specialized = limits_type::is_specialized; static MyInt min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return limits_type::min BOOST_PREVENT_MACRO_SUBSTITUTION (); } static MyInt max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return limits_type::max BOOST_PREVENT_MACRO_SUBSTITUTION (); } static MyInt lowest() throw() { return min BOOST_PREVENT_MACRO_SUBSTITUTION (); } // C++11 static const int digits = limits_type::digits; static const int digits10 = limits_type::digits10; static const int max_digits10 = 0; // C++11 static const bool is_signed = limits_type::is_signed; static const bool is_integer = limits_type::is_integer; static const bool is_exact = limits_type::is_exact; static const int radix = limits_type::radix; static MyInt epsilon() throw() { return limits_type::epsilon(); } static MyInt round_error() throw() { return limits_type::round_error(); } static const int min_exponent = limits_type::min_exponent; static const int min_exponent10 = limits_type::min_exponent10; static const int max_exponent = limits_type::max_exponent; static const int max_exponent10 = limits_type::max_exponent10; static const bool has_infinity = limits_type::has_infinity; static const bool has_quiet_NaN = limits_type::has_quiet_NaN; static const bool has_signaling_NaN = limits_type::has_signaling_NaN; static const float_denorm_style has_denorm = limits_type::has_denorm; static const bool has_denorm_loss = limits_type::has_denorm_loss; static MyInt infinity() throw() { return limits_type::infinity(); } static MyInt quiet_NaN() throw() { return limits_type::quiet_NaN(); } static MyInt signaling_NaN() throw() {return limits_type::signaling_NaN();} static MyInt denorm_min() throw() { return limits_type::denorm_min(); } static const bool is_iec559 = limits_type::is_iec559; static const bool is_bounded = limits_type::is_bounded; static const bool is_modulo = limits_type::is_modulo; static const bool traps = limits_type::traps; static const bool tinyness_before = limits_type::tinyness_before; static const float_round_style round_style = limits_type::round_style; }; // std::numeric_limits<MyInt> template < > class numeric_limits< MyOverflowingUnsigned > { typedef numeric_limits<unsigned> limits_type; public: static const bool is_specialized = limits_type::is_specialized; static MyOverflowingUnsigned min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return limits_type::min BOOST_PREVENT_MACRO_SUBSTITUTION (); } static MyOverflowingUnsigned max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return limits_type::max BOOST_PREVENT_MACRO_SUBSTITUTION (); } static MyOverflowingUnsigned lowest() throw() { return min BOOST_PREVENT_MACRO_SUBSTITUTION (); } // C++11 static const int digits = limits_type::digits; static const int digits10 = limits_type::digits10; static const int max_digits10 = 0; // C++11 static const bool is_signed = limits_type::is_signed; static const bool is_integer = limits_type::is_integer; static const bool is_exact = limits_type::is_exact; static const int radix = limits_type::radix; static MyOverflowingUnsigned epsilon() throw() { return limits_type::epsilon(); } static MyOverflowingUnsigned round_error() throw() {return limits_type::round_error();} static const int min_exponent = limits_type::min_exponent; static const int min_exponent10 = limits_type::min_exponent10; static const int max_exponent = limits_type::max_exponent; static const int max_exponent10 = limits_type::max_exponent10; static const bool has_infinity = limits_type::has_infinity; static const bool has_quiet_NaN = limits_type::has_quiet_NaN; static const bool has_signaling_NaN = limits_type::has_signaling_NaN; static const float_denorm_style has_denorm = limits_type::has_denorm; static const bool has_denorm_loss = limits_type::has_denorm_loss; static MyOverflowingUnsigned infinity() throw() { return limits_type::infinity(); } static MyOverflowingUnsigned quiet_NaN() throw() { return limits_type::quiet_NaN(); } static MyOverflowingUnsigned signaling_NaN() throw() { return limits_type::signaling_NaN(); } static MyOverflowingUnsigned denorm_min() throw() { return limits_type::denorm_min(); } static const bool is_iec559 = limits_type::is_iec559; static const bool is_bounded = limits_type::is_bounded; static const bool is_modulo = limits_type::is_modulo; static const bool traps = limits_type::traps; static const bool tinyness_before = limits_type::tinyness_before; static const float_round_style round_style = limits_type::round_style; }; // std::numeric_limits<MyOverflowingUnsigned> } // namespace std namespace { // This fixture replaces the check of rational's packing at the start of main. class rational_size_check { typedef INT_TYPE int_type; typedef ::boost::rational<int_type> rational_type; public: rational_size_check() { using ::std::cout; char const * const int_name = BOOST_PP_STRINGIZE( INT_TYPE ); cout << "Running tests for boost::rational<" << int_name << ">\n\n"; cout << "Implementation issue: the minimal size for a rational\n" << "is twice the size of the underlying integer type.\n\n"; cout << "Checking to see if space is being wasted.\n" << "\tsizeof(" << int_name << ") == " << sizeof( int_type ) << "\n"; cout << "\tsizeof(boost::rational<" << int_name << ">) == " << sizeof( rational_type ) << "\n\n"; cout << "Implementation has " << ( (sizeof( rational_type ) > 2u * sizeof( int_type )) ? "included padding bytes" : "minimal size" ) << "\n\n"; } }; // This fixture groups all the common settings. class my_configuration { public: template < typename T > class hook { public: typedef ::boost::rational<T> rational_type; private: struct parts { rational_type parts_[ 9 ]; }; static parts generate_rationals() { rational_type r1, r2( 0 ), r3( 1 ), r4( -3 ), r5( 7, 2 ), r6( 5, 15 ), r7( 14, -21 ), r8( -4, 6 ), r9( -14, -70 ); parts result; result.parts_[0] = r1; result.parts_[1] = r2; result.parts_[2] = r3; result.parts_[3] = r4; result.parts_[4] = r5; result.parts_[5] = r6; result.parts_[6] = r7; result.parts_[7] = r8; result.parts_[8] = r9; return result; } parts p_; // Order Dependency public: rational_type ( &r_ )[ 9 ]; // Order Dependency hook() : p_( generate_rationals() ), r_( p_.parts_ ) {} }; }; // Instead of controlling the integer type needed with a #define, use a list of // all available types. Since the headers #included don't change because of the // integer #define, only the built-in types and MyInt are available. (Any other // arbitrary integer type introduced by the #define would get compiler errors // because its header can't be #included.) typedef ::boost::mpl::list<short, int, long> builtin_signed_test_types; typedef ::boost::mpl::list<short, int, long, MyInt> all_signed_test_types; // Without these explicit instantiations, MSVC++ 6.5/7.0 does not find // some friend operators in certain contexts. ::boost::rational<short> dummy1; ::boost::rational<int> dummy2; ::boost::rational<long> dummy3; ::boost::rational<MyInt> dummy4; ::boost::rational<MyOverflowingUnsigned> dummy5; ::boost::rational<unsigned> dummy6; // Should there be regular tests with unsigned integer types? } // namespace // Check if rational is the smallest size possible BOOST_GLOBAL_FIXTURE( rational_size_check ); #if BOOST_CONTROL_RATIONAL_HAS_GCD // The factoring function template suite BOOST_AUTO_TEST_SUITE( factoring_suite ) // GCD tests BOOST_AUTO_TEST_CASE_TEMPLATE( gcd_test, T, all_signed_test_types ) { BOOST_CHECK_EQUAL( boost::gcd<T>( 1, -1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::gcd<T>( -1, 1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 1, 1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::gcd<T>( -1, -1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 0, 0), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 7, 0), static_cast<T>( 7) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 0, 9), static_cast<T>( 9) ); BOOST_CHECK_EQUAL( boost::gcd<T>( -7, 0), static_cast<T>( 7) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 0, -9), static_cast<T>( 9) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 42, 30), static_cast<T>( 6) ); BOOST_CHECK_EQUAL( boost::gcd<T>( 6, -9), static_cast<T>( 3) ); BOOST_CHECK_EQUAL( boost::gcd<T>(-10, -10), static_cast<T>(10) ); BOOST_CHECK_EQUAL( boost::gcd<T>(-25, -10), static_cast<T>( 5) ); } // LCM tests BOOST_AUTO_TEST_CASE_TEMPLATE( lcm_test, T, all_signed_test_types ) { BOOST_CHECK_EQUAL( boost::lcm<T>( 1, -1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::lcm<T>( -1, 1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 1, 1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::lcm<T>( -1, -1), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 0, 0), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 6, 0), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 0, 7), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( boost::lcm<T>( -5, 0), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 0, -4), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 18, 30), static_cast<T>(90) ); BOOST_CHECK_EQUAL( boost::lcm<T>( -6, 9), static_cast<T>(18) ); BOOST_CHECK_EQUAL( boost::lcm<T>(-10, -10), static_cast<T>(10) ); BOOST_CHECK_EQUAL( boost::lcm<T>( 25, -10), static_cast<T>(50) ); } BOOST_AUTO_TEST_SUITE_END() #endif // BOOST_CONTROL_RATIONAL_HAS_GCD // The basic test suite BOOST_FIXTURE_TEST_SUITE( basic_rational_suite, my_configuration ) // Initialization tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_initialization_test, T, all_signed_test_types ) { my_configuration::hook<T> h; boost::rational<T> &r1 = h.r_[ 0 ], &r2 = h.r_[ 1 ], &r3 = h.r_[ 2 ], &r4 = h.r_[ 3 ], &r5 = h.r_[ 4 ], &r6 = h.r_[ 5 ], &r7 = h.r_[ 6 ], &r8 = h.r_[ 7 ], &r9 = h.r_[ 8 ]; BOOST_CHECK_EQUAL( r1.numerator(), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( r2.numerator(), static_cast<T>( 0) ); BOOST_CHECK_EQUAL( r3.numerator(), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( r4.numerator(), static_cast<T>(-3) ); BOOST_CHECK_EQUAL( r5.numerator(), static_cast<T>( 7) ); BOOST_CHECK_EQUAL( r6.numerator(), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( r7.numerator(), static_cast<T>(-2) ); BOOST_CHECK_EQUAL( r8.numerator(), static_cast<T>(-2) ); BOOST_CHECK_EQUAL( r9.numerator(), static_cast<T>( 1) ); BOOST_CHECK_EQUAL( r1.denominator(), static_cast<T>(1) ); BOOST_CHECK_EQUAL( r2.denominator(), static_cast<T>(1) ); BOOST_CHECK_EQUAL( r3.denominator(), static_cast<T>(1) ); BOOST_CHECK_EQUAL( r4.denominator(), static_cast<T>(1) ); BOOST_CHECK_EQUAL( r5.denominator(), static_cast<T>(2) ); BOOST_CHECK_EQUAL( r6.denominator(), static_cast<T>(3) ); BOOST_CHECK_EQUAL( r7.denominator(), static_cast<T>(3) ); BOOST_CHECK_EQUAL( r8.denominator(), static_cast<T>(3) ); BOOST_CHECK_EQUAL( r9.denominator(), static_cast<T>(5) ); BOOST_CHECK_THROW( boost::rational<T>( 3, 0), boost::bad_rational ); BOOST_CHECK_THROW( boost::rational<T>(-2, 0), boost::bad_rational ); BOOST_CHECK_THROW( boost::rational<T>( 0, 0), boost::bad_rational ); } // Assignment (non-operator) tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_assign_test, T, all_signed_test_types ) { my_configuration::hook<T> h; boost::rational<T> & r = h.r_[ 0 ]; r.assign( 6, 8 ); BOOST_CHECK_EQUAL( r.numerator(), static_cast<T>(3) ); BOOST_CHECK_EQUAL( r.denominator(), static_cast<T>(4) ); r.assign( 0, -7 ); BOOST_CHECK_EQUAL( r.numerator(), static_cast<T>(0) ); BOOST_CHECK_EQUAL( r.denominator(), static_cast<T>(1) ); BOOST_CHECK_THROW( r.assign( 4, 0), boost::bad_rational ); BOOST_CHECK_THROW( r.assign( 0, 0), boost::bad_rational ); BOOST_CHECK_THROW( r.assign(-7, 0), boost::bad_rational ); } // Comparison tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_comparison_test, T, all_signed_test_types ) { my_configuration::hook<T> h; const boost::rational<T> &r1 = h.r_[ 0 ], &r2 = h.r_[ 1 ], &r3 = h.r_[ 2 ], &r4 = h.r_[ 3 ], &r5 = h.r_[ 4 ], &r6 = h.r_[ 5 ], &r7 = h.r_[ 6 ], &r8 = h.r_[ 7 ], &r9 = h.r_[ 8 ]; BOOST_CHECK( r1 == r2 ); BOOST_CHECK( r2 != r3 ); BOOST_CHECK( r4 < r3 ); BOOST_CHECK( r4 <= r5 ); BOOST_CHECK( r1 <= r2 ); BOOST_CHECK( r5 > r6 ); BOOST_CHECK( r5 >= r6 ); BOOST_CHECK( r7 >= r8 ); BOOST_CHECK( !(r3 == r2) ); BOOST_CHECK( !(r1 != r2) ); BOOST_CHECK( !(r1 < r2) ); BOOST_CHECK( !(r5 < r6) ); BOOST_CHECK( !(r9 <= r2) ); BOOST_CHECK( !(r8 > r7) ); BOOST_CHECK( !(r8 > r2) ); BOOST_CHECK( !(r4 >= r6) ); BOOST_CHECK( r1 == static_cast<T>( 0) ); BOOST_CHECK( r2 != static_cast<T>(-1) ); BOOST_CHECK( r3 < static_cast<T>( 2) ); BOOST_CHECK( r4 <= static_cast<T>(-3) ); BOOST_CHECK( r5 > static_cast<T>( 3) ); BOOST_CHECK( r6 >= static_cast<T>( 0) ); BOOST_CHECK( static_cast<T>( 0) == r2 ); BOOST_CHECK( static_cast<T>( 0) != r7 ); BOOST_CHECK( static_cast<T>(-1) < r8 ); BOOST_CHECK( static_cast<T>(-2) <= r9 ); BOOST_CHECK( static_cast<T>( 1) > r1 ); BOOST_CHECK( static_cast<T>( 1) >= r3 ); // Extra tests with values close in continued-fraction notation boost::rational<T> const x1( static_cast<T>(9), static_cast<T>(4) ); boost::rational<T> const x2( static_cast<T>(61), static_cast<T>(27) ); boost::rational<T> const x3( static_cast<T>(52), static_cast<T>(23) ); boost::rational<T> const x4( static_cast<T>(70), static_cast<T>(31) ); BOOST_CHECK( x1 < x2 ); BOOST_CHECK( !(x1 < x1) ); BOOST_CHECK( !(x2 < x2) ); BOOST_CHECK( !(x2 < x1) ); BOOST_CHECK( x2 < x3 ); BOOST_CHECK( x4 < x2 ); BOOST_CHECK( !(x3 < x4) ); BOOST_CHECK( r7 < x1 ); // not actually close; wanted -ve v. +ve instead BOOST_CHECK( !(x2 < r7) ); } // Increment & decrement tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_1step_test, T, all_signed_test_types ) { my_configuration::hook<T> h; boost::rational<T> &r1 = h.r_[ 0 ], &r2 = h.r_[ 1 ], &r3 = h.r_[ 2 ], &r7 = h.r_[ 6 ], &r8 = h.r_[ 7 ]; BOOST_CHECK( r1++ == r2 ); BOOST_CHECK( r1 != r2 ); BOOST_CHECK( r1 == r3 ); BOOST_CHECK( --r1 == r2 ); BOOST_CHECK( r8-- == r7 ); BOOST_CHECK( r8 != r7 ); BOOST_CHECK( ++r8 == r7 ); } // Absolute value tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_abs_test, T, all_signed_test_types ) { typedef my_configuration::hook<T> hook_type; typedef typename hook_type::rational_type rational_type; hook_type h; rational_type &r2 = h.r_[ 1 ], &r5 = h.r_[ 4 ], &r8 = h.r_[ 7 ]; #ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP // This is a nasty hack, required because some compilers do not implement // "Koenig Lookup." Basically, if I call abs(r), the C++ standard says that // the compiler should look for a definition of abs in the namespace which // contains r's class (in this case boost)--among other places. using boost::abs; #endif BOOST_CHECK_EQUAL( abs(r2), r2 ); BOOST_CHECK_EQUAL( abs(r5), r5 ); BOOST_CHECK_EQUAL( abs(r8), rational_type(2, 3) ); } // Unary operator tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_unary_test, T, all_signed_test_types ) { my_configuration::hook<T> h; boost::rational<T> &r2 = h.r_[ 1 ], &r3 = h.r_[ 2 ], &r4 = h.r_[ 3 ], &r5 = h.r_[ 4 ]; BOOST_CHECK_EQUAL( +r5, r5 ); BOOST_CHECK( -r3 != r3 ); BOOST_CHECK_EQUAL( -(-r3), r3 ); BOOST_CHECK_EQUAL( -r4, static_cast<T>(3) ); BOOST_CHECK( !r2 ); BOOST_CHECK( !!r3 ); BOOST_CHECK( ! static_cast<bool>(r2) ); BOOST_CHECK( r3 ); } BOOST_AUTO_TEST_SUITE_END() // The rational arithmetic operations suite BOOST_AUTO_TEST_SUITE( rational_arithmetic_suite ) // Addition & subtraction tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_additive_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; BOOST_CHECK_EQUAL( rational_type( 1, 2) + rational_type(1, 2), static_cast<T>(1) ); BOOST_CHECK_EQUAL( rational_type(11, 3) + rational_type(1, 2), rational_type( 25, 6) ); BOOST_CHECK_EQUAL( rational_type(-8, 3) + rational_type(1, 5), rational_type(-37, 15) ); BOOST_CHECK_EQUAL( rational_type(-7, 6) + rational_type(1, 7), rational_type( 1, 7) - rational_type(7, 6) ); BOOST_CHECK_EQUAL( rational_type(13, 5) - rational_type(1, 2), rational_type( 21, 10) ); BOOST_CHECK_EQUAL( rational_type(22, 3) + static_cast<T>(1), rational_type( 25, 3) ); BOOST_CHECK_EQUAL( rational_type(12, 7) - static_cast<T>(2), rational_type( -2, 7) ); BOOST_CHECK_EQUAL( static_cast<T>(3) + rational_type(4, 5), rational_type( 19, 5) ); BOOST_CHECK_EQUAL( static_cast<T>(4) - rational_type(9, 2), rational_type( -1, 2) ); rational_type r( 11 ); r -= rational_type( 20, 3 ); BOOST_CHECK_EQUAL( r, rational_type(13, 3) ); r += rational_type( 1, 2 ); BOOST_CHECK_EQUAL( r, rational_type(29, 6) ); r -= static_cast<T>( 5 ); BOOST_CHECK_EQUAL( r, rational_type( 1, -6) ); r += rational_type( 1, 5 ); BOOST_CHECK_EQUAL( r, rational_type( 1, 30) ); r += static_cast<T>( 2 ); BOOST_CHECK_EQUAL( r, rational_type(61, 30) ); } // Assignment tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_assignment_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; rational_type r; r = rational_type( 1, 10 ); BOOST_CHECK_EQUAL( r, rational_type( 1, 10) ); r = static_cast<T>( -9 ); BOOST_CHECK_EQUAL( r, rational_type(-9, 1) ); } // Multiplication tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_multiplication_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; BOOST_CHECK_EQUAL( rational_type(1, 3) * rational_type(-3, 4), rational_type(-1, 4) ); BOOST_CHECK_EQUAL( rational_type(2, 5) * static_cast<T>(7), rational_type(14, 5) ); BOOST_CHECK_EQUAL( static_cast<T>(-2) * rational_type(1, 6), rational_type(-1, 3) ); rational_type r = rational_type( 3, 7 ); r *= static_cast<T>( 14 ); BOOST_CHECK_EQUAL( r, static_cast<T>(6) ); r *= rational_type( 3, 8 ); BOOST_CHECK_EQUAL( r, rational_type(9, 4) ); } // Division tests BOOST_AUTO_TEST_CASE_TEMPLATE( rational_division_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; BOOST_CHECK_EQUAL( rational_type(-1, 20) / rational_type(4, 5), rational_type(-1, 16) ); BOOST_CHECK_EQUAL( rational_type( 5, 6) / static_cast<T>(7), rational_type( 5, 42) ); BOOST_CHECK_EQUAL( static_cast<T>(8) / rational_type(2, 7), static_cast<T>(28) ); BOOST_CHECK_THROW( rational_type(23, 17) / rational_type(), boost::bad_rational ); BOOST_CHECK_THROW( rational_type( 4, 15) / static_cast<T>(0), boost::bad_rational ); rational_type r = rational_type( 4, 3 ); r /= rational_type( 5, 4 ); BOOST_CHECK_EQUAL( r, rational_type(16, 15) ); r /= static_cast<T>( 4 ); BOOST_CHECK_EQUAL( r, rational_type( 4, 15) ); BOOST_CHECK_THROW( r /= rational_type(), boost::bad_rational ); BOOST_CHECK_THROW( r /= static_cast<T>(0), boost::bad_rational ); BOOST_CHECK_EQUAL( rational_type(-1) / rational_type(-3), rational_type(1, 3) ); } // Tests for operations on self BOOST_AUTO_TEST_CASE_TEMPLATE( rational_self_operations_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; rational_type r = rational_type( 4, 3 ); r += r; BOOST_CHECK_EQUAL( r, rational_type( 8, 3) ); r *= r; BOOST_CHECK_EQUAL( r, rational_type(64, 9) ); r /= r; BOOST_CHECK_EQUAL( r, rational_type( 1, 1) ); r -= r; BOOST_CHECK_EQUAL( r, rational_type( 0, 1) ); BOOST_CHECK_THROW( r /= r, boost::bad_rational ); } BOOST_AUTO_TEST_CASE_TEMPLATE( gcd_and_lcm_on_rationals, T, all_signed_test_types ) { typedef boost::rational<T> rational; BOOST_CHECK_EQUAL(boost::integer::gcd(rational(1, 4), rational(1, 3)), rational(1, 12)); BOOST_CHECK_EQUAL(boost::integer::lcm(rational(1, 4), rational(1, 3)), rational(1)); } // Assignment tests BOOST_AUTO_TEST_CASE_TEMPLATE(rational_mixed_test, T, /*all_signed_test_types*/ builtin_signed_test_types) { { typedef boost::rational<boost::intmax_t> rational_type; T val1 = 20; boost::intmax_t val2 = 30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); } { typedef boost::rational<boost::uintmax_t> rational_type2; T val1 = 20; boost::uintmax_t val3 = 30; rational_type2 r2(val1, val3); BOOST_CHECK_EQUAL(r2, rational_type2(20, 30)); r2.assign(val1, val3); BOOST_CHECK_EQUAL(r2, rational_type2(20, 30)); } { typedef boost::rational<short> rational_type; T val1 = 20; short val2 = 30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); } { typedef boost::rational<unsigned short> rational_type; T val1 = 20; unsigned short val2 = 30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); } { typedef boost::rational<long> rational_type; T val1 = 20; long val2 = 30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); } { typedef boost::rational<unsigned long> rational_type; T val1 = 20; unsigned long val2 = 30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, 30)); } { typedef boost::rational<boost::intmax_t> rational_type; T val1 = 20; boost::intmax_t val2 = -30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, -30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(20, -30)); } { typedef boost::rational<short> rational_type; T val1 = -20; short val2 = -30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(-20, -30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(-20, -30)); } { typedef boost::rational<long> rational_type; T val1 = -20; long val2 = 30; rational_type r(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(-20, 30)); r.assign(val1, val2); BOOST_CHECK_EQUAL(r, rational_type(-20, 30)); } } BOOST_AUTO_TEST_CASE(conversions) { typedef boost::rational<boost::int32_t> signed_rat; boost::int32_t signed_max = (std::numeric_limits<boost::int32_t>::max)(); boost::int32_t signed_min = (std::numeric_limits<boost::int32_t>::min)(); boost::int32_t signed_min_num = signed_min + 1; BOOST_CHECK_EQUAL(signed_rat(signed_max).numerator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(signed_min).numerator(), signed_min); BOOST_CHECK_EQUAL(signed_rat(signed_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(signed_min, 1).numerator(), signed_min); BOOST_CHECK_EQUAL(signed_rat(1, signed_max).denominator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(1, signed_min_num).denominator(), -signed_min_num); // This throws because we can't negate signed_min: BOOST_CHECK_THROW(signed_rat(1, signed_min).denominator(), std::domain_error); signed_rat sr; BOOST_CHECK_EQUAL(sr.assign(signed_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(sr.assign(1, signed_max).denominator(), signed_max); BOOST_CHECK_EQUAL(sr.assign(signed_min, 1).numerator(), signed_min); BOOST_CHECK_EQUAL(sr.assign(1, signed_min_num).denominator(), -signed_min_num); BOOST_CHECK_THROW(sr.assign(1, signed_min), std::domain_error); BOOST_CHECK_EQUAL((sr = signed_max).numerator(), signed_max); BOOST_CHECK_EQUAL((sr = signed_min).numerator(), signed_min); boost::int64_t big_signed_max = (std::numeric_limits<boost::int32_t>::max)(); boost::int64_t big_signed_min = (std::numeric_limits<boost::int32_t>::min)(); boost::int64_t big_signed_min_num = signed_min + 1; BOOST_CHECK_EQUAL(signed_rat(big_signed_max).numerator(), big_signed_max); BOOST_CHECK_EQUAL(signed_rat(big_signed_min).numerator(), big_signed_min); BOOST_CHECK_EQUAL(signed_rat(big_signed_max, 1).numerator(), big_signed_max); BOOST_CHECK_EQUAL(signed_rat(big_signed_min, 1).numerator(), big_signed_min); BOOST_CHECK_EQUAL(signed_rat(1, big_signed_max).denominator(), big_signed_max); BOOST_CHECK_EQUAL(signed_rat(1, big_signed_min_num).denominator(), -big_signed_min_num); // This throws because we can't negate big_signed_min: BOOST_CHECK_THROW(signed_rat(1, big_signed_min).denominator(), std::domain_error); BOOST_CHECK_EQUAL(sr.assign(big_signed_max, 1).numerator(), big_signed_max); BOOST_CHECK_EQUAL(sr.assign(1, big_signed_max).denominator(), big_signed_max); BOOST_CHECK_EQUAL(sr.assign(big_signed_min, 1).numerator(), big_signed_min); BOOST_CHECK_EQUAL(sr.assign(1, big_signed_min_num).denominator(), -big_signed_min_num); BOOST_CHECK_THROW(sr.assign(1, big_signed_min), std::domain_error); BOOST_CHECK_EQUAL((sr = big_signed_max).numerator(), big_signed_max); BOOST_CHECK_EQUAL((sr = big_signed_min).numerator(), big_signed_min); ++big_signed_max; --big_signed_min; BOOST_CHECK_THROW(signed_rat(big_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(big_signed_min).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(big_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(big_signed_min, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(1, big_signed_max).denominator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(big_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(1, big_signed_max).denominator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(big_signed_min, 1).numerator(), std::domain_error); BOOST_CHECK_THROW((sr = big_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW((sr = big_signed_min).numerator(), std::domain_error); boost::int16_t small_signed_max = (std::numeric_limits<boost::int16_t>::max)(); boost::int16_t small_signed_min = (std::numeric_limits<boost::int16_t>::min)(); BOOST_CHECK_EQUAL(signed_rat(small_signed_max).numerator(), small_signed_max); BOOST_CHECK_EQUAL(signed_rat(small_signed_min).numerator(), small_signed_min); BOOST_CHECK_EQUAL(signed_rat(small_signed_max, 1).numerator(), small_signed_max); BOOST_CHECK_EQUAL(signed_rat(small_signed_min, 1).numerator(), small_signed_min); BOOST_CHECK_EQUAL(signed_rat(1, small_signed_max).denominator(), small_signed_max); BOOST_CHECK_EQUAL(signed_rat(1, small_signed_min).denominator(), -static_cast<boost::int32_t>(small_signed_min)); BOOST_CHECK_EQUAL(sr.assign(small_signed_max, 1).numerator(), small_signed_max); BOOST_CHECK_EQUAL(sr.assign(1, small_signed_max).denominator(), small_signed_max); BOOST_CHECK_EQUAL(sr.assign(small_signed_min, 1).numerator(), small_signed_min); BOOST_CHECK_EQUAL(sr.assign(1, small_signed_min).denominator(), -static_cast<boost::int32_t>(small_signed_min)); BOOST_CHECK_EQUAL((sr = small_signed_max).numerator(), small_signed_max); BOOST_CHECK_EQUAL((sr = small_signed_min).numerator(), small_signed_min); boost::uint32_t unsigned_max = signed_max; BOOST_CHECK_EQUAL(signed_rat(unsigned_max).numerator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(unsigned_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(1, unsigned_max).denominator(), signed_max); BOOST_CHECK_EQUAL(sr.assign(unsigned_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(sr.assign(1, unsigned_max).denominator(), signed_max); BOOST_CHECK_EQUAL((sr = unsigned_max).numerator(), signed_max); ++unsigned_max; BOOST_CHECK_THROW(signed_rat(unsigned_max).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(unsigned_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(1, unsigned_max).denominator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(unsigned_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(1, unsigned_max).denominator(), std::domain_error); BOOST_CHECK_THROW((sr = unsigned_max).numerator(), std::domain_error); boost::uint64_t big_unsigned_max = signed_max; BOOST_CHECK_EQUAL(signed_rat(big_unsigned_max).numerator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(big_unsigned_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(signed_rat(1, big_unsigned_max).denominator(), signed_max); BOOST_CHECK_EQUAL(sr.assign(big_unsigned_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(sr.assign(1, big_unsigned_max).denominator(), signed_max); BOOST_CHECK_EQUAL((sr = big_unsigned_max).numerator(), signed_max); ++big_unsigned_max; BOOST_CHECK_THROW(signed_rat(big_unsigned_max).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(big_unsigned_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(signed_rat(1, big_unsigned_max).denominator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(big_unsigned_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(sr.assign(1, big_unsigned_max).denominator(), std::domain_error); BOOST_CHECK_THROW((sr = big_unsigned_max).numerator(), std::domain_error); boost::uint16_t small_unsigned_max = signed_max; BOOST_CHECK_EQUAL(signed_rat(small_unsigned_max).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(signed_rat(small_unsigned_max, 1).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(signed_rat(1, small_unsigned_max).denominator(), small_unsigned_max); BOOST_CHECK_EQUAL(sr.assign(small_unsigned_max, 1).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(sr.assign(1, small_unsigned_max).denominator(), small_unsigned_max); BOOST_CHECK_EQUAL((sr = small_unsigned_max).numerator(), small_unsigned_max); // Over again with unsigned rational type: typedef boost::rational<boost::uint32_t> unsigned_rat; unsigned_max = (std::numeric_limits<boost::uint32_t>::max)(); BOOST_CHECK_EQUAL(unsigned_rat(unsigned_max).numerator(), unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(unsigned_max, 1).numerator(), unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(1, unsigned_max).denominator(), unsigned_max); unsigned_rat ur; BOOST_CHECK_EQUAL((ur = unsigned_max).numerator(), unsigned_max); BOOST_CHECK_EQUAL(ur.assign(unsigned_max, 1).numerator(), unsigned_max); BOOST_CHECK_EQUAL(ur.assign(1, unsigned_max).denominator(), unsigned_max); big_unsigned_max = unsigned_max; BOOST_CHECK_EQUAL(unsigned_rat(big_unsigned_max).numerator(), big_unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(big_unsigned_max, 1).numerator(), big_unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(1, big_unsigned_max).denominator(), big_unsigned_max); BOOST_CHECK_EQUAL((ur = big_unsigned_max).numerator(), big_unsigned_max); BOOST_CHECK_EQUAL(ur.assign(big_unsigned_max, 1).numerator(), big_unsigned_max); BOOST_CHECK_EQUAL(ur.assign(1, big_unsigned_max).denominator(), big_unsigned_max); ++big_unsigned_max; BOOST_CHECK_THROW(unsigned_rat(big_unsigned_max).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(big_unsigned_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(1, big_unsigned_max).denominator(), std::domain_error); BOOST_CHECK_THROW((ur = big_unsigned_max).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(big_unsigned_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(1, big_unsigned_max).denominator(), std::domain_error); BOOST_CHECK_EQUAL(unsigned_rat(small_unsigned_max).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(small_unsigned_max, 1).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(1, small_unsigned_max).denominator(), small_unsigned_max); BOOST_CHECK_EQUAL((ur = small_unsigned_max).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(ur.assign(small_unsigned_max, 1).numerator(), small_unsigned_max); BOOST_CHECK_EQUAL(ur.assign(1, small_unsigned_max).denominator(), small_unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(signed_max).numerator(), signed_max); BOOST_CHECK_EQUAL(unsigned_rat(signed_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(unsigned_rat(1, signed_max).denominator(), signed_max); BOOST_CHECK_EQUAL((ur = signed_max).numerator(), signed_max); BOOST_CHECK_EQUAL(ur.assign(signed_max, 1).numerator(), signed_max); BOOST_CHECK_EQUAL(ur.assign(1, signed_max).denominator(), signed_max); BOOST_CHECK_THROW(unsigned_rat(signed_min).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(signed_min, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(1, signed_min).denominator(), std::domain_error); BOOST_CHECK_THROW((ur = signed_min).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(signed_min, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(1, signed_min).denominator(), std::domain_error); big_signed_max = unsigned_max; BOOST_CHECK_EQUAL(unsigned_rat(big_signed_max).numerator(), unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(big_signed_max, 1).numerator(), unsigned_max); BOOST_CHECK_EQUAL(unsigned_rat(1, big_signed_max).denominator(), unsigned_max); BOOST_CHECK_EQUAL((ur = big_signed_max).numerator(), unsigned_max); BOOST_CHECK_EQUAL(ur.assign(big_signed_max, 1).numerator(), unsigned_max); BOOST_CHECK_EQUAL(ur.assign(1, big_signed_max).denominator(), unsigned_max); ++big_signed_max; BOOST_CHECK_THROW(unsigned_rat(big_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(big_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(1, big_signed_max).denominator(), std::domain_error); BOOST_CHECK_THROW((ur = big_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(big_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(1, big_signed_max).denominator(), std::domain_error); big_signed_max = -1; BOOST_CHECK_THROW(unsigned_rat(big_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(big_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(1, big_signed_max).denominator(), std::domain_error); BOOST_CHECK_THROW((ur = big_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(big_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(1, big_signed_max).denominator(), std::domain_error); BOOST_CHECK_EQUAL(unsigned_rat(small_signed_max).numerator(), small_signed_max); BOOST_CHECK_EQUAL(unsigned_rat(small_signed_max, 1).numerator(), small_signed_max); BOOST_CHECK_EQUAL(unsigned_rat(1, small_signed_max).denominator(), small_signed_max); BOOST_CHECK_EQUAL((ur = small_signed_max).numerator(), small_signed_max); BOOST_CHECK_EQUAL(ur.assign(small_signed_max, 1).numerator(), small_signed_max); BOOST_CHECK_EQUAL(ur.assign(1, small_signed_max).denominator(), small_signed_max); small_signed_max = -1; BOOST_CHECK_THROW(unsigned_rat(small_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(small_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(unsigned_rat(1, small_signed_max).denominator(), std::domain_error); BOOST_CHECK_THROW((ur = small_signed_max).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(small_signed_max, 1).numerator(), std::domain_error); BOOST_CHECK_THROW(ur.assign(1, small_signed_max).denominator(), std::domain_error); } BOOST_AUTO_TEST_SUITE_END() // The non-basic rational operations suite BOOST_AUTO_TEST_SUITE( rational_extras_suite ) #ifndef BOOST_NO_IOSTREAM // Output test BOOST_AUTO_TEST_CASE_TEMPLATE( rational_output_test, T, all_signed_test_types ) { using namespace std; typedef boost::rational<T> rational_type; // Basic test ostringstream oss; oss << rational_type( 44, 14 ); BOOST_CHECK_EQUAL( oss.str(), "22/7" ); // Width oss.clear(); oss.str( "" ); oss << setw( 5 ) << setfill('*') << rational_type( 1, 2 ) << 'r'; BOOST_CHECK_EQUAL( oss.str(), "**1/2r" ); // not "****1/2r" // Positive-sign oss.clear(); oss.str( "" ); oss << showpos << rational_type( 2, 3 ) << noshowpos; BOOST_CHECK_EQUAL( oss.str(), "+2/3" ); // not "+2/+3" // Internal padding oss.clear(); oss.str( "" ); oss << setw( 8 ) << internal << rational_type( 36, -15 ) << right << 'r'; BOOST_CHECK_EQUAL( oss.str(), "-***12/5r" ); // not "-*****12/5r" // Showbase prefix oss.clear(); oss.str( "" ); oss << showbase << hex << rational_type( 34, 987 ) << noshowbase << dec; BOOST_CHECK_EQUAL( oss.str(), "0x22/3db" ); // not "0x22/0x3db" } // Input test, failing BOOST_AUTO_TEST_CASE_TEMPLATE( rational_input_failing_test, T, all_signed_test_types ) { std::istringstream iss( "" ); boost::rational<T> r; iss >> r; BOOST_CHECK( !iss ); BOOST_CHECK( !iss.bad() ); iss.clear(); iss.str( "42" ); iss >> r; BOOST_CHECK( !iss ); iss.clear(); iss.str( "57A" ); iss >> r; BOOST_CHECK( !iss ); iss.clear(); iss.str( "20-20" ); iss >> r; BOOST_CHECK( !iss ); iss.clear(); iss.str( "1/" ); iss >> r; BOOST_CHECK( !iss ); iss.clear(); iss.str( "1/ 2" ); iss >> r; BOOST_CHECK( !iss ); iss.clear(); iss.str( "1 /2" ); iss >> r; BOOST_CHECK( !iss ); // Illegal value check(s) typedef std::numeric_limits<T> limits_type; iss.clear(); iss.str( "3/0" ); iss >> r; BOOST_CHECK( !iss ); if ( limits_type::is_signed && limits_type::is_bounded && limits_type::min BOOST_PREVENT_MACRO_SUBSTITUTION () + limits_type::max BOOST_PREVENT_MACRO_SUBSTITUTION () < T(0) ) { std::ostringstream oss; oss << 1 << '/' << limits_type::min BOOST_PREVENT_MACRO_SUBSTITUTION (); iss.clear(); iss.str( oss.str() ); iss.exceptions( std::ios::failbit ); BOOST_CHECK( iss.good() ); BOOST_CHECK_THROW( iss >> r, boost::bad_rational ); BOOST_CHECK( iss.fail() && !iss.bad() ); iss.exceptions( std::ios::goodbit ); } } // Input test, passing BOOST_AUTO_TEST_CASE_TEMPLATE( rational_input_passing_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; std::istringstream iss( "1/2 12" ); rational_type r; int n = 0; BOOST_CHECK( iss >> r >> n ); BOOST_CHECK_EQUAL( r, rational_type(1, 2) ); BOOST_CHECK_EQUAL( n, 12 ); iss.clear(); iss.str( "34/67" ); BOOST_CHECK( iss >> r ); BOOST_CHECK_EQUAL( r, rational_type(34, 67) ); iss.clear(); iss.str( "-3/-6" ); BOOST_CHECK( iss >> r ); BOOST_CHECK_EQUAL( r, rational_type(1, 2) ); } #endif // BOOST_NO_IOSTREAM // Conversion test BOOST_AUTO_TEST_CASE( rational_cast_test ) { // Note that these are not generic. The problem is that rational_cast<T> // requires a conversion from IntType to T. However, for a user-defined // IntType, it is not possible to define such a conversion except as an // "operator T()". This causes problems with overloading resolution. boost::rational<int> const half( 1, 2 ); BOOST_CHECK_CLOSE( boost::rational_cast<double>(half), 0.5, 0.01 ); BOOST_CHECK_EQUAL( boost::rational_cast<int>(half), 0 ); BOOST_CHECK_EQUAL( boost::rational_cast<MyInt>(half), MyInt() ); BOOST_CHECK_EQUAL( boost::rational_cast<boost::rational<MyInt> >(half), boost::rational<MyInt>(1, 2) ); // Conversions via explicit-marked constructors // (Note that the "explicit" mark prevents conversion to // boost::rational<MyOverflowingUnsigned>.) boost::rational<MyInt> const threehalves( 3, 2 ); BOOST_CHECK_EQUAL( boost::rational_cast<MyOverflowingUnsigned>(threehalves), MyOverflowingUnsigned(1u) ); // // Converting constructor should throw if a bad rational number results: // BOOST_CHECK_THROW(boost::rational<short>(boost::rational<long>(1, 1 << sizeof(short) * CHAR_BIT)), boost::bad_rational); // // New tests from checked narrowing conversions: // BOOST_CHECK_THROW(boost::rational<unsigned>(-1), boost::bad_rational); BOOST_CHECK_THROW(boost::rational<unsigned>(-1, 1), boost::bad_rational); BOOST_CHECK_THROW(boost::rational<unsigned>(1, -1), boost::bad_rational); unsigned ui_max = (std::numeric_limits<unsigned>::max)(); BOOST_CHECK_THROW(boost::rational<int>(static_cast<unsigned>(ui_max)), boost::bad_rational); BOOST_CHECK_THROW(boost::rational<int>(ui_max, 1u), boost::bad_rational); BOOST_CHECK_THROW(boost::rational<int>(1u, ui_max), boost::bad_rational); // // Check assignments that should succeed from both wider and narrower types: // boost::rational<boost::int32_t> rat; #ifndef BOOST_NO_INT64_T boost::int64_t ll, ll1(1); boost::uint64_t ull, ull1(1); boost::int32_t imax = (std::numeric_limits<boost::int32_t>::max)(); boost::int32_t imin = (std::numeric_limits<boost::int32_t>::min)(); ll = imax; rat.assign(ll, ll1); BOOST_CHECK_EQUAL(rat.numerator(), imax); BOOST_CHECK_EQUAL(rat.denominator(), 1); ++ll; BOOST_CHECK_THROW(rat.assign(ll, ll1), boost::bad_rational); ll = imin; rat.assign(ll, ll1); BOOST_CHECK_EQUAL(rat.numerator(), imin); BOOST_CHECK_EQUAL(rat.denominator(), 1); --ll; BOOST_CHECK_THROW(rat.assign(ll, ll1), boost::bad_rational); ull = imax; rat.assign(ull, ull1); BOOST_CHECK_EQUAL(rat.numerator(), imax); BOOST_CHECK_EQUAL(rat.denominator(), 1); ++ull; BOOST_CHECK_THROW(rat.assign(ull, ull1), boost::bad_rational); ull = 0; rat.assign(ull, ull1); BOOST_CHECK_EQUAL(rat.numerator(), 0); BOOST_CHECK_EQUAL(rat.denominator(), 1); #endif boost::int16_t smax = (std::numeric_limits<boost::int16_t>::max)(); boost::int16_t smin = (std::numeric_limits<boost::int16_t>::min)(); boost::int16_t s1 = 1; rat.assign(smax, s1); BOOST_CHECK_EQUAL(rat.numerator(), smax); BOOST_CHECK_EQUAL(rat.denominator(), 1); rat.assign(smin, s1); BOOST_CHECK_EQUAL(rat.numerator(), smin); BOOST_CHECK_EQUAL(rat.denominator(), 1); boost::uint16_t usmax = (std::numeric_limits<boost::uint16_t>::max)(); boost::uint16_t usmin = (std::numeric_limits<boost::uint16_t>::min)(); boost::uint16_t us1 = 1; rat.assign(usmax, us1); BOOST_CHECK_EQUAL(rat.numerator(), usmax); BOOST_CHECK_EQUAL(rat.denominator(), 1); rat.assign(usmin, us1); BOOST_CHECK_EQUAL(rat.numerator(), usmin); BOOST_CHECK_EQUAL(rat.denominator(), 1); // // Over again with unsigned rational: // boost::rational<boost::uint32_t> urat; unsigned uimax = (std::numeric_limits<boost::uint32_t>::max)(); unsigned uimin = (std::numeric_limits<boost::uint32_t>::min)(); #ifndef BOOST_NO_INT64_T ll = uimax; urat.assign(ll, ll1); BOOST_CHECK_EQUAL(urat.numerator(), uimax); BOOST_CHECK_EQUAL(urat.denominator(), 1); ++ll; BOOST_CHECK_THROW(urat.assign(ll, ll1), boost::bad_rational); ll = uimin; urat.assign(ll, ll1); BOOST_CHECK_EQUAL(urat.numerator(), uimin); BOOST_CHECK_EQUAL(urat.denominator(), 1); --ll; BOOST_CHECK_THROW(urat.assign(ll, ll1), boost::bad_rational); ull = uimax; urat.assign(ull, ull1); BOOST_CHECK_EQUAL(urat.numerator(), uimax); BOOST_CHECK_EQUAL(urat.denominator(), 1); ++ull; BOOST_CHECK_THROW(urat.assign(ull, ull1), boost::bad_rational); ull = 0; urat.assign(ull, ull1); BOOST_CHECK_EQUAL(urat.numerator(), 0); BOOST_CHECK_EQUAL(urat.denominator(), 1); #endif smin = 0; s1 = 1; urat.assign(smax, s1); BOOST_CHECK_EQUAL(urat.numerator(), smax); BOOST_CHECK_EQUAL(urat.denominator(), 1); urat.assign(smin, s1); BOOST_CHECK_EQUAL(urat.numerator(), smin); BOOST_CHECK_EQUAL(urat.denominator(), 1); urat.assign(usmax, us1); BOOST_CHECK_EQUAL(urat.numerator(), usmax); BOOST_CHECK_EQUAL(urat.denominator(), 1); urat.assign(usmin, us1); BOOST_CHECK_EQUAL(urat.numerator(), usmin); BOOST_CHECK_EQUAL(urat.denominator(), 1); // // Conversions that must not be allowed: // BOOST_STATIC_ASSERT(!boost::is_convertible<float, boost::rational<int> >::value); BOOST_STATIC_ASSERT(!boost::is_convertible<double, boost::rational<int> >::value); BOOST_STATIC_ASSERT(!boost::is_convertible<long double, boost::rational<int> >::value); // And ones that should: BOOST_STATIC_ASSERT(boost::is_convertible<char, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<signed char, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<unsigned char, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<short, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<unsigned short, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<int, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<unsigned int, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<long, boost::rational<int> >::value); BOOST_STATIC_ASSERT(boost::is_convertible<unsigned long, boost::rational<int> >::value); } #ifndef BOOST_NO_MEMBER_TEMPLATES // Cross-conversion constructor test BOOST_AUTO_TEST_CASE( rational_cross_constructor_test ) { // This template will be repeated a lot. using boost::rational; // Create a bunch of explicit conversions. rational<int> const half_i( 2, 4 ); rational<unsigned> const half_u( half_i ); rational<MyInt> const half_mi( half_i ); rational<MyOverflowingUnsigned> const half_mu1(half_u), half_mu2(half_mi); BOOST_CHECK_EQUAL( half_u.numerator(), 1u ); BOOST_CHECK_EQUAL( half_u.denominator(), 2u ); BOOST_CHECK_EQUAL( half_mi.numerator(), MyInt(1) ); BOOST_CHECK_EQUAL( half_mi.denominator(), MyInt(2) ); BOOST_CHECK_EQUAL( half_mu1.numerator(), MyOverflowingUnsigned(1u) ); BOOST_CHECK_EQUAL( half_mu1.denominator(), MyOverflowingUnsigned(2u) ); BOOST_CHECK_EQUAL( half_mu2.numerator(), MyOverflowingUnsigned(1u) ); BOOST_CHECK_EQUAL( half_mu2.denominator(), MyOverflowingUnsigned(2u) ); #if 0 // This will fail since it needs an implicit conversion. // (Try it if your compiler supports C++11 lambdas.) BOOST_CHECK( [](rational<unsigned> x){return !!x;}(half_i) ); #endif // Translation from a built-in unsigned type to a signed one is // implementation-defined, so hopefully we won't get a trap value. // (We're counting on static_cast<int>(UINT_MAX) being negative.) rational<unsigned> const too_small( 1u, UINT_MAX ); rational<int> receiver; BOOST_CHECK_THROW( receiver=rational<int>(too_small), boost::bad_rational ); } #endif // BOOST_NO_MEMBER_TEMPLATES // Dice tests (a non-main test) BOOST_AUTO_TEST_CASE_TEMPLATE( dice_roll_test, T, all_signed_test_types ) { typedef boost::rational<T> rational_type; // Determine the mean number of times a fair six-sided die // must be thrown until each side has appeared at least once. rational_type r = T( 0 ); for ( int i = 1 ; i <= 6 ; ++i ) { r += rational_type( 1, i ); } r *= static_cast<T>( 6 ); BOOST_CHECK_EQUAL( r, rational_type(147, 10) ); } BOOST_AUTO_TEST_SUITE_END() // The bugs, patches, and requests checking suite BOOST_AUTO_TEST_SUITE( bug_patch_request_suite ) // "rational operator< can overflow" BOOST_AUTO_TEST_CASE( bug_798357_test ) { // Choose values such that rational-number comparisons will overflow if // the multiplication method (n1/d1 ? n2/d2 == n1*d2 ? n2*d1) is used. // (And make sure that the large components are relatively prime, so they // won't partially cancel to make smaller, more reasonable, values.) unsigned const n1 = UINT_MAX - 2u, d1 = UINT_MAX - 1u; unsigned const n2 = d1, d2 = UINT_MAX; boost::rational<MyOverflowingUnsigned> const r1( n1, d1 ), r2( n2, d2 ); BOOST_REQUIRE_EQUAL( boost::integer::gcd(n1, d1), 1u ); BOOST_REQUIRE_EQUAL( boost::integer::gcd(n2, d2), 1u ); BOOST_REQUIRE( n1 > UINT_MAX / d2 ); BOOST_REQUIRE( n2 > UINT_MAX / d1 ); BOOST_CHECK( r1 < r2 ); BOOST_CHECK( !(r1 < r1) ); BOOST_CHECK( !(r2 < r1) ); } // "rational::operator< fails for unsigned value types" BOOST_AUTO_TEST_CASE( patch_1434821_test ) { // If a zero-rational v. positive-integer comparison involves negation, then // it may fail with unsigned types, which wrap around (for built-ins) or // throw/be-undefined (for user-defined types). boost::rational<unsigned> const r( 0u ); BOOST_CHECK( r < 1u ); } // "rational.hpp::gcd returns a negative value sometimes" BOOST_AUTO_TEST_CASE( patch_1438626_test ) { // The issue only manifests with 2's-complement integers that use their // entire range of bits. [This means that ln(-INT_MIN)/ln(2) is an integer // and INT_MAX + INT_MIN == -1.] The common computer platforms match this. #if (INT_MAX + INT_MIN == -1) && ((INT_MAX ^ INT_MIN) == -1) // If a GCD routine takes the absolute value of an argument only before // processing, it won't realize that -INT_MIN -> INT_MIN (i.e. no change // from negation) and will propagate a negative sign to its result. BOOST_REQUIRE_EQUAL( boost::integer::gcd(INT_MIN, 6), 2 ); // That is bad if the rational number type does not check for that // possibility during normalization. boost::rational<int> const r1( INT_MIN / 2 + 3, 6 ), r2( INT_MIN / 2 - 3, 6 ), r3 = r1 + r2; // If the error happens, the signs of the components will be switched. // (The numerators' sum is INT_MIN, and its GCD with 6 would be negated.) BOOST_CHECK_EQUAL( r3.numerator(), INT_MIN / 2 ); BOOST_CHECK_EQUAL( r3.denominator(), 3 ); #endif } // The bug/patch numbers for the above 3 tests are from our SourceForge repo // before we moved to our own SVN & Trac server. At the time this note is // written, it seems that SourceForge has reset their tracking numbers at least // once, so I don't know how to recover those old tickets. The ticket numbers // for the following tests are from our SVN/Trac repo. //"narrowing conversion error with -std=c++0x in operator< with int_type != int" BOOST_AUTO_TEST_CASE( ticket_5855_test ) { // The internals of operator< currently store a structure of two int_type // (where int_type is the component type of a boost::rational template // class) and two computed types. These computed types, results of // arithmetic operations among int_type values, are either int_type // themselves or a larger type that can implicitly convert to int_type. // Those conversions aren't usually a problem. But when an arithmetic // operation involving two values of a built-in scalar type smaller than int // are involved, the result is an int. But the resulting int-to-shorter // conversion is considered narrowing, resulting in a warning or error on // some compilers. Notably, C++11 compilers are supposed to consider it an // error. // // The solution is to force an explicit conversion, although it's otherwise // not needed. (The compiler can rescind the narrowing warning if the // results of the larger type still fit in the smaller one, and that proof // can be generated at constexpr time.) typedef short shorter_than_int_type; typedef boost::rational<shorter_than_int_type> rational_type; bool const dummy = rational_type() < rational_type(); BOOST_REQUIRE( !dummy ); } // "rational::assign" doesn't even have the basic guarantee BOOST_AUTO_TEST_CASE( ticket_9067_test ) { using boost::rational; using boost::integer::gcd; rational<int> a( 6, -8 ); // Normalize to maintain invariants BOOST_CHECK_EQUAL( a.numerator(), -3 ); BOOST_CHECK_EQUAL( a.denominator(), 4 ); BOOST_CHECK( a.denominator() > 0 ); BOOST_CHECK_EQUAL( gcd(a.numerator(), a.denominator()), 1 ); // Do we maintain the basic guarantee after a failed component-assign? BOOST_CHECK_THROW( a.assign(1, 0), boost::bad_rational ); BOOST_CHECK_NE( a.denominator(), 0 ); BOOST_CHECK( a.denominator() > 0 ); BOOST_CHECK_EQUAL( gcd(a.numerator(), a.denominator()), 1 ); // Do we get the strong guarantee? BOOST_CHECK_EQUAL( a.numerator(), -3 ); BOOST_CHECK_EQUAL( a.denominator(), 4 ); #if INT_MIN + INT_MAX < 0 // Try an example without a zero-denominator a = rational<int>( -9, 12 ); BOOST_CHECK_EQUAL( a.numerator(), -3 ); BOOST_CHECK_EQUAL( a.denominator(), 4 ); BOOST_CHECK( a.denominator() > 0 ); BOOST_CHECK_EQUAL( gcd(a.numerator(), a.denominator()), 1 ); BOOST_CHECK_THROW( a.assign(-(INT_MIN + 1), INT_MIN), boost::bad_rational ); BOOST_CHECK( a.denominator() > 0 ); BOOST_CHECK_EQUAL( gcd(a.numerator(), a.denominator()), 1 ); BOOST_CHECK_EQUAL( a.numerator(), -3 ); BOOST_CHECK_EQUAL( a.denominator(), 4 ); #endif } BOOST_AUTO_TEST_SUITE_END()