| Home | Libraries | People | FAQ | More

### Policies Have Sensible Defaults

Most of the time you can just ignore the policy framework.

*The defaults for the various policies are as follows, if these work OK for you then you can stop reading now!

Domain Error

  Throws a `std::domain_error` exception.

Pole Error

  Occurs when a function is evaluated at a pole: throws a `std::domain_error` exception.

Overflow Error

  Throws a `std::overflow_error` exception.

Underflow

  Ignores the underflow, and returns zero.

Denormalised Result

  Ignores the fact that the result is denormalised, and returns it.

Rounding Error

  Throws a `boost::math::rounding_error` exception.

Internal Evaluation Error

  Throws a `boost::math::evaluation_error` exception.

Indeterminate Result Error

  Returns a result that depends on the function where the error occurred.

Promotion of float to double

  Does occur by default - gives full float precision results.

Promotion of double to long double

  Does occur by default if long double offers more precision than double.

Precision of Approximation Used

  By default uses an approximation that will result in the lowest level of error for the type of the result.

Behaviour of Discrete Quantiles

  The quantile function will by default return an integer result that has been rounded outwards. That is to say lower quantiles (where the probability is less than 0.5) are rounded downward, and upper quantiles (where the probability is greater than 0.5) are rounded upwards. This behaviour ensures that if an X% quantile is requested, then at least the requested coverage will be present in the central region, and no more than the requested coverage will be present in the tails.

  This behaviour can be changed so that the quantile functions are rounded differently, or even return a real-valued result using Policies. It is strongly recommended that you read the tutorial Understanding Quantiles of Discrete Distributions before using the quantile function on a discrete distribution. The reference docs describe how to change the rounding policy for these distributions.

What's more, if you define your own policy type, then it automatically inherits the defaults for any policies not explicitly set, so given:

    using namespace boost::math::policies;
    //
    // Define a policy that sets ::errno on overflow, and does
    // not promote double to long double internally:

    typedef policy
    <
      domain_error<errno_on_error>,
      promote_double<false>
    > my_policy;

then `my_policy` defines a policy where only the overflow error handling and `double`-promotion policies differ from the defaults.

We can also add a desired precision, for example, 9 bits or 3 decimal digits, to an error-handling policy, usually to trade precision for speed:

    typedef policy<domain_error<errno_on_error>, digit2<9> > my_policy;

Or if you want to further modify an existing user policy, use `normalise`:

    using boost::math::policies::normalise;

    typedef normalise<my_policy, digits2<9>>::type my_policy_9; // errno on error, and limited precision.