Merge 1.4->1.8 from HEAD to RC_1_34_0
[SVN r36158]
This commit is contained in:
Vladimir Prus
parent
c61be11ed7
commit
f13d99bc0a
@ -1,6 +1,6 @@
|
||||
// Boost GCD & LCM common_factor.hpp test program --------------------------//
|
||||
|
||||
// (C) Copyright Daryle Walker 2001.
|
||||
// (C) Copyright Daryle Walker 2001, 2006.
|
||||
// Distributed under 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)
|
||||
@ -8,81 +8,319 @@
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// Revision History
|
||||
// 10 Nov 2006 Make long long and __int64 mutually exclusive (Daryle Walker)
|
||||
// 04 Nov 2006 Use more built-in numeric types, binary-GCD (Daryle Walker)
|
||||
// 03 Nov 2006 Use custom numeric types (Daryle Walker)
|
||||
// 02 Nov 2006 Change to Boost.Test's unit test system (Daryle Walker)
|
||||
// 07 Nov 2001 Initial version (Daryle Walker)
|
||||
|
||||
#define BOOST_INCLUDE_MAIN
|
||||
#define BOOST_TEST_MAIN "Boost.Math GCD & LCM unit tests"
|
||||
|
||||
#include <boost/config.hpp> // for BOOST_MSVC
|
||||
#include <boost/cstdlib.hpp> // for boost::exit_success
|
||||
#include <boost/config.hpp> // for BOOST_MSVC, etc.
|
||||
#include <boost/math/common_factor.hpp> // for boost::math::gcd, etc.
|
||||
#include <boost/test/test_tools.hpp> // for main, BOOST_CHECK
|
||||
#include <boost/mpl/list.hpp> // for boost::mpl::list
|
||||
#include <boost/operators.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/test/test_case_template.hpp>
|
||||
|
||||
#include <iostream> // for std::cout (std::endl indirectly)
|
||||
#include <istream> // for std::basic_istream
|
||||
#include <limits> // for std::numeric_limits
|
||||
#include <ostream> // for std::basic_ostream
|
||||
|
||||
|
||||
// Control to determine what kind of built-in integers are used
|
||||
#ifndef CONTROL_INT_TYPE
|
||||
#define CONTROL_INT_TYPE int
|
||||
namespace {
|
||||
|
||||
// TODO: add polynominal/non-real type; especially after any switch to the
|
||||
// binary-GCD algorithm for built-in types
|
||||
|
||||
// Custom integer class (template)
|
||||
template < typename IntType, int ID = 0 >
|
||||
class my_wrapped_integer
|
||||
: private ::boost::shiftable1<my_wrapped_integer<IntType, ID>,
|
||||
::boost::operators<my_wrapped_integer<IntType, ID> > >
|
||||
{
|
||||
// Helper type-aliases
|
||||
typedef my_wrapped_integer self_type;
|
||||
typedef IntType self_type::* bool_type;
|
||||
|
||||
// Member data
|
||||
IntType v_;
|
||||
|
||||
public:
|
||||
// Template parameters
|
||||
typedef IntType int_type;
|
||||
|
||||
static int const id = ID;
|
||||
|
||||
// Lifetime management (use automatic destructor and copy constructor)
|
||||
my_wrapped_integer( int_type const &v = int_type() ) : v_( v ) {}
|
||||
|
||||
// Accessors
|
||||
int_type value() const { return this->v_; }
|
||||
|
||||
// Operators (use automatic copy assignment)
|
||||
operator bool_type() const { return this->v_ ? &self_type::v_ : 0; }
|
||||
|
||||
self_type & operator ++() { ++this->v_; return *this; }
|
||||
self_type & operator --() { --this->v_; return *this; }
|
||||
|
||||
self_type operator ~() const { return self_type( ~this->v_ ); }
|
||||
self_type operator !() const { return self_type( !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) {this->v_ *= r.v_; return *this;}
|
||||
self_type &operator /=(self_type const &r) {this->v_ /= r.v_; return *this;}
|
||||
self_type &operator %=(self_type const &r) {this->v_ %= r.v_; return *this;}
|
||||
self_type &operator +=(self_type const &r) {this->v_ += r.v_; return *this;}
|
||||
self_type &operator -=(self_type const &r) {this->v_ -= r.v_; return *this;}
|
||||
self_type &operator<<=(self_type const &r){this->v_ <<= r.v_; return *this;}
|
||||
self_type &operator>>=(self_type const &r){this->v_ >>= r.v_; return *this;}
|
||||
self_type &operator &=(self_type const &r) {this->v_ &= r.v_; return *this;}
|
||||
self_type &operator |=(self_type const &r) {this->v_ |= r.v_; return *this;}
|
||||
self_type &operator ^=(self_type const &r) {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_; }
|
||||
|
||||
}; // my_wrapped_integer
|
||||
|
||||
template < typename IntType, int ID >
|
||||
my_wrapped_integer<IntType, ID> abs( my_wrapped_integer<IntType, ID> const &x )
|
||||
{ return ( x < my_wrapped_integer<IntType, ID>(0) ) ? -x : +x; }
|
||||
|
||||
typedef my_wrapped_integer<int> MyInt1;
|
||||
typedef my_wrapped_integer<unsigned> MyUnsigned1;
|
||||
typedef my_wrapped_integer<int, 1> MyInt2;
|
||||
typedef my_wrapped_integer<unsigned, 1> MyUnsigned2;
|
||||
|
||||
// Various types to test with each GCD/LCM
|
||||
typedef ::boost::mpl::list<signed char, short, int, long,
|
||||
#ifdef BOOST_HAS_LONG_LONG
|
||||
long long,
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
__int64,
|
||||
#endif
|
||||
MyInt1> signed_test_types;
|
||||
typedef ::boost::mpl::list<unsigned char, unsigned short, unsigned,
|
||||
unsigned long,
|
||||
#ifdef BOOST_HAS_LONG_LONG
|
||||
unsigned long long,
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
unsigned __int64,
|
||||
#endif
|
||||
MyUnsigned1, MyUnsigned2> unsigned_test_types;
|
||||
|
||||
} // namespace
|
||||
|
||||
|
||||
// Main testing function
|
||||
int
|
||||
test_main
|
||||
(
|
||||
int , // "argc" is unused
|
||||
char * [] // "argv" is unused
|
||||
)
|
||||
{
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
// Specialize numeric_limits for _some_ of our types
|
||||
namespace std
|
||||
{
|
||||
|
||||
template < >
|
||||
class numeric_limits< MyInt1 >
|
||||
{
|
||||
typedef MyInt1::int_type int_type;
|
||||
typedef numeric_limits<int_type> limits_type;
|
||||
|
||||
public:
|
||||
static const bool is_specialized = limits_type::is_specialized;
|
||||
|
||||
static MyInt1 min() throw() { return limits_type::min(); }
|
||||
static MyInt1 max() throw() { return limits_type::max(); }
|
||||
|
||||
static const int digits = limits_type::digits;
|
||||
static const int digits10 = limits_type::digits10;
|
||||
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 MyInt1 epsilon() throw() { return limits_type::epsilon(); }
|
||||
static MyInt1 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 MyInt1 infinity() throw() { return limits_type::infinity(); }
|
||||
static MyInt1 quiet_NaN() throw() { return limits_type::quiet_NaN(); }
|
||||
static MyInt1 signaling_NaN() throw() {return limits_type::signaling_NaN();}
|
||||
static MyInt1 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<MyInt1>
|
||||
|
||||
template < >
|
||||
class numeric_limits< MyUnsigned1 >
|
||||
{
|
||||
typedef MyUnsigned1::int_type int_type;
|
||||
typedef numeric_limits<int_type> limits_type;
|
||||
|
||||
public:
|
||||
static const bool is_specialized = limits_type::is_specialized;
|
||||
|
||||
static MyUnsigned1 min() throw() { return limits_type::min(); }
|
||||
static MyUnsigned1 max() throw() { return limits_type::max(); }
|
||||
|
||||
static const int digits = limits_type::digits;
|
||||
static const int digits10 = limits_type::digits10;
|
||||
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 MyUnsigned1 epsilon() throw() { return limits_type::epsilon(); }
|
||||
static MyUnsigned1 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 MyUnsigned1 infinity() throw() { return limits_type::infinity(); }
|
||||
static MyUnsigned1 quiet_NaN() throw() { return limits_type::quiet_NaN(); }
|
||||
static MyUnsigned1 signaling_NaN() throw()
|
||||
{ return limits_type::signaling_NaN(); }
|
||||
static MyUnsigned1 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<MyUnsigned1>
|
||||
|
||||
} // namespace std
|
||||
|
||||
|
||||
// GCD tests
|
||||
BOOST_AUTO_TEST_SUITE( gcd_test_suite )
|
||||
|
||||
// GCD on signed integer types
|
||||
BOOST_AUTO_TEST_CASE_TEMPLATE( gcd_int_test, T, signed_test_types )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::gcd;
|
||||
using boost::math::static_gcd;
|
||||
using boost::math::lcm;
|
||||
using boost::math::static_lcm;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
typedef CONTROL_INT_TYPE int_type;
|
||||
typedef unsigned CONTROL_INT_TYPE uint_type;
|
||||
// Originally from Boost.Rational tests
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 1, -1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( -1, 1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 1, 1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( -1, -1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 0, 0), static_cast<T>( 0) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 7, 0), static_cast<T>( 7) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 0, 9), static_cast<T>( 9) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( -7, 0), static_cast<T>( 7) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 0, -9), static_cast<T>( 9) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 42, 30), static_cast<T>( 6) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 6, -9), static_cast<T>( 3) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>(-10, -10), static_cast<T>(10) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>(-25, -10), static_cast<T>( 5) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 3, 7), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 8, 9), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 7, 49), static_cast<T>( 7) );
|
||||
}
|
||||
|
||||
// GCD tests
|
||||
cout << "Doing tests on gcd." << endl;
|
||||
// GCD on unmarked signed integer type
|
||||
BOOST_AUTO_TEST_CASE( gcd_unmarked_int_test )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::gcd;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
BOOST_CHECK( gcd<int_type>( 1, -1) == 1 );
|
||||
BOOST_CHECK( gcd<int_type>( -1, 1) == 1 );
|
||||
BOOST_CHECK( gcd<int_type>( 1, 1) == 1 );
|
||||
BOOST_CHECK( gcd<int_type>( -1, -1) == 1 );
|
||||
BOOST_CHECK( gcd<int_type>( 0, 0) == 0 );
|
||||
BOOST_CHECK( gcd<int_type>( 7, 0) == 7 );
|
||||
BOOST_CHECK( gcd<int_type>( 0, 9) == 9 );
|
||||
BOOST_CHECK( gcd<int_type>( -7, 0) == 7 );
|
||||
BOOST_CHECK( gcd<int_type>( 0, -9) == 9 );
|
||||
BOOST_CHECK( gcd<int_type>( 42, 30) == 6 );
|
||||
BOOST_CHECK( gcd<int_type>( 6, -9) == 3 );
|
||||
BOOST_CHECK( gcd<int_type>(-10, -10) == 10 );
|
||||
BOOST_CHECK( gcd<int_type>(-25, -10) == 5 );
|
||||
BOOST_CHECK( gcd<int_type>( 3, 7) == 1 );
|
||||
BOOST_CHECK( gcd<int_type>( 8, 9) == 1 );
|
||||
BOOST_CHECK( gcd<int_type>( 7, 49) == 7 );
|
||||
// The regular signed-integer GCD function performs the unsigned version,
|
||||
// then does an absolute-value on the result. Signed types that are not
|
||||
// marked as such (due to no std::numeric_limits specialization) may be off
|
||||
// by a sign.
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 1, -1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( -1, 1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 1, 1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( -1, -1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 0, 0 )), MyInt2( 0) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 7, 0 )), MyInt2( 7) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 0, 9 )), MyInt2( 9) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( -7, 0 )), MyInt2( 7) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 0, -9 )), MyInt2( 9) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 42, 30 )), MyInt2( 6) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 6, -9 )), MyInt2( 3) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( -10, -10 )), MyInt2(10) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( -25, -10 )), MyInt2( 5) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 3, 7 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 8, 9 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(gcd<MyInt2>( 7, 49 )), MyInt2( 7) );
|
||||
}
|
||||
|
||||
// GCD tests
|
||||
cout << "Doing tests on unsigned-gcd." << endl;
|
||||
// GCD on unsigned integer types
|
||||
BOOST_AUTO_TEST_CASE_TEMPLATE( gcd_unsigned_test, T, unsigned_test_types )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::gcd;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
BOOST_CHECK( gcd<uint_type>( 1u, 1u) == 1u );
|
||||
BOOST_CHECK( gcd<uint_type>( 0u, 0u) == 0u );
|
||||
BOOST_CHECK( gcd<uint_type>( 7u, 0u) == 7u );
|
||||
BOOST_CHECK( gcd<uint_type>( 0u, 9u) == 9u );
|
||||
BOOST_CHECK( gcd<uint_type>( 42u, 30u) == 6u );
|
||||
BOOST_CHECK( gcd<uint_type>( 3u, 7u) == 1u );
|
||||
BOOST_CHECK( gcd<uint_type>( 8u, 9u) == 1u );
|
||||
BOOST_CHECK( gcd<uint_type>( 7u, 49u) == 7u );
|
||||
// Note that unmarked types (i.e. have no std::numeric_limits
|
||||
// specialization) are treated like non/unsigned types
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 1u, 1u), static_cast<T>( 1u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 0u, 0u), static_cast<T>( 0u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 7u, 0u), static_cast<T>( 7u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 0u, 9u), static_cast<T>( 9u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>(42u, 30u), static_cast<T>( 6u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 3u, 7u), static_cast<T>( 1u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 8u, 9u), static_cast<T>( 1u) );
|
||||
BOOST_CHECK_EQUAL( gcd<T>( 7u, 49u), static_cast<T>( 7u) );
|
||||
}
|
||||
|
||||
cout << "Doing tests on static_gcd." << endl;
|
||||
// GCD at compile-time
|
||||
BOOST_AUTO_TEST_CASE( gcd_static_test )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::static_gcd;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
// Can't use "BOOST_CHECK_EQUAL", otherwise the "value" member will be
|
||||
// disqualified as compile-time-only constant, needing explicit definition
|
||||
BOOST_CHECK( (static_gcd< 1, 1>::value) == 1 );
|
||||
BOOST_CHECK( (static_gcd< 0, 0>::value) == 0 );
|
||||
BOOST_CHECK( (static_gcd< 7, 0>::value) == 7 );
|
||||
@ -91,40 +329,109 @@ test_main
|
||||
BOOST_CHECK( (static_gcd< 3, 7>::value) == 1 );
|
||||
BOOST_CHECK( (static_gcd< 8, 9>::value) == 1 );
|
||||
BOOST_CHECK( (static_gcd< 7, 49>::value) == 7 );
|
||||
}
|
||||
|
||||
// LCM tests
|
||||
cout << "Doing tests on lcm." << endl;
|
||||
// TODO: non-built-in signed and unsigned integer tests, with and without
|
||||
// numeric_limits specialization; polynominal tests; note any changes if
|
||||
// built-ins switch to binary-GCD algorithm
|
||||
|
||||
BOOST_CHECK( lcm<int_type>( 1, -1) == 1 );
|
||||
BOOST_CHECK( lcm<int_type>( -1, 1) == 1 );
|
||||
BOOST_CHECK( lcm<int_type>( 1, 1) == 1 );
|
||||
BOOST_CHECK( lcm<int_type>( -1, -1) == 1 );
|
||||
BOOST_CHECK( lcm<int_type>( 0, 0) == 0 );
|
||||
BOOST_CHECK( lcm<int_type>( 6, 0) == 0 );
|
||||
BOOST_CHECK( lcm<int_type>( 0, 7) == 0 );
|
||||
BOOST_CHECK( lcm<int_type>( -5, 0) == 0 );
|
||||
BOOST_CHECK( lcm<int_type>( 0, -4) == 0 );
|
||||
BOOST_CHECK( lcm<int_type>( 18, 30) == 90 );
|
||||
BOOST_CHECK( lcm<int_type>( -6, 9) == 18 );
|
||||
BOOST_CHECK( lcm<int_type>(-10, -10) == 10 );
|
||||
BOOST_CHECK( lcm<int_type>( 25, -10) == 50 );
|
||||
BOOST_CHECK( lcm<int_type>( 3, 7) == 21 );
|
||||
BOOST_CHECK( lcm<int_type>( 8, 9) == 72 );
|
||||
BOOST_CHECK( lcm<int_type>( 7, 49) == 49 );
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
cout << "Doing tests on unsigned-lcm." << endl;
|
||||
|
||||
BOOST_CHECK( lcm<uint_type>( 1u, 1u) == 1u );
|
||||
BOOST_CHECK( lcm<uint_type>( 0u, 0u) == 0u );
|
||||
BOOST_CHECK( lcm<uint_type>( 6u, 0u) == 0u );
|
||||
BOOST_CHECK( lcm<uint_type>( 0u, 7u) == 0u );
|
||||
BOOST_CHECK( lcm<uint_type>( 18u, 30u) == 90u );
|
||||
BOOST_CHECK( lcm<uint_type>( 3u, 7u) == 21u );
|
||||
BOOST_CHECK( lcm<uint_type>( 8u, 9u) == 72u );
|
||||
BOOST_CHECK( lcm<uint_type>( 7u, 49u) == 49u );
|
||||
// LCM tests
|
||||
BOOST_AUTO_TEST_SUITE( lcm_test_suite )
|
||||
|
||||
cout << "Doing tests on static_lcm." << endl;
|
||||
// LCM on signed integer types
|
||||
BOOST_AUTO_TEST_CASE_TEMPLATE( lcm_int_test, T, signed_test_types )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::lcm;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
// Originally from Boost.Rational tests
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 1, -1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( -1, 1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 1, 1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( -1, -1), static_cast<T>( 1) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 0, 0), static_cast<T>( 0) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 6, 0), static_cast<T>( 0) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 0, 7), static_cast<T>( 0) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( -5, 0), static_cast<T>( 0) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 0, -4), static_cast<T>( 0) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 18, 30), static_cast<T>(90) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( -6, 9), static_cast<T>(18) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>(-10, -10), static_cast<T>(10) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 25, -10), static_cast<T>(50) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 3, 7), static_cast<T>(21) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 8, 9), static_cast<T>(72) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 7, 49), static_cast<T>(49) );
|
||||
}
|
||||
|
||||
// LCM on unmarked signed integer type
|
||||
BOOST_AUTO_TEST_CASE( lcm_unmarked_int_test )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::lcm;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
// The regular signed-integer LCM function performs the unsigned version,
|
||||
// then does an absolute-value on the result. Signed types that are not
|
||||
// marked as such (due to no std::numeric_limits specialization) may be off
|
||||
// by a sign.
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 1, -1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( -1, 1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 1, 1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( -1, -1 )), MyInt2( 1) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 0, 0 )), MyInt2( 0) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 6, 0 )), MyInt2( 0) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 0, 7 )), MyInt2( 0) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( -5, 0 )), MyInt2( 0) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 0, -4 )), MyInt2( 0) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 18, 30 )), MyInt2(90) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( -6, 9 )), MyInt2(18) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( -10, -10 )), MyInt2(10) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 25, -10 )), MyInt2(50) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 3, 7 )), MyInt2(21) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 8, 9 )), MyInt2(72) );
|
||||
BOOST_CHECK_EQUAL( abs(lcm<MyInt2>( 7, 49 )), MyInt2(49) );
|
||||
}
|
||||
|
||||
// LCM on unsigned integer types
|
||||
BOOST_AUTO_TEST_CASE_TEMPLATE( lcm_unsigned_test, T, unsigned_test_types )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::lcm;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
// Note that unmarked types (i.e. have no std::numeric_limits
|
||||
// specialization) are treated like non/unsigned types
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 1u, 1u), static_cast<T>( 1u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 0u, 0u), static_cast<T>( 0u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 6u, 0u), static_cast<T>( 0u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 0u, 7u), static_cast<T>( 0u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>(18u, 30u), static_cast<T>(90u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 3u, 7u), static_cast<T>(21u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 8u, 9u), static_cast<T>(72u) );
|
||||
BOOST_CHECK_EQUAL( lcm<T>( 7u, 49u), static_cast<T>(49u) );
|
||||
}
|
||||
|
||||
// LCM at compile-time
|
||||
BOOST_AUTO_TEST_CASE( lcm_static_test )
|
||||
{
|
||||
#ifndef BOOST_MSVC
|
||||
using boost::math::static_lcm;
|
||||
#else
|
||||
using namespace boost::math;
|
||||
#endif
|
||||
|
||||
// Can't use "BOOST_CHECK_EQUAL", otherwise the "value" member will be
|
||||
// disqualified as compile-time-only constant, needing explicit definition
|
||||
BOOST_CHECK( (static_lcm< 1, 1>::value) == 1 );
|
||||
BOOST_CHECK( (static_lcm< 0, 0>::value) == 0 );
|
||||
BOOST_CHECK( (static_lcm< 6, 0>::value) == 0 );
|
||||
@ -133,6 +440,8 @@ test_main
|
||||
BOOST_CHECK( (static_lcm< 3, 7>::value) == 21 );
|
||||
BOOST_CHECK( (static_lcm< 8, 9>::value) == 72 );
|
||||
BOOST_CHECK( (static_lcm< 7, 49>::value) == 49 );
|
||||
|
||||
return boost::exit_success;
|
||||
}
|
||||
|
||||
// TODO: see GCD to-do
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user