Библиотека предоставляет некоторый вспомогательный код, чтобы помочь в определении новых констант; процесс определения константы под названием<my_constant>выглядит следующим образом:

1.Определить функцию, вычисляющую значение постоянной. Это должна быть функция шаблона и быть помещена в<boost/math/constants/calculate_constants.hpp>, если константа должна быть добавлена в эту библиотеку или определена в верхней части исходного файла, если нет.

Функция должна выглядеть так:

namespace boost{ namespace math{ namespace constants{ namespace detail{
template <class Real>
template <int N>
Real constant_my_constant<Real>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
{
  int required_precision = N ? N : tools::digits<Real>();
  Real result = /* value computed to required_precision bits */ ;
  return result;
}
}}}} // namespaces

Затем определите заполнитель для самой константы:

namespace boost{ namespace math{ namespace constants{
BOOST_DEFINE_MATH_CONSTANT(my_constant, 0.0, "0");
}}}

Например, вычислить π/2, добавить к<boost/math/constants/calculate_constants.hpp>

template <class T>
template<int N>
inline T constant_half_pi<T>::compute(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE_SPEC(mpl::int_<N>))
{
   BOOST_MATH_STD_USING
   return pi<T, policies::policy<policies::digits2<N> > >() / static_cast<T>(2);
}

<boost/math/constants/constants.hpp>Добавить:

BOOST_DEFINE_MATH_CONSTANT(half_pi, 0.0, "0");  // Actual values are temporary, we'll replace them later.

	Note
	Можно использовать ранее определенные константы, такие как pi и e, ноне просто вызов<pi<T>()>; для обеспечения полной точности необходимо указать точность с помощью политики<pi<T, policies::policy<policies::digits2<N>>>()>.

Warning

Новые константы могут быть использованы только после их включения в<boost/math/constants/constants.hpp>. Если вы добавите<template<classT,classN>Tconstant_my_constant{...}>, то не сможете определить<constant_my_constant>, пока не добавите временное<BOOST_DEFINE_MATH_CONSTANT(my_constant,0.0, "0")>. Неспособность сделать это приведет к удивительным ошибкам компиляции: error C2143: syntax error : missing ';' before '<' error C2433: 'constant_root_two_div_pi' : 'inline' not permitted on data declarations error C2888: 'T constant_root_two_div_pi' : symbol cannot be defined within namespace 'detail' error C2988: unrecognizable template declaration/definition

2.Для вычисления значения потребуется произвольный тип точности. Эта библиотека в настоящее время поддерживает либо<cpp_float>,<NTL::RR>или<mpfr_class>, используемые через привязки в<boost/math/bindings>. По умолчанию используется<NTL::RR>, если вы не определите альтернативный макрос, например<USE_MPFR>или<USE_CPP_FLOAT>в начале вашей программы.

3.Необходимо привязать к бусту. Библиотека Regex и, вероятно, выбранная вами библиотека произвольного типа.

4.В компилятор нужно добавить<libs\math\include_private>путь включения, поскольку необходимый заголовок по умолчанию не устанавливается в обычных местах (это позволяет избежать циклической зависимости между заголовками библиотеки Math и Multiprecision).

5.Полная программа для генерации константы<half_pi>с помощью функции<calculate_half_pi>заключается в следующем:

#define USE_CPP_FLOAT // If required.
#include <boost/math/constants/generate.hpp>
int main()
{
   BOOST_CONSTANTS_GENERATE(half_pi);
}

Выход из программы представляет собой фрагмент кода C++ (на самом деле макро-вызов), который может быть вырезан и вставлен в<boost/math/constants/constants.hpp>или в ваш собственный код, например:

  BOOST_DEFINE_MATH_CONSTANT(half_pi, 1.570796326794896619231321691639751442e+00, "1.57079632679489661923132169163975144209858469968755291048747229615390820314310449931401741267105853399107404326e+00");

Этот макрософт BOOST_DEFINE_MATH_CONSTANT вставляет фрагмент структурированного кода C++, который объявляет<float>,<double>и<long double>версии константы, плюс десятичное представление строки с точностью до 100 десятичных цифр и все механизмы метапрограммирования, необходимые для выбора между ними.

Результат расширенного макроса для Pi показан ниже.

// Preprocessed pi constant, annotated.
namespace boost
{
  namespace math
  {
    namespace constants
    {
      namespace detail
      {
        template <class T> struct constant_pi
        {
          private:
            // Default implementations from string of decimal digits:
            static inline T get_from_string()
            {
            static const T result
               = detail::convert_from_string<T>("3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651e+00",
               boost::is_convertible<const char*, T>());
              return result;
            }
            template <int N> static T compute();
          public:
            // Default implementations from string of decimal digits:
            static inline T get(const mpl::int_<construct_from_string>&)
            {
              constant_initializer<T, & constant_pi<T>::get_from_string >::do_nothing();
              return get_from_string();
            }
            // Float, double and long double versions:
            static inline T get(const mpl::int_<construct_from_float>)
            {
              return 3.141592653589793238462643383279502884e+00F;
            }
            static inline  T get(const mpl::int_<construct_from_double>&)
            {
              return 3.141592653589793238462643383279502884e+00;
            }
            static inline  T get(const mpl::int_<construct_from_long_double>&)
            {
              return 3.141592653589793238462643383279502884e+00L;
            }
            // For very high precision that is nonetheless can be calculated at compile time:
            template <int N> static inline T get(const mpl::int_<N>& n)
            {
              constant_initializer2<T, N, & constant_pi<T>::template compute<N> >::do_nothing();
              return compute<N>();
            }
            //For true arbitrary precision, which may well vary at runtime.
            static inline T get(const mpl::int_<0>&)
            {
              return tools::digits<T>() > max_string_digits ? compute<0>() : get(mpl::int_<construct_from_string>());
            }
         }; // template <class T> struct constant_pi
      } //  namespace detail
      // The actual forwarding function (including policy to control precision).
      template <class T, class Policy> inline T pi( )
      {
        return detail:: constant_pi<T>::get(typename construction_traits<T, Policy>::type());
      }
      // The actual forwarding function (using default policy to control precision).
      template <class T> inline  T pi()
      {
        return pi<T, boost::math::policies::policy<> >()
      }
    } //     namespace constants
    // Namespace specific versions, for the three built-in floats:
    namespace float_constants
    {
      static const float pi = 3.141592653589793238462643383279502884e+00F;
    }
    namespace double_constants
    {
      static const double pi = 3.141592653589793238462643383279502884e+00;
    }
    namespace long_double_constants
    {
      static const long double pi = 3.141592653589793238462643383279502884e+00L;
    }
    namespace constants{;
    } // namespace constants
  } // namespace math
} // namespace boost