[Boost-commit] svn:boost r65665 - trunk/libs/math/example

Subject: [Boost-commit] svn:boost r65665 - trunk/libs/math/example
From: pbristow_at_[hidden]
Date: 2010-09-29 06:32:57

Author: pbristow
Date: 2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
New Revision: 65665
URL: http://svn.boost.org/trac/boost/changeset/65665

Log:
Changed to avoid using namespace boost::math
Removed:
   trunk/libs/math/example/binomial_example3.cpp
Text files modified: 
   trunk/libs/math/example/c_error_policy_example.cpp    |     8 ++++--                                  
   trunk/libs/math/example/chi_square_std_dev_test.cpp   |    16 +++++++-------                          
   trunk/libs/math/example/distribution_construction.cpp |    42 ++++++++++++++++++++--------------------
   trunk/libs/math/example/error_handling_example.cpp    |    30 ++++++++++++++++------------            
   trunk/libs/math/example/error_policies_example.cpp    |     3 +                                       
   trunk/libs/math/example/policy_eg_1.cpp               |     1                                         
   trunk/libs/math/example/policy_eg_2.cpp               |     1                                         
   trunk/libs/math/example/policy_eg_4.cpp               |     7 +++--                                   
   trunk/libs/math/example/policy_eg_5.cpp               |    16 ++++++++------                          
   trunk/libs/math/example/policy_eg_6.cpp               |    19 +++++++++--------                       
   trunk/libs/math/example/policy_eg_7.cpp               |     1                                         
   trunk/libs/math/example/policy_eg_8.cpp               |     3 +                                       
   trunk/libs/math/example/policy_eg_9.cpp               |    31 ++++++++++++++---------------           
   trunk/libs/math/example/policy_ref_snip13.cpp         |     4 +-                                      
   14 files changed, 98 insertions(+), 84 deletions(-)

Deleted: trunk/libs/math/example/binomial_example3.cpp
==============================================================================
--- trunk/libs/math/example/binomial_example3.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
+++ (empty file)
@@ -1,91 +0,0 @@
-// Copyright Paul A. 2006
-// Copyright John Maddock 2006
-// 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)
-
-// Simple example of computing probabilities for a binomial random variable.
-// Replication of source nag_binomial_dist (g01bjc).
-
-// Shows how to replace NAG C library calls by Boost Math Toolkit C++ calls.
-
-#ifdef _MSC_VER
-#  pragma warning(disable: 4512) // assignment operator could not be generated.
-#  pragma warning(disable: 4510) // default constructor could not be generated.
-#  pragma warning(disable: 4610) // can never be instantiated - user defined constructor required.
-#endif
-
-#include <iostream>
-using std::cout;
-using std::endl;
-using std::ios;
-using std::showpoint;
-#include <iomanip>
-using std::fixed;
-using std::setw;
-#include <boost/math/distributions/binomial.hpp>
-
-int main()
-{
-  cout << "Example 3 of using the binomial distribution to replicate a NAG library call." << endl;
-  using boost::math::binomial_distribution;
-
-  // This replicates the computation of the examples of using nag-binomial_dist
-  // using g01bjc in section g01 Sample Calculations on Statistical Data.
-  // http://www.nag.co.uk/numeric/cl/manual/pdf/G01/g01bjc.pdf
-  // Program results section 8.3 page 3.g01bjc.3
-    //8.2. Program Data
-    //g01bjc Example Program Data
-    //4 0.50 2 : n, p, k
-    //19 0.44 13
-    //100 0.75 67
-    //2000 0.33 700
-    //8.3. Program Results
-    //g01bjc Example Program Results
-    //n p k plek pgtk peqk
-    //4 0.500 2 0.68750 0.31250 0.37500
-    //19 0.440 13 0.99138 0.00862 0.01939
-    //100 0.750 67 0.04460 0.95540 0.01700
-    //2000 0.330 700 0.97251 0.02749 0.00312
-
-  cout.setf(ios::showpoint); // Trailing zeros to show significant decimal digits.
-  cout.precision(5); // Should be able to calculate this?
-  cout << fixed;
-  //  Binomial distribution.
-  
-  // Note  that  cdf(dist, k) is equivalent to NAG library plek probability of <= k
-  // cdf(complement(dist, k)) is equivalent to NAG library pgtk probability of > k
-  //             pdf(dist, k) is equivalent to NAG library peqk probability of == k
-
-  cout << " n        p     k     plek     pgtk     peqk " << endl;
-  binomial_distribution<>my_dist(4, 0.5);
-  cout << setw(4) << (int)my_dist.trials() <<  "  "  << my_dist.success_fraction() << "   "<< 2 << "  "
-    << cdf(my_dist, 2) << "  " << cdf(complement(my_dist, 2)) << "  " << pdf(my_dist, 2) << endl;
-  binomial_distribution<>two(19, 0.440);
-  cout << setw(4) << (int)two.trials() <<  "  "  << two.success_fraction() << "  " << 13 << "  "
-    << cdf(two, 13) << "  " << cdf(complement(two, 13)) << "  " << pdf(two, 13) << endl;
-  binomial_distribution<>three(100, 0.750);
-  cout << setw(4) << (int)three.trials() <<  "  "  << three.success_fraction() << "  " << 67 << "  "
-    << cdf(three, 67) << "  " << cdf(complement(three, 67)) << "  " << pdf(three, 67) << endl;
-  binomial_distribution<>four(2000, 0.330);
-  cout << setw(4) << (int)four.trials() <<  "  "  << four.success_fraction() << " " << 700 << "  "
-    << cdf(four, 700) << "  " << cdf(complement(four, 700)) << "  " << pdf(four, 700) << endl;
-
-  return 0;
-} // int main()
-
-/*
-
-Autorun "i:\boost-sandbox\math_toolkit\libs\math\test\msvc80\debug\binomial_example3.exe"
-Example 3 of using the binomial distribution.
- n        p     k     plek     pgtk     peqk 
-   4  0.50000   2  0.68750  0.31250  0.37500
-  19  0.44000  13  0.99138  0.00862  0.01939
- 100  0.75000  67  0.04460  0.95540  0.01700
-2000  0.33000 700  0.97251  0.02749  0.00312
-
-
-
- */
-

Modified: trunk/libs/math/example/c_error_policy_example.cpp
==============================================================================
--- trunk/libs/math/example/c_error_policy_example.cpp	(original)
+++ trunk/libs/math/example/c_error_policy_example.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -11,6 +11,8 @@
 // Suppose we want a call to tgamma  to behave in a C-compatible way
 // and set global ::errno rather than throw an exception.
 
+#include <cerrno> // for ::errno
+
 #include <boost/math/special_functions/gamma.hpp>
 using boost::math::tgamma;
 
@@ -58,7 +60,7 @@
          overflow_error<errno_on_error>(),
          evaluation_error<errno_on_error>() 
       ));
-  cout << "tgamma(4., make_policy( ...) = " << t << endl; // 6
+  cout << "tgamma(4., make_policy(...) = " << t << endl; // 6
 
   return 0;
 } // int main()
@@ -72,8 +74,8 @@
   Finished generating code
   c_error_policy_example.vcxproj -> J:\Cpp\MathToolkit\test\Math_test\Release\c_error_policy_example.exe
   tgamma(4., C_error_policy() = 6
-  tgamma(4., make_policy( ...) = 6
+  tgamma(4., make_policy(...) = 6
   tgamma(4., C_error_policy() = 6
-  tgamma(4., make_policy( ...) = 6
+  tgamma(4., make_policy(...) = 6
 
 */

Modified: trunk/libs/math/example/chi_square_std_dev_test.cpp
==============================================================================
--- trunk/libs/math/example/chi_square_std_dev_test.cpp	(original)
+++ trunk/libs/math/example/chi_square_std_dev_test.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -76,10 +76,10 @@
 
 void confidence_limits_on_std_deviation_alpha(
         double Sd,    // Sample Standard Deviation
-        double alpha  // confidence 
-        )   
+        double alpha  // confidence
+        )
 {  // Calculate confidence intervals for the standard deviation.
-   // for the alpha parameter, for a range number of observations, 
+   // for the alpha parameter, for a range number of observations,
    // from a mere 2 up to a million.
    // O. L. Davies, Statistical Methods in Research and Production, ISBN 0 05 002437 X,
    // 4.33 Page 68, Table H, pp 452 459.
@@ -111,7 +111,7 @@
      unsigned int N = obs[i]; // Observations
      // Start by declaring the distribution with the appropriate :
      chi_squared dist(N - 1);
-     
+
      // Now print out the data for the table row.
       cout << fixed << setprecision(3) << setw(10) << right << N;
       // Calculate limits: (alpha /2 because it is a two-sided (upper and lower limit) test.
@@ -244,17 +244,17 @@
    {
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
-      // calculate df for a lower single-sided test:
+      // Calculate df for a lower single-sided test:
       double df = chi_squared::find_degrees_of_freedom(
          -diff, alpha[i], alpha[i], variance);
-      // convert to sample size:
+      // Convert to integral sample size (df is a floating point value in this implementation):
       double size = ceil(df) + 1;
       // Print size:
       cout << fixed << setprecision(0) << setw(16) << right << size;
-      // calculate df for an upper single-sided test:
+      // Calculate df for an upper single-sided test:
       df = chi_squared::find_degrees_of_freedom(
          diff, alpha[i], alpha[i], variance);
-      // convert to sample size:
+      // Convert to integral sample size:
       size = ceil(df) + 1;
       // Print size:
       cout << fixed << setprecision(0) << setw(16) << right << size << endl;

Modified: trunk/libs/math/example/distribution_construction.cpp
==============================================================================
--- trunk/libs/math/example/distribution_construction.cpp	(original)
+++ trunk/libs/math/example/distribution_construction.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -42,7 +42,7 @@
 int main()
 {
 //[distribution_construction2
-/*` 
+/*`
 First, a negative binomial distribution with 8 successes
 and a success fraction 0.25, 25% or 1 in 4, is constructed like this:
 */
@@ -50,10 +50,10 @@
   /*`
   But this is inconveniently long, so we might be tempted to write
   */
-  using namespace boost::math; 
+  using namespace boost::math;
   /*`
-  but this might risk ambiguity with names in std random so *much better* is
-  explicit 'using boost::math:: ' ... statements like
+  but this might risk ambiguity with names in std random so
+  *much better is explicit `using boost::math:: ` * ... statements like
   */
   using boost::math::negative_binomial_distribution;
   /*`
@@ -73,7 +73,7 @@
      typedef negative_binomial_distribution<double> negative_binomial; // Reserved name of type double.
 
   [caution
-  This convenience typedef is /not/ provided if a clash would occur 
+  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.
   ]
@@ -82,7 +82,7 @@
   */
 
   using boost::math::negative_binomial;
-  
+
   /*`
   we have a convenient typedef to `negative_binomial_distribution<double>`:
   */
@@ -111,7 +111,7 @@
   /*`
   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 
+  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;
@@ -119,12 +119,12 @@
 
   Which produces the error messages:
 
-  [pre 
+  [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;
@@ -137,41 +137,41 @@
   /*`
   We can, of course, still provide the type explicitly thus:
   */
-  
+
   // Explicit double precision:
-  negative_binomial_distribution<double>        mydist1(8., 0.25); 
+  negative_binomial_distribution<double>        mydist1(8., 0.25);
 
   // Explicit float precision, double arguments are truncated to float:
   negative_binomial_distribution<float>         mydist2(8., 0.25);
 
   // Explicit float precision, integer & double arguments converted to float.
-  negative_binomial_distribution<float>         mydist3(8, 0.25); 
+  negative_binomial_distribution<float>         mydist3(8, 0.25);
 
   // Explicit float precision, float arguments, so no conversion:
-  negative_binomial_distribution<float>         mydist4(8.F, 0.25F); 
+  negative_binomial_distribution<float>         mydist4(8.F, 0.25F);
 
   // Explicit float precision, integer arguments promoted to float.
-  negative_binomial_distribution<float>         mydist5(8, 1); 
+  negative_binomial_distribution<float>         mydist5(8, 1);
 
   // Explicit double precision:
-  negative_binomial_distribution<double>        mydist6(8., 0.25); 
+  negative_binomial_distribution<double>        mydist6(8., 0.25);
 
   // Explicit long double precision:
-  negative_binomial_distribution<long double>   mydist7(8., 0.25); 
+  negative_binomial_distribution<long double>   mydist7(8., 0.25);
 
   /*`
   And if you have your own RealType called MyFPType,
   for example NTL RR (an arbitrary precision type), then we can write:
-  
+
      negative_binomial_distribution<MyFPType>  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,
@@ -179,13 +179,13 @@
   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);
 
   So in this case we can write:
   */
   using boost::math::normal;
-  
+
   normal norm1;       // Standard normal distribution.
   normal norm2(2);    // Mean = 2, std deviation = 1.
   normal norm3(2, 3); // Mean = 2, std deviation = 3.

Modified: trunk/libs/math/example/error_handling_example.cpp
==============================================================================
--- trunk/libs/math/example/error_handling_example.cpp	(original)
+++ trunk/libs/math/example/error_handling_example.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -1,6 +1,6 @@
 // example_error_handling.cpp
 
-// Copyright Paul A. Bristow 2007.
+// Copyright Paul A. Bristow 2007, 2010.
 // Copyright John Maddock 2007.
 
 // Use, modification and distribution are subject to the
@@ -11,6 +11,11 @@
 // Note that this file contains quickbook markup as well as code
 // and comments, don't change any of the special comment markups!
 
+// Optional macro definitions described in text below:
+//   #define BOOST_MATH_DOMAIN_ERROR_POLICY ignore_error
+//   #define BOOST_MATH_DOMAIN_ERROR_POLICY errno_on_error
+//   #define BOOST_MATH_DOMAIN_ERROR_POLICY is set to: throw_on_error
+
 //[error_handling_example
 /*`
 The following example demonstrates the effect of
@@ -59,11 +64,9 @@
    using std::exception;
 
 /*`
-
 Next we'll define the program's main() to call the student's t
-distribution with an invalid degrees of freedom parameter, the program
-is set up to handle either an exception or a NaN:
-
+distribution with an invalid degrees of freedom parameter,
+the program is set up to handle either an exception or a NaN:
 */
 
 int main()
@@ -77,14 +80,17 @@
 
    try
    {
-      errno = 0;
-      students_t dist(degrees_of_freedom); // exception is thrown here if enabled
+      errno = 0; // Clear/reset.
+      students_t dist(degrees_of_freedom); // exception is thrown here if enabled.
       double p = cdf(dist, t);
-      // test for error reported by other means:
+      // Test for error reported by other means:
       if((boost::math::isnan)(p))
       {
          cout << "cdf returned a NaN!" << endl;
-         cout << "errno is set to: " << errno << endl;
+         if (errno != 0)
+         { // So errno has been set.
+           cout << "errno is set to: " << errno << endl;
+         }
       }
       else
          cout << "Probability of Student's t is " << p << endl;
@@ -94,14 +100,13 @@
       std::cout <<
          "\n""Message from thrown exception was:\n   " << e.what() << std::endl;
    }
-
    return 0;
 } // int main()
 
 /*`
 
 Here's what the program output looks like with a default build
-(one that does throw exceptions):
+(one that *does throw exceptions*):
 
 [pre
 Example error handling using Student's t function.
@@ -122,14 +127,13 @@
 Example error handling using Student's t function.
 BOOST_MATH_DOMAIN_ERROR_POLICY is set to: ignore_error
 cdf returned a NaN!
-errno is set to: 0
 ]
 
 And finally let's build with:
 
    #define BOOST_MATH_DOMAIN_ERROR_POLICY errno_on_error
 
-Which gives the output:
+Which gives the output show errno:
 
 [pre
 Example error handling using Student's t function.

Modified: trunk/libs/math/example/error_policies_example.cpp
==============================================================================
--- trunk/libs/math/example/error_policies_example.cpp	(original)
+++ trunk/libs/math/example/error_policies_example.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -30,6 +30,8 @@
    using std::cout;
    using std::endl;
 
+// using namespace boost::math::policies; or
+
 using boost::math::policies::policy;
 // Possible errors
 using boost::math::policies::overflow_error;
@@ -38,7 +40,6 @@
 using boost::math::policies::pole_error;
 using boost::math::policies::denorm_error;
 using boost::math::policies::evaluation_error;
-
 using boost::math::policies::ignore_error;
 
 // Define a custom policy to ignore just overflow:

Modified: trunk/libs/math/example/policy_eg_1.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_1.cpp	(original)
+++ trunk/libs/math/example/policy_eg_1.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -6,6 +6,7 @@
 
 #include <iostream>
 using std::cout; using std::endl;
+#include <cerrno> // for ::errno
 
 //[policy_eg_1
 

Modified: trunk/libs/math/example/policy_eg_2.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_2.cpp	(original)
+++ trunk/libs/math/example/policy_eg_2.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -6,6 +6,7 @@
 
 #include <iostream>
 using std::cout; using std::endl;
+#include <cerrno> // for ::errno
 
 //[policy_eg_2
 

Modified: trunk/libs/math/example/policy_eg_4.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_4.cpp	(original)
+++ trunk/libs/math/example/policy_eg_4.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -10,6 +10,7 @@
 
 #include <iostream>
 using std::cout;  using std::endl;
+#include <cerrno> // for ::errno
 
 //[policy_eg_4
 
@@ -17,7 +18,7 @@
 Suppose we want `C::foo()` to behave in a C-compatible way and set
 `::errno` on error rather than throwing any exceptions.
 
-We'll begin by including the needed header:
+We'll begin by including the needed header for our function:
 */
 
 #include <boost/math/special_functions.hpp>
@@ -25,14 +26,14 @@
 
 /*`
 Open up the "C" namespace that we'll use for our functions, and
-define the policy type we want: in this case one that sets
+define the policy type we want: in this case a C-style one that sets
 ::errno and returns a standard value, rather than throwing exceptions.
 
 Any policies we don't specify here will inherit the defaults.
 */
 
 namespace C
-{
+{ // To hold our C-style policy.
   //using namespace boost::math::policies; or explicitly:
   using boost::math::policies::policy;
 

Modified: trunk/libs/math/example/policy_eg_5.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_5.cpp	(original)
+++ trunk/libs/math/example/policy_eg_5.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -9,16 +9,17 @@
 
 #include <iostream>
 using std::cout;  using std::endl;
+#include <cerrno> // for ::errno
 
 //[policy_eg_5
 
 #include <boost/math/special_functions.hpp>
- //using boost::math::tgamma; // Would create an ambiguity between 
+// using boost::math::tgamma; // Would create an ambiguity between
 // 'double boost::math::tgamma<int>(T)' and
 // 'double 'anonymous-namespace'::tgamma<int>(RT)'.
 
 namespace
-{ // not named
+{ // unnamed
 
 using namespace boost::math::policies;
 
@@ -26,13 +27,14 @@
    domain_error<errno_on_error>,
    pole_error<errno_on_error>,
    overflow_error<errno_on_error>,
-   evaluation_error<errno_on_error> 
+   evaluation_error<errno_on_error>
 > c_policy;
 
 BOOST_MATH_DECLARE_SPECIAL_FUNCTIONS(c_policy)
+
 /*`
-  So that when we call `tgamma(z)`, we really end up calling
-`boost::math::tgamma(z, anonymous-namespace::c_policy())`:
+So that when we call `tgamma(z)`, we really end up calling
+ `boost::math::tgamma(z, anonymous-namespace::c_policy())`.
 */
 
 } // close unnamed namespace
@@ -40,11 +42,11 @@
 int main()
 {
    errno = 0;
-   cout << "Result of tgamma(30000) is: " 
+   cout << "Result of tgamma(30000) is: "
       << tgamma(30000) << endl;
       // tgamma in unnamed namespace in this translation unit (file) only.
    cout << "errno = " << errno << endl;
-   cout << "Result of tgamma(-10) is: " 
+   cout << "Result of tgamma(-10) is: "
       << tgamma(-10) << endl;
    cout << "errno = " << errno << endl;
    // Default tgamma policy would throw an exception, and abort.

Modified: trunk/libs/math/example/policy_eg_6.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_6.cpp	(original)
+++ trunk/libs/math/example/policy_eg_6.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -9,6 +9,7 @@
 
 #include <iostream>
 using std::cout;  using std::endl;
+#include <cerrno> // for ::errno
 
 //[policy_eg_6
 
@@ -27,9 +28,9 @@
 
 /*`
 
-Open up an appropriate namespace for our distributions, and
-define the policy type we want.  Any policies we don't
-specify here will inherit the defaults:
+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:
 
 */
 
@@ -79,22 +80,22 @@
 {
    // Construct distribution with something we know will overflow
   // (using double rather than if promoted to long double):
-   my_distributions::normal norm(10, 2); 
+   my_distributions::normal norm(10, 2);
 
    errno = 0;
-   cout << "Result of quantile(norm, 0) is: " 
+   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: " 
+   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: " 
+   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: " 
+   cout << "Result of quantile(complement(binom, 0.05)) is: "
       << quantile(complement(binom, 0.05)) << endl;
 }
 
@@ -111,7 +112,7 @@
 Result of quantile(complement(binom, 0.05)) is: 8
 ]
 
-This mechanism is particularly useful when we want to define a 
+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).
 

Modified: trunk/libs/math/example/policy_eg_7.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_7.cpp	(original)
+++ trunk/libs/math/example/policy_eg_7.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -9,6 +9,7 @@
 
 #include <iostream>
 using std::cout;  using std::endl;
+#include <cerrno> // for ::errno
 
 //[policy_eg_7
 

Modified: trunk/libs/math/example/policy_eg_8.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_8.cpp	(original)
+++ trunk/libs/math/example/policy_eg_8.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -45,7 +45,8 @@
 
 So out first job is to include the header we want to use, and then
 provide definitions for our user-defined error handlers that we want to use.
-We only provide our special domain and pole error handlers, other errors use the default.
+We only provide our special domain and pole error handlers;
+other errors like overflow and underflow use the default.
 */
 
 #include <boost/math/special_functions.hpp>

Modified: trunk/libs/math/example/policy_eg_9.cpp
==============================================================================
--- trunk/libs/math/example/policy_eg_9.cpp	(original)
+++ trunk/libs/math/example/policy_eg_9.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -22,8 +22,8 @@
 
    template <class T>
    T user_``['error_type]``(
-      const char* function, 
-      const char* message, 
+      const char* function,
+      const char* message,
       const T& val);
 
 and accepts three arguments:
@@ -32,7 +32,7 @@
 [[const char* function]
    [The name of the function that raised the error, this string
    contains one or more %1% format specifiers that should be
-   replaced by the name of type T.]]
+   replaced by the name of real type T, like float or double.]]
 [[const char* message]
    [A message associated with the error, normally this
    contains a %1% format specifier that should be replaced with
@@ -53,7 +53,7 @@
 #include <boost/math/special_functions.hpp>
 
 /*`
-Next we'll implement our own error handlers for each type of error, 
+Next we'll implement our own error handlers for each type of error,
 starting with domain errors:
 */
 
@@ -85,7 +85,7 @@
    // int prec = std::numeric_limits<T>::max_digits10; //  For C++0X Standard Library
    msg += (boost::format(message) % boost::io::group(std::setprecision(prec), val)).str();
    /*`
-   Now we just have to do something with the message, we could throw an 
+   Now we just have to do something with the message, we could throw an
    exception, but for the purposes of this example we'll just dump the message
    to std::cerr:
    */
@@ -97,7 +97,7 @@
 }
 
 /*`
-Pole errors are essentially a special case of domain errors, 
+Pole errors are essentially a special case of domain errors,
 so in this example we'll just return the result of a domain error:
 */
 
@@ -126,9 +126,9 @@
    msg += message;
 
    std::cerr << msg << std::endl;
-   
+
    // Value passed to the function is an infinity, just return it:
-   return val; 
+   return val;
 }
 
 /*`
@@ -150,9 +150,9 @@
    msg += message;
 
    std::cerr << msg << std::endl;
-   
+
    // Value passed to the function is zero, just return it:
-   return val; 
+   return val;
 }
 
 /*`
@@ -174,13 +174,13 @@
    msg += message;
 
    std::cerr << msg << std::endl;
-   
+
    // Value passed to the function is denormalised, just return it:
-   return val; 
+   return val;
 }
 
 /*`
-Which leaves us with evaluation errors, these occur when an internal
+Which leaves us with evaluation errors: these occur when an internal
 error occurs that prevents the function being fully evaluated.
 The parameter /val/ contains the closest approximation to the result
 found so far:
@@ -205,9 +205,8 @@
 
    std::cerr << msg << std::endl;
 
-   // What do we return here?  This is generally a fatal error,
-   // that should never occur, just return a NaN for the purposes
-   // of the example:
+   // What do we return here?  This is generally a fatal error, that should never occur,
+   // so we just return a NaN for the purposes of the example:
    return std::numeric_limits<T>::quiet_NaN();
 }
 

Modified: trunk/libs/math/example/policy_ref_snip13.cpp
==============================================================================
--- trunk/libs/math/example/policy_ref_snip13.cpp	(original)
+++ trunk/libs/math/example/policy_ref_snip13.cpp	2010-09-29 06:32:55 EDT (Wed, 29 Sep 2010)
@@ -42,8 +42,8 @@
 // myspace::mypolicy:
 //
 // This compiles but throws a domain error exception at runtime.
-// (Caution, if you omit the try'n'catch blocks, it will just terminate,
-// giving no clues as to why! 
+// Caution! If you omit the try'n'catch blocks, 
+// it will just silently terminate, giving no clues as to why! 
 // So try'n'catch blocks are very strongly recommended.
 
 void test_cauchy()