Initial commit

libs/math/example/policy_eg_6.cpp

@@ -0,0 +1,121 @@
+//  Copyright John Maddock 2007.
+//  Copyright Paul A. Bristow 2010
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Note that this file contains quickbook mark-up as well as code
+// and comments, don't change any of the special comment mark-ups!
+
+#include <iostream>
+using std::cout;  using std::endl;
+#include <cerrno> // for ::errno
+
+//[policy_eg_6
+
+/*`
+Suppose we want a set of distributions to behave as follows:
+
+* Return infinity on overflow, rather than throwing an exception.
+* Don't perform any promotion from double to long double internally.
+* Return the closest integer result from the quantiles of discrete
+distributions.
+
+We'll begin by including the needed header for all the distributions:
+*/
+
+#include <boost/math/distributions.hpp>
+
+/*`
+
+Open up an appropriate namespace, calling it `my_distributions`,
+for our distributions, and define the policy type we want.
+Any policies we don't specify here will inherit the defaults:
+
+*/
+
+namespace my_distributions
+{
+  using namespace boost::math::policies;
+  // using boost::math::policies::errno_on_error; // etc.
+
+  typedef policy<
+     // return infinity and set errno rather than throw:
+     overflow_error<errno_on_error>,
+     // Don't promote double -> long double internally:
+     promote_double<false>,
+     // Return the closest integer result for discrete quantiles:
+     discrete_quantile<integer_round_nearest>
+  > my_policy;
+
+/*`
+
+All we need do now is invoke the BOOST_MATH_DECLARE_DISTRIBUTIONS
+macro passing the floating point type `double` and policy types `my_policy` as arguments:
+
+*/
+
+BOOST_MATH_DECLARE_DISTRIBUTIONS(double, my_policy)
+
+} // close namespace my_namespace
+
+/*`
+
+We now have a set of typedefs defined in namespace my_distributions
+that all look something like this:
+
+``
+typedef boost::math::normal_distribution<double, my_policy> normal;
+typedef boost::math::cauchy_distribution<double, my_policy> cauchy;
+typedef boost::math::gamma_distribution<double, my_policy> gamma;
+// etc
+``
+
+So that when we use my_distributions::normal we really end up using
+`boost::math::normal_distribution<double, my_policy>`:
+
+*/
+
+int main()
+{
+   // Construct distribution with something we know will overflow
+  // (using double rather than if promoted to long double):
+   my_distributions::normal norm(10, 2);
+
+   errno = 0;
+   cout << "Result of quantile(norm, 0) is: "
+      << quantile(norm, 0) << endl; // -infinity.
+   cout << "errno = " << errno << endl;
+   errno = 0;
+   cout << "Result of quantile(norm, 1) is: "
+      << quantile(norm, 1) << endl; // +infinity.
+   cout << "errno = " << errno << endl;
+
+   // Now try a discrete distribution.
+   my_distributions::binomial binom(20, 0.25);
+   cout << "Result of quantile(binom, 0.05) is: "
+      << quantile(binom, 0.05) << endl; // To check we get integer results.
+   cout << "Result of quantile(complement(binom, 0.05)) is: "
+      << quantile(complement(binom, 0.05)) << endl;
+}
+
+/*`
+
+Which outputs:
+
+[pre
+Result of quantile(norm, 0) is: -1.#INF
+errno = 34
+Result of quantile(norm, 1) is: 1.#INF
+errno = 34
+Result of quantile(binom, 0.05) is: 1
+Result of quantile(complement(binom, 0.05)) is: 8
+]
+
+This mechanism is particularly useful when we want to define a
+project-wide policy, and don't want to modify the Boost source
+or set  project wide build macros (possibly fragile and easy to forget).
+
+*/
+//] //[/policy_eg_6]
+