Boost logo

Boost-Commit :

From: pbristow_at_[hidden]
Date: 2007-09-21 13:39:58


Author: pbristow
Date: 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
New Revision: 39453
URL: http://svn.boost.org/trac/boost/changeset/39453

Log:
Warning squashing and estimate to find
Text files modified:
   sandbox/math_toolkit/libs/math/doc/dist_tutorial.qbk | 2
   sandbox/math_toolkit/libs/math/doc/distributions/beta.qbk | 22 ++++++++++----------
   sandbox/math_toolkit/libs/math/doc/distributions/binomial.qbk | 34 ++++++++++++++++----------------
   sandbox/math_toolkit/libs/math/doc/distributions/binomial_example.qbk | 24 +++++++++++-----------
   sandbox/math_toolkit/libs/math/doc/distributions/chi_squared.qbk | 4 +-
   sandbox/math_toolkit/libs/math/doc/distributions/chi_squared_examples.qbk | 8 +++---
   sandbox/math_toolkit/libs/math/doc/distributions/negative_binomial.qbk | 32 +++++++++++++++---------------
   sandbox/math_toolkit/libs/math/doc/distributions/students_t.qbk | 4 +-
   sandbox/math_toolkit/libs/math/doc/distributions/students_t_examples.qbk | 10 ++++----
   sandbox/math_toolkit/libs/math/example/Jamfile.v2 | 3 +
   sandbox/math_toolkit/libs/math/example/binomial_confidence_limits.cpp | 8 +++---
   sandbox/math_toolkit/libs/math/example/binomial_sample_sizes.cpp | 12 +++++-----
   sandbox/math_toolkit/libs/math/example/chi_square_std_dev_test.cpp | 4 +-
   sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp | 2
   sandbox/math_toolkit/libs/math/example/find_root_example.cpp | 6 ++--
   sandbox/math_toolkit/libs/math/example/normal_misc_examples.cpp | 1
   sandbox/math_toolkit/libs/math/example/policy_eg_3.cpp | 11 ++++++++-
   sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp | 8 ++++++
   sandbox/math_toolkit/libs/math/example/policy_ref_snip13.cpp | 9 ++++++-
   sandbox/math_toolkit/libs/math/example/policy_ref_snip4.cpp | 10 +++++++-
   sandbox/math_toolkit/libs/math/example/students_t_single_sample.cpp | 10 ++++----
   sandbox/math_toolkit/libs/math/test/Jamfile.v2 | 5 ++-
   sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp | 16 +++++++-------
   sandbox/math_toolkit/libs/math/test/test_binomial.cpp | 42 ++++++++++++++++++++--------------------
   sandbox/math_toolkit/libs/math/test/test_chi_squared.cpp | 8 +++---
   sandbox/math_toolkit/libs/math/test/test_students_t.cpp | 12 +++++-----
   26 files changed, 166 insertions(+), 141 deletions(-)

Modified: sandbox/math_toolkit/libs/math/doc/dist_tutorial.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/dist_tutorial.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/dist_tutorial.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -323,7 +323,7 @@
 each distribution. They are implemented as static member functions
 of the distributions, for example:
 
- students_t::estimate_degrees_of_freedom(
+ students_t::find_degrees_of_freedom(
       1.3, // difference from true mean to detect
       0.05, // maximum risk of falsely rejecting the null-hypothesis.
       0.1, // maximum risk of falsely failing to reject the null-hypothesis.

Modified: sandbox/math_toolkit/libs/math/doc/distributions/beta.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/beta.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/beta.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -26,23 +26,23 @@
       RealType beta() const;
       
       // Parameter estimators of alpha or beta from mean and variance.
- static RealType estimate_alpha(
+ static RealType find_alpha(
         RealType mean, // Expected value of mean.
         RealType variance); // Expected value of variance.
       
- static RealType estimate_beta(
+ static RealType find_beta(
         RealType mean, // Expected value of mean.
         RealType variance); // Expected value of variance.
   
       // Parameter estimators from from
       // either alpha or beta, and x and probability.
       
- static RealType estimate_alpha(
+ static RealType find_alpha(
         RealType beta, // from beta.
         RealType x, // x.
         RealType probability); // cdf
       
- static RealType estimate_beta(
+ static RealType find_beta(
         RealType alpha, // alpha.
         RealType x, // probability x.
         RealType probability); // probability cdf.
@@ -148,21 +148,21 @@
 [@http://www.epi.ucdavis.edu/diagnostictests/betabuster.html Beta Buster]
 but this is not yet implemented here.
 
- static RealType estimate_alpha(
+ static RealType find_alpha(
         RealType mean, // Expected value of mean.
         RealType variance); // Expected value of variance.
         
 Returns the unique value of [alpha][space] that corresponds to a
 beta distribution with mean /mean/ and variance /variance/.
       
- static RealType estimate_beta(
+ static RealType find_beta(
         RealType mean, // Expected value of mean.
         RealType variance); // Expected value of variance.
   
 Returns the unique value of [beta][space] that corresponds to a
 beta distribution with mean /mean/ and variance /variance/.
       
- static RealType estimate_alpha(
+ static RealType find_alpha(
         RealType beta, // from beta.
         RealType x, // x.
         RealType probability); // probability cdf
@@ -170,7 +170,7 @@
 Returns the value of [alpha][space] that gives:
 `cdf(beta_distribution<RealType>(alpha, beta), x) == probability`.
       
- static RealType estimate_beta(
+ static RealType find_beta(
         RealType alpha, // alpha.
         RealType x, // probability x.
         RealType probability); // probability cdf.
@@ -250,7 +250,7 @@
 [[beta
 
   from mean and variance][`(1 - mean) * (((mean * (1 - mean)) /variance)-1)`]]
-[[The member functions `estimate_alpha` and `estimate_beta`
+[[The member functions `find_alpha` and `find_beta`
 
   from cdf and probability x
   
@@ -258,8 +258,8 @@
       [Implemented in terms of the inverse incomplete beta functions
       
 __ibeta_inva, and __ibeta_invb respectively.]]
-[[`estimate_alpha`][`ibeta_inva(beta, x, probability)`]]
-[[`estimate_beta`][`ibeta_invb(alpha, x, probability)`]]
+[[`find_alpha`][`ibeta_inva(beta, x, probability)`]]
+[[`find_beta`][`ibeta_invb(alpha, x, probability)`]]
 ]
 
 [h4 References]

Modified: sandbox/math_toolkit/libs/math/doc/distributions/binomial.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/binomial.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/binomial.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -28,24 +28,24 @@
       RealType trials() const;
       
       // Bounds on success fraction:
- static RealType estimate_lower_bound_on_p(
+ static RealType find_lower_bound_on_p(
          RealType trials,
          RealType successes,
          RealType probability,
          ``['unspecified-type]`` method = clopper_pearson_exact_interval);
- static RealType estimate_upper_bound_on_p(
+ static RealType find_upper_bound_on_p(
          RealType trials,
          RealType successes,
          RealType probability,
          ``['unspecified-type]`` method = clopper_pearson_exact_interval);
          
       // estimate min/max number of trials:
- static RealType estimate_minimum_number_of_trials(
+ static RealType find_minimum_number_of_trials(
          RealType k, // number of events
          RealType p, // success fraction
          RealType alpha); // risk level
          
- static RealType estimate_maximum_number_of_trials(
+ static RealType find_maximum_number_of_trials(
          RealType k, // number of events
          RealType p, // success fraction
          RealType alpha); // risk level
@@ -108,7 +108,7 @@
 
 [h5 Lower Bound on the Success Fraction]
 
- static RealType estimate_lower_bound_on_p(
+ static RealType find_lower_bound_on_p(
       RealType trials,
       RealType successes,
       RealType alpha,
@@ -130,7 +130,7 @@
 want to be 95% sure that the true value is [*greater than] some value,
 ['p[sub min]], then:
 
- p``[sub min]`` = binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ p``[sub min]`` = binomial_distribution<RealType>::find_lower_bound_on_p(
                        n, k, 0.05);
 
 [link math_toolkit.dist.stat_tut.weg.binom_eg.binom_conf See worked example.]
@@ -140,7 +140,7 @@
 or /jeffreys_prior_interval/. These constants are both members of
 class template `binomial_distribution`, so usage is for example:
 
- p = binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ p = binomial_distribution<RealType>::find_lower_bound_on_p(
        n, k, 0.05, binomial_distribution<RealType>::jeffreys_prior_interval);
        
 The default method if this parameter is not specified is the Clopper Pearson
@@ -186,7 +186,7 @@
 
 [h5 Upper Bound on the Success Fraction]
 
- static RealType estimate_upper_bound_on_p(
+ static RealType find_upper_bound_on_p(
       RealType trials,
       RealType successes,
       RealType alpha,
@@ -201,7 +201,7 @@
          the success fraction is [*greater than] the value returned.]]
 [[method][An optional parameter that specifies the method to be used
          to compute the interval. Refer to the documentation for
- `estimate_upper_bound_on_p` above for the meaning of the
+ `find_upper_bound_on_p` above for the meaning of the
          method options.]]
 ]
 
@@ -210,14 +210,14 @@
 want to be 95% sure that the true value is [*less than] some value,
 ['p[sub max]], then:
 
- p``[sub max]`` = binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ p``[sub max]`` = binomial_distribution<RealType>::find_upper_bound_on_p(
                        n, k, 0.05);
                        
 [link math_toolkit.dist.stat_tut.weg.binom_eg.binom_conf See worked example.]
 
 [note
 In order to obtain a two sided bound on the success fraction, you
-call both `estimate_lower_bound_on_p` *and* `estimate_upper_bound_on_p`
+call both `find_lower_bound_on_p` *and* `find_upper_bound_on_p`
 each with the same arguments.
 
 If the desired risk level
@@ -233,7 +233,7 @@
 
 [h5 Estimating the Number of Trials Required for a Certain Number of Successes]
 
- static RealType estimate_minimum_number_of_trials(
+ static RealType find_minimum_number_of_trials(
       RealType k, // number of events
       RealType p, // success fraction
       RealType alpha); // probability threshold
@@ -250,14 +250,14 @@
 
 For example:
    
- binomial_distribution<RealType>::estimate_number_of_trials(10, 0.5, 0.05);
+ binomial_distribution<RealType>::find_number_of_trials(10, 0.5, 0.05);
       
 Returns the smallest number of trials we must conduct to be 95% sure
 of seeing 10 events that occur with frequency one half.
    
 [h5 Estimating the Maximum Number of Trials to Ensure no more than a Certain Number of Successes]
 
- static RealType estimate_maximum_number_of_trials(
+ static RealType find_maximum_number_of_trials(
       RealType k, // number of events
       RealType p, // success fraction
       RealType alpha); // probability threshold
@@ -274,7 +274,7 @@
 
 For example:
    
- binomial_distribution<RealType>::estimate_maximum_number_of_trials(0, 1e-6, 0.05);
+ binomial_distribution<RealType>::find_maximum_number_of_trials(0, 1e-6, 0.05);
       
 Returns the largest number of trials we can conduct and still be 95% certain
 of not observing any events that occur with one in a million frequency.
@@ -382,8 +382,8 @@
 [[skewness][`(1 - 2 * p) / sqrt(n * p * (1 - p))`]]
 [[kurtosis][`3 - (6 / n) + (1 / (n * p * (1 - p)))`]]
 [[kurtosis excess][`(1 - 6 * p * q) / (n * p * q)`]]
-[[parameter estimation][The member functions `estimate_upper_bound_on_p`
- `estimate_lower_bound_on_p` and `estimate_number_of_trials` are
+[[parameter estimation][The member functions `find_upper_bound_on_p`
+ `find_lower_bound_on_p` and `find_number_of_trials` are
        implemented in terms of the inverse incomplete beta functions
        __ibetac_inv, __ibeta_inv, and __ibetac_invb respectively]]
 ]

Modified: sandbox/math_toolkit/libs/math/doc/distributions/binomial_example.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/binomial_example.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/binomial_example.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -35,8 +35,8 @@
 by /k/ \/ /N/, for /k/ successes out of /N/ trials. However our confidence in that
 estimate will be shaped by how many trials were conducted, and how many successes
 were observed. The static member functions
-`binomial_distribution<>::estimate_lower_bound_on_p` and
-`binomial_distribution<>::estimate_upper_bound_on_p` allow you to calculate
+`binomial_distribution<>::find_lower_bound_on_p` and
+`binomial_distribution<>::find_upper_bound_on_p` allow you to calculate
 the confidence intervals for your estimate of the occurrence frequency.
 
 The sample program [@../../example/binomial_confidence_limits.cpp
@@ -87,8 +87,8 @@
 
 
 And now for the important part - the intervals themselves - for each
-value of /alpha/, we call `estimate_lower_bound_on_p` and
-`estimate_lower_upper_on_p` to obtain lower and upper bounds
+value of /alpha/, we call `find_lower_bound_on_p` and
+`find_lower_upper_on_p` to obtain lower and upper bounds
 respectively. Note that since we are calculating a two-sided interval,
 we must divide the value of alpha in two.
 
@@ -122,18 +122,18 @@
          // Confidence value:
          cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
          // Calculate Clopper Pearson bounds:
- double l = binomial_distribution<>::estimate_lower_bound_on_p(
+ double l = binomial_distribution<>::find_lower_bound_on_p(
                         trials, successes, alpha[i]/2);
- double u = binomial_distribution<>::estimate_upper_bound_on_p(
+ double u = binomial_distribution<>::find_upper_bound_on_p(
                         trials, successes, alpha[i]/2);
          // Print Clopper Pearson Limits:
          cout << fixed << setprecision(5) << setw(15) << right << l;
          cout << fixed << setprecision(5) << setw(15) << right << u;
          // Calculate Jeffreys Prior Bounds:
- l = binomial_distribution<>::estimate_lower_bound_on_p(
+ l = binomial_distribution<>::find_lower_bound_on_p(
                trials, successes, alpha[i]/2,
                binomial_distribution<>::jeffreys_prior_interval);
- u = binomial_distribution<>::estimate_upper_bound_on_p(
+ u = binomial_distribution<>::find_upper_bound_on_p(
                trials, successes, alpha[i]/2,
                binomial_distribution<>::jeffreys_prior_interval);
          // Print Jeffreys Prior Limits:
@@ -217,7 +217,7 @@
 routine replacement of the component so that its chance of failure between
 routine replacements is less than P%. If the failures follow a binomial
 distribution (each time the component is "used" it either fails or does not)
-then the static member function `binomial_distibution<>::estimate_maximum_number_of_trials`
+then the static member function `binomial_distibution<>::find_maximum_number_of_trials`
 can be used to estimate the maximum number of "uses" of that component for some
 acceptable risk level /alpha/.
 
@@ -226,7 +226,7 @@
 demonstrates its usage. It centres on a routine that prints out
 a table of maximum sample sizes for various probability thresholds:
 
- void estimate_max_sample_size(
+ void find_max_sample_size(
       double p, // success ratio.
       unsigned successes) // Total number of observed successes permitted.
    {
@@ -248,7 +248,7 @@
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
       // calculate trials:
- double t = binomial::estimate_maximum_number_of_trials(
+ double t = binomial::find_maximum_number_of_trials(
                      successes, p, alpha[i]);
       t = floor(t);
       // Print Trials:
@@ -259,7 +259,7 @@
 calculating the maximum number of trials permitted, we'll err on the safe
 side and take the floor of the result. Had we been calculating the
 /minimum/ number of trials required to observe a certain number of /successes/
-using `estimate_minimum_number_of_trials` we would have taken the ceiling instead.
+using `find_minimum_number_of_trials` we would have taken the ceiling instead.
 
 We'll finish off by looking at some sample output, firstly for
 a 1 in 1000 chance of component failure with each use:

Modified: sandbox/math_toolkit/libs/math/doc/distributions/chi_squared.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/chi_squared.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/chi_squared.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -24,7 +24,7 @@
       RealType degrees_of_freedom()const;
 
       // Parameter estimation:
- static RealType estimate_degrees_of_freedom(
+ static RealType find_degrees_of_freedom(
          RealType difference_from_mean,
          RealType alpha,
          RealType beta,
@@ -63,7 +63,7 @@
       
 Returns the parameter /v/ from which this object was constructed.
 
- static RealType estimate_degrees_of_freedom(
+ static RealType find_degrees_of_freedom(
          RealType difference_from_variance,
          RealType alpha,
          RealType beta,

Modified: sandbox/math_toolkit/libs/math/doc/distributions/chi_squared_examples.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/chi_squared_examples.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/chi_squared_examples.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -303,7 +303,7 @@
 
 The class template [link math_toolkit.dist.dist_ref.dists.chi_squared_dist
 chi_squared_distribution] has a static method
-`estimate_degrees_of_freedom` that will calculate this value for
+`find_degrees_of_freedom` that will calculate this value for
 some acceptable risk of type I failure /alpha/, type II failure
 /beta/, and difference from the standard deviation /diff/. Please
 note that the method used works on variance, and not standard deviation
@@ -343,7 +343,7 @@
 where it is greater than the true value by /diff/. Thanks to the
 asymmetric nature of the Chi Squared distribution these two values will
 not be the same, the difference in their calculation differs only in the
-sign of /diff/ that's passed to `estimate_degrees_of_freedom`. Finally
+sign of /diff/ that's passed to `find_degrees_of_freedom`. Finally
 in this example we'll simply things, and let risk level /beta/ be the
 same as /alpha/:
 
@@ -362,14 +362,14 @@
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
       // calculate df for a lower single sided test:
- double df = chi_squared::estimate_degrees_of_freedom(
+ double df = chi_squared::find_degrees_of_freedom(
          -diff, alpha[i], alpha[i], variance);
       // convert to sample size:
       double size = ceil(df) + 1;
       // Print size:
       cout << fixed << setprecision(0) << setw(16) << right << size;
       // calculate df for an upper single sided test:
- df = chi_squared::estimate_degrees_of_freedom(
+ df = chi_squared::find_degrees_of_freedom(
          diff, alpha[i], alpha[i], variance);
       // convert to sample size:
       size = ceil(df) + 1;

Modified: sandbox/math_toolkit/libs/math/doc/distributions/negative_binomial.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/negative_binomial.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/negative_binomial.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -24,21 +24,21 @@
       RealType successes() const;
       
       // Bounds on success fraction:
- static RealType estimate_lower_bound_on_p(
+ static RealType find_lower_bound_on_p(
          RealType trials,
          RealType successes,
          RealType probability); // alpha
- static RealType estimate_upper_bound_on_p(
+ static RealType find_upper_bound_on_p(
          RealType trials,
          RealType successes,
          RealType probability); // alpha
          
       // Estimate min/max number of trials:
- static RealType estimate_minimum_number_of_trials(
+ static RealType find_minimum_number_of_trials(
          RealType k, // Number of failures.
          RealType p, // Success fraction.
          RealType probability); // Probability threshold alpha.
- static RealType estimate_maximum_number_of_trials(
+ static RealType find_maximum_number_of_trials(
          RealType k, // Number of failures.
          RealType p, // Success fraction.
          RealType probability); // Probability threshold alpha.
@@ -133,7 +133,7 @@
 
 [h5 Lower Bound on Parameter p]
 
- static RealType estimate_lower_bound_on_p(
+ static RealType find_lower_bound_on_p(
         RealType failures,
         RealType successes,
         RealType probability) // (0 <= alpha <= 1), 0.05 equivalent to 95% confidence.
@@ -152,7 +152,7 @@
 want to be 95% sure that the true value is [*greater than] some value,
 ['p[sub min]], then:
 
- p``[sub min]`` = negative_binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ p``[sub min]`` = negative_binomial_distribution<RealType>::find_lower_bound_on_p(
                        failures, successes, 0.05);
 
 [link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
@@ -169,7 +169,7 @@
 
 [h5 Upper Bound on Parameter p]
 
- static RealType estimate_upper_bound_on_p(
+ static RealType find_upper_bound_on_p(
       RealType trials,
       RealType successes,
       RealType alpha); // (0 <= alpha <= 1), 0.05 equivalent to 95% confidence.
@@ -188,7 +188,7 @@
 want to be 95% sure that the true value is [*less than] some value,
 ['p[sub max]], then:
 
- p``[sub max]`` = negative_binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ p``[sub max]`` = negative_binomial_distribution<RealType>::find_upper_bound_on_p(
                        r, k, 0.05);
 
 [link math_toolkit.dist.stat_tut.weg.neg_binom_eg.neg_binom_conf See negative binomial confidence interval example.]
@@ -205,7 +205,7 @@
 
 [h5 Estimating Number of Trials to Ensure at Least a Certain Number of Failures]
 
- static RealType estimate_minimum_number_of_trials(
+ static RealType find_minimum_number_of_trials(
       RealType k, // number of failures.
       RealType p, // success fraction.
       RealType alpha); // probability threshold (0.05 equivalent to 95%).
@@ -221,7 +221,7 @@
 
 For example:
    
- negative_binomial_distribution<RealType>::estimate_minimum_number_of_trials(10, 0.5, 0.05);
+ negative_binomial_distribution<RealType>::find_minimum_number_of_trials(10, 0.5, 0.05);
       
 Returns the smallest number of trials we must conduct to be 95% sure
 of seeing 10 failures that occur with frequency one half.
@@ -235,7 +235,7 @@
 
 [h5 Estimating Number of Trials to Ensure a Maximum Number of Failures or Less]
 
- static RealType estimate_maximum_number_of_trials(
+ static RealType find_maximum_number_of_trials(
       RealType k, // number of failures.
       RealType p, // success fraction.
       RealType alpha); // probability threshold (0.05 equivalent to 95%).
@@ -251,7 +251,7 @@
 
 For example:
    
- negative_binomial_distribution<RealType>::estimate_maximum_number_of_trials(0, 1.0-1.0/1000000, 0.05);
+ negative_binomial_distribution<RealType>::find_maximum_number_of_trials(0, 1.0-1.0/1000000, 0.05);
       
 Returns the largest number of trials we can conduct and still be 95% sure
 of seeing no failures that occur with frequency one in one million.
@@ -345,10 +345,10 @@
 [[kurtosis][`6 / r + (p * p) / r * (1 - p )`]]
 [[kurtosis excess][`6 / r + (p * p) / r * (1 - p ) -3`]]
 [[parameter estimation member functions][]]
-[[`estimate_lower_bound_on_p`][ibeta_inv(successes, failures + 1, alpha)]]
-[[`estimate_upper_bound_on_p`][ibetac_inv(successes, failures, alpha) plus see comments in code.]]
-[[`estimate_minimum_number_of_trials`][ibeta_inva(k + 1, p, alpha)]]
-[[`estimate_maximum_number_of_trials`][ibetac_inva(k + 1, p, alpha)]]
+[[`find_lower_bound_on_p`][ibeta_inv(successes, failures + 1, alpha)]]
+[[`find_upper_bound_on_p`][ibetac_inv(successes, failures, alpha) plus see comments in code.]]
+[[`find_minimum_number_of_trials`][ibeta_inva(k + 1, p, alpha)]]
+[[`find_maximum_number_of_trials`][ibetac_inva(k + 1, p, alpha)]]
 ]
 
 Implementation notes:

Modified: sandbox/math_toolkit/libs/math/doc/distributions/students_t.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/students_t.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/students_t.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -23,7 +23,7 @@
       RealType degrees_of_freedom()const;
       
       // degrees of freedom estimation:
- static RealType estimate_degrees_of_freedom(
+ static RealType find_degrees_of_freedom(
          RealType difference_from_mean,
          RealType alpha,
          RealType beta,
@@ -71,7 +71,7 @@
    
 Returns the number of degrees of freedom of this distribution.
 
- static RealType estimate_degrees_of_freedom(
+ static RealType find_degrees_of_freedom(
       RealType difference_from_mean,
       RealType alpha,
       RealType beta,

Modified: sandbox/math_toolkit/libs/math/doc/distributions/students_t_examples.qbk
==============================================================================
--- sandbox/math_toolkit/libs/math/doc/distributions/students_t_examples.qbk (original)
+++ sandbox/math_toolkit/libs/math/doc/distributions/students_t_examples.qbk 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -419,7 +419,7 @@
    using namespace boost::math;
    using namespace std;
 
- void single_sample_estimate_df(
+ void single_sample_find_df(
       double M, // M = true mean.
       double Sm, // Sm = Sample Mean.
       double Sd) // Sd = Sample Standard Deviation.
@@ -442,7 +442,7 @@
 
 And now the important part: the sample sizes required. Class
 `students_t_distribution` has a static member function
-`estimate_degrees_of_freedom` that will calculate how large
+`find_degrees_of_freedom` that will calculate how large
 a sample size needs to be in order to give a definitive result.
 
 The first argument is the difference between the means that you
@@ -458,7 +458,7 @@
 The final parameter of the function is the standard deviation of the sample.
 
 In this example, we assume that alpha and beta are the same, and call
-`estimate_degrees_of_freedom` twice: once with alpha for a one-sided test,
+`find_degrees_of_freedom` twice: once with alpha for a one-sided test,
 and once with alpha/2 for a two-sided test.
 
       for(unsigned i = 0; i < sizeof(alpha)/sizeof(alpha[0]); ++i)
@@ -466,14 +466,14 @@
          // Confidence value:
          cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
          // calculate df for single sided test:
- double df = students_t::estimate_degrees_of_freedom(
+ double df = students_t::find_degrees_of_freedom(
             fabs(M - Sm), alpha[i], alpha[i], Sd);
          // convert to sample size:
          double size = ceil(df) + 1;
          // Print size:
          cout << fixed << setprecision(0) << setw(16) << right << size;
          // calculate df for two sided test:
- df = students_t::estimate_degrees_of_freedom(
+ df = students_t::find_degrees_of_freedom(
             fabs(M - Sm), alpha[i]/2, alpha[i], Sd);
          // convert to sample size:
          size = ceil(df) + 1;

Modified: sandbox/math_toolkit/libs/math/example/Jamfile.v2
==============================================================================
--- sandbox/math_toolkit/libs/math/example/Jamfile.v2 (original)
+++ sandbox/math_toolkit/libs/math/example/Jamfile.v2 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -22,6 +22,7 @@
       <toolset>msvc:<cxxflags>/wd4127
       <toolset>msvc:<cxxflags>/wd4701
       <toolset>msvc:<cxxflags>/wd4127
+ <toolset>msvc:<cxxflags>/wd4305
       <include>../../..
     ;
 
@@ -38,7 +39,7 @@
 run f_test.cpp ;
 run neg_binom_confidence_limits.cpp ;
 run neg_binomial_sample_sizes.cpp ;
-run negative_binomial_construction_examples.cpp ;
+# run negative_binomial_construction_examples.cpp ; delete for now
 run negative_binomial_example1.cpp ;
 run negative_binomial_example2.cpp ;
 # run negative_binomial_example3.cpp ;

Modified: sandbox/math_toolkit/libs/math/example/binomial_confidence_limits.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/binomial_confidence_limits.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/binomial_confidence_limits.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -56,14 +56,14 @@
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
       // Calculate Clopper Pearson bounds:
- double l = binomial_distribution<>::estimate_lower_bound_on_p(trials, successes, alpha[i]/2);
- double u = binomial_distribution<>::estimate_upper_bound_on_p(trials, successes, alpha[i]/2);
+ double l = binomial_distribution<>::find_lower_bound_on_p(trials, successes, alpha[i]/2);
+ double u = binomial_distribution<>::find_upper_bound_on_p(trials, successes, alpha[i]/2);
       // Print Clopper Pearson Limits:
       cout << fixed << setprecision(5) << setw(15) << right << l;
       cout << fixed << setprecision(5) << setw(15) << right << u;
       // Calculate Jeffreys Prior Bounds:
- l = binomial_distribution<>::estimate_lower_bound_on_p(trials, successes, alpha[i]/2, binomial_distribution<>::jeffreys_prior_interval);
- u = binomial_distribution<>::estimate_upper_bound_on_p(trials, successes, alpha[i]/2, binomial_distribution<>::jeffreys_prior_interval);
+ l = binomial_distribution<>::find_lower_bound_on_p(trials, successes, alpha[i]/2, binomial_distribution<>::jeffreys_prior_interval);
+ u = binomial_distribution<>::find_upper_bound_on_p(trials, successes, alpha[i]/2, binomial_distribution<>::jeffreys_prior_interval);
       // Print Jeffreys Prior Limits:
       cout << fixed << setprecision(5) << setw(15) << right << l;
       cout << fixed << setprecision(5) << setw(15) << right << u << std::endl;

Modified: sandbox/math_toolkit/libs/math/example/binomial_sample_sizes.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/binomial_sample_sizes.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/binomial_sample_sizes.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -14,7 +14,7 @@
 #include <iomanip>
 #include <boost/math/distributions/binomial.hpp>
 
-void estimate_max_sample_size(double p, unsigned successes)
+void find_max_sample_size(double p, unsigned successes)
 {
    //
    // p = success ratio.
@@ -56,7 +56,7 @@
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
       // calculate trials:
- double t = binomial_distribution<>::estimate_maximum_number_of_trials(successes, p, alpha[i]);
+ double t = binomial_distribution<>::find_maximum_number_of_trials(successes, p, alpha[i]);
       t = floor(t);
       // Print Trials:
       cout << fixed << setprecision(0) << setw(15) << right << t << endl;
@@ -66,10 +66,10 @@
 
 int main()
 {
- estimate_max_sample_size(1.0/1000, 0);
- estimate_max_sample_size(1.0/10000, 0);
- estimate_max_sample_size(1.0/100000, 0);
- estimate_max_sample_size(1.0/1000000, 0);
+ find_max_sample_size(1.0/1000, 0);
+ find_max_sample_size(1.0/10000, 0);
+ find_max_sample_size(1.0/100000, 0);
+ find_max_sample_size(1.0/1000000, 0);
 
    return 0;
 }

Modified: sandbox/math_toolkit/libs/math/example/chi_square_std_dev_test.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/chi_square_std_dev_test.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/chi_square_std_dev_test.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -187,14 +187,14 @@
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
       // calculate df for a lower single-sided test:
- double df = chi_squared::estimate_degrees_of_freedom(
+ double df = chi_squared::find_degrees_of_freedom(
          -diff, alpha[i], alpha[i], variance);
       // convert to sample size:
       double size = ceil(df) + 1;
       // Print size:
       cout << fixed << setprecision(0) << setw(16) << right << size;
       // calculate df for an upper single-sided test:
- df = chi_squared::estimate_degrees_of_freedom(
+ df = chi_squared::find_degrees_of_freedom(
          diff, alpha[i], alpha[i], variance);
       // convert to sample size:
       size = ceil(df) + 1;

Modified: sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/find_mean_and_sd_normal.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -115,7 +115,7 @@
 
 /*`
 This calculation is generalized as the free function called
-[link to math_toolkit.dist.dist_ref.dist_algorithms find_location].
+[link math_toolkit.dist.dist_ref.dist_algorithms find_location].
 
 To use this we will need to
 */

Modified: sandbox/math_toolkit/libs/math/example/find_root_example.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/find_root_example.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/find_root_example.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -76,13 +76,13 @@
 } // namespace detail
 
 template <class RealType, class Policy>
-RealType normal_distribution<RealType, Policy>::estimate_standard_deviation(
+RealType normal_distribution<RealType, Policy>::find_standard_deviation(
       RealType difference_from_mean,
       RealType mean,
       RealType sd,
       RealType hint) // Best guess available - current sd if none better?
 {
- static const char* function = "boost::math::normal_distribution<%1%>::estimate_standard_deviation";
+ static const char* function = "boost::math::normal_distribution<%1%>::find_standard_deviation";
 
    // Check for domain errors:
    RealType error_result;
@@ -108,7 +108,7 @@
          " or the answer is infinite. Current best guess is %1%", result, Policy());
    }
    return result;
-} // estimate_standard_deviation
+} // find_standard_deviation
 } // namespace tools
 } // namespace math
 } // namespace boost

Modified: sandbox/math_toolkit/libs/math/example/normal_misc_examples.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/normal_misc_examples.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/normal_misc_examples.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -389,7 +389,6 @@
 
 //] [/normal_bulbs_example4 Quickbook end]
   }
-// So we should package this as estimate_mean and sd????
 
   { // K. Krishnamoorthy, Handbook of Statistical Distributions with Applications,
     // ISBN 1 58488 635 8, page 125, example 10.3.8

Modified: sandbox/math_toolkit/libs/math/example/policy_eg_3.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/policy_eg_3.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/policy_eg_3.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -1,8 +1,15 @@
 // Copyright John Maddock 2007.
+// 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)
 
+#ifdef _MSC_VER
+# pragma warning (disable : 4305) // 'initializing' : truncation from 'long double' to 'const eval_type'
+# pragma warning (disable : 4244) // conversion from 'long double' to 'const eval_type'
+#endif
+
 #include <iostream>
 
 //[policy_eg_3
@@ -15,8 +22,8 @@
 //
 using namespace boost::math::policies;
 typedef policy<
- promote_float<false>,
- discrete_quantile<integer_round_nearest>
+ promote_float<false>,
+ discrete_quantile<integer_round_nearest>
> mypolicy;
 //
 // Then define a distribution that uses it:

Modified: sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/policy_eg_8.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -1,4 +1,5 @@
 // Copyright John Maddock 2007.
+// 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)
@@ -6,13 +7,18 @@
 // Note that this file contains quickbook mark-up as well as code
 // and comments, don't change any of the special comment mark-ups!
 
+#ifdef _MSC_VER
+# pragma warning (disable : 4100) // 'unreferenced formal parameter
+#endif
+
+
 #include <iostream>
 
 //[policy_eg_8
 
 /*`
 
-Suppose we want our own user-defined error handlers rather than the
+Suppose we want our own user-defined error handlers rather than the
 any of the default ones supplied by the library to be used. If
 we set the policy for a specific type of error to `user_error`
 then the library will call a user-supplied error handler.

Modified: sandbox/math_toolkit/libs/math/example/policy_ref_snip13.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/policy_ref_snip13.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/policy_ref_snip13.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -6,6 +6,10 @@
 // Note that this file contains quickbook mark-up as well as code
 // and comments, don't change any of the special comment mark-ups!
 
+#ifdef _MSC_VER
+#pragma warning (disable : 4189) // 'd' : local variable is initialized but not referenced
+#endif
+
 //[policy_ref_snip13
 
 #include <boost/math/distributions/cauchy.hpp>
@@ -30,8 +34,9 @@
 //
 void test_cauchy()
 {
- try{
- double d = mean(myspace::cauchy());
+ try
+ {
+ double d = mean(myspace::cauchy());
    }
    catch(const std::domain_error& e)
    {

Modified: sandbox/math_toolkit/libs/math/example/policy_ref_snip4.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/policy_ref_snip4.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/policy_ref_snip4.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -1,4 +1,5 @@
 // Copyright John Maddock 2007.
+// 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)
@@ -6,6 +7,11 @@
 // Note that this file contains quickbook mark-up as well as code
 // and comments, don't change any of the special comment mark-ups!
 
+#ifdef _MSC_VER
+# pragma warning (disable : 4305) // 'initializing' : truncation from 'long double' to 'const eval_type'
+# pragma warning (disable : 4244) // 'conversion' : truncation from 'long double' to 'const eval_type'
+#endif
+
 //[policy_ref_snip4
 
 #include <boost/math/distributions/normal.hpp>
@@ -17,14 +23,14 @@
 typedef policy<
       promote_float<false>
> my_policy;
-
+
 // Define the distribution:
 typedef normal_distribution<float, my_policy> my_norm;
 
 // Get a quantile:
 float q = quantile(my_norm(), 0.05f);
 
-//]
+//] [policy_ref_snip4]
 
 #include <iostream>
 

Modified: sandbox/math_toolkit/libs/math/example/students_t_single_sample.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/example/students_t_single_sample.cpp (original)
+++ sandbox/math_toolkit/libs/math/example/students_t_single_sample.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -161,7 +161,7 @@
    cout << endl << endl;
 }
 
-void single_sample_estimate_df(double M, double Sm, double Sd)
+void single_sample_find_df(double M, double Sm, double Sd)
 {
    //
    // M = true mean.
@@ -201,14 +201,14 @@
       // Confidence value:
       cout << fixed << setprecision(3) << setw(10) << right << 100 * (1-alpha[i]);
       // calculate df for single sided test:
- double df = students_t::estimate_degrees_of_freedom(
+ double df = students_t::find_degrees_of_freedom(
          fabs(M - Sm), alpha[i], alpha[i], Sd);
       // convert to sample size:
       double size = ceil(df) + 1;
       // Print size:
       cout << fixed << setprecision(0) << setw(16) << right << size;
       // calculate df for two sided test:
- df = students_t::estimate_degrees_of_freedom(
+ df = students_t::find_degrees_of_freedom(
          fabs(M - Sm), alpha[i]/2, alpha[i], Sd);
       // convert to sample size:
       size = ceil(df) + 1;
@@ -228,7 +228,7 @@
    //
    confidence_limits_on_mean(9.261460, 0.2278881e-01, 195);
    single_sample_t_test(5, 9.261460, 0.2278881e-01, 195, 0.05);
- single_sample_estimate_df(5, 9.261460, 0.2278881e-01);
+ single_sample_find_df(5, 9.261460, 0.2278881e-01);
 
    //
    // Data for this example from:
@@ -247,7 +247,7 @@
    // 90% test:
    single_sample_t_test(38.9, 37.8, 0.964365, 3, 0.1);
    // parameter estimate:
- single_sample_estimate_df(38.9, 37.8, 0.964365);
+ single_sample_find_df(38.9, 37.8, 0.964365);
 
    return 0;
 }

Modified: sandbox/math_toolkit/libs/math/test/Jamfile.v2
==============================================================================
--- sandbox/math_toolkit/libs/math/test/Jamfile.v2 (original)
+++ sandbox/math_toolkit/libs/math/test/Jamfile.v2 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -22,8 +22,9 @@
       <toolset>msvc:<cxxflags>/wd4610
       <toolset>msvc:<cxxflags>/wd4510
       <toolset>msvc:<cxxflags>/wd4127
- <toolset>msvc:<cxxflags>/wd4701
- <toolset>msvc:<cxxflags>/wd4127
+ <toolset>msvc:<cxxflags>/wd4701 # needed for lexical cast - temporary.
+ # <toolset>msvc:<cxxflags>/wd4506 has no effect?
+ # suppress xstring(237) : warning C4506: no definition for inline function
       <include>../../..
       <source>/boost/regex//boost_regex
       <link>shared:<define>BOOST_REGEX_DYN_LINK=1

Modified: sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_beta_dist.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -94,18 +94,18 @@
       // Estimate alpha & beta from mean and variance:
 
       BOOST_CHECK_CLOSE_FRACTION(
- beta_distribution<RealType>::estimate_alpha(mean(abeta), variance(abeta)),
+ beta_distribution<RealType>::find_alpha(mean(abeta), variance(abeta)),
          abeta.alpha(), tol);
       BOOST_CHECK_CLOSE_FRACTION(
- beta_distribution<RealType>::estimate_beta(mean(abeta), variance(abeta)),
+ beta_distribution<RealType>::find_beta(mean(abeta), variance(abeta)),
          abeta.beta(), tol);
 
       // Estimate sample alpha and beta from others:
       BOOST_CHECK_CLOSE_FRACTION(
- beta_distribution<RealType>::estimate_alpha(abeta.beta(), x, P),
+ beta_distribution<RealType>::find_alpha(abeta.beta(), x, P),
          abeta.alpha(), tol);
       BOOST_CHECK_CLOSE_FRACTION(
- beta_distribution<RealType>::estimate_beta(abeta.alpha(), x, P),
+ beta_distribution<RealType>::find_beta(abeta.alpha(), x, P),
          abeta.beta(), tol);
    } // if((P < 0.99) && (Q < 0.99)
   
@@ -524,11 +524,11 @@
    BOOST_CHECK_CLOSE_FRACTION(kurtosis_excess(mybeta22), -144.0 / 168, tol);
    BOOST_CHECK_CLOSE_FRACTION(skewness(beta_distribution<>(3, 5)), 0.30983866769659335081434123198259, tol);
 
- BOOST_CHECK_CLOSE_FRACTION(beta_distribution<double>::estimate_alpha(mean(mybeta22), variance(mybeta22)), mybeta22.alpha(), tol); // mean, variance, probability.
- BOOST_CHECK_CLOSE_FRACTION(beta_distribution<double>::estimate_beta(mean(mybeta22), variance(mybeta22)), mybeta22.beta(), tol);// mean, variance, probability.
+ BOOST_CHECK_CLOSE_FRACTION(beta_distribution<double>::find_alpha(mean(mybeta22), variance(mybeta22)), mybeta22.alpha(), tol); // mean, variance, probability.
+ BOOST_CHECK_CLOSE_FRACTION(beta_distribution<double>::find_beta(mean(mybeta22), variance(mybeta22)), mybeta22.beta(), tol);// mean, variance, probability.
 
- BOOST_CHECK_CLOSE_FRACTION(mybeta22.estimate_alpha(mybeta22.beta(), 0.8, cdf(mybeta22, 0.8)), mybeta22.alpha(), tol);
- BOOST_CHECK_CLOSE_FRACTION(mybeta22.estimate_beta(mybeta22.alpha(), 0.8, cdf(mybeta22, 0.8)), mybeta22.beta(), tol);
+ BOOST_CHECK_CLOSE_FRACTION(mybeta22.find_alpha(mybeta22.beta(), 0.8, cdf(mybeta22, 0.8)), mybeta22.alpha(), tol);
+ BOOST_CHECK_CLOSE_FRACTION(mybeta22.find_beta(mybeta22.alpha(), 0.8, cdf(mybeta22, 0.8)), mybeta22.beta(), tol);
 
 
    beta_distribution<real_concept> rcbeta22(2, 2); // Using RealType real_concept.

Modified: sandbox/math_toolkit/libs/math/test/test_binomial.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_binomial.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_binomial.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -84,15 +84,15 @@
       if(k > 0)
       {
          // estimate success ratio:
- // Note lower bound uses a different formual imternally
+ // Note lower bound uses a different formual internally
          // from upper bound, have to adjust things to prevent
          // fencepost errors:
          BOOST_CHECK_CLOSE(
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                N, k+1, Q),
             p, tol);
          BOOST_CHECK_CLOSE(
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                N, k, P),
             p, tol);
 
@@ -100,32 +100,32 @@
          {
             // Default method (Clopper Pearson)
             BOOST_CHECK(
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, Q)
                   <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, Q)
                   );
             BOOST_CHECK((
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, Q)
                   <= k/N) && (k/N <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, Q))
                   );
             // Bayes Method (Jeffreys Prior)
             BOOST_CHECK(
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                N, k, Q, binomial_distribution<RealType>::jeffreys_prior_interval)
                   <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, Q, binomial_distribution<RealType>::jeffreys_prior_interval)
                   );
             BOOST_CHECK((
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, Q, binomial_distribution<RealType>::jeffreys_prior_interval)
                   <= k/N) && (k/N <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, Q, binomial_distribution<RealType>::jeffreys_prior_interval))
                   );
          }
@@ -133,32 +133,32 @@
          {
             // Default method (Clopper Pearson)
             BOOST_CHECK(
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, P)
                   <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, P)
                   );
             BOOST_CHECK(
- (binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ (binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, P)
                   <= k / N) && (k/N <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, P))
                   );
             // Bayes Method (Jeffreys Prior)
             BOOST_CHECK(
- binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, P, binomial_distribution<RealType>::jeffreys_prior_interval)
                   <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, P, binomial_distribution<RealType>::jeffreys_prior_interval)
                   );
             BOOST_CHECK(
- (binomial_distribution<RealType>::estimate_lower_bound_on_p(
+ (binomial_distribution<RealType>::find_lower_bound_on_p(
                   N, k, P, binomial_distribution<RealType>::jeffreys_prior_interval)
                   <= k / N) && (k/N <=
- binomial_distribution<RealType>::estimate_upper_bound_on_p(
+ binomial_distribution<RealType>::find_upper_bound_on_p(
                   N, k, P, binomial_distribution<RealType>::jeffreys_prior_interval))
                   );
          }
@@ -167,11 +167,11 @@
       // estimate sample size:
       //
       BOOST_CHECK_CLOSE(
- binomial_distribution<RealType>::estimate_minimum_number_of_trials(
+ binomial_distribution<RealType>::find_minimum_number_of_trials(
             k, p, P),
          N, tol);
       BOOST_CHECK_CLOSE(
- binomial_distribution<RealType>::estimate_maximum_number_of_trials(
+ binomial_distribution<RealType>::find_maximum_number_of_trials(
             k, p, Q),
          N, tol);
    }

Modified: sandbox/math_toolkit/libs/math/test/test_chi_squared.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_chi_squared.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_chi_squared.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -508,16 +508,16 @@
     // Subsequent tests just test our empirically generated values, they
     // catch regressions, but otherwise aren't worth much.
     BOOST_CHECK_EQUAL(
- ceil(chi_squared_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
          55, 0.05f, 0.01f, 100)), static_cast<RealType>(170));
     BOOST_CHECK_EQUAL(
- ceil(chi_squared_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
          10, 0.05f, 0.01f, 100)), static_cast<RealType>(3493));
     BOOST_CHECK_EQUAL(
- ceil(chi_squared_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
          -55, 0.05f, 0.01f, 100)), static_cast<RealType>(49));
     BOOST_CHECK_EQUAL(
- ceil(chi_squared_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
          -10, 0.05f, 0.01f, 100)), static_cast<RealType>(2826));
 } // template <class RealType>void test_spots(RealType)
 

Modified: sandbox/math_toolkit/libs/math/test/test_students_t.cpp
==============================================================================
--- sandbox/math_toolkit/libs/math/test/test_students_t.cpp (original)
+++ sandbox/math_toolkit/libs/math/test/test_students_t.cpp 2007-09-21 13:39:55 EDT (Fri, 21 Sep 2007)
@@ -330,42 +330,42 @@
     // freedom required, particularly when the result is small.
     //
     BOOST_CHECK_EQUAL(
- ceil(students_t_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(students_t_distribution<RealType>::find_degrees_of_freedom(
          static_cast<RealType>(0.5),
          static_cast<RealType>(0.005),
          static_cast<RealType>(0.01),
          static_cast<RealType>(1.0))),
          99);
     BOOST_CHECK_EQUAL(
- ceil(students_t_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(students_t_distribution<RealType>::find_degrees_of_freedom(
          static_cast<RealType>(1.5),
          static_cast<RealType>(0.005),
          static_cast<RealType>(0.01),
          static_cast<RealType>(1.0))),
          14);
     BOOST_CHECK_EQUAL(
- ceil(students_t_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(students_t_distribution<RealType>::find_degrees_of_freedom(
          static_cast<RealType>(0.5),
          static_cast<RealType>(0.025),
          static_cast<RealType>(0.01),
          static_cast<RealType>(1.0))),
          76);
     BOOST_CHECK_EQUAL(
- ceil(students_t_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(students_t_distribution<RealType>::find_degrees_of_freedom(
          static_cast<RealType>(1.5),
          static_cast<RealType>(0.025),
          static_cast<RealType>(0.01),
          static_cast<RealType>(1.0))),
          11);
     BOOST_CHECK_EQUAL(
- ceil(students_t_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(students_t_distribution<RealType>::find_degrees_of_freedom(
          static_cast<RealType>(0.5),
          static_cast<RealType>(0.05),
          static_cast<RealType>(0.01),
          static_cast<RealType>(1.0))),
          65);
     BOOST_CHECK_EQUAL(
- ceil(students_t_distribution<RealType>::estimate_degrees_of_freedom(
+ ceil(students_t_distribution<RealType>::find_degrees_of_freedom(
          static_cast<RealType>(1.5),
          static_cast<RealType>(0.05),
          static_cast<RealType>(0.01),


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk