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:

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 ratio<N1,D1> and ratio<N2,D2> have the same normalized form if ratio<N1,D1>::type is the same type as ratio<N2,D2>::type

ratio()=default;

template <intmax_t N2, intmax_t D2>
  ratio(const ratio<N2, D2>& r);

template <intmax_t N2, intmax_t D2>
  ratio& operator=(const ratio<N2, D2>& r);

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;

static value_type value();
value_type operator()() const;

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

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:

When BOOST_RATIO_EXTENSIONS is defined Boost.Ratio provides the following extensions:

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

template<class Ratio, class CharT>
basic_string<charT>
ratio_string<Ratio, CharT>::symbol();

template<class Ratio, class CharT>
basic_string<charT>
ratio_string<Ratio, CharT>::long_name();

template<class Ratio, class CharT>
basic_string<charT>
ratio_string<Ratio, CharT>::short_name();

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

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

The specialization relays on the ratio_add template class.

template<>
struct plus_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_add<R1, R2>
    {
    };
};

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

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

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

The specialization relays on the ratio_gcd template class.

template<>
struct gcd_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_gcd<R1, R2>
    {
    };
};

The specialization relays on the ratio_lcm template class.

template<>
struct lcm_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_lcm<R1, R2>
    {
    };
};

The specialization relays on the ratio_negate template class.

template<>
struct negate_impl< rational_c_tag >
{
    template< typename R > struct apply
        : ratio_negate<R>
    {
    };
};

The specialization relays on the ratio_abs template class.

template<>
struct abs_impl< rational_c_tag >
{
    template< typename R > struct apply
        : ratio_abs<R>
    {
    };
};

The specialization relays on the ratio_sign template class.

template<>
struct sign_impl< rational_c_tag >
{
    template< typename R > struct apply
        : ratio_sign<R>
    {
    };
};

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

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

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

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

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

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