The library provides some helper code to assist in defining new constants; the process for defining a constant called my_constant goes like this:

1. Define a function that calculates the value of the constant. This should be a template function, and be placed in boost/math/constants/calculate_constants.hpp if the constant is to be added to this library, or else defined at the top of your source file if not.

The function should look like this:

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

Then define a placeholder for the constant itself:

namespace boost{ namespace math{ namespace constants{

BOOST_DEFINE_MATH_CONSTANT(my_constant, 0.0, "0");

}}}

For example, to calculate π/2, add to 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);
}

Then to boost/math/constants/constants.hpp add:

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

	Note
	Previously defined constants like pi and e can be used, but by not simply calling pi<T>(); specifying the precision via the policy pi<T, policies::policy<policies::digits2<N> > >() is essential to ensure full accuracy.

Warning

Newly defined constants can only be used once they are included in boost/math/constants/constants.hpp. So if you add template <class T, class N> T constant_my_constant{...}, then you cannot define constant_my_constant until you add the temporary BOOST_DEFINE_MATH_CONSTANT(my_constant, 0.0, "0"). Failing to do this will result in surprising compile errors: 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. You will need an arbitrary precision type to use to calculate the value. This library currently supports either cpp_float, NTL::RR or mpfr_class used via the bindings in boost/math/bindings. The default is to use NTL::RR unless you define an alternate macro, for example, USE_MPFR or USE_CPP_FLOAT at the start of your program.

3. It is necessary to link to the Boost.Regex library, and probably to your chosen arbitrary precision type library.

4. You need to add libs\math\include_private to your compiler's include path as the needed header is not installed in the usual places by default (this avoids a cyclic dependency between the Math and Multiprecision library's headers).

5. The complete program to generate the constant half_pi using function calculate_half_pi is then:

#define USE_CPP_FLOAT // If required.
#include <boost/math/constants/generate.hpp>

int main()
{
   BOOST_CONSTANTS_GENERATE(half_pi);
}

The output from the program is a snippet of C++ code (actually a macro call) that can be cut and pasted into boost/math/constants/constants.hpp or else into your own code, for example:

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

This macro BOOST_DEFINE_MATH_CONSTANT inserts a C++ struct code snippet that declares the float, double and long double versions of the constant, plus a decimal digit string representation correct to 100 decimal digits, and all the meta-programming machinery needed to select between them.

The result of an expanded macro for Pi is shown below.

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