Boost logo

Boost-Commit :

From: eric_at_[hidden]
Date: 2008-01-08 13:43:46


Author: eric_niebler
Date: 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
New Revision: 42620
URL: http://svn.boost.org/trac/boost/changeset/42620

Log:
fix signed/unsigned warnings, clean up trailing whitespace
Text files modified:
   trunk/libs/accumulators/test/covariance.cpp | 16 ++++++++--------
   trunk/libs/accumulators/test/extended_p_square.cpp | 2 +-
   trunk/libs/accumulators/test/extended_p_square_quantile.cpp | 4 ++--
   trunk/libs/accumulators/test/kurtosis.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/mean.cpp | 2 +-
   trunk/libs/accumulators/test/median.cpp | 10 +++++-----
   trunk/libs/accumulators/test/p_square_cumulative_distribution.cpp | 16 ++++++++--------
   trunk/libs/accumulators/test/p_square_quantile.cpp | 10 +++++-----
   trunk/libs/accumulators/test/pot_quantile.cpp | 18 +++++++++---------
   trunk/libs/accumulators/test/reference.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/skewness.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/tail_mean.cpp | 10 +++++-----
   trunk/libs/accumulators/test/tail_quantile.cpp | 16 ++++++++--------
   trunk/libs/accumulators/test/tail_variate_means.cpp | 26 +++++++++++++-------------
   trunk/libs/accumulators/test/variance.cpp | 2 +-
   trunk/libs/accumulators/test/weighted_covariance.cpp | 18 +++++++++---------
   trunk/libs/accumulators/test/weighted_extended_p_square.cpp | 16 ++++++++--------
   trunk/libs/accumulators/test/weighted_kurtosis.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/weighted_mean.cpp | 6 +++---
   trunk/libs/accumulators/test/weighted_median.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/weighted_moment.cpp | 6 +++---
   trunk/libs/accumulators/test/weighted_p_square_cum_dist.cpp | 26 +++++++++++++-------------
   trunk/libs/accumulators/test/weighted_p_square_quantile.cpp | 10 +++++-----
   trunk/libs/accumulators/test/weighted_pot_quantile.cpp | 22 +++++++++++-----------
   trunk/libs/accumulators/test/weighted_skewness.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/weighted_tail_mean.cpp | 12 ++++++------
   trunk/libs/accumulators/test/weighted_tail_quantile.cpp | 14 +++++++-------
   trunk/libs/accumulators/test/weighted_tail_variate_means.cpp | 24 ++++++++++++------------
   trunk/libs/accumulators/test/weighted_variance.cpp | 12 ++++++------
   29 files changed, 191 insertions(+), 191 deletions(-)

Modified: trunk/libs/accumulators/test/covariance.cpp
==============================================================================
--- trunk/libs/accumulators/test/covariance.cpp (original)
+++ trunk/libs/accumulators/test/covariance.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -24,12 +24,12 @@
     std::vector<double> dummy;
     dummy.push_back(0);
     dummy.push_back(0);
-
+
     accumulator_set<double, stats<tag::covariance<double, tag::covariate1> > > acc;
     accumulator_set<std::vector<double>, stats<tag::covariance<double, tag::covariate1> > > acc2(sample = dummy);
     accumulator_set<double, stats<tag::covariance<std::vector<double>, tag::covariate1> > > acc3(covariate1 = dummy);
     accumulator_set<std::vector<double>, stats<tag::covariance<std::vector<double>, tag::covariate1> > > acc4(sample = dummy, covariate1 = dummy);
-
+
     std::vector<double> a;
     a.push_back(1.);
     a.push_back(2.);
@@ -42,7 +42,7 @@
     std::vector<double> d;
     d.push_back(4.);
     d.push_back(2.);
-
+
     // double - double
     {
         acc(1., covariate1 = 2.);
@@ -50,7 +50,7 @@
         acc(2., covariate1 = 3.);
         acc(6., covariate1 = 1.);
     }
-
+
     // vector - double
     {
         acc2(a, covariate1 = 1.);
@@ -58,7 +58,7 @@
         acc2(c, covariate1 = 2.);
         acc2(d, covariate1 = 6.);
     }
-
+
     // double - vector
     {
         acc3(1., covariate1 = a);
@@ -66,7 +66,7 @@
         acc3(2., covariate1 = c);
         acc3(6., covariate1 = d);
     }
-
+
     // vector - vector
     {
         acc4(a, covariate1 = b);
@@ -74,9 +74,9 @@
         acc4(a, covariate1 = c);
         acc4(d, covariate1 = b);
     }
-
+
     double epsilon = 1e-6;
-
+
     BOOST_CHECK_CLOSE((covariance(acc)), -1.75, epsilon);
     BOOST_CHECK_CLOSE((covariance(acc2))[0], 1.75, epsilon);
     BOOST_CHECK_CLOSE((covariance(acc2))[1], -1.125, epsilon);

Modified: trunk/libs/accumulators/test/extended_p_square.cpp
==============================================================================
--- trunk/libs/accumulators/test/extended_p_square.cpp (original)
+++ trunk/libs/accumulators/test/extended_p_square.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -53,7 +53,7 @@
     BOOST_CHECK_CLOSE(extended_p_square(acc)[0], probs[0], 25);
     BOOST_CHECK_CLOSE(extended_p_square(acc)[1], probs[1], 10);
     BOOST_CHECK_CLOSE(extended_p_square(acc)[2], probs[2], 5);
-
+
     for (std::size_t i=3; i<probs.size(); ++i)
     {
         BOOST_CHECK_CLOSE(extended_p_square(acc)[i], probs[i], epsilon);

Modified: trunk/libs/accumulators/test/extended_p_square_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/extended_p_square_quantile.cpp (original)
+++ trunk/libs/accumulators/test/extended_p_square_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -53,7 +53,7 @@
     accumulator_t_weighted acc_weighted(extended_p_square_probabilities = probs);
     accumulator_t_quadratic acc2(extended_p_square_probabilities = probs);
     accumulator_t_weighted_quadratic acc_weighted2(extended_p_square_probabilities = probs);
-
+
     for (int i=0; i<10000; ++i)
     {
         double sample = rng();
@@ -62,7 +62,7 @@
         acc_weighted(sample, weight = 1.);
         acc_weighted2(sample, weight = 1.);
     }
-
+
     for (std::size_t i = 0; i < probs.size() - 1; ++i)
     {
         BOOST_CHECK_CLOSE(

Modified: trunk/libs/accumulators/test/kurtosis.cpp
==============================================================================
--- trunk/libs/accumulators/test/kurtosis.cpp (original)
+++ trunk/libs/accumulators/test/kurtosis.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -26,29 +26,29 @@
 {
     // tolerance in %
     // double epsilon = 1;
-
+
     accumulator_set<double, stats<tag::kurtosis > > acc1;
     accumulator_set<int, stats<tag::kurtosis > > acc2;
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         acc1(normal());
     }
-
+
     // This check fails because epsilon is relative and not absolute
- // BOOST_CHECK_CLOSE( kurtosis(acc1), 0., epsilon );
-
+ // BOOST_CHECK_CLOSE( kurtosis(acc1), 0., epsilon );
+
     acc2(2);
     acc2(7);
     acc2(4);
     acc2(9);
     acc2(3);
-
+
     BOOST_CHECK_EQUAL( mean(acc2), 5 );
     BOOST_CHECK_EQUAL( moment<2>(acc2), 159./5. );
     BOOST_CHECK_EQUAL( moment<3>(acc2), 1171./5. );

Modified: trunk/libs/accumulators/test/mean.cpp
==============================================================================
--- trunk/libs/accumulators/test/mean.cpp (original)
+++ trunk/libs/accumulators/test/mean.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -38,7 +38,7 @@
     BOOST_CHECK_EQUAL(1u, count(acc));
     BOOST_CHECK_EQUAL(1, sum(acc));
     BOOST_CHECK_CLOSE(3., (mean_of_variates<int, tag::covariate1>(acc)), 1e-5);
-
+
     acc(0, covariate1 = 4);
     BOOST_CHECK_CLOSE(0.5, mean(acc), 1e-5);
     BOOST_CHECK_EQUAL(2u, count(acc));

Modified: trunk/libs/accumulators/test/median.cpp
==============================================================================
--- trunk/libs/accumulators/test/median.cpp (original)
+++ trunk/libs/accumulators/test/median.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -24,13 +24,13 @@
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(mu,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     accumulator_set<double, stats<tag::median(with_p_square_quantile) > > acc;
- accumulator_set<double, stats<tag::median(with_density) > >
+ accumulator_set<double, stats<tag::median(with_density) > >
         acc_dens( density_cache_size = 10000, density_num_bins = 1000 );
- accumulator_set<double, stats<tag::median(with_p_square_cumulative_distribution) > >
+ accumulator_set<double, stats<tag::median(with_p_square_cumulative_distribution) > >
         acc_cdist( p_square_cumulative_distribution_num_cells = 100 );
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         double sample = normal();
@@ -38,7 +38,7 @@
         acc_dens(sample);
         acc_cdist(sample);
     }
-
+
     BOOST_CHECK_CLOSE(1., median(acc), 1.);
     BOOST_CHECK_CLOSE(1., median(acc_dens), 1.);
     BOOST_CHECK_CLOSE(1., median(acc_cdist), 3.);

Modified: trunk/libs/accumulators/test/p_square_cumulative_distribution.cpp
==============================================================================
--- trunk/libs/accumulators/test/p_square_cumulative_distribution.cpp (original)
+++ trunk/libs/accumulators/test/p_square_cumulative_distribution.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -43,28 +43,28 @@
     double epsilon = 3;
 
     typedef accumulator_set<double, stats<tag::p_square_cumulative_distribution> > accumulator_t;
-
+
     accumulator_t acc(p_square_cumulative_distribution_num_cells = 100);
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         acc(normal());
     }
-
+
     typedef iterator_range<std::vector<std::pair<double, double> >::iterator > histogram_type;
     histogram_type histogram = p_square_cumulative_distribution(acc);
-
+
     for (std::size_t i = 0; i < histogram.size(); ++i)
- {
+ {
         // problem with small results: epsilon is relative (in percent), not absolute!
- if ( histogram[i].second > 0.001 )
+ if ( histogram[i].second > 0.001 )
             BOOST_CHECK_CLOSE( 0.5 * (1.0 + my_erf( histogram[i].first / sqrt(2.0) )), histogram[i].second, epsilon );
- }
+ }
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/p_square_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/p_square_quantile.cpp (original)
+++ trunk/libs/accumulators/test/p_square_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -28,10 +28,10 @@
 
     // tolerance in %
     double epsilon = 1;
-
+
     // a random number generator
     boost::lagged_fibonacci607 rng;
-
+
     accumulator_t acc0(quantile_probability = 0.001);
     accumulator_t acc1(quantile_probability = 0.01 );
     accumulator_t acc2(quantile_probability = 0.1 );
@@ -41,7 +41,7 @@
     accumulator_t acc6(quantile_probability = 0.9 );
     accumulator_t acc7(quantile_probability = 0.99 );
     accumulator_t acc8(quantile_probability = 0.999);
-
+
     for (int i=0; i<100000; ++i)
     {
         double sample = rng();
@@ -55,7 +55,7 @@
         acc7(sample);
         acc8(sample);
     }
-
+
     BOOST_CHECK_CLOSE( p_square_quantile(acc0), 0.001, 15*epsilon );
     BOOST_CHECK_CLOSE( p_square_quantile(acc1), 0.01 , 5*epsilon );
     BOOST_CHECK_CLOSE( p_square_quantile(acc2), 0.1 , epsilon );
@@ -64,7 +64,7 @@
     BOOST_CHECK_CLOSE( p_square_quantile(acc5), 0.75 , epsilon );
     BOOST_CHECK_CLOSE( p_square_quantile(acc6), 0.9 , epsilon );
     BOOST_CHECK_CLOSE( p_square_quantile(acc7), 0.99 , epsilon );
- BOOST_CHECK_CLOSE( p_square_quantile(acc8), 0.999, epsilon );
+ BOOST_CHECK_CLOSE( p_square_quantile(acc8), 0.999, epsilon );
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/pot_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/pot_quantile.cpp (original)
+++ trunk/libs/accumulators/test/pot_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -34,7 +34,7 @@
     boost::exponential_distribution<> lambda(1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::exponential_distribution<> > exponential(rng, lambda);
-
+
     accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc1(
         pot_threshold_value = 3.
     );
@@ -49,7 +49,7 @@
         left_tail_cache_size = 2000
       , pot_threshold_probability = 0.01
     );
-
+
     accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc5(
         pot_threshold_value = 5.
     );
@@ -57,7 +57,7 @@
         right_tail_cache_size = 2000
       , pot_threshold_probability = 0.995
     );
-
+
     for (std::size_t i = 0; i < 100000; ++i)
     {
         double sample = normal();
@@ -66,21 +66,21 @@
         acc3(sample);
         acc4(sample);
     }
-
+
     for (std::size_t i = 0; i < 100000; ++i)
     {
         double sample = exponential();
         acc5(sample);
         acc6(sample);
     }
-
+
     BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, epsilon );
- BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.999), 3.090232, epsilon );
+ BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.999), 3.090232, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.001), -3.090232, epsilon );
- BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = 0.001), -3.090232, epsilon );
-
+ BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = 0.001), -3.090232, epsilon );
+
     BOOST_CHECK_CLOSE( quantile(acc5, quantile_probability = 0.999), 6.908, epsilon );
- BOOST_CHECK_CLOSE( quantile(acc6, quantile_probability = 0.999), 6.908, epsilon );
+ BOOST_CHECK_CLOSE( quantile(acc6, quantile_probability = 0.999), 6.908, epsilon );
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/reference.cpp
==============================================================================
--- trunk/libs/accumulators/test/reference.cpp (original)
+++ trunk/libs/accumulators/test/reference.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -52,9 +52,9 @@
 
     sum_acc(1);
     sum_acc(2); // sum is now 3 for both
-
- BOOST_CHECK_EQUAL(sum(acc_with_ref), sum(sum_acc));
- BOOST_CHECK_EQUAL(sum(acc_with_ref), 3);
+
+ BOOST_CHECK_EQUAL(sum(acc_with_ref), sum(sum_acc));
+ BOOST_CHECK_EQUAL(sum(acc_with_ref), 3);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -69,15 +69,15 @@
       , stats<
             tag::mean
             // make sum external and hold a reference to it
- , tag::external<tag::sum, my::tag::sum_acc, sum_acc_type>
+ , tag::external<tag::sum, my::tag::sum_acc, sum_acc_type>
>
> acc_with_ref(my::sum_acc = sum_acc); // initialize the reference sum
 
     sum_acc(1);
     sum_acc(2); // sum is now 3 for both
-
- BOOST_CHECK_EQUAL(sum(acc_with_ref), sum(sum_acc));
- BOOST_CHECK_EQUAL(sum(acc_with_ref), 3);
+
+ BOOST_CHECK_EQUAL(sum(acc_with_ref), sum(sum_acc));
+ BOOST_CHECK_EQUAL(sum(acc_with_ref), 3);
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/skewness.cpp
==============================================================================
--- trunk/libs/accumulators/test/skewness.cpp (original)
+++ trunk/libs/accumulators/test/skewness.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -26,29 +26,29 @@
 {
     // tolerance in %
     // double epsilon = 1;
-
+
     accumulator_set<double, stats<tag::skewness > > acc1;
     accumulator_set<int, stats<tag::skewness > > acc2;
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         acc1(normal());
     }
-
+
     // This check fails because epsilon is relative and not absolute
- // BOOST_CHECK_CLOSE( skewness(acc1), 0., epsilon );
-
+ // BOOST_CHECK_CLOSE( skewness(acc1), 0., epsilon );
+
     acc2(2);
     acc2(7);
     acc2(4);
     acc2(9);
     acc2(3);
-
+
     BOOST_CHECK_EQUAL( mean(acc2), 5 );
     BOOST_CHECK_EQUAL( moment<2>(acc2), 159./5. );
     BOOST_CHECK_EQUAL( moment<3>(acc2), 1171./5. );

Modified: trunk/libs/accumulators/test/tail_mean.cpp
==============================================================================
--- trunk/libs/accumulators/test/tail_mean.cpp (original)
+++ trunk/libs/accumulators/test/tail_mean.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -27,10 +27,10 @@
 {
     // tolerance in %
     double epsilon = 1;
-
+
     std::size_t n = 100000; // number of MC steps
     std::size_t c = 10000; // cache size
-
+
     typedef accumulator_set<double, stats<tag::non_coherent_tail_mean<right>, tag::tail_quantile<right> > > accumulator_t_right1;
     typedef accumulator_set<double, stats<tag::non_coherent_tail_mean<left>, tag::tail_quantile<left> > > accumulator_t_left1;
     typedef accumulator_set<double, stats<tag::coherent_tail_mean<right>, tag::tail_quantile<right> > > accumulator_t_right2;
@@ -40,10 +40,10 @@
     accumulator_t_left1 acc1( left_tail_cache_size = c );
     accumulator_t_right2 acc2( right_tail_cache_size = c );
     accumulator_t_left2 acc3( left_tail_cache_size = c );
-
+
     // a random number generator
     boost::lagged_fibonacci607 rng;
-
+
     for (std::size_t i = 0; i < n; ++i)
     {
         double sample = rng();
@@ -52,7 +52,7 @@
         acc2(sample);
         acc3(sample);
     }
-
+
     // check uniform distribution
     BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc0, quantile_probability = 0.95), 0.975, epsilon );
     BOOST_CHECK_CLOSE( non_coherent_tail_mean(acc0, quantile_probability = 0.975), 0.9875, epsilon );

Modified: trunk/libs/accumulators/test/tail_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/tail_quantile.cpp (original)
+++ trunk/libs/accumulators/test/tail_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -26,23 +26,23 @@
 {
     // tolerance in %
     double epsilon = 1;
-
+
     std::size_t n = 100000; // number of MC steps
     std::size_t c = 10000; // cache size
-
+
     typedef accumulator_set<double, stats<tag::tail_quantile<right> > > accumulator_t_right;
     typedef accumulator_set<double, stats<tag::tail_quantile<left> > > accumulator_t_left;
-
+
     accumulator_t_right acc0( right_tail_cache_size = c );
     accumulator_t_right acc1( right_tail_cache_size = c );
     accumulator_t_left acc2( left_tail_cache_size = c );
     accumulator_t_left acc3( left_tail_cache_size = c );
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     for (std::size_t i = 0; i < n; ++i)
     {
         double sample1 = rng();
@@ -52,7 +52,7 @@
         acc2(sample1);
         acc3(sample2);
     }
-
+
     // check uniform distribution
     BOOST_CHECK_CLOSE( quantile(acc0, quantile_probability = 0.95 ), 0.95, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc0, quantile_probability = 0.975), 0.975, epsilon );
@@ -62,13 +62,13 @@
     BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.025), 0.025, 2 );
     BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.01 ), 0.01, 3 );
     BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.001), 0.001, 20 );
-
+
     // check standard normal distribution
     BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.975), 1.959963, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.025), -1.959963, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.001), -3.090232, epsilon );
-
+
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/tail_variate_means.cpp
==============================================================================
--- trunk/libs/accumulators/test/tail_variate_means.cpp (original)
+++ trunk/libs/accumulators/test/tail_variate_means.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -26,20 +26,20 @@
 void test_stat()
 {
     std::size_t c = 5; // cache size
-
+
     typedef double variate_type;
     typedef std::vector<variate_type> variate_set_type;
-
+
     typedef accumulator_set<double, stats<tag::tail_variate_means<right, variate_set_type, tag::covariate1>(relative)> > accumulator_t1;
     typedef accumulator_set<double, stats<tag::tail_variate_means<right, variate_set_type, tag::covariate1>(absolute)> > accumulator_t2;
     typedef accumulator_set<double, stats<tag::tail_variate_means<left, variate_set_type, tag::covariate1>(relative)> > accumulator_t3;
     typedef accumulator_set<double, stats<tag::tail_variate_means<left, variate_set_type, tag::covariate1>(absolute)> > accumulator_t4;
-
+
     accumulator_t1 acc1( right_tail_cache_size = c );
     accumulator_t2 acc2( right_tail_cache_size = c );
     accumulator_t3 acc3( left_tail_cache_size = c );
     accumulator_t4 acc4( left_tail_cache_size = c );
-
+
     variate_set_type cov1, cov2, cov3, cov4, cov5;
     double c1[] = { 10., 20., 30., 40. }; // 100
     double c2[] = { 26., 4., 17., 3. }; // 50
@@ -50,32 +50,32 @@
     cov2.assign(c2, c2 + sizeof(c2)/sizeof(variate_type));
     cov3.assign(c3, c3 + sizeof(c3)/sizeof(variate_type));
     cov4.assign(c4, c4 + sizeof(c4)/sizeof(variate_type));
- cov5.assign(c5, c5 + sizeof(c5)/sizeof(variate_type));
-
+ cov5.assign(c5, c5 + sizeof(c5)/sizeof(variate_type));
+
     acc1(100., covariate1 = cov1);
     acc1( 50., covariate1 = cov2);
     acc1(200., covariate1 = cov3);
     acc1( 80., covariate1 = cov4);
     acc1( 20., covariate1 = cov5);
-
+
     acc2(100., covariate1 = cov1);
     acc2( 50., covariate1 = cov2);
     acc2(200., covariate1 = cov3);
     acc2( 80., covariate1 = cov4);
     acc2( 20., covariate1 = cov5);
-
+
     acc3(100., covariate1 = cov1);
     acc3( 50., covariate1 = cov2);
     acc3(200., covariate1 = cov3);
     acc3( 80., covariate1 = cov4);
     acc3( 20., covariate1 = cov5);
-
+
     acc4(100., covariate1 = cov1);
     acc4( 50., covariate1 = cov2);
     acc4(200., covariate1 = cov3);
     acc4( 80., covariate1 = cov4);
     acc4( 20., covariate1 = cov5);
-
+
     // check relative risk contributions
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.7).begin() ), 14./75. ); // (10 + 46) / 300 = 14/75
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 1), 7./25. ); // (20 + 64) / 300 = 7/25
@@ -85,7 +85,7 @@
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 1), 3./35. ); // ( 4 + 2) / 70 = 3/35
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 2), 19./70. ); // (17 + 2) / 70 = 19/70
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 3), 17./70. ); // ( 3 + 14) / 70 = 17/70
-
+
     // check absolute risk contributions
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.7).begin() ), 28 ); // (10 + 46) / 2 = 28
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.7).begin() + 1), 42 ); // (20 + 64) / 2 = 42
@@ -95,7 +95,7 @@
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() + 1), 3 ); // ( 4 + 2) / 2 = 3
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() + 2),9.5 ); // (17 + 2) / 2 = 9.5
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc4, quantile_probability = 0.3).begin() + 3),8.5 ); // ( 3 + 14) / 2 = 8.5
-
+
     // check relative risk contributions
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.9).begin() ), 23./100. ); // 46/200 = 23/100
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 1), 8./25. ); // 64/200 = 8/25
@@ -105,7 +105,7 @@
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 1), 1./10. ); // 2/ 20 = 1/10
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 2), 1./10. ); // 2/ 20 = 1/10
     BOOST_CHECK_EQUAL( *(relative_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 3), 7./10. ); // 14/ 20 = 7/10
-
+
     // check absolute risk contributions
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.9).begin() ), 46 ); // 46
     BOOST_CHECK_EQUAL( *(tail_variate_means(acc2, quantile_probability = 0.9).begin() + 1), 64 ); // 64

Modified: trunk/libs/accumulators/test/variance.cpp
==============================================================================
--- trunk/libs/accumulators/test/variance.cpp (original)
+++ trunk/libs/accumulators/test/variance.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -23,7 +23,7 @@
     // >> mean(samples)
     // ans = 3
     // >> sum(samples .* samples) / length(samples)
- // ans = 11
+ // ans = 11
     // >> sum(samples .* samples) / length(samples) - mean(samples)^2
     // ans = 2
 

Modified: trunk/libs/accumulators/test/weighted_covariance.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_covariance.cpp (original)
+++ trunk/libs/accumulators/test/weighted_covariance.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -24,12 +24,12 @@
     std::vector<double> dummy;
     dummy.push_back(0);
     dummy.push_back(0);
-
+
     accumulator_set<double, stats<tag::weighted_covariance<double, tag::covariate1> >, double > acc;
     accumulator_set<std::vector<double>, stats<tag::weighted_covariance<double, tag::covariate1> >, double > acc2(sample = dummy);
     accumulator_set<double, stats<tag::weighted_covariance<std::vector<double>, tag::covariate1> >, double > acc3(covariate1 = dummy);
     accumulator_set<std::vector<double>, stats<tag::weighted_covariance<std::vector<double>, tag::covariate1> >, double > acc4(sample = dummy, covariate1 = dummy);
-
+
     std::vector<double> a;
     a.push_back(1.);
     a.push_back(2.);
@@ -42,15 +42,15 @@
     std::vector<double> d;
     d.push_back(4.);
     d.push_back(2.);
-
+
     // double - double
     {
         acc(1., weight = 1.1, covariate1 = 2.);
         acc(1., weight = 2.2, covariate1 = 4.);
         acc(2., weight = 3.3, covariate1 = 3.);
- acc(6., weight = 4.4, covariate1 = 1.);
+ acc(6., weight = 4.4, covariate1 = 1.);
     }
-
+
     // vector - double
     {
         acc2(a, weight = 1.1, covariate1 = 1.);
@@ -58,7 +58,7 @@
         acc2(c, weight = 3.3, covariate1 = 2.);
         acc2(d, weight = 4.4, covariate1 = 6.);
     }
-
+
     // double - vector
     {
         acc3(1., weight = 1.1, covariate1 = a);
@@ -66,7 +66,7 @@
         acc3(2., weight = 3.3, covariate1 = c);
         acc3(6., weight = 4.4, covariate1 = d);
     }
-
+
     // vector - vector
     {
         acc4(a, weight = 1.1, covariate1 = b);
@@ -74,9 +74,9 @@
         acc4(a, weight = 3.3, covariate1 = c);
         acc4(d, weight = 4.4, covariate1 = b);
     }
-
+
     double epsilon = 1e-6;
-
+
     BOOST_CHECK_CLOSE((weighted_covariance(acc)), -2.39, epsilon);
     BOOST_CHECK_CLOSE((weighted_covariance(acc2))[0], 1.93, epsilon);
     BOOST_CHECK_CLOSE((weighted_covariance(acc2))[1], -2.09, epsilon);

Modified: trunk/libs/accumulators/test/weighted_extended_p_square.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_extended_p_square.cpp (original)
+++ trunk/libs/accumulators/test/weighted_extended_p_square.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -28,7 +28,7 @@
     typedef accumulator_set<double, stats<tag::weighted_extended_p_square>, double> accumulator_t;
 
     // problem with small results: epsilon is relative (in percent), not absolute
-
+
     // tolerance in %
     double epsilon = 1;
 
@@ -45,17 +45,17 @@
 
     double p1[] = {/*0.001,*/ 0.01, 0.1, 0.5, 0.9, 0.99, 0.999};
     probs_uniform.assign(p1, p1 + sizeof(p1) / sizeof(double));
-
+
     double p2[] = {0.001, 0.025};
     double p3[] = {0.975, 0.999};
     probs_normal1.assign(p2, p2 + sizeof(p2) / sizeof(double));
     probs_normal2.assign(p3, p3 + sizeof(p3) / sizeof(double));
-
+
     double p4[] = {-3.090232, -1.959963};
     double p5[] = {1.959963, 3.090232};
     probs_normal_exact1.assign(p4, p4 + sizeof(p4) / sizeof(double));
     probs_normal_exact2.assign(p5, p5 + sizeof(p5) / sizeof(double));
-
+
     accumulator_t acc_uniform(extended_p_square_probabilities = probs_uniform);
     accumulator_t acc_normal1(extended_p_square_probabilities = probs_normal1);
     accumulator_t acc_normal2(extended_p_square_probabilities = probs_normal2);
@@ -63,19 +63,19 @@
     for (std::size_t i = 0; i < 100000; ++i)
     {
         acc_uniform(rng(), weight = 1.);
-
+
         double sample1 = normal1();
         double sample2 = normal2();
         acc_normal1(sample1, weight = std::exp(-mu1 * (sample1 - 0.5 * mu1)));
         acc_normal2(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2)));
     }
-
- // check for uniform distribution
+
+ // check for uniform distribution
     for (std::size_t i = 0; i < probs_uniform.size(); ++i)
     {
         BOOST_CHECK_CLOSE(weighted_extended_p_square(acc_uniform)[i], probs_uniform[i], epsilon);
     }
-
+
     // check for standard normal distribution
     for (std::size_t i = 0; i < probs_normal1.size(); ++i)
     {

Modified: trunk/libs/accumulators/test/weighted_kurtosis.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_kurtosis.cpp (original)
+++ trunk/libs/accumulators/test/weighted_kurtosis.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -26,29 +26,29 @@
 {
     // tolerance in %
     // double epsilon = 1;
-
+
     accumulator_set<double, stats<tag::weighted_kurtosis>, double > acc1;
     accumulator_set<int, stats<tag::weighted_kurtosis>, int > acc2;
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         acc1(normal(), weight = rng());
     }
-
+
     // This check fails because epsilon is relative and not absolute
- // BOOST_CHECK_CLOSE( weighted_kurtosis(acc1), 0., epsilon );
-
+ // BOOST_CHECK_CLOSE( weighted_kurtosis(acc1), 0., epsilon );
+
     acc2(2, weight = 4);
     acc2(7, weight = 1);
     acc2(4, weight = 3);
     acc2(9, weight = 1);
     acc2(3, weight = 2);
-
+
     BOOST_CHECK_EQUAL( weighted_mean(acc2), 42./11. );
     BOOST_CHECK_EQUAL( weighted_moment<2>(acc2), 212./11. );
     BOOST_CHECK_EQUAL( weighted_moment<3>(acc2), 1350./11. );

Modified: trunk/libs/accumulators/test/weighted_mean.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_mean.cpp (original)
+++ trunk/libs/accumulators/test/weighted_mean.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -32,7 +32,7 @@
           , tag::mean_of_weights
           , tag::weighted_mean_of_variates<int, tag::covariate1>
>
- , int
+ , int
> acc, test_acc(sample = 0);
 
     acc(1, weight = 2, covariate1 = 3);
@@ -73,13 +73,13 @@
     BOOST_CHECK_EQUAL(1u, count(acc2));
     BOOST_CHECK_CLOSE(2., mean_of_weights(acc2), 1e-5);
     BOOST_CHECK_CLOSE(3., (weighted_mean_of_variates<int, tag::covariate1>(acc2)), 1e-5);
-
+
     acc2(0, weight = 4, covariate1 = 4);
     BOOST_CHECK_CLOSE(1./3., weighted_mean(acc2), 1e-5);
     BOOST_CHECK_EQUAL(2u, count(acc2));
     BOOST_CHECK_CLOSE(3., mean_of_weights(acc2), 1e-5);
     BOOST_CHECK_CLOSE(11./3., (weighted_mean_of_variates<int, tag::covariate1>(acc2)), 1e-5);
-
+
     acc2(2, weight = 9, covariate1 = 8);
     BOOST_CHECK_CLOSE(4./3., weighted_mean(acc2), 1e-5);
     BOOST_CHECK_EQUAL(3u, count(acc2));

Modified: trunk/libs/accumulators/test/weighted_median.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_median.cpp (original)
+++ trunk/libs/accumulators/test/weighted_median.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -22,7 +22,7 @@
 {
     // Median estimation of normal distribution N(1,1) using samples from a narrow normal distribution N(1,0.01)
     // The weights equal to the likelihood ratio of the corresponding samples
-
+
     // two random number generators
     double mu = 1.;
     double sigma_narrow = 0.01;
@@ -30,14 +30,14 @@
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma_narrow(mu,sigma_narrow);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal_narrow(rng, mean_sigma_narrow);
-
+
     accumulator_set<double, stats<tag::weighted_median(with_p_square_quantile) >, double > acc;
- accumulator_set<double, stats<tag::weighted_median(with_density) >, double >
+ accumulator_set<double, stats<tag::weighted_median(with_density) >, double >
         acc_dens( density_cache_size = 10000, density_num_bins = 1000 );
- accumulator_set<double, stats<tag::weighted_median(with_p_square_cumulative_distribution) >, double >
+ accumulator_set<double, stats<tag::weighted_median(with_p_square_cumulative_distribution) >, double >
         acc_cdist( p_square_cumulative_distribution_num_cells = 100 );
-
-
+
+
     for (std::size_t i=0; i<100000; ++i)
     {
         double sample = normal_narrow();
@@ -45,7 +45,7 @@
         acc_dens(sample, weight = std::exp(0.5 * (sample - mu) * (sample - mu) * ( 1./sigma_narrow/sigma_narrow - 1./sigma/sigma )));
         acc_cdist(sample, weight = std::exp(0.5 * (sample - mu) * (sample - mu) * ( 1./sigma_narrow/sigma_narrow - 1./sigma/sigma )));
     }
-
+
     BOOST_CHECK_CLOSE(1., weighted_median(acc), 1e-1);
     BOOST_CHECK_CLOSE(1., weighted_median(acc_dens), 1e-1);
     BOOST_CHECK_CLOSE(1., weighted_median(acc_cdist), 1e-1);

Modified: trunk/libs/accumulators/test/weighted_moment.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_moment.cpp (original)
+++ trunk/libs/accumulators/test/weighted_moment.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -20,15 +20,15 @@
 {
     accumulator_set<double, stats<tag::weighted_moment<2> >, double> acc2;
     accumulator_set<double, stats<tag::weighted_moment<7> >, double> acc7;
-
+
     acc2(2.1, weight = 0.7);
     acc2(2.7, weight = 1.4);
     acc2(1.8, weight = 0.9);
-
+
     acc7(2.1, weight = 0.7);
     acc7(2.7, weight = 1.4);
     acc7(1.8, weight = 0.9);
-
+
     BOOST_CHECK_CLOSE(5.403, weighted_moment<2>(acc2), 1e-5);
     BOOST_CHECK_CLOSE(548.54182, weighted_moment<7>(acc7), 1e-5);
 }

Modified: trunk/libs/accumulators/test/weighted_p_square_cum_dist.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_p_square_cum_dist.cpp (original)
+++ trunk/libs/accumulators/test/weighted_p_square_cum_dist.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -43,10 +43,10 @@
     double epsilon = 4;
 
     typedef accumulator_set<double, stats<tag::weighted_p_square_cumulative_distribution>, double > accumulator_t;
-
+
     accumulator_t acc_upper(p_square_cumulative_distribution_num_cells = 100);
     accumulator_t acc_lower(p_square_cumulative_distribution_num_cells = 100);
-
+
     // two random number generators
     double mu_upper = 1.0;
     double mu_lower = -1.0;
@@ -55,38 +55,38 @@
     boost::normal_distribution<> mean_sigma_lower(mu_lower,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal_upper(rng, mean_sigma_upper);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal_lower(rng, mean_sigma_lower);
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         double sample = normal_upper();
         acc_upper(sample, weight = std::exp(-mu_upper * (sample - 0.5 * mu_upper)));
     }
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         double sample = normal_lower();
         acc_lower(sample, weight = std::exp(-mu_lower * (sample - 0.5 * mu_lower)));
     }
-
+
     typedef iterator_range<std::vector<std::pair<double, double> >::iterator > histogram_type;
     histogram_type histogram_upper = weighted_p_square_cumulative_distribution(acc_upper);
     histogram_type histogram_lower = weighted_p_square_cumulative_distribution(acc_lower);
-
- // Note that applaying importance sampling results in a region of the distribution
+
+ // Note that applaying importance sampling results in a region of the distribution
     // to be estimated more accurately and another region to be estimated less accurately
     // than without importance sampling, i.e., with unweighted samples
-
+
     for (std::size_t i = 0; i < histogram_upper.size(); ++i)
- {
+ {
         // problem with small results: epsilon is relative (in percent), not absolute!
-
+
         // check upper region of distribution
- if ( histogram_upper[i].second > 0.1 )
+ if ( histogram_upper[i].second > 0.1 )
             BOOST_CHECK_CLOSE( 0.5 * (1.0 + my_erf( histogram_upper[i].first / sqrt(2.0) )), histogram_upper[i].second, epsilon );
         // check lower region of distribution
- if ( histogram_lower[i].second < -0.1 )
+ if ( histogram_lower[i].second < -0.1 )
             BOOST_CHECK_CLOSE( 0.5 * (1.0 + my_erf( histogram_lower[i].first / sqrt(2.0) )), histogram_lower[i].second, epsilon );
- }
+ }
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/weighted_p_square_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_p_square_quantile.cpp (original)
+++ trunk/libs/accumulators/test/weighted_p_square_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -29,7 +29,7 @@
 
     // tolerance in %
     double epsilon = 1;
-
+
     // some random number generators
     double mu4 = -1.0;
     double mu5 = -1.0;
@@ -44,7 +44,7 @@
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal5(rng, mean_sigma5);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal6(rng, mean_sigma6);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal7(rng, mean_sigma7);
-
+
     accumulator_t acc0(quantile_probability = 0.001);
     accumulator_t acc1(quantile_probability = 0.025);
     accumulator_t acc2(quantile_probability = 0.975);
@@ -55,7 +55,7 @@
     accumulator_t acc6(quantile_probability = 0.975);
     accumulator_t acc7(quantile_probability = 0.999);
 
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         double sample = rng();
@@ -63,7 +63,7 @@
         acc1(sample, weight = 1.);
         acc2(sample, weight = 1.);
         acc3(sample, weight = 1.);
-
+
         double sample4 = normal4();
         double sample5 = normal5();
         double sample6 = normal6();
@@ -78,7 +78,7 @@
     BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc1), 0.025, 5 );
     BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc2), 0.975, epsilon );
     BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc3), 0.999, epsilon );
-
+
     // check for shifted standard normal distribution ("importance sampling")
     BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc4), -3.090232, epsilon );
     BOOST_CHECK_CLOSE( weighted_p_square_quantile(acc5), -1.959963, epsilon );

Modified: trunk/libs/accumulators/test/weighted_pot_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_pot_quantile.cpp (original)
+++ trunk/libs/accumulators/test/weighted_pot_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -28,11 +28,11 @@
     double epsilon = 1.;
 
     double mu1, mu2, l;
-
+
     mu1 = 1.;
     mu2 = -1.;
     l = 0.5;
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma1(mu1,1);
@@ -41,7 +41,7 @@
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal1(rng, mean_sigma1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal2(rng, mean_sigma2);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::exponential_distribution<> > exponential(rng, lambda);
-
+
     accumulator_set<double, stats<tag::weighted_pot_quantile<right>(with_threshold_value)>, double > acc1(
         pot_threshold_value = 3.
     );
@@ -56,7 +56,7 @@
         left_tail_cache_size = 10000
       , pot_threshold_probability = 0.01
     );
-
+
     accumulator_set<double, stats<tag::weighted_pot_quantile<right>(with_threshold_value)>, double > acc5(
         pot_threshold_value = 5.
     );
@@ -64,7 +64,7 @@
         right_tail_cache_size = 10000
       , pot_threshold_probability = 0.995
     );
-
+
     for (std::size_t i = 0; i < 100000; ++i)
     {
         double sample1 = normal1();
@@ -74,21 +74,21 @@
         acc3(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2)));
         acc4(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2)));
     }
-
+
     for (std::size_t i = 0; i < 100000; ++i)
     {
         double sample = exponential();
         acc5(sample, weight = 1./l * std::exp(-sample * (1. - l)));
         acc6(sample, weight = 1./l * std::exp(-sample * (1. - l)));
     }
-
+
     BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, epsilon );
- BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.999), 3.090232, epsilon );
+ BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.999), 3.090232, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = 0.001), -3.090232, epsilon );
- BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = 0.001), -3.090232, epsilon );
-
+ BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = 0.001), -3.090232, epsilon );
+
     BOOST_CHECK_CLOSE( quantile(acc5, quantile_probability = 0.999), 6.908, epsilon );
- BOOST_CHECK_CLOSE( quantile(acc6, quantile_probability = 0.999), 6.908, epsilon );
+ BOOST_CHECK_CLOSE( quantile(acc6, quantile_probability = 0.999), 6.908, epsilon );
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/weighted_skewness.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_skewness.cpp (original)
+++ trunk/libs/accumulators/test/weighted_skewness.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -26,29 +26,29 @@
 {
     // tolerance in %
     // double epsilon = 1;
-
+
     accumulator_set<double, stats<tag::weighted_skewness>, double > acc1;
     accumulator_set<int, stats<tag::weighted_skewness>, int > acc2;
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
+
     for (std::size_t i=0; i<100000; ++i)
     {
         acc1(normal(), weight = rng());
     }
-
+
     // This check fails because epsilon is relative and not absolute
- // BOOST_CHECK_CLOSE( weighted_skewness(acc1), 0., epsilon );
-
+ // BOOST_CHECK_CLOSE( weighted_skewness(acc1), 0., epsilon );
+
     acc2(2, weight = 4);
     acc2(7, weight = 1);
     acc2(4, weight = 3);
     acc2(9, weight = 1);
     acc2(3, weight = 2);
-
+
     BOOST_CHECK_EQUAL( weighted_mean(acc2), 42./11. );
     BOOST_CHECK_EQUAL( weighted_moment<2>(acc2), 212./11. );
     BOOST_CHECK_EQUAL( weighted_moment<3>(acc2), 1350./11. );

Modified: trunk/libs/accumulators/test/weighted_tail_mean.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_tail_mean.cpp (original)
+++ trunk/libs/accumulators/test/weighted_tail_mean.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -28,30 +28,30 @@
 {
     // tolerance in %
     double epsilon = 1;
-
+
     std::size_t n = 100000; // number of MC steps
     std::size_t c = 25000; // cache size
-
+
     accumulator_set<double, stats<tag::non_coherent_weighted_tail_mean<right> >, double >
         acc0( right_tail_cache_size = c );
     accumulator_set<double, stats<tag::non_coherent_weighted_tail_mean<left> >, double >
         acc1( left_tail_cache_size = c );
-
+
     // random number generators
     boost::lagged_fibonacci607 rng;
-
+
     for (std::size_t i = 0; i < n; ++i)
     {
         double smpl = std::sqrt(rng());
         acc0(smpl, weight = 1./smpl);
     }
-
+
     for (std::size_t i = 0; i < n; ++i)
     {
         double smpl = rng();
         acc1(smpl*smpl, weight = smpl);
     }
-
+
     // check uniform distribution
     BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc0, quantile_probability = 0.95), 0.975, epsilon );
     BOOST_CHECK_CLOSE( non_coherent_weighted_tail_mean(acc0, quantile_probability = 0.975), 0.9875, epsilon );

Modified: trunk/libs/accumulators/test/weighted_tail_quantile.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_tail_quantile.cpp (original)
+++ trunk/libs/accumulators/test/weighted_tail_quantile.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -27,10 +27,10 @@
 {
     // tolerance in %
     double epsilon = 1;
-
+
     std::size_t n = 100000; // number of MC steps
     std::size_t c = 20000; // cache size
-
+
     double mu1 = 1.0;
     double mu2 = -1.0;
     boost::lagged_fibonacci607 rng;
@@ -38,13 +38,13 @@
     boost::normal_distribution<> mean_sigma2(mu2,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal1(rng, mean_sigma1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal2(rng, mean_sigma2);
-
+
     accumulator_set<double, stats<tag::weighted_tail_quantile<right> >, double>
         acc1(right_tail_cache_size = c);
 
     accumulator_set<double, stats<tag::weighted_tail_quantile<left> >, double>
- acc2(left_tail_cache_size = c);
-
+ acc2(left_tail_cache_size = c);
+
     for (std::size_t i = 0; i < n; ++i)
     {
         double sample1 = normal1();
@@ -52,13 +52,13 @@
         acc1(sample1, weight = std::exp(-mu1 * (sample1 - 0.5 * mu1)));
         acc2(sample2, weight = std::exp(-mu2 * (sample2 - 0.5 * mu2)));
     }
-
+
     // check standard normal distribution
     BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.975), 1.959963, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = 0.999), 3.090232, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.025), -1.959963, epsilon );
     BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = 0.001), -3.090232, epsilon );
-
+
 }
 
 ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/libs/accumulators/test/weighted_tail_variate_means.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_tail_variate_means.cpp (original)
+++ trunk/libs/accumulators/test/weighted_tail_variate_means.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -27,10 +27,10 @@
 void test_stat()
 {
     std::size_t c = 5; // cache size
-
+
     typedef double variate_type;
     typedef std::vector<variate_type> variate_set_type;
-
+
     accumulator_set<double, stats<tag::weighted_tail_variate_means<right, variate_set_type, tag::covariate1>(relative)>, double >
         acc1( right_tail_cache_size = c );
     accumulator_set<double, stats<tag::weighted_tail_variate_means<right, variate_set_type, tag::covariate1>(absolute)>, double >
@@ -39,7 +39,7 @@
         acc3( left_tail_cache_size = c );
     accumulator_set<double, stats<tag::weighted_tail_variate_means<left, variate_set_type, tag::covariate1>(absolute)>, double >
         acc4( left_tail_cache_size = c );
-
+
     variate_set_type cov1, cov2, cov3, cov4, cov5;
     double c1[] = { 10., 20., 30., 40. }; // 100
     double c2[] = { 26., 4., 17., 3. }; // 50
@@ -50,32 +50,32 @@
     cov2.assign(c2, c2 + sizeof(c2)/sizeof(variate_type));
     cov3.assign(c3, c3 + sizeof(c3)/sizeof(variate_type));
     cov4.assign(c4, c4 + sizeof(c4)/sizeof(variate_type));
- cov5.assign(c5, c5 + sizeof(c5)/sizeof(variate_type));
-
+ cov5.assign(c5, c5 + sizeof(c5)/sizeof(variate_type));
+
     acc1(100., weight = 0.8, covariate1 = cov1);
     acc1( 50., weight = 0.9, covariate1 = cov2);
     acc1(200., weight = 1.0, covariate1 = cov3);
     acc1( 80., weight = 1.1, covariate1 = cov4);
     acc1( 20., weight = 1.2, covariate1 = cov5);
-
+
     acc2(100., weight = 0.8, covariate1 = cov1);
     acc2( 50., weight = 0.9, covariate1 = cov2);
     acc2(200., weight = 1.0, covariate1 = cov3);
     acc2( 80., weight = 1.1, covariate1 = cov4);
     acc2( 20., weight = 1.2, covariate1 = cov5);
-
+
     acc3(100., weight = 0.8, covariate1 = cov1);
     acc3( 50., weight = 0.9, covariate1 = cov2);
     acc3(200., weight = 1.0, covariate1 = cov3);
     acc3( 80., weight = 1.1, covariate1 = cov4);
     acc3( 20., weight = 1.2, covariate1 = cov5);
-
+
     acc4(100., weight = 0.8, covariate1 = cov1);
     acc4( 50., weight = 0.9, covariate1 = cov2);
     acc4(200., weight = 1.0, covariate1 = cov3);
     acc4( 80., weight = 1.1, covariate1 = cov4);
     acc4( 20., weight = 1.2, covariate1 = cov5);
-
+
     // check relative risk contributions
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.7).begin() ), (0.8*10 + 1.0*46)/(0.8*100 + 1.0*200) );
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.7).begin() + 1), (0.8*20 + 1.0*64)/(0.8*100 + 1.0*200) );
@@ -85,7 +85,7 @@
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 1), (0.9*4 + 1.2*2)/(0.9*50 + 1.2*20) );
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 2), (0.9*17 + 1.2*2)/(0.9*50 + 1.2*20) );
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.3).begin() + 3), (0.9*3 + 1.2*14)/(0.9*50 + 1.2*20) );
-
+
     // check absolute risk contributions
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.7).begin() ), (0.8*10 + 1.0*46)/1.8 );
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.7).begin() + 1), (0.8*20 + 1.0*64)/1.8 );
@@ -95,7 +95,7 @@
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() + 1), (0.9*4 + 1.2*2)/2.1 );
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() + 2), (0.9*17 + 1.2*2)/2.1 );
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc4, quantile_probability = 0.3).begin() + 3), (0.9*3 + 1.2*14)/2.1 );
-
+
     // check relative risk contributions
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.9).begin() ), 1.0*46/(1.0*200) );
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc1, quantile_probability = 0.9).begin() + 1), 1.0*64/(1.0*200) );
@@ -105,7 +105,7 @@
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 1), 1.2*2/(1.2*20) );
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 2), 1.2*2/(1.2*20) );
     BOOST_CHECK_EQUAL( *(relative_weighted_tail_variate_means(acc3, quantile_probability = 0.1).begin() + 3), 1.2*14/(1.2*20) );
-
+
     // check absolute risk contributions
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.9).begin() ), 1.0*46/1.0 );
     BOOST_CHECK_EQUAL( *(weighted_tail_variate_means(acc2, quantile_probability = 0.9).begin() + 1), 1.0*64/1.0 );

Modified: trunk/libs/accumulators/test/weighted_variance.cpp
==============================================================================
--- trunk/libs/accumulators/test/weighted_variance.cpp (original)
+++ trunk/libs/accumulators/test/weighted_variance.cpp 2008-01-08 13:43:43 EST (Tue, 08 Jan 2008)
@@ -46,24 +46,24 @@
     BOOST_CHECK_EQUAL(5u, count(acc2));
     BOOST_CHECK_CLOSE(2.9090909, weighted_mean(acc2), 1e-5);
     BOOST_CHECK_CLOSE(1.7190083, weighted_variance(acc2), 1e-5);
-
+
     // check lazy and immediate variance with random numbers
-
+
     // two random number generators
     boost::lagged_fibonacci607 rng;
     boost::normal_distribution<> mean_sigma(0,1);
     boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
-
- accumulator_set<double, stats<tag::weighted_variance>, double > acc_lazy;
+
+ accumulator_set<double, stats<tag::weighted_variance>, double > acc_lazy;
     accumulator_set<double, stats<tag::weighted_variance(immediate)>, double > acc_immediate;
-
+
     for (std::size_t i=0; i<10000; ++i)
     {
         double value = normal();
         acc_lazy(value, weight = rng());
         acc_immediate(value, weight = rng());
     }
-
+
     BOOST_CHECK_CLOSE(1., weighted_variance(acc_lazy), 1.);
     BOOST_CHECK_CLOSE(1., weighted_variance(acc_immediate), 1.);
 }


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