Reference . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Chapter 31. Boost.Ratio 2.1.0

// Configuration macros
#define BOOST_RATIO_VERSION 
#define BOOST_RATIO_EXTENSIONS
#define BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
#define BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0 
#define BOOST_RATIO_USES_STATIC_ASSERT
#define BOOST_RATIO_USES_MPL_ASSERT
#define BOOST_RATIO_USES_ARRAY_ASSERT

Extensions

Когда<BOOST_RATIO_EXTENSIONS>определено,Boost.Ratioобеспечивает дополнительно некоторое расширение стандарта C++, см. ниже.

Deprecated

Когда<BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0>определено, предоставляются амортизированные признаки, указанные как DEPRECATED V2.

Когда<BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0>определено, амортизационные признаки, указанные как DEPRECATED V2, не предоставляются.

Version

<BOOST_RATIO_VERSION>означает «Усиление». Соотношение версии, которое может быть 1 или 2. По умолчанию до 1.55 является версией 1. С 1.56 это будет 2.

Когда<BOOST_RATIO_VERSION>1<BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0>определено по умолчанию.

Когда<BOOST_RATIO_VERSION>2<BOOST_RATIO_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V2_0_0>определено по умолчанию.

Static Assert

При определении BOOST_NO_STATIC_ASSERT пользователь может выбрать способ представления статических утверждений. определять

<BOOST_RATIO_USES_STATIC_ASSERT>использовать буст. Статик-ассерт.
<BOOST_RATIO_USES_MPL_ASSERT>использоватьBoost.MPLстатические утверждения.
<BOOST_RATIO_USES_ARRAY_ASSERT>использоватьBoost.Ratioвнутренние статические утверждения.

Поведение по умолчанию, как если бы<BOOST_RATIO_USES_ARRAY_ASSERT>было определено.

Если<BOOST_RATIO_USES_MPL_ASSERT>не определено, то показаны следующие символы:

#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"

В зависимости от используемой системы статического утверждения, намек на отказное утверждение появится в той или иной форме в диагностическом выходе компилятора.

C++0x Recommendation

Header <boost/ratio.hpp>
Header <boost/ratio/ratio_fwd.hpp>
Header <boost/ratio/ratio.hpp>

Header `<boost/ratio.hpp>`

Этот заголовок включает в себя все связанные с соотношением файлы заголовка

#include <boost/ratio/ratio.hpp>
#include <boost/ratio/ratio_io.hpp>
#include <boost/ratio/rational_constant.hpp>

Header `<boost/ratio/ratio_fwd.hpp>`

Этот заголовок содержит форвардные декларации для файла<<boost/ratio/ratio.hpp>>.

namespace boost  {
    template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
    // ratio arithmetic
    template <class R1, class R2> struct ratio_add;
    template <class R1, class R2> struct ratio_subtract;
    template <class R1, class R2> struct ratio_multiply;
    template <class R1, class R2> struct ratio_divide;
#ifdef BOOST_RATIO_EXTENSIONS
    template <class R,int P> struct ratio_power;
    template <class R> struct ratio_negate;
    template <class R> struct ratio_sign;
    template <class R> struct ratio_abs;
    template <class R1, class R2> struct ratio_gcd;
    template <class R1, class R2> struct ratio_lcm;
#endif
    // ratio comparison
    template <class R1, class R2> struct ratio_equal;
    template <class R1, class R2> struct ratio_not_equal;
    template <class R1, class R2> struct ratio_less;
    template <class R1, class R2> struct ratio_less_equal;
    template <class R1, class R2> struct ratio_greater;
    template <class R1, class R2> struct ratio_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
}

Header `<boost/ratio/ratio.hpp>`

Class Template ratio<>
ratio Arithmetic
ratio Comparison
SI typedefs
IEC typedefs
Limitations
Extensions

<ratio>является средством, которое полезно для определения рациональных констант времени компиляции. Компиляционно-временная рациональная арифметика поддерживается защитой от переполнения и деления на ноль. Такая установка очень удобна для эффективного представления 1/3 наносекунды или для указания дюйма с точки зрения метров (например, 254/10000 метров - что<ratio>сократится до 127/5000 метров).

Class Template `ratio<>`

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

Диагностика испускается, если<ratio>инстанцируется<D== 0>, или если абсолютное значение<N>или<D>не может быть представлено.Примечание:Эти правила гарантируют, что можно избежать бесконечных соотношений и что для любого отрицательного входа существует репрезентабельное значение его абсолютного значения, которое является положительным. В представлении двух комплементов это исключает самое отрицательное значение.

Члены num и den будут нормализованными значениями шаблонных аргументов N и D, вычисленных следующим образом. Пусть<gcd>обозначает наибольший общий делитель абсолютной величины<N>и абсолютной величины<D>. Тогда:

<num>имеет значение<sign(N)*sign(D)*abs(N)/gcd>.
<den>имеет значение<abs(D)/gcd>.

Вложенный типдеф<type>обозначает нормализованную форму этого<ratio>типа. Он должен использоваться, когда требуется нормализованная форма аргументов шаблона, поскольку аргументы не обязательно нормализуются.

Два<ratio>класса<ratio><N1>и<ratio><N2>D2>D2>имеют такую же нормализованную форму, если<ratio><N1>::D1>::типявляется тем же типом, что и<




Construction
            and Assignment

Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.

              Default
              Constructor
            ratio()=default;

Эффекты:Конструирует<ratio>объект.

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

Эффекты:Конструирует<ratio>объект.
Замечания:Этот конструктор не будет участвовать в разрешении перегрузки, если<r>не имеет такой же нормализованной формы, как<*this>.

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

Эффекты:Назначает<ratio>объект.
176Возвращается:*это.
Замечания:Этот оператор не будет участвовать в разрешении перегрузки, если<r>не имеет такой же нормализованной формы, как<*this>.



MPL Numeric
            Metafunctions

Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Для работы сBoost.MPLчисловыми метафункциями в качествеRational Constantбыло добавлено следующее:
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;




Observers

Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
static value_type value();
value_type operator()() const;

Возврат:значение_тип (номер, ден);




ratio Arithmetic

Для каждого из шаблонов классов в этом разделе каждый параметр шаблона относится к<ratio>. Если реализация не может сформировать указанный<ratio>из-за переполнения, будет выдана диагностика.


            ratio_add<>
          
template <class R1, class R2> struct ratio_add {
   typedef [/see below] type;
};

Вложенный типдеф<type>является синонимом<ratio><R1::R2::denR2::R1,R1denR2::den>]::тип.


            ratio_subtract<>
          
template <class R1, class R2> struct ratio_subtract {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio><R1::R2денR2::R1::дендендендендендендендентип.


            ratio_multiply<>
          
template <class R1, class R2> struct ratio_multiply {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio><R1::numR2::num,R1::denR2den>::тип.


            ratio_divide<>
          
template <class R1, class R2> struct ratio_divide {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio><R1::numR2::den,R2::numR1::den>::тип.


            ratio_power<>
          
Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
template <class R, int P> struct ratio_power {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<R*
           *R>P раз.


            ratio_negate<>
          
Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Это расширение стандарта C++ помогает в определении некоторыхBoost.MPLчисловых метафункций.
template <class R> struct ratio_negate {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio><-R::num,R::den>::тип.


            ratio_abs<>
          
Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Это расширение стандарта C++ помогает в определении некоторыхBoost.MPLчисловых метафункций.
template <class R> struct ratio_abs {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio><abs_c<intmax_t,R::num>::значение,Rden>::тип.


            ratio_sign<>
          
Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Это расширение стандарта C++ помогает в определении некоторыхBoost.MPLчисловых метафункций.
template <class R> struct ratio_sign {
   typedef  [/see below]  type;
};

Вложенный шрифт<type>является синонимом<sign_c<intmax_t,R::num>::type>.


            ratio_gcd<>
          
Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Это расширение стандарта C++ помогает в определении некоторыхBoost.MPLчисловых метафункций.
template <class R1, class R2> struct ratio_gcd {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio<gcd_c<intmax_t,R1::num,R2::num>::value,mpl::lcm_c<intmax_t,R1::den,R2::den>::value>::type>.


            ratio_lcm<>
          
Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Это расширение стандарта C++ помогает в определении некоторыхBoost.MPLчисловых метафункций.
template <class R1, class R2> struct ratio_lcm {
   typedef  [/see below]  type;
};

Вложенный типдеф<type>является синонимом<ratio<lcm_c<intmax_t,R1::num,R2::num>::value,gcd_c<intmax_t,R1::den,R2::den>::value>::type>.



ratio Comparison



            ratio_equal<>
          
template <class R1, class R2>  struct ratio_equal
    : public boost::integral_constant<bool, [/see below] > {};

Если R1::num == R2::num && R1::den == R2::den, ratio_equal происходит от true_type, то другое происходит от 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] > {};

Если R1::num * R2::den< R2::num * R1::den, ratio_less происходит от true_type, то другое происходит от 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> {};




SI
          typedefs

Международная система единицопределяет двадцать префиксов СИ.Соотношениеопределяет все, кроме<yocto>,<zepto>,<zetta>и<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;




IEC
          typedefs

Включено только в том случае, если<BOOST_RATIO_EXTENSIONS>определено.
Конкретные единицы IEC 60027-2 A.2 и ISO/IEC 80000определяют префиксы IEC по высоте.Соотношениеопределяет все, кроме<zebi>и<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;




Limitations

Ниже приведены ограничения Boost. Соотношение относительно спецификации в проекте стандарта C++0x:

Четыре единицы типа SI —<yocto>,<zepto>,<zetta>и<yotta>— должны поддерживаться условно, если позволяет диапазон<intmax_t>, но не поддерживаютсяBoost.Ratio.
Соотношение должно быть статичным<constexpr
               intmax_t>(см.) Значения коэффициентов должны быть constexpr, но для компилятора, не поддерживающего<constexpr>сегодня,Boost.Ratioиспользует<static
               constintmax_t>.
Рациональная арифметика должна использовать псевдонимы шаблонов (см.Рациональная арифметика должна использовать псевдонимы шаблонов), но они не доступны в C++03, поэтому вместо этого используется наследование.




Extensions

Когда<BOOST_RATIO_EXTENSIONS>определеноBoost.Ratioобеспечивает следующие расширения:

Расширяет требования стандарта проекта C++0x, заставляя конструктора копий и оператора присваивания копий иметь одну и ту же нормированную форму (см.конструктор копий и присваивание между соотношениями, имеющими одну и ту же нормированную форму).
Более стандартный C++, такой как метафункции, применяется к типам соотношений, таким как __static_abs или __static_negate.
Рациональная константа __Boost_Mpl и связанные с ней арифметические и сравнительные специализации __Boost_Mpl, включая __numeric_cast, __plus, __equal_to.




Ratio I/O

Header <boost/ratio/ratio_io.hpp>


Header <boost/ratio/ratio_io.hpp>


Template
          Class ratio_string<>
Specializations
          for ratio_string<>

Этот заголовок предоставляет<ratio_string<>>, который может генерировать текстовое представление<ratio<>>в виде<std::basic_string<>>. Эти строки могут быть полезны для ввода/вывода.
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_string<>

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

Шаблон класса ratio_string предоставляет текстовые представления соответствующего соотношения, соответствующего типу символа charT.
Основной шаблон предоставляет общие строки. Специализации обеспечивают те же статические функции членов, но эти функции возвращают английский префикс SI и названия символов, как указано Генеральной конференцией по весам и мерам.


Static
            Member function prefix()

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

Возвращение: A basic_string of the form: [Соотношение::num/Ratio::den]
Пример:<ratio_string<ratio<2,60>,wchar_t>::prefix()>возвращает<L"[1/30]">.



Static
            Member function symbol()

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

Возвращение: приставка().



Static
            Member function long_name() DEPRECATED V2

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

Возвращение: приставка().



Static
            Member function short_name() DEPRECATED V2

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

Возвращение: символ().




Specializations
          for ratio_string<>

С компиляторами, поддерживающими char16_t и char32_t, и со стандартной библиотекой, не предоставляющей std::u16string и std::u32string, вам нужно будет определить макросы BOOST_NO_CXX11_U16STRING и BOOST_NO_CXX11_U32STRING до Boost. Config определяет их.
Для каждой специализации таблица дает значение возврата для<prefix()>и<symbol()>.

Table 31.1. The return values of specializations of ratio_string








                    Специализация
                  

                    <prefix()>
                  

                    <symbol()>
                  



<ratio_string<atto,char>>

<"atto">

<"a">



<ratio_string<atto,char16_t>>

<u"atto">

<u"a">



<ratio_string<atto,char32_t>>

<U"atto">

<U"a">



<ratio_string<atto,wchar_t>>

<L"atto">

<L"a">



<ratio_string<femto,char>>

<"femto">

<"f">



<ratio_string<femto,char16_t>>

<u"femto">

<u"f">



<ratio_string<femto,char32_t>>

<U"femto">

<U"f">



<ratio_string<femto,wchar_t>>

<L"femto">

<L"f">



<ratio_string<pico,char>>

<"pico">

<"p">



<ratio_string<pico,char16_t>>

<u"pico">

<u"p">



<ratio_string<pico,char32_t>>

<U"pico">

<U"p">



<ratio_string<pico,wchar_t>>

<L"pico">

<L"p">



<ratio_string<nano,char>>

<"nano">

<"a">



<ratio_string<nano,char16_t>>

<u"nano">

<u"a">



<ratio_string<nano,char32_t>>

<U"nano">

<U"a">



<ratio_string<nano,wchar_t>>

<L"nano">

<L"a">



<ratio_string<micro,char>>

<"micro">

<u8"\u00B5">



<ratio_string<micro,char16_t>>

<u"micro">

<u"\u00B5">



<ratio_string<micro,char32_t>>

<U"micro">

<U"\u00B5">



<ratio_string<micro,wchar_t>>

<L"micro">

<Lu8"\u00B5">



<ratio_string<milli,char>>

<"milli">

<"m">



<ratio_string<milli,char16_t>>

<u"milli">

<u"m">



<ratio_string<milli,char32_t>>

<U"milli">

<U"m">



<ratio_string<milli,wchar_t>>

<L"milli">

<L"m">



<ratio_string<centi,char>>

<"centi">

<"c">



<ratio_string<centi,char16_t>>

<u"centi">

<u"c">



<ratio_string<centi,char32_t>>

<U"centi">

<U"c">



<ratio_string<centi,wchar_t>>

<L"centi">

<L"c">



<ratio_string<deci,char>>

<"deci">

<"d">



<ratio_string<deci,char16_t>>

<u"deci">

<u"d">



<ratio_string<deci,char32_t>>

<U"deci">

<U"d">



<ratio_string<deci,wchar_t>>

<L"deci">

<L"d">



<ratio_string<deca,char>>

<"deca">

<"da">



<ratio_string<deca,char16_t>>

<u"deca">

<u"da">



<ratio_string<deca,char32_t>>

<U"deca">

<U"da">



<ratio_string<deca,wchar_t>>

<L"deca">

<L"da">



<ratio_string<hecto,char>>

<"hecto">

<"h">



<ratio_string<hecto,char16_t>>

<u"hecto">

<u"h">



<ratio_string<hecto,char32_t>>

<U"hecto">

<U"h">



<ratio_string<hecto,wchar_t>>

<L"hecto">

<L"h">



<ratio_string<kilo,char>>

<"kilo">

<"k">



<ratio_string<kilo,char16_t>>

<u"kilo">

<u"k">



<ratio_string<kilo,char32_t>>

<U"kilo">

<U"k">



<ratio_string<kilo,wchar_t>>

<L"kilo">

<L"k">



<ratio_string<mega,char>>

<"mega">

<"M">



<ratio_string<mega,char16_t>>

<u"mega">

<u"M">



<ratio_string<mega,char32_t>>

<U"mega">

<U"M">



<ratio_string<mega,wchar_t>>

<L"mega">

<L"M">



<ratio_string<giga,char>>

<"giga">

<"G">



<ratio_string<giga,char16_t>>

<u"giga">

<u"G">



<ratio_string<giga,char32_t>>

<U"giga">

<U"G">



<ratio_string<giga,wchar_t>>

<L"giga">

<L"G">



<ratio_string<tera,char>>

<"tera">

<"T">



<ratio_string<tera,char16_t>>

<u"tera">

<u"T">



<ratio_string<tera,char32_t>>

<U"tera">

<U"T">



<ratio_string<tera,wchar_t>>

<L"tera">

<L"T">



<ratio_string<peta,char>>

<"peta">

<"P">



<ratio_string<peta,char16_t>>

<u"peta">

<u"P">



<ratio_string<peta,char32_t>>

<U"peta">

<U"P">



<ratio_string<peta,wchar_t>>

<L"peta">

<L"P">



<ratio_string<exa,char>>

<"exa">

<"E">



<ratio_string<exa,char16_t>>

<u"exa">

<u"E">



<ratio_string<exa,char32_t>>

<U"exa">

<U"E">



<ratio_string<exa,wchar_t>>

<L"exa">

<L"E">












Rational Constant


Rational Constant
        Concept
Header
        <boost/ratio/mpl/rational_constant.hpp>
Header
        <boost/ratio/mpl/rational_c_tag.hpp>
Header <boost/ratio/mpl/numeric_cast.hpp>
Header <boost/ratio/mpl/arithmetic.hpp>
Header <boost/ratio/mpl/plus.hpp>
Header <boost/ratio/mpl/minus.hpp>
Header <boost/ratio/mpl/times.hpp>
Header <boost/ratio/mpl/divides.hpp>
Header <boost/ratio/mpl/gcd.hpp>
Header <boost/ratio/mpl/lcm.hpp>
Header <boost/ratio/mpl/negate.hpp>
Header <boost/ratio/mpl/abs.hpp>
Header <boost/ratio/mpl/sign.hpp>
Header <boost/ratio/mpl/comparison.hpp>
Header <boost/ratio/mpl/equal_to.hpp>
Header <boost/ratio/mpl/not_equal_to.hpp>
Header <boost/ratio/mpl/less.hpp>
Header <boost/ratio/mpl/less_equal.hpp>
Header <boost/ratio/mpl/greater.hpp>
Header
        <boost/ratio/mpl/greater_equal.hpp>



Rational Constant
        Concept



          Description
        
Рациональная постояннаяявляется классом держателей для значения времени компиляции рационального типа. КаждаяРациональная постояннаятакже является нулевой метафункцией, возвращающейся сама собой. Рациональный постоянный объект неявно преобразуется в соответствующее значение времени выполнения рационального типа.


          Expression
          requirements
        
В следующей таблице и последующих спецификациях r является модельюRational Constant.








                  выражение

                  Тип

                  сложность




                  
                    r::tag
                  
<rational_c_tag>

Постоянное время




                  
                    r::value_type
                  
Рациональный тип

Постоянное время



<r::num_type>

Интегральный тип

Постоянное время



<r::den_type>

Интегральный тип

Постоянное время



<r::num>

Интегральное постоянное выражение

Постоянное время



<r::den>

Интегральное постоянное выражение

Постоянное время




                  
                    r::type
                  

                  
                    Rational
                    Constant
                  
Постоянное время



<r::value_typeconst
                   c=r()>


Постоянное время






          Expression
          semantics
        







                  выражение

                  Семантика




                  
                    r::tag
                  
r's tag type; r::tag::value is r's conversion rank.




                  
                    r::value_type
                  

                  
                    A cv-unqualified type of r()
                  


<r::num_type>

<r::num>



<r::den_type>


                  
                    A cv-unqualified type of r::den
                  


<r::num>

Числитель рациональной постоянной



<r::den>

Знаменатель рациональной постоянной




                  
                    r::type
                  
equal_to::value == true.



<r::value_typeconst
                   c=r()>


                  
                    r::value_type const
                    c=r::value_type(r::num,r::den)
                  





          Models
        
<ratio><>



Header
        <boost/ratio/mpl/rational_constant.hpp>

Этот заголовок включает в себя все рациональные постоянные связанные файлы заголовка.
#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>




Header
        <boost/ratio/mpl/rational_c_tag.hpp>

namespace boost {
namespace mpl {
    struct rational_c_tag : int_<10> {};
}
}




Header <boost/ratio/mpl/numeric_cast.hpp>

mpl::numeric_cast<>
          Specialization
namespace boost {
namespace mpl {
    template<> struct numeric_cast< integral_c_tag,rational_c_tag >;
}
}



mpl::numeric_cast<>
          Specialization

Интегральная постоянная рассматривается как отношение с числителем, значением интегральной постоянной и знаменателем 1.
template<> struct numeric_cast< integral_c_tag,rational_c_tag >
{
    template< typename N > struct apply
        : ratio< N::value, 1 >
    {
    };
};





Header <boost/ratio/mpl/arithmetic.hpp>

Этот заголовок включает в себя все рациональные постоянные арифметические специализации MPL.
#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>




Header <boost/ratio/mpl/plus.hpp>

mpl::plus_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct plus_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::plus_impl<>
          Specialization

Специализация реле на<ratio_add>класс шаблонов.
template<>
struct plus_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_add<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/minus.hpp>

mpl::minus_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct minus_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::minus_impl<>
          Specialization

Специализация реле на<ratio_subtract>класс шаблонов.
template<>
struct plus_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_subtract<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/times.hpp>

mpl::times_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct times_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::times_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_multiply>.
template<>
struct times_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_multiply<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/divides.hpp>

mpl::divides_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct divides_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::divides_impl<>
          Specialization

Специализация реле на<ratio_divide>класс шаблонов.
template<>
struct divides_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_divide<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/gcd.hpp>

mpl::gcd_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct gcd_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::gcd_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_gcd>.
template<>
struct gcd_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_gcd<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/lcm.hpp>

mpl::lcm_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct lcm_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::lcm_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_lcm>.
template<>
struct lcm_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_lcm<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/negate.hpp>

mpl::negate_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct negate_impl< rational_c_tag >;
}
}



mpl::negate_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_negate>.
template<>
struct negate_impl< rational_c_tag >
{
    template< typename R > struct apply
        : ratio_negate<R>
    {
    };
};





Header <boost/ratio/mpl/abs.hpp>

mpl::abs_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct abs_impl< rational_c_tag >;
}
}



mpl::abs_impl<>
          Specialization

Специализация реле на<ratio_abs>класс шаблонов.
template<>
struct abs_impl< rational_c_tag >
{
    template< typename R > struct apply
        : ratio_abs<R>
    {
    };
};





Header <boost/ratio/mpl/sign.hpp>

mpl::sign_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct sign_impl< rational_c_tag >;
}
}



mpl::sign_impl<>
          Specialization

Специализация реле на<ratio_sign>класс шаблонов.
template<>
struct sign_impl< rational_c_tag >
{
    template< typename R > struct apply
        : ratio_sign<R>
    {
    };
};





Header <boost/ratio/mpl/comparison.hpp>

Этот заголовок включает в себя все рациональные специализации постоянного сравнения MPL.
#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>




Header <boost/ratio/mpl/equal_to.hpp>

mpl::equal_to_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct equal_to_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::equal_to_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_equal>.
template<>
struct equal_to_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_equal<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/not_equal_to.hpp>

mpl::not_equal_to_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct not_equal_to_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::not_equal_to_impl<>
          Specialization

Специализация реле на<ratio_not_equal>класс шаблонов.
template<>
struct not_equal_to_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_not_equal<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/less.hpp>

mpl::less_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct less_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::less_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_less>.
template<>
struct less_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_less<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/less_equal.hpp>

mpl::less_equal_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct less_equal_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::less_equal_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_less_equal>.
template<>
struct less_equal_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_less_equal<R1, R2>
    {
    };
};





Header <boost/ratio/mpl/greater.hpp>

mpl::greater_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct greater_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::greater_impl<>
          Specialization

Специализация ретранслируется на класс шаблонов<ratio_greater>.
template<>
struct greater_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_greater<R1, R2>
    {
    };
};





Header
        <boost/ratio/mpl/greater_equal.hpp>

mpl::greater_equal_impl<>
          Specialization
namespace boost {
namespace mpl {
    template<>
    struct greater_equal_impl< rational_c_tag,rational_c_tag >;
}
}



mpl::greater_equal_impl<>
          Specialization

Специализация реле на<ratio_greater_equal>класс шаблонов.
template<>
struct greater_equal_impl< rational_c_tag,rational_c_tag >
{
    template< typename R1, typename R2 > struct apply
        : ratio_greater_equal<R1, R2>
    {
    };
};