184 lines
5.5 KiB
C++
184 lines
5.5 KiB
C++
// 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!
|
|
|
|
//[policy_eg_10
|
|
|
|
/*`
|
|
|
|
To understand how the rounding policies for
|
|
the discrete distributions can be used, we'll
|
|
use the 50-sample binomial distribution with a
|
|
success fraction of 0.5 once again, and calculate
|
|
all the possible quantiles at 0.05 and 0.95.
|
|
|
|
Begin by including the needed headers (and some using statements for conciseness):
|
|
|
|
*/
|
|
#include <iostream>
|
|
using std::cout; using std::endl;
|
|
using std::left; using std::fixed; using std::right; using std::scientific;
|
|
#include <iomanip>
|
|
using std::setw;
|
|
using std::setprecision;
|
|
|
|
#include <boost/math/distributions/binomial.hpp>
|
|
/*`
|
|
|
|
Next we'll bring the needed declarations into scope, and
|
|
define distribution types for all the available rounding policies:
|
|
|
|
*/
|
|
// Avoid
|
|
// using namespace std; // and
|
|
// using namespace boost::math;
|
|
// to avoid potential ambiguity of names, like binomial.
|
|
// using namespace boost::math::policies; is small risk, but
|
|
// the necessary items are brought into scope thus:
|
|
|
|
using boost::math::binomial_distribution;
|
|
using boost::math::policies::policy;
|
|
using boost::math::policies::discrete_quantile;
|
|
|
|
using boost::math::policies::integer_round_outwards;
|
|
using boost::math::policies::integer_round_down;
|
|
using boost::math::policies::integer_round_up;
|
|
using boost::math::policies::integer_round_nearest;
|
|
using boost::math::policies::integer_round_inwards;
|
|
using boost::math::policies::real;
|
|
|
|
using boost::math::binomial_distribution; // Not std::binomial_distribution.
|
|
|
|
typedef binomial_distribution<
|
|
double,
|
|
policy<discrete_quantile<integer_round_outwards> > >
|
|
binom_round_outwards;
|
|
|
|
typedef binomial_distribution<
|
|
double,
|
|
policy<discrete_quantile<integer_round_inwards> > >
|
|
binom_round_inwards;
|
|
|
|
typedef binomial_distribution<
|
|
double,
|
|
policy<discrete_quantile<integer_round_down> > >
|
|
binom_round_down;
|
|
|
|
typedef binomial_distribution<
|
|
double,
|
|
policy<discrete_quantile<integer_round_up> > >
|
|
binom_round_up;
|
|
|
|
typedef binomial_distribution<
|
|
double,
|
|
policy<discrete_quantile<integer_round_nearest> > >
|
|
binom_round_nearest;
|
|
|
|
typedef binomial_distribution<
|
|
double,
|
|
policy<discrete_quantile<real> > >
|
|
binom_real_quantile;
|
|
|
|
/*`
|
|
Now let's set to work calling those quantiles:
|
|
*/
|
|
|
|
int main()
|
|
{
|
|
cout <<
|
|
"Testing rounding policies for a 50 sample binomial distribution,\n"
|
|
"with a success fraction of 0.5.\n\n"
|
|
"Lower quantiles are calculated at p = 0.05\n\n"
|
|
"Upper quantiles at p = 0.95.\n\n";
|
|
|
|
cout << setw(25) << right
|
|
<< "Policy"<< setw(18) << right
|
|
<< "Lower Quantile" << setw(18) << right
|
|
<< "Upper Quantile" << endl;
|
|
|
|
// Test integer_round_outwards:
|
|
cout << setw(25) << right
|
|
<< "integer_round_outwards"
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_outwards(50, 0.5), 0.05)
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_outwards(50, 0.5), 0.95)
|
|
<< endl;
|
|
|
|
// Test integer_round_inwards:
|
|
cout << setw(25) << right
|
|
<< "integer_round_inwards"
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_inwards(50, 0.5), 0.05)
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_inwards(50, 0.5), 0.95)
|
|
<< endl;
|
|
|
|
// Test integer_round_down:
|
|
cout << setw(25) << right
|
|
<< "integer_round_down"
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_down(50, 0.5), 0.05)
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_down(50, 0.5), 0.95)
|
|
<< endl;
|
|
|
|
// Test integer_round_up:
|
|
cout << setw(25) << right
|
|
<< "integer_round_up"
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_up(50, 0.5), 0.05)
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_up(50, 0.5), 0.95)
|
|
<< endl;
|
|
|
|
// Test integer_round_nearest:
|
|
cout << setw(25) << right
|
|
<< "integer_round_nearest"
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_nearest(50, 0.5), 0.05)
|
|
<< setw(18) << right
|
|
<< quantile(binom_round_nearest(50, 0.5), 0.95)
|
|
<< endl;
|
|
|
|
// Test real:
|
|
cout << setw(25) << right
|
|
<< "real"
|
|
<< setw(18) << right
|
|
<< quantile(binom_real_quantile(50, 0.5), 0.05)
|
|
<< setw(18) << right
|
|
<< quantile(binom_real_quantile(50, 0.5), 0.95)
|
|
<< endl;
|
|
} // int main()
|
|
|
|
/*`
|
|
|
|
Which produces the program output:
|
|
|
|
[pre
|
|
policy_eg_10.vcxproj -> J:\Cpp\MathToolkit\test\Math_test\Release\policy_eg_10.exe
|
|
Testing rounding policies for a 50 sample binomial distribution,
|
|
with a success fraction of 0.5.
|
|
|
|
Lower quantiles are calculated at p = 0.05
|
|
|
|
Upper quantiles at p = 0.95.
|
|
|
|
Policy Lower Quantile Upper Quantile
|
|
integer_round_outwards 18 31
|
|
integer_round_inwards 19 30
|
|
integer_round_down 18 30
|
|
integer_round_up 19 31
|
|
integer_round_nearest 19 30
|
|
real 18.701 30.299
|
|
]
|
|
|
|
*/
|
|
|
|
//] //[policy_eg_10] ends quickbook import.
|