The member typedefs of class policy
are intended for internal use but are documented briefly here for the sake
of completeness.

policy<...>::domain_error_type

Specifies how domain errors are handled, will be an instance of boost::math::policies::domain_error<>
with the template argument to domain_error
one of the error_policy_type
enumerated values.

policy<...>::pole_error_type

Specifies how pole-errors are handled, will be an instance of boost::math::policies::pole_error<>
with the template argument to pole_error
one of the error_policy_type
enumerated values.

policy<...>::overflow_error_type

Specifies how overflow errors are handled, will be an instance of boost::math::policies::overflow_error<>
with the template argument to overflow_error
one of the error_policy_type
enumerated values.

policy<...>::underflow_error_type

Specifies how underflow errors are handled, will be an instance of boost::math::policies::underflow_error<>
with the template argument to underflow_error
one of the error_policy_type
enumerated values.

policy<...>::denorm_error_type

Specifies how denorm errors are handled, will be an instance of boost::math::policies::denorm_error<>
with the template argument to denorm_error
one of the error_policy_type
enumerated values.

policy<...>::rounding_error_type

Specifies how rounding errors are handled, will be an instance of boost::math::policies::rounding_error<>
with the template argument to rounding_error
one of the error_policy_type
enumerated values.

policy<...>::evaluation_error_type

Specifies how evaluation errors are handled, will be an instance of boost::math::policies::evaluation_error<>
with the template argument to evaluation_error
one of the error_policy_type
enumerated values.

policy<...>::indeterminate_error_type

Specifies how indeterminate result errors are handled, will be an instance
of boost::math::policies::indeterminate_result_error<>
with the template argument to indeterminate_result_error
one of the error_policy_type
enumerated values.

policy<...>::precision_type

Specifies the internal precision to use in binary digits (uses zero to represent
whatever the default precision is). Will be an instance of boost::math::policies::digits2<N> which
in turn inherits from boost::mpl::int_<N>.

policy<...>::promote_float_type

Specifies whether or not to promote float
arguments to double precision
internally. Will be an instance of boost::math::policies::promote_float<B>
which in turn inherits from boost::mpl::bool_<B>.

policy<...>::promote_double_type

Specifies whether or not to promote double
arguments to longdouble
precision internally. Will be an instance of boost::math::policies::promote_float<B>
which in turn inherits from boost::mpl::bool_<B>.

policy<...>::discrete_quantile_type

Specifies how discrete quantiles are evaluated, will be an instance of boost::math::policies::discrete_quantile<>
instantiated with one of the discrete_quantile_policy_type
enumerated type.

policy<...>::assert_undefined_type

Specifies whether mathematically-undefined properties are asserted as compile-time
errors, or treated as runtime errors instead. Will be an instance of boost::math::policies::assert_undefined<B> which
in turn inherits from boost::math::mpl::bool_<B>.

The normalise class template
converts one instantiation of the policy
class into a normalised form. This is used internally to reduce code bloat:
so that instantiating a special function on policy<A,B> or
policy<B,A> actually both generate the same code
internally.

Further more, normalise can
be used to combine a policy with one or more policies: for example many of
the special functions will use this to set policies which they don't make
use of to their default values, before forwarding to the actual implementation.
In this way code bloat is reduced, since the actual implementation depends
only on the policy types that they actually use.