...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
// Configuration macros #defineBOOST_RATIO_VERSION
#defineBOOST_RATIO_EXTENSIONS
#defineBOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
#defineBOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
#defineBOOST_RATIO_USES_STATIC_ASSERT
#defineBOOST_RATIO_USES_MPL_ASSERT
#defineBOOST_RATIO_USES_ARRAY_ASSERT
When BOOST_RATIO_EXTENSIONS
is defined, Boost.Ratio provides in addition
some extension to the C++ standard, see below.
When BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
is defined the deprecated features stated as DEPRECATED V2 are provided.
When BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
is defined the deprecated features stated as DEPRECATED
V2 are NOT provided.
BOOST_RATIO_VERSION
stands for the Boost.Ratio version which can be 1 or 2.
The default up to 1.55 is version 1. Since 1.56 it will be 2.
When BOOST_RATIO_VERSION
is 1 BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
is defined by default.
When BOOST_RATIO_VERSION
is 2 BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0
is defined by default.
When BOOST_NO_STATIC_ASSERT is defined, the user can select the way static assertions are reported. Define
BOOST_RATIO_USES_STATIC_ASSERT
to use Boost.StaticAssert.
BOOST_RATIO_USES_MPL_ASSERT
to use Boost.MPL static assertions.
BOOST_RATIO_USES_ARRAY_ASSERT
to use Boost.Ratio internal static
assertions.
The default behavior is as if BOOST_RATIO_USES_ARRAY_ASSERT
was defined.
When BOOST_RATIO_USES_MPL_ASSERT
is not defined the following symbols are defined as shown:
#define BOOST_RATIO_OVERFLOW_IN_ADD "overflow in ratio add" #define BOOST_RATIO_OVERFLOW_IN_SUB "overflow in ratio sub" #define BOOST_RATIO_OVERFLOW_IN_MUL "overflow in ratio mul" #define BOOST_RATIO_OVERFLOW_IN_DIV "overflow in ratio div" #define BOOST_RATIO_NUMERATOR_IS_OUT_OF_RANGE "ratio numerator is out of range" #define BOOST_RATIO_DIVIDE_BY_0 "ratio divide by 0" #define BOOST_RATIO_DENOMINATOR_IS_OUT_OF_RANGE "ratio denominator is out of range"
Depending upon the static assertion system used, a hint as to the failing assertion will appear in some form in the compiler diagnostic output.
This header includes all the ratio related header files
#include <boost/ratio/ratio.hpp> #include <boost/ratio/ratio_io.hpp> #include <boost/ratio/rational_constant.hpp>
This header provides forward declarations for the <boost/ratio/ratio.hpp>
file.
namespace boost { template <boost::intmax_t N, boost::intmax_t D = 1> classratio
; // ratio arithmetic template <class R1, class R2> structratio_add
; template <class R1, class R2> structratio_subtract
; template <class R1, class R2> structratio_multiply
; template <class R1, class R2> structratio_divide
; #ifdef BOOST_RATIO_EXTENSIONS template <class R,int P> structratio_power
; template <class R> structratio_negate
; template <class R> structratio_sign
; template <class R> structratio_abs
; template <class R1, class R2> structratio_gcd
; template <class R1, class R2> structratio_lcm
; #endif // ratio comparison template <class R1, class R2> structratio_equal
; template <class R1, class R2> structratio_not_equal
; template <class R1, class R2> structratio_less
; template <class R1, class R2> structratio_less_equal
; template <class R1, class R2> structratio_greater
; template <class R1, class R2> structratio_greater_equal
; // convenience SI typedefs typedef ratio<1LL, 1000000000000000000LL>atto
; typedef ratio<1LL, 1000000000000000LL>femto
; typedef ratio<1LL, 1000000000000LL>pico
; typedef ratio<1LL, 1000000000LL>nano
; typedef ratio<1LL, 1000000LL>micro
; typedef ratio<1LL, 1000LL>milli
; typedef ratio<1LL, 100LL>centi
; typedef ratio<1LL, 10LL>deci
; typedef ratio< 10LL, 1LL>deca
; typedef ratio< 100LL, 1LL>hecto
; typedef ratio< 1000LL, 1LL>kilo
; typedef ratio< 1000000LL, 1LL>mega
; typedef ratio< 1000000000LL, 1LL>giga
; typedef ratio< 1000000000000LL, 1LL>tera
; typedef ratio< 1000000000000000LL, 1LL>peta
; typedef ratio<1000000000000000000LL, 1LL>exa
; #ifdef BOOST_RATIO_EXTENSIONS // convenience IEC typedefs typedef ratio< 1024LL>kibi
; typedef ratio< 1024LL*1024LL>mebi
; typedef ratio< 1024LL*1024LL*1024LL>gibi
; typedef ratio< 1024LL*1024LL*1024LL*1024LL>tebi
; typedef ratio< 1024LL*1024LL*1024LL*1024LL*1024LL>pebi
; typedef ratio<1024LL*1024LL*1024LL*1024LL*1024LL*1024LL>exbi
; #endif }
ratio
is a facility which is useful in specifying compile-time rational constants.
Compile-time rational arithmetic is supported with protection against overflow
and divide by zero. Such a facility is very handy to efficiently represent
1/3 of a nanosecond, or to specify an inch in terms of meters (for example
254/10000 meters - which ratio
will reduce to 127/5000
meters).
template <boost::intmax_t N, boost::intmax_t D>
class ratio {
public:
static const boost::intmax_t num;
static const boost::intmax_t den;
typedef ratio<num, den> type;
#ifdef BOOST_RATIO_EXTENSIONS
typedef mpl::rational_c_tag tag;
typedef boost::rational<boost::intmax_t> value_type;
typedef boost::intmax_t num_type;
typedef boost::intmax_t den_type;
ratio() = default;
template <intmax_t _N2, intmax_t _D2>
ratio(const ratio<_N2, _D2>&);
template <intmax_t _N2, intmax_t _D2>
ratio& operator=(const ratio<_N2, _D2>&);
static value_type value();
value_type operator()() const;
#endif
};
A diagnostic will be emitted if ratio
is instantiated with
D ==
0
, or if the absolute value of
N
or D
cannot be represented. Note: These rules
ensure that infinite ratios are avoided and that for any negative input,
there exists a representable value of its absolute value which is positive.
In a two's complement representation, this excludes the most negative
value.
The members num and den will be normalized values of the template arguments
N and D computed as follows. Let gcd
denote the greatest common divisor of N
's
absolute value and of D
's
absolute value. Then:
num
has the value
sign(N)*sign(D)*abs(N)/gcd
.
den
has the value
abs(D)/gcd
.
The nested typedef type
denotes the normalized form of this ratio
type. It should be used
when the normalized form of the template arguments are required, since
the arguments are not necessarily normalized.
Two ratio
classes
and ratio
<N1,D1>
have the same normalized form if ratio
<N2,D2>
is the same type as ratio
<N1,D1>::typeratio
<N2,D2>::type
Included only if BOOST_RATIO_EXTENSIONS
is
defined.
ratio()=default;
Effects: Constructs a ratio
object.
template <intmax_t N2, intmax_t D2>
ratio(const ratio
<N2, D2>& r);
Effects: Constructs a ratio
object.
Remarks: This constructor will not
participate in overload resolution unless r
has the same normalized form as *this
.
template <intmax_t N2, intmax_t D2>ratio
& operator=(constratio
<N2, D2>& r);
Effects: Assigns a ratio
object.
Returns: *this.
Remarks: This operator will not participate
in overload resolution unless r
has the same normalized form as *this
.
Included only if BOOST_RATIO_EXTENSIONS
is
defined.
In order to work with Boost.MPL numeric metafunctions as a Rational Constant, the following has beed added:
typedef mpl::rational_c_tag tag; typedef boost::rational<boost::intmax_t> value_type; typedef boost::intmax_t num_type; typedef boost::intmax_t den_type;
Included only if BOOST_RATIO_EXTENSIONS
is
defined.
static value_type value(); value_type operator()() const;
Returns: value_type(num,den);
For each of the class templates in this section, each template parameter
refers to a ratio
. If
the implementation is unable to form the indicated ratio
due to overflow, a diagnostic
will be issued.
ratio_add<>
template <class R1, class R2> struct ratio_add { typedef [/see below] type; };
The nested typedef type
is a synonym for
.
ratio
<R1::num * R2::den + R2::num * R1::den, R1::den * R2::den>::type
ratio_subtract<>
template <class R1, class R2> struct ratio_subtract { typedef [/see below] type; };
The nested typedef type
is a synonym for
.
ratio
<R1::num * R2::den - R2::num * R1::den, R1::den * R2::den>::type
ratio_multiply<>
template <class R1, class R2> struct ratio_multiply { typedef [/see below] type; };
The nested typedef type
is a synonym for
.
ratio
<R1::num * R2::num, R1::den * R2::den>::type
ratio_divide<>
template <class R1, class R2> struct ratio_divide { typedef [/see below] type; };
The nested typedef type
is a synonym for
.
ratio
<R1::num * R2::den, R2::num * R1::den>::type
ratio_power<>
Included only if BOOST_RATIO_EXTENSIONS
is defined.
template <class R, int P> struct ratio_power { typedef [/see below] type; };
The nested typedef type
is a synonym for R*
*R
P times.
ratio_negate<>
Included only if BOOST_RATIO_EXTENSIONS
is defined.
This extension of the C++ standard helps in the definition of some Boost.MPL numeric metafunctions.
template <class R> struct ratio_negate { typedef [/see below] type; };
The nested typedef type
is a synonym for
.
ratio
<-R::num, R::den>::type
ratio_abs<>
Included only if BOOST_RATIO_EXTENSIONS
is defined.
This extension of the C++ standard helps in the definition of some Boost.MPL numeric metafunctions.
template <class R> struct ratio_abs { typedef [/see below] type; };
The nested typedef type
is a synonym for
.
ratio
<abs_c<intmax_t,R::num>::value, R::den>::type
ratio_sign<>
Included only if BOOST_RATIO_EXTENSIONS
is defined.
This extension of the C++ standard helps in the definition of some Boost.MPL numeric metafunctions.
template <class R> struct ratio_sign { typedef [/see below] type; };
The nested typedef type
is a synonym for sign_c<intmax_t,R::num>::type
.
ratio_gcd<>
Included only if BOOST_RATIO_EXTENSIONS
is defined.
This extension of the C++ standard helps in the definition of some Boost.MPL numeric metafunctions.
template <class R1, class R2> struct ratio_gcd { typedef [/see below] type; };
The nested typedef type
is a synonym for ratio<gcd_c<intmax_t, R1::num, R2::num>::value, mpl::lcm_c<intmax_t, R1::den, R2::den>::value>::type
.
ratio_lcm<>
Included only if BOOST_RATIO_EXTENSIONS
is defined.
This extension of the C++ standard helps in the definition of some Boost.MPL numeric metafunctions.
template <class R1, class R2> struct ratio_lcm { typedef [/see below] type; };
The nested typedef type
is a synonym for ratio<lcm_c<intmax_t, R1::num, R2::num>::value, gcd_c<intmax_t, R1::den, R2::den>::value>::type
.
ratio_equal<>
template <class R1, class R2> struct ratio_equal : public boost::integral_constant<bool, [/see below] > {};
If R1::num == R2::num && R1::den == R2::den, ratio_equal derives from true_type, else derives from false_type.
ratio_not_equal<>
template <class R1, class R2> struct ratio_not_equal : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value> {};
ratio_less<>
template <class R1, class R2> struct ratio_less : public boost::integral_constant<bool, [/see below] > {};
If R1::num * R2::den < R2::num * R1::den, ratio_less derives from true_type, else derives from false_type.
ratio_less_equal<>
template <class R1, class R2> struct ratio_less_equal : public boost::integral_constant<bool, !ratio_less<R2, R1>::value> {};
ratio_greater<>
template <class R1, class R2> struct ratio_greater : public boost::integral_constant<bool, ratio_less<R2, R1>::value> {};
ratio_greater_equal<>
template <class R1, class R2> struct ratio_greater_equal : public boost::integral_constant<bool, !ratio_less<R1, R2>::value> {};
The International
System of Units specifies twenty SI prefixes. Boost.Ratio
defines all except yocto
,
zepto
, zetta
, and yotta
// convenience SI typedefs typedefratio
<1LL, 1000000000000000000LL> atto; typedefratio
<1LL, 1000000000000000LL> femto; typedefratio
<1LL, 1000000000000LL> pico; typedefratio
<1LL, 1000000000LL> nano; typedefratio
<1LL, 1000000LL> micro; typedefratio
<1LL, 1000LL> milli; typedefratio
<1LL, 100LL> centi; typedefratio
<1LL, 10LL> deci; typedefratio
< 10LL, 1LL> deca; typedefratio
< 100LL, 1LL> hecto; typedefratio
< 1000LL, 1LL> kilo; typedefratio
< 1000000LL, 1LL> mega; typedefratio
< 1000000000LL, 1LL> giga; typedefratio
< 1000000000000LL, 1LL> tera; typedefratio
< 1000000000000000LL, 1LL> peta; typedefratio
<1000000000000000000LL, 1LL> exa;
Included only if BOOST_RATIO_EXTENSIONS
is defined.
The Specific
units of IEC 60027-2 A.2 and ISO/IEC 80000 specifies height IEC
prefixes. Boost.Ratio defines all except
zebi
and yobi
// convenience ETC typedefs typedef ratio< 1024LL> kibi; typedef ratio< 1024LL*1024LL> mebi; typedef ratio< 1024LL*1024LL*1024LL> gibi; typedef ratio< 1024LL*1024LL*1024LL*1024LL> tebi; typedef ratio< 1024LL*1024LL*1024LL*1024LL*1024LL> pebi; typedef ratio<1024LL*1024LL*1024LL*1024LL*1024LL*1024LL> exbi;
The following are limitations of Boost.Ratio relative to the specification in the C++0x draft standard:
yocto
,
zepto
, zetta
, and yotta
-- are to be conditionally supported, if the range of intmax_t
allows, but are not supported
by Boost.Ratio.
constexpr
intmax_t
(see Ratio
values should be constexpr), but for compiler not supporting
constexpr
today, Boost.Ratio uses static
const intmax_t
instead.
When BOOST_RATIO_EXTENSIONS
is defined Boost.Ratio provides the
following extensions:
This header provides ratio_string<>
which can generate a textual representation
of a ratio<>
in the form of a std::basic_string<>
.
These strings can be useful for I/O.
namespace boost { template <class Ratio, class charT> struct ratio_string; template <> struct ratio_string<atto, char>; template <> struct ratio_string<atto, char16_t>; template <> struct ratio_string<atto, char32_t>; template <> struct ratio_string<atto, wchar_t>; template <> struct ratio_string<femto, char>; template <> struct ratio_string<femto, char16_t>; template <> struct ratio_string<femto, char32_t>; template <> struct ratio_string<femto, wchar_t>; template <> struct ratio_string<pico, char>; template <> struct ratio_string<pico, char16_t>; template <> struct ratio_string<pico, char32_t>; template <> struct ratio_string<pico, wchar_t>; template <> struct ratio_string<nano, char>; template <> struct ratio_string<nano, char16_t>; template <> struct ratio_string<nano, char32_t>; template <> struct ratio_string<nano, wchar_t>; template <> struct ratio_string<micro, char>; template <> struct ratio_string<micro, char16_t>; template <> struct ratio_string<micro, char32_t>; template <> struct ratio_string<micro, wchar_t>; template <> struct ratio_string<milli, char>; template <> struct ratio_string<milli, char16_t>; template <> struct ratio_string<milli, char32_t>; template <> struct ratio_string<milli, wchar_t>; template <> struct ratio_string<centi, char>; template <> struct ratio_string<centi, char16_t>; template <> struct ratio_string<centi, char32_t>; template <> struct ratio_string<centi, wchar_t>; template <> struct ratio_string<deci, char>; template <> struct ratio_string<deci, char16_t>; template <> struct ratio_string<deci, char32_t>; template <> struct ratio_string<deci, wchar_t>; template <> struct ratio_string<deca, char>; template <> struct ratio_string<deca, char16_t>; template <> struct ratio_string<deca, char32_t>; template <> struct ratio_string<deca, wchar_t>; template <> struct ratio_string<hecto, char>; template <> struct ratio_string<hecto, char16_t>; template <> struct ratio_string<hecto, char32_t>; template <> struct ratio_string<hecto, wchar_t>; template <> struct ratio_string<kilo, char>; template <> struct ratio_string<kilo, char16_t>; template <> struct ratio_string<kilo, char32_t>; template <> struct ratio_string<kilo, wchar_t>; template <> struct ratio_string<mega, char>; template <> struct ratio_string<mega, char16_t>; template <> struct ratio_string<mega, char32_t>; template <> struct ratio_string<mega, wchar_t>; template <> struct ratio_string<giga, char>; template <> struct ratio_string<giga, char16_t>; template <> struct ratio_string<giga, char32_t>; template <> struct ratio_string<giga, wchar_t>; template <> struct ratio_string<tera, char>; template <> struct ratio_string<tera, char16_t>; template <> struct ratio_string<tera, char32_t>; template <> struct ratio_string<tera, wchar_t>; template <> struct ratio_string<peta, char>; template <> struct ratio_string<peta, char16_t>; template <> struct ratio_string<peta, char32_t>; template <> struct ratio_string<peta, wchar_t>; template <> struct ratio_string<exa, char>; template <> struct ratio_string<exa, char16_t>; template <> struct ratio_string<exa, char32_t>; template <> struct ratio_string<exa, wchar_t>; template <> struct ratio_string<kibi, char>; template <> struct ratio_string<kibi, char16_t>; template <> struct ratio_string<kibi, char32_t>; template <> struct ratio_string<kibi, wchar_t>; template <> struct ratio_string<mebi, char>; template <> struct ratio_string<mebi, char16_t>; template <> struct ratio_string<mebi, char32_t>; template <> struct ratio_string<mebi, wchar_t>; template <> struct ratio_string<gibi, char>; template <> struct ratio_string<gibi, char16_t>; template <> struct ratio_string<gibi, char32_t>; template <> struct ratio_string<gibi, wchar_t>; template <> struct ratio_string<tebi, char>; template <> struct ratio_string<tebi, char16_t>; template <> struct ratio_string<tebi, char32_t>; template <> struct ratio_string<tebi, wchar_t>; template <> struct ratio_string<pebi, char>; template <> struct ratio_string<pebi, char16_t>; template <> struct ratio_string<pebi, char32_t>; template <> struct ratio_string<pebi, wchar_t>; template <> struct ratio_string<yobi, char>; template <> struct ratio_string<yobi, char16_t>; template <> struct ratio_string<yobi, char32_t>; template <> struct ratio_string<yobi, wchar_t>; }
template <class Ratio, class CharT> struct ratio_string { static std::basic_string<CharT> symbol(); static std::basic_string<CharT> prefix(); static std::basic_string<CharT> short_name(); // DEPRECATED V2 static std::basic_string<CharT> long_name(); // DEPRECATED V2 };
The class template ratio_string provides textual representations of the associated ratio appropriate for the character type charT.
The primary template provides generic strings. Specializations provide the same static member functions but these functions return the English SI prefix and symbol names as specified by the General Conference on Weights and Measures.
template<class Ratio, class CharT> basic_string<charT> ratio_string<Ratio, CharT>::prefix();
Returns: A basic_string of the form: [Ratio::num/Ratio::den]
Example: ratio_string<ratio<2, 60>, wchar_t>::prefix()
returns L"[1/30]"
.
template<class Ratio, class CharT> basic_string<charT> ratio_string<Ratio, CharT>::symbol();
Returns: prefix().
template<class Ratio, class CharT> basic_string<charT> ratio_string<Ratio, CharT>::long_name();
Returns: prefix().
template<class Ratio, class CharT> basic_string<charT> ratio_string<Ratio, CharT>::short_name();
Returns: symbol().
With compilers supporting char16_t and char32_t and with a standard library don't providing std::u16string and std::u32string you will need to define the macros BOOST_NO_CXX11_U16STRING and BOOST_NO_CXX11_U32STRING until Boost.Config defines them.
For each specialization the table gives the return value for prefix()
and symbol()
.
Table 31.1. The return values of specializations of ratio_string
Specialization |
|
|
---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<boost/ratio/mpl/rational_constant.hpp>
<boost/ratio/mpl/rational_c_tag.hpp>
<boost/ratio/mpl/numeric_cast.hpp>
<boost/ratio/mpl/arithmetic.hpp>
<boost/ratio/mpl/plus.hpp>
<boost/ratio/mpl/minus.hpp>
<boost/ratio/mpl/times.hpp>
<boost/ratio/mpl/divides.hpp>
<boost/ratio/mpl/gcd.hpp>
<boost/ratio/mpl/lcm.hpp>
<boost/ratio/mpl/negate.hpp>
<boost/ratio/mpl/abs.hpp>
<boost/ratio/mpl/sign.hpp>
<boost/ratio/mpl/comparison.hpp>
<boost/ratio/mpl/equal_to.hpp>
<boost/ratio/mpl/not_equal_to.hpp>
<boost/ratio/mpl/less.hpp>
<boost/ratio/mpl/less_equal.hpp>
<boost/ratio/mpl/greater.hpp>
<boost/ratio/mpl/greater_equal.hpp>
A Rational Constant is a holder class for a compile-time value of a rational type. Every Rational Constant is also a nullary Metafunction, returning itself. A rational constant object is implicitly convertible to the corresponding run-time value of the rational type.
In the following table and subsequent specifications, r is a model of Rational Constant.
Expression |
Type |
Complexity |
---|---|---|
|
|
Constant time |
|
A rational type |
Constant time |
|
An integral type |
Constant time |
|
An integral type |
Constant time |
|
An Integral constant expression |
Constant time |
|
An Integral constant expression |
Constant time |
|
Constant time |
|
|
Constant time |
Expression |
Semantics |
---|---|
|
r's tag type; r::tag::value is r's conversion rank. |
|
A cv-unqualified type of |
|
A cv-unqualified type of |
|
A cv-unqualified type of |
|
The numerator of the rational constant |
|
The denominator of the rational constant |
|
equal_to<n::type,n>::value == true. |
|
|
ratio
<>
This header includes all the rational constant related header files
#include <boost/ratio/mpl/rational_c_tag.hpp> #include <boost/ratio/mpl/numeric_cast.hpp> #include <boost/ratio/mpl/arithmetic.hpp> #include <boost/ratio/mpl/comparison.hpp>
namespace boost { namespace mpl { struct rational_c_tag : int_<10> {}; } }
namespace boost { namespace mpl { template<> struct numeric_cast< integral_c_tag,rational_c_tag >; } }
A Integral Constant is seen as a ratio with numerator the Integral Constant value and denominator 1.
template<> struct numeric_cast< integral_c_tag,rational_c_tag > { template< typename N > struct apply : ratio< N::value, 1 > { }; };
This header includes all the rational constant arithmetic MPL specializations.
#include <boost/ratio/mpl/plus.hpp> #include <boost/ratio/mpl/minus.hpp> #include <boost/ratio/mpl/times.hpp> #include <boost/ratio/mpl/divides.hpp> #include <boost/ratio/mpl/negate.hpp> #include <boost/ratio/mpl/abs.hpp> #include <boost/ratio/mpl/sign.hpp> #include <boost/ratio/mpl/gcd.hpp> #include <boost/ratio/mpl/lcm.hpp>
namespace boost { namespace mpl { template<> struct plus_impl< rational_c_tag,rational_c_tag >; } }
namespace boost { namespace mpl { template<> struct minus_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_subtract
template class.
template<>
struct plus_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_subtract
<R1, R2>
{
};
};
namespace boost { namespace mpl { template<> struct times_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_multiply
template class.
template<>
struct times_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_multiply
<R1, R2>
{
};
};
namespace boost { namespace mpl { template<> struct divides_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_divide
template class.
template<>
struct divides_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_divide
<R1, R2>
{
};
};
namespace boost { namespace mpl { template<> struct gcd_impl< rational_c_tag,rational_c_tag >; } }
namespace boost { namespace mpl { template<> struct lcm_impl< rational_c_tag,rational_c_tag >; } }
namespace boost { namespace mpl { template<> struct negate_impl< rational_c_tag >; } }
The specialization relays on the ratio_negate
template class.
template<>
struct negate_impl< rational_c_tag >
{
template< typename R > struct apply
: ratio_negate
<R>
{
};
};
namespace boost { namespace mpl { template<> struct abs_impl< rational_c_tag >; } }
namespace boost { namespace mpl { template<> struct sign_impl< rational_c_tag >; } }
The specialization relays on the ratio_sign
template class.
template<>
struct sign_impl< rational_c_tag >
{
template< typename R > struct apply
: ratio_sign
<R>
{
};
};
This header includes all the rational constant comparison MPL specializations.
#include <boost/ratio/mpl/equal_to.hpp> #include <boost/ratio/mpl/not_equal_to.hpp> #include <boost/ratio/mpl/less.hpp> #include <boost/ratio/mpl/less_equal.hpp> #include <boost/ratio/mpl/greater.hpp> #include <boost/ratio/mpl/greater_equal.hpp>
namespace boost { namespace mpl { template<> struct equal_to_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_equal
template class.
template<>
struct equal_to_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_equal
<R1, R2>
{
};
};
namespace boost { namespace mpl { template<> struct not_equal_to_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_not_equal
template class.
template<>
struct not_equal_to_impl< rational_c_tag,rational_c_tag >
{
template< typename R1, typename R2 > struct apply
: ratio_not_equal
<R1, R2>
{
};
};
namespace boost { namespace mpl { template<> struct less_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_less
template class.
template<> struct less_impl< rational_c_tag,rational_c_tag > { template< typename R1, typename R2 > struct apply : ratio_less<R1, R2> { }; };
namespace boost { namespace mpl { template<> struct less_equal_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_less_equal
template class.
template<> struct less_equal_impl< rational_c_tag,rational_c_tag > { template< typename R1, typename R2 > struct apply : ratio_less_equal<R1, R2> { }; };
namespace boost { namespace mpl { template<> struct greater_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_greater
template class.
template<> struct greater_impl< rational_c_tag,rational_c_tag > { template< typename R1, typename R2 > struct apply : ratio_greater<R1, R2> { }; };
namespace boost { namespace mpl { template<> struct greater_equal_impl< rational_c_tag,rational_c_tag >; } }
The specialization relays on the ratio_greater_equal
template
class.
template<> struct greater_equal_impl< rational_c_tag,rational_c_tag > { template< typename R1, typename R2 > struct apply : ratio_greater_equal<R1, R2> { }; };