// distribution_construction.cpp // Copyright Paul A. Bristow 2007. // 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) // Caution: this file contains Quickbook markup as well as code // and comments, don't change any of the special comment markups! //[distribution_construction1 /*` The structure of distributions is rather different from some other statistical libraries, for example in less object-oriented language like FORTRAN and C, that provide a few arguments to each free function. This library provides each distribution as a template C++ class. A distribution is constructed with a few arguments, and then member and non-member functions are used to find values of the distribution, often a function of a random variate. First we need some includes to access the negative binomial distribution (and the binomial, beta and gamma too). */ #include // for negative_binomial_distribution using boost::math::negative_binomial_distribution; // default type is double. using boost::math::negative_binomial; // typedef provides default type is double. #include // for binomial_distribution. #include // for beta_distribution. #include // for gamma_distribution. //] [/distribution_construction1 end of Quickbook in C++ markup] //[distribution_construction2 /*` Several examples of constructing distributions follow: */ int main() { /*` First, a negative binomial distribution with 8 successes and a success fraction 0.25, 25% or 1 in 4, is constructed like this: */ boost::math::negative_binomial_distribution mydist0(8., 0.25); /*` But this is inconveniently long, so by writing */ using namespace boost::math; /*` or */ using boost::math::negative_binomial_distribution; /*` we can reduce typing. Since the vast majority of applications use double, the RealType default is chosen to be double, so we can also write: */ negative_binomial_distribution<> mydist9(8., 0.25); // Uses default RealType = double. /*` But the name "negative_binomial_distribution" is still inconveniently long, so for most distributions, a conveniance typedef is provided, for example: typedef negative_binomial_distribution negative_binomial; // Reserved name of type double. [caution This convenience typedef is /not/ provided if a clash would occur with the name of a function: currently only "beta" and "gamma" fall into this category. ] So, after a using statement, */ using boost::math::negative_binomial; /*` we have a convenient reference to negative_binomial_distribution thus: */ negative_binomial mydist(8., 0.25); /*` Some more examples using the provided convenience typedef: */ negative_binomial mydist10(5., 0.4); // Both arguments double. /*` And automatic conversion takes place, so you can use integers and floats: */ negative_binomial mydist11(5, 0.4); // Using provided typedef double, int and double arguments. /*` This is probably the most common usage. */ negative_binomial mydist12(5., 0.4F); // Double and float arguments. negative_binomial mydist13(5, 1); // Both arguments integer. /*` Similarly for most other distributions like the binomial. */ binomial mybinomial(1, 0.5); // is more concise than binomial_distribution<> mybinomd1(1, 0.5); /*` For cases when the typdef distribution name would clash with a math special function (currently only beta and gamma) the typedef is deliberately not provided, and the longer version of the name must be used. For example do not use: using boost::math::beta; beta mybetad0(1, 0.5); // Error beta is a math FUNCTION! Which produces the error messages: [pre error C2146: syntax error : missing ';' before identifier 'mybetad0' warning C4551: function call missing argument list error C3861: 'mybetad0': identifier not found ] Instead you should use: */ using boost::math::beta_distribution; beta_distribution<> mybetad1(1, 0.5); /*` or for the gamma distribution: */ gamma_distribution<> mygammad1(1, 0.5); /*` We can, of course, still provide the type explicitly thus: */ negative_binomial_distribution mydist1(8., 0.25); // Explicit double. negative_binomial_distribution mydist2(8., 0.25); // Explicit float, double arguments -> float. negative_binomial_distribution mydist3(8, 0.25); // Explicit float, integer & double arguments -> float. negative_binomial_distribution mydist4(8.F, 0.25F); // Explicit float, float arguments, no conversion. negative_binomial_distribution mydist5(8, 1); // Explicit integer, integer arguments -> float. negative_binomial_distribution mydist6(8., 0.25); // Explicit double. negative_binomial_distribution mydist7(8., 0.25); // Explicit long double. /*` And if you have your own RealType called MyFPType, for example NTL RR (an arbitrary precision type), then we can write: negative_binomial_distribution mydist6(8, 1); // Integer arguments -> MyFPType. [heading Default arguments to distribution constructors.] Note that default constructor arguments are only provided for some distributions. So if you wrongly assume a default argument you will get an error message, for example: negative_binomial_distribution<> mydist8; [pre error C2512 no appropriate default constructor available.] No default constructors are provided for the negative binomial, because it is difficult to chose any sensible default values for this distribution. For other distributions, like the normal distribution, it is obviously very useful to provide 'standard' defaults for the mean and standard deviation thus: normal_distribution(RealType mean = 0, RealType sd = 1); */ return 0; } // int main() /*`There is no useful output from this program, of course. */ //] [/end of distribution_construction2]