//  Boost GCD & LCM common_factor.hpp test program  --------------------------//

//  (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)

//  See http://www.boost.org for most recent version including documentation.

//  Revision History

//  01 Dec 2006  Various fixes for old compilers (Joaquín M López Muñoz)

//  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_TEST_MAIN  "Boost.Math GCD & LCM unit tests"

#include <boost/config.hpp>              // for BOOST_MSVC, etc.

#include <boost/detail/workaround.hpp>

#include <boost/math/common_factor.hpp>  // for boost::math::gcd, etc.

#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 <istream>  // for std::basic_istream

#include <limits>   // for std::numeric_limits

#include <ostream>  // for std::basic_ostream

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;

    BOOST_STATIC_CONSTANT(int,id = ID);

    // Lifetime management (use automatic destructor and copy constructor)

    my_wrapped_integer( int_type const &v = int_type() )  : v_( v )  {}

#ifdef __ARMCC__

#pragma diag_suppress 177

#endif

    // 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

    friend std::istream & operator >>( std::istream &i, self_type &x )

    { return i >> x.v_; }

    friend std::ostream & operator <<( std::ostream &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;

// Without these explicit instantiations, MSVC++ 6.5/7.0 does not find

// some friend operators in certain contexts.

MyInt1       dummy1;

MyUnsigned1  dummy2;

MyInt2       dummy3;

MyUnsigned2  dummy4;

// 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

// 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:

    BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);

    static MyInt1 min() throw()  { return limits_type::min(); }

    static MyInt1 max() throw()  { return limits_type::max(); }

    BOOST_STATIC_CONSTANT(int, digits      = limits_type::digits);

    BOOST_STATIC_CONSTANT(int, digits10    = limits_type::digits10);

    BOOST_STATIC_CONSTANT(bool, is_signed  = limits_type::is_signed);

    BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);

    BOOST_STATIC_CONSTANT(bool, is_exact   = limits_type::is_exact);

    BOOST_STATIC_CONSTANT(int, radix       = limits_type::radix);

    static MyInt1 epsilon() throw()      { return limits_type::epsilon(); }

    static MyInt1 round_error() throw()  { return limits_type::round_error(); }

    BOOST_STATIC_CONSTANT(int, min_exponent   = limits_type::min_exponent);

    BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);

    BOOST_STATIC_CONSTANT(int, max_exponent   = limits_type::max_exponent);

    BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);

    BOOST_STATIC_CONSTANT(bool, has_infinity             = limits_type::has_infinity);

    BOOST_STATIC_CONSTANT(bool, has_quiet_NaN            = limits_type::has_quiet_NaN);

    BOOST_STATIC_CONSTANT(bool, has_signaling_NaN        = limits_type::has_signaling_NaN);

    BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = static_cast<std::float_denorm_style>(limits_type::has_denorm));

    BOOST_STATIC_CONSTANT(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(); }

    BOOST_STATIC_CONSTANT(bool, is_iec559  = limits_type::is_iec559);

    BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);

    BOOST_STATIC_CONSTANT(bool, is_modulo  = limits_type::is_modulo);

    BOOST_STATIC_CONSTANT(bool, traps                    = limits_type::traps);

    BOOST_STATIC_CONSTANT(bool, tinyness_before          = limits_type::tinyness_before);

    BOOST_STATIC_CONSTANT(float_round_style, round_style = static_cast<std::float_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:

    BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);

    static MyUnsigned1 min() throw()  { return limits_type::min(); }

    static MyUnsigned1 max() throw()  { return limits_type::max(); }

    BOOST_STATIC_CONSTANT(int, digits      = limits_type::digits);

    BOOST_STATIC_CONSTANT(int, digits10    = limits_type::digits10);

    BOOST_STATIC_CONSTANT(bool, is_signed  = limits_type::is_signed);

    BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);

    BOOST_STATIC_CONSTANT(bool, is_exact   = limits_type::is_exact);

    BOOST_STATIC_CONSTANT(int, radix       = limits_type::radix);

    static MyUnsigned1 epsilon() throw()      { return limits_type::epsilon(); }

    static MyUnsigned1 round_error() throw(){return limits_type::round_error();}

    BOOST_STATIC_CONSTANT(int, min_exponent   = limits_type::min_exponent);

    BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);

    BOOST_STATIC_CONSTANT(int, max_exponent   = limits_type::max_exponent);

    BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);

    BOOST_STATIC_CONSTANT(bool, has_infinity             = limits_type::has_infinity);

    BOOST_STATIC_CONSTANT(bool, has_quiet_NaN            = limits_type::has_quiet_NaN);

    BOOST_STATIC_CONSTANT(bool, has_signaling_NaN        = limits_type::has_signaling_NaN);

    BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = static_cast<std::float_denorm_style>(limits_type::has_denorm));

    BOOST_STATIC_CONSTANT(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(); }

    BOOST_STATIC_CONSTANT(bool, is_iec559  = limits_type::is_iec559);

    BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);

    BOOST_STATIC_CONSTANT(bool, is_modulo  = limits_type::is_modulo);

    BOOST_STATIC_CONSTANT(bool, traps                    = limits_type::traps);

    BOOST_STATIC_CONSTANT(bool, tinyness_before          = limits_type::tinyness_before);

    BOOST_STATIC_CONSTANT(float_round_style, round_style = static_cast<std::float_round_style>(limits_type::round_style));

};  // std::numeric_limits<MyUnsigned1>

#if BOOST_WORKAROUND(BOOST_MSVC,<1300)

// MSVC 6.0 lacks operator<< for __int64, see

// http://support.microsoft.com/default.aspx?scid=kb;en-us;168440

inline ostream& operator<<(ostream& os, __int64 i)

{

    char buf[20];

    sprintf(buf,"%I64d", i);

    os << buf;

    return os;

}

inline ostream& operator<<(ostream& os, unsigned __int64 i)

{

    char buf[20];

    sprintf(buf,"%I64u", i);

    os << buf;

    return os;

}

#endif

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

#else

    using namespace boost::math;

#endif

    // 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 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

    // 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 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

    // 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) );

}

// 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 );

    BOOST_CHECK( (static_gcd< 0,  9>::value) == 9 );

    BOOST_CHECK( (static_gcd<42, 30>::value) == 6 );

    BOOST_CHECK( (static_gcd< 3,  7>::value) == 1 );

    BOOST_CHECK( (static_gcd< 8,  9>::value) == 1 );

    BOOST_CHECK( (static_gcd< 7, 49>::value) == 7 );

}

// 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_AUTO_TEST_SUITE_END()

// LCM tests

BOOST_AUTO_TEST_SUITE( lcm_test_suite )

// 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 );

    BOOST_CHECK( (static_lcm< 0,  7>::value) ==  0 );

    BOOST_CHECK( (static_lcm<18, 30>::value) == 90 );

    BOOST_CHECK( (static_lcm< 3,  7>::value) == 21 );

    BOOST_CHECK( (static_lcm< 8,  9>::value) == 72 );

    BOOST_CHECK( (static_lcm< 7, 49>::value) == 49 );

}

// TODO: see GCD to-do

BOOST_AUTO_TEST_SUITE_END()