|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r85424 - in branches/release: . boost boost/accumulators/numeric boost/accumulators/numeric/functional boost/accumulators/statistics libs libs/accumulators/doc
From: eric_at_[hidden]
Date: 2013-08-22 15:39:56
Author: eric_niebler
Date: 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013)
New Revision: 85424
URL: http://svn.boost.org/trac/boost/changeset/85424
Log:
merge [85122],[85123],[85124] from trunk to release; fixes #7915, fixes #8850, fixes #8262
Properties modified:
branches/release/ (props changed)
branches/release/boost/ (props changed)
branches/release/libs/ (props changed)
Text files modified:
branches/release/boost/accumulators/numeric/functional.hpp | 24 +++++-
branches/release/boost/accumulators/numeric/functional/valarray.hpp | 4
branches/release/boost/accumulators/numeric/functional/vector.hpp | 2
branches/release/boost/accumulators/numeric/functional_fwd.hpp | 8 +-
branches/release/boost/accumulators/statistics/covariance.hpp | 8 +-
branches/release/boost/accumulators/statistics/density.hpp | 14 ++--
branches/release/boost/accumulators/statistics/error_of_mean.hpp | 4
branches/release/boost/accumulators/statistics/extended_p_square.hpp | 2
branches/release/boost/accumulators/statistics/extended_p_square_quantile.hpp | 14 ++--
branches/release/boost/accumulators/statistics/kurtosis.hpp | 4
branches/release/boost/accumulators/statistics/mean.hpp | 10 +-
branches/release/boost/accumulators/statistics/median.hpp | 12 +-
branches/release/boost/accumulators/statistics/moment.hpp | 4
branches/release/boost/accumulators/statistics/p_square_cumul_dist.hpp | 6
branches/release/boost/accumulators/statistics/p_square_quantile.hpp | 4
branches/release/boost/accumulators/statistics/peaks_over_threshold.hpp | 26 ++++----
branches/release/boost/accumulators/statistics/pot_quantile.hpp | 2
branches/release/boost/accumulators/statistics/pot_tail_mean.hpp | 2
branches/release/boost/accumulators/statistics/rolling_mean.hpp | 4
branches/release/boost/accumulators/statistics/skewness.hpp | 4
branches/release/boost/accumulators/statistics/tail_mean.hpp | 10 +-
branches/release/boost/accumulators/statistics/tail_variate_means.hpp | 2
branches/release/boost/accumulators/statistics/variance.hpp | 10 +-
branches/release/boost/accumulators/statistics/weighted_covariance.hpp | 8 +-
branches/release/boost/accumulators/statistics/weighted_density.hpp | 14 ++--
branches/release/boost/accumulators/statistics/weighted_extended_p_square.hpp | 2
branches/release/boost/accumulators/statistics/weighted_kurtosis.hpp | 4
branches/release/boost/accumulators/statistics/weighted_mean.hpp | 10 +-
branches/release/boost/accumulators/statistics/weighted_median.hpp | 12 +-
branches/release/boost/accumulators/statistics/weighted_moment.hpp | 4
branches/release/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp | 6
branches/release/boost/accumulators/statistics/weighted_p_square_quantile.hpp | 2
branches/release/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp | 28 ++++----
branches/release/boost/accumulators/statistics/weighted_skewness.hpp | 4
branches/release/boost/accumulators/statistics/weighted_tail_mean.hpp | 6
branches/release/boost/accumulators/statistics/weighted_tail_quantile.hpp | 2
branches/release/boost/accumulators/statistics/weighted_tail_variate_means.hpp | 4
branches/release/boost/accumulators/statistics/weighted_variance.hpp | 10 +-
branches/release/libs/accumulators/doc/accumulators.qbk | 130 ++++++++++++++++++++--------------------
39 files changed, 220 insertions(+), 206 deletions(-)
Modified: branches/release/boost/accumulators/numeric/functional.hpp
==============================================================================
--- branches/release/boost/accumulators/numeric/functional.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/numeric/functional.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -245,14 +245,14 @@
};
template<typename Left, typename Right, typename EnableIf>
- struct average_base
+ struct fdiv_base
: functional::divides<Left, Right>
{};
// partial specialization that promotes the arguments to double for
// integral division.
template<typename Left, typename Right>
- struct average_base<Left, Right, typename enable_if<are_integral<Left, Right> >::type>
+ struct fdiv_base<Left, Right, typename enable_if<are_integral<Left, Right> >::type>
: functional::divides<double const, double const>
{};
@@ -348,8 +348,15 @@
{};
template<typename Left, typename Right, typename LeftTag, typename RightTag>
+ struct fdiv
+ : fdiv_base<Left, Right, void>
+ {};
+
+ /// INTERNAL ONLY
+ /// For back-compat only. Use fdiv.
+ template<typename Left, typename Right, typename LeftTag, typename RightTag>
struct average
- : average_base<Left, Right, void>
+ : fdiv<Left, Right, LeftTag, RightTag>
{};
template<typename Arg, typename Tag>
@@ -388,8 +395,13 @@
: boost::detail::function2<functional::max_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > >
{};
+ struct fdiv
+ : boost::detail::function2<functional::fdiv<_1, _2, functional::tag<_1>, functional::tag<_2> > >
+ {};
+
+ /// INTERNAL ONLY
struct average
- : boost::detail::function2<functional::average<_1, _2, functional::tag<_1>, functional::tag<_2> > >
+ : boost::detail::function2<functional::fdiv<_1, _2, functional::tag<_1>, functional::tag<_2> > >
{};
struct as_min
@@ -413,7 +425,8 @@
{
op::min_assign const &min_assign = boost::detail::pod_singleton<op::min_assign>::instance;
op::max_assign const &max_assign = boost::detail::pod_singleton<op::max_assign>::instance;
- op::average const &average = boost::detail::pod_singleton<op::average>::instance;
+ op::fdiv const &fdiv = boost::detail::pod_singleton<op::fdiv>::instance;
+ op::fdiv const &average = boost::detail::pod_singleton<op::fdiv>::instance; ///< INTERNAL ONLY
op::as_min const &as_min = boost::detail::pod_singleton<op::as_min>::instance;
op::as_max const &as_max = boost::detail::pod_singleton<op::as_max>::instance;
op::as_zero const &as_zero = boost::detail::pod_singleton<op::as_zero>::instance;
@@ -421,6 +434,7 @@
BOOST_ACCUMULATORS_IGNORE_GLOBAL(min_assign)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(max_assign)
+ BOOST_ACCUMULATORS_IGNORE_GLOBAL(fdiv)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(average)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_min)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_max)
Modified: branches/release/boost/accumulators/numeric/functional/valarray.hpp
==============================================================================
--- branches/release/boost/accumulators/numeric/functional/valarray.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/numeric/functional/valarray.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -234,9 +234,9 @@
}
};
- // partial specialization of numeric::average<> for std::valarray.
+ // partial specialization of numeric::fdiv<> for std::valarray.
template<typename Left, typename Right, typename RightTag>
- struct average<Left, Right, std_valarray_tag, RightTag>
+ struct fdiv<Left, Right, std_valarray_tag, RightTag>
: mpl::if_<
are_integral<typename Left::value_type, Right>
, divides<Left, double const>
Modified: branches/release/boost/accumulators/numeric/functional/vector.hpp
==============================================================================
--- branches/release/boost/accumulators/numeric/functional/vector.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/numeric/functional/vector.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -231,7 +231,7 @@
// partial specialization for std::vector.
template<typename Left, typename Right>
- struct average<Left, Right, std_vector_tag, void>
+ struct fdiv<Left, Right, std_vector_tag, void>
: mpl::if_<
are_integral<typename Left::value_type, Right>
, divides<Left, double const>
Modified: branches/release/boost/accumulators/numeric/functional_fwd.hpp
==============================================================================
--- branches/release/boost/accumulators/numeric/functional_fwd.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/numeric/functional_fwd.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -141,7 +141,7 @@
template<typename Left, typename Right, typename EnableIf = void>
struct max_assign_base;
template<typename Left, typename Right, typename EnableIf = void>
- struct average_base;
+ struct fdiv_base;
template<typename Arg, typename EnableIf = void>
struct as_min_base;
template<typename Arg, typename EnableIf = void>
@@ -158,7 +158,7 @@
template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
struct max_assign;
template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
- struct average;
+ struct fdiv;
template<typename Arg, typename Tag = typename tag<Arg>::type>
struct as_min;
template<typename Arg, typename Tag = typename tag<Arg>::type>
@@ -175,7 +175,7 @@
struct promote;
struct min_assign;
struct max_assign;
- struct average;
+ struct fdiv;
struct as_min;
struct as_max;
struct as_zero;
@@ -186,7 +186,7 @@
{
extern op::min_assign const &min_assign;
extern op::max_assign const &max_assign;
- extern op::average const &average;
+ extern op::fdiv const &fdiv;
extern op::as_min const &as_min;
extern op::as_max const &as_max;
extern op::as_zero const &as_zero;
Modified: branches/release/boost/accumulators/statistics/covariance.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/covariance.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/covariance.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -122,8 +122,8 @@
struct covariance_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type sample_type;
- typedef typename numeric::functional::average<VariateType, std::size_t>::result_type variate_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type sample_type;
+ typedef typename numeric::functional::fdiv<VariateType, std::size_t>::result_type variate_type;
// for boost::result_of
typedef typename numeric::functional::outer_product<sample_type, variate_type>::result_type result_type;
@@ -131,8 +131,8 @@
covariance_impl(Args const &args)
: cov_(
numeric::outer_product(
- numeric::average(args[sample | Sample()], (std::size_t)1)
- , numeric::average(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
+ numeric::fdiv(args[sample | Sample()], (std::size_t)1)
+ , numeric::fdiv(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
)
)
{
Modified: branches/release/boost/accumulators/statistics/density.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/density.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/density.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -61,7 +61,7 @@
struct density_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef std::vector<float_type> array_type;
// for boost::result_of
@@ -77,8 +77,8 @@
, histogram(
num_bins + 2
, std::make_pair(
- numeric::average(args[sample | Sample()],(std::size_t)1)
- , numeric::average(args[sample | Sample()],(std::size_t)1)
+ numeric::fdiv(args[sample | Sample()],(std::size_t)1)
+ , numeric::fdiv(args[sample | Sample()],(std::size_t)1)
)
)
, is_dirty(true)
@@ -103,9 +103,9 @@
// Store their lower bounds (bin_positions) and fill the bins with the cached samples (samples_in_bin).
if (cnt == this->cache_size)
{
- float_type minimum = numeric::average((min)(args), (std::size_t)1);
- float_type maximum = numeric::average((max)(args), (std::size_t)1);
- float_type bin_size = numeric::average(maximum - minimum, this->num_bins );
+ float_type minimum = numeric::fdiv((min)(args), (std::size_t)1);
+ float_type maximum = numeric::fdiv((max)(args), (std::size_t)1);
+ float_type bin_size = numeric::fdiv(maximum - minimum, this->num_bins );
// determine bin positions (their lower bounds)
for (std::size_t i = 0; i < this->num_bins + 2; ++i)
@@ -177,7 +177,7 @@
for (std::size_t i = 0; i < this->num_bins + 2; ++i)
{
- this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::average(this->samples_in_bin[i], count(args)));
+ this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::fdiv(this->samples_in_bin[i], count(args)));
}
}
// returns a range of pairs
Modified: branches/release/boost/accumulators/statistics/error_of_mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/error_of_mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/error_of_mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -29,7 +29,7 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
error_of_mean_impl(dont_care) {}
@@ -38,7 +38,7 @@
{
using namespace std;
extractor<Variance> const variance = {};
- return sqrt(numeric::average(variance(args), count(args) - 1));
+ return sqrt(numeric::fdiv(variance(args), count(args) - 1));
}
};
Modified: branches/release/boost/accumulators/statistics/extended_p_square.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/extended_p_square.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/extended_p_square.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -69,7 +69,7 @@
struct extended_p_square_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<float_type> array_type;
// for boost::result_of
typedef iterator_range<
Modified: branches/release/boost/accumulators/statistics/extended_p_square_quantile.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/extended_p_square_quantile.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/extended_p_square_quantile.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -57,7 +57,7 @@
struct extended_p_square_quantile_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<float_type> array_type;
typedef iterator_range<
detail::lvalue_index_iterator<
@@ -137,7 +137,7 @@
float_type h1 = *iter_heights;
float_type h0 = *(iter_heights - 1);
- float_type a = numeric::average(h1 - h0, p1 - p0);
+ float_type a = numeric::fdiv(h1 - h0, p1 - p0);
float_type b = h1 - p1 * a;
res = a * this->probability + b;
@@ -169,12 +169,12 @@
h2 = *iter_heights;
}
- float_type hp21 = numeric::average(h2 - h1, p2 - p1);
- float_type hp10 = numeric::average(h1 - h0, p1 - p0);
- float_type p21 = numeric::average(p2 * p2 - p1 * p1, p2 - p1);
- float_type p10 = numeric::average(p1 * p1 - p0 * p0, p1 - p0);
+ float_type hp21 = numeric::fdiv(h2 - h1, p2 - p1);
+ float_type hp10 = numeric::fdiv(h1 - h0, p1 - p0);
+ float_type p21 = numeric::fdiv(p2 * p2 - p1 * p1, p2 - p1);
+ float_type p10 = numeric::fdiv(p1 * p1 - p0 * p0, p1 - p0);
- float_type a = numeric::average(hp21 - hp10, p21 - p10);
+ float_type a = numeric::fdiv(hp21 - hp10, p21 - p10);
float_type b = hp21 - a * p21;
float_type c = h2 - a * p2 * p2 - b * p2;
Modified: branches/release/boost/accumulators/statistics/kurtosis.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/kurtosis.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/kurtosis.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -47,14 +47,14 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, Sample>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, Sample>::result_type result_type;
kurtosis_impl(dont_care) {}
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(
+ return numeric::fdiv(
accumulators::moment<4>(args)
- 4. * accumulators::moment<3>(args) * mean(args)
+ 6. * accumulators::moment<2>(args) * mean(args) * mean(args)
Modified: branches/release/boost/accumulators/statistics/mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -31,7 +31,7 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
mean_impl(dont_care) {}
@@ -39,7 +39,7 @@
result_type result(Args const &args) const
{
extractor<SumFeature> sum;
- return numeric::average(sum(args), count(args));
+ return numeric::fdiv(sum(args), count(args));
}
};
@@ -48,11 +48,11 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
template<typename Args>
immediate_mean_impl(Args const &args)
- : mean(numeric::average(args[sample | Sample()], numeric::one<std::size_t>::value))
+ : mean(numeric::fdiv(args[sample | Sample()], numeric::one<std::size_t>::value))
{
}
@@ -60,7 +60,7 @@
void operator ()(Args const &args)
{
std::size_t cnt = count(args);
- this->mean = numeric::average(
+ this->mean = numeric::fdiv(
(this->mean * (cnt - 1)) + args[parameter::keyword<Tag>::get()]
, cnt
);
Modified: branches/release/boost/accumulators/statistics/median.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/median.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/median.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -39,7 +39,7 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
median_impl(dont_care) {}
@@ -63,7 +63,7 @@
struct with_density_median_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef iterator_range<typename histogram_type::iterator> range_type;
// for boost::result_of
@@ -71,7 +71,7 @@
template<typename Args>
with_density_median_impl(Args const &args)
- : sum(numeric::average(args[sample | Sample()], (std::size_t)1))
+ : sum(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
, is_dirty(true)
{
}
@@ -98,7 +98,7 @@
++it;
}
--it;
- float_type over = numeric::average(this->sum - 0.5 * cnt, it->second * cnt);
+ float_type over = numeric::fdiv(this->sum - 0.5 * cnt, it->second * cnt);
this->median = it->first * over + (it + 1)->first * (1. - over);
}
@@ -125,7 +125,7 @@
struct with_p_square_cumulative_distribution_median_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef iterator_range<typename histogram_type::iterator> range_type;
// for boost::result_of
@@ -154,7 +154,7 @@
{
++it;
}
- float_type over = numeric::average(it->second - 0.5, it->second - (it - 1)->second);
+ float_type over = numeric::fdiv(it->second - 0.5, it->second - (it - 1)->second);
this->median = it->first * over + (it + 1)->first * ( 1. - over );
}
Modified: branches/release/boost/accumulators/statistics/moment.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/moment.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/moment.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -55,7 +55,7 @@
{
BOOST_MPL_ASSERT_RELATION(N::value, >, 0);
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
template<typename Args>
moment_impl(Args const &args)
@@ -72,7 +72,7 @@
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(this->sum, count(args));
+ return numeric::fdiv(this->sum, count(args));
}
private:
Modified: branches/release/boost/accumulators/statistics/p_square_cumul_dist.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/p_square_cumul_dist.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/p_square_cumul_dist.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -54,7 +54,7 @@
struct p_square_cumulative_distribution_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<float_type> array_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
// for boost::result_of
@@ -76,7 +76,7 @@
{
this->actual_positions[i] = i + 1.;
this->desired_positions[i] = i + 1.;
- this->positions_increments[i] = numeric::average(i, b);
+ this->positions_increments[i] = numeric::fdiv(i, b);
}
}
@@ -198,7 +198,7 @@
for (std::size_t i = 0; i < this->histogram.size(); ++i)
{
- this->histogram[i] = std::make_pair(this->heights[i], numeric::average(this->actual_positions[i], cnt));
+ this->histogram[i] = std::make_pair(this->heights[i], numeric::fdiv(this->actual_positions[i], cnt));
}
}
//return histogram;
Modified: branches/release/boost/accumulators/statistics/p_square_quantile.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/p_square_quantile.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/p_square_quantile.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -54,7 +54,7 @@
struct p_square_quantile_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef array<float_type, 5> array_type;
// for boost::result_of
typedef float_type result_type;
@@ -69,7 +69,7 @@
{
for(std::size_t i = 0; i < 5; ++i)
{
- this->actual_positions[i] = i + 1;
+ this->actual_positions[i] = i + 1.;
}
this->desired_positions[0] = 1.;
Modified: branches/release/boost/accumulators/statistics/peaks_over_threshold.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/peaks_over_threshold.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/peaks_over_threshold.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -125,7 +125,7 @@
struct peaks_over_threshold_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef boost::tuple<float_type, float_type, float_type> result_type;
// for left tail fitting, mirror the extreme values
@@ -134,8 +134,8 @@
template<typename Args>
peaks_over_threshold_impl(Args const &args)
: Nu_(0)
- , mu_(sign::value * numeric::average(args[sample | Sample()], (std::size_t)1))
- , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
+ , mu_(sign::value * numeric::fdiv(args[sample | Sample()], (std::size_t)1))
+ , sigma2_(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
, threshold_(sign::value * args[pot_threshold_value])
, fit_parameters_(boost::make_tuple(0., 0., 0.))
, is_dirty_(true)
@@ -164,13 +164,13 @@
std::size_t cnt = count(args);
- this->mu_ = sign::value * numeric::average(this->mu_, this->Nu_);
- this->sigma2_ = numeric::average(this->sigma2_, this->Nu_);
+ this->mu_ = sign::value * numeric::fdiv(this->mu_, this->Nu_);
+ this->sigma2_ = numeric::fdiv(this->sigma2_, this->Nu_);
this->sigma2_ -= this->mu_ * this->mu_;
- float_type threshold_probability = numeric::average(cnt - this->Nu_, cnt);
+ float_type threshold_probability = numeric::fdiv(cnt - this->Nu_, cnt);
- float_type tmp = numeric::average(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
+ float_type tmp = numeric::fdiv(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
float_type xi_hat = 0.5 * ( 1. - tmp );
float_type beta_hat = 0.5 * ( this->mu_ - this->threshold_ ) * ( 1. + tmp );
float_type beta_bar = beta_hat * std::pow(1. - threshold_probability, xi_hat);
@@ -205,7 +205,7 @@
struct peaks_over_threshold_prob_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef boost::tuple<float_type, float_type, float_type> result_type;
// for left tail fitting, mirror the extreme values
@@ -213,8 +213,8 @@
template<typename Args>
peaks_over_threshold_prob_impl(Args const &args)
- : mu_(sign::value * numeric::average(args[sample | Sample()], (std::size_t)1))
- , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
+ : mu_(sign::value * numeric::fdiv(args[sample | Sample()], (std::size_t)1))
+ , sigma2_(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
, threshold_probability_(args[pot_threshold_probability])
, fit_parameters_(boost::make_tuple(0., 0., 0.))
, is_dirty_(true)
@@ -272,14 +272,14 @@
sigma2_ += *(tail(args).begin() + i) * (*(tail(args).begin() + i));
}
- this->mu_ = sign::value * numeric::average(this->mu_, n);
- this->sigma2_ = numeric::average(this->sigma2_, n);
+ this->mu_ = sign::value * numeric::fdiv(this->mu_, n);
+ this->sigma2_ = numeric::fdiv(this->sigma2_, n);
this->sigma2_ -= this->mu_ * this->mu_;
if (is_same<LeftRight, left>::value)
this->threshold_probability_ = 1. - this->threshold_probability_;
- float_type tmp = numeric::average(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
+ float_type tmp = numeric::fdiv(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
float_type xi_hat = 0.5 * ( 1. - tmp );
float_type beta_hat = 0.5 * ( this->mu_ - u ) * ( 1. + tmp );
float_type beta_bar = beta_hat * std::pow(1. - threshold_probability_, xi_hat);
Modified: branches/release/boost/accumulators/statistics/pot_quantile.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/pot_quantile.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/pot_quantile.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -49,7 +49,7 @@
struct pot_quantile_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef float_type result_type;
Modified: branches/release/boost/accumulators/statistics/pot_tail_mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/pot_tail_mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/pot_tail_mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -52,7 +52,7 @@
struct pot_tail_mean_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef float_type result_type;
Modified: branches/release/boost/accumulators/statistics/rolling_mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/rolling_mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/rolling_mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -31,7 +31,7 @@
struct rolling_mean_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
rolling_mean_impl(dont_care)
{}
@@ -39,7 +39,7 @@
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(rolling_sum(args), rolling_count(args));
+ return numeric::fdiv(rolling_sum(args), rolling_count(args));
}
};
Modified: branches/release/boost/accumulators/statistics/skewness.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/skewness.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/skewness.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -48,7 +48,7 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, Sample>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, Sample>::result_type result_type;
skewness_impl(dont_care)
{
@@ -57,7 +57,7 @@
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(
+ return numeric::fdiv(
accumulators::moment<3>(args)
- 3. * accumulators::moment<2>(args) * mean(args)
+ 2. * mean(args) * mean(args) * mean(args)
Modified: branches/release/boost/accumulators/statistics/tail_mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/tail_mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/tail_mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -62,7 +62,7 @@
struct coherent_tail_mean_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef float_type result_type;
@@ -82,10 +82,10 @@
extractor<tag::non_coherent_tail_mean<LeftRight> > const some_non_coherent_tail_mean = {};
return some_non_coherent_tail_mean(args)
- + numeric::average(quantile(args), n)
+ + numeric::fdiv(quantile(args), n)
* (
( is_same<LeftRight, left>::value ) ? args[quantile_probability] : 1. - args[quantile_probability]
- - numeric::average(n, count(args))
+ - numeric::fdiv(n, count(args))
);
}
};
@@ -117,7 +117,7 @@
struct non_coherent_tail_mean_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef float_type result_type;
@@ -136,7 +136,7 @@
// If n is in a valid range, return result, otherwise return NaN or throw exception
if (n <= static_cast<std::size_t>(tail(args).size()))
- return numeric::average(
+ return numeric::fdiv(
std::accumulate(
tail(args).begin()
, tail(args).begin() + n
Modified: branches/release/boost/accumulators/statistics/tail_variate_means.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/tail_variate_means.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/tail_variate_means.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -79,7 +79,7 @@
struct tail_variate_means_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<float_type> array_type;
// for boost::result_of
typedef iterator_range<typename array_type::iterator> result_type;
Modified: branches/release/boost/accumulators/statistics/variance.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/variance.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/variance.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -42,7 +42,7 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
lazy_variance_impl(dont_care) {}
@@ -85,11 +85,11 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
template<typename Args>
variance_impl(Args const &args)
- : variance(numeric::average(args[sample | Sample()], numeric::one<std::size_t>::value))
+ : variance(numeric::fdiv(args[sample | Sample()], numeric::one<std::size_t>::value))
{
}
@@ -103,8 +103,8 @@
extractor<MeanFeature> mean;
result_type tmp = args[parameter::keyword<Tag>::get()] - mean(args);
this->variance =
- numeric::average(this->variance * (cnt - 1), cnt)
- + numeric::average(tmp * tmp, cnt - 1);
+ numeric::fdiv(this->variance * (cnt - 1), cnt)
+ + numeric::fdiv(tmp * tmp, cnt - 1);
}
}
Modified: branches/release/boost/accumulators/statistics/weighted_covariance.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_covariance.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_covariance.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -57,8 +57,8 @@
struct weighted_covariance_impl
: accumulator_base
{
- typedef typename numeric::functional::multiplies<Weight, typename numeric::functional::average<Sample, std::size_t>::result_type>::result_type weighted_sample_type;
- typedef typename numeric::functional::multiplies<Weight, typename numeric::functional::average<VariateType, std::size_t>::result_type>::result_type weighted_variate_type;
+ typedef typename numeric::functional::multiplies<Weight, typename numeric::functional::fdiv<Sample, std::size_t>::result_type>::result_type weighted_sample_type;
+ typedef typename numeric::functional::multiplies<Weight, typename numeric::functional::fdiv<VariateType, std::size_t>::result_type>::result_type weighted_variate_type;
// for boost::result_of
typedef typename numeric::functional::outer_product<weighted_sample_type, weighted_variate_type>::result_type result_type;
@@ -66,9 +66,9 @@
weighted_covariance_impl(Args const &args)
: cov_(
numeric::outer_product(
- numeric::average(args[sample | Sample()], (std::size_t)1)
+ numeric::fdiv(args[sample | Sample()], (std::size_t)1)
* numeric::one<Weight>::value
- , numeric::average(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
+ , numeric::fdiv(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
* numeric::one<Weight>::value
)
)
Modified: branches/release/boost/accumulators/statistics/weighted_density.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_density.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_density.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -50,7 +50,7 @@
struct weighted_density_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Weight, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Weight, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef std::vector<float_type> array_type;
// for boost::result_of
@@ -66,8 +66,8 @@
, histogram(
num_bins + 2
, std::make_pair(
- numeric::average(args[sample | Sample()],(std::size_t)1)
- , numeric::average(args[sample | Sample()],(std::size_t)1)
+ numeric::fdiv(args[sample | Sample()],(std::size_t)1)
+ , numeric::fdiv(args[sample | Sample()],(std::size_t)1)
)
)
, is_dirty(true)
@@ -92,9 +92,9 @@
// Store their lower bounds (bin_positions) and fill the bins with the cached samples (samples_in_bin).
if (cnt == this->cache_size)
{
- float_type minimum = numeric::average((min)(args),(std::size_t)1);
- float_type maximum = numeric::average((max)(args),(std::size_t)1);
- float_type bin_size = numeric::average(maximum - minimum, this->num_bins);
+ float_type minimum = numeric::fdiv((min)(args),(std::size_t)1);
+ float_type maximum = numeric::fdiv((max)(args),(std::size_t)1);
+ float_type bin_size = numeric::fdiv(maximum - minimum, this->num_bins);
// determine bin positions (their lower bounds)
for (std::size_t i = 0; i < this->num_bins + 2; ++i)
@@ -163,7 +163,7 @@
for (std::size_t i = 0; i < this->num_bins + 2; ++i)
{
- this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::average(this->samples_in_bin[i], sum_of_weights(args)));
+ this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::fdiv(this->samples_in_bin[i], sum_of_weights(args)));
}
}
Modified: branches/release/boost/accumulators/statistics/weighted_extended_p_square.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_extended_p_square.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_extended_p_square.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -67,7 +67,7 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type float_type;
typedef std::vector<float_type> array_type;
// for boost::result_of
typedef iterator_range<
Modified: branches/release/boost/accumulators/statistics/weighted_kurtosis.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_kurtosis.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_kurtosis.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -52,7 +52,7 @@
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, weighted_sample>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, weighted_sample>::result_type result_type;
weighted_kurtosis_impl(dont_care)
{
@@ -61,7 +61,7 @@
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(
+ return numeric::fdiv(
accumulators::weighted_moment<4>(args)
- 4. * accumulators::weighted_moment<3>(args) * weighted_mean(args)
+ 6. * accumulators::weighted_moment<2>(args) * weighted_mean(args) * weighted_mean(args)
Modified: branches/release/boost/accumulators/statistics/weighted_mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -36,7 +36,7 @@
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, Weight>::result_type result_type;
weighted_mean_impl(dont_care) {}
@@ -53,7 +53,7 @@
extractor<weighted_sum_tag> const some_weighted_sum = {};
- return numeric::average(some_weighted_sum(args), sum_of_weights(args));
+ return numeric::fdiv(some_weighted_sum(args), sum_of_weights(args));
}
};
@@ -66,12 +66,12 @@
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, Weight>::result_type result_type;
template<typename Args>
immediate_weighted_mean_impl(Args const &args)
: mean(
- numeric::average(
+ numeric::fdiv(
args[parameter::keyword<Tag>::get() | Sample()]
* numeric::one<Weight>::value
, numeric::one<Weight>::value
@@ -89,7 +89,7 @@
Weight w_sum = sum_of_weights(args);
Weight w = args[weight];
weighted_sample const &s = args[parameter::keyword<Tag>::get()] * w;
- this->mean = numeric::average(this->mean * (w_sum - w) + s, w_sum);
+ this->mean = numeric::fdiv(this->mean * (w_sum - w) + s, w_sum);
}
result_type result(dont_care) const
Modified: branches/release/boost/accumulators/statistics/weighted_median.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_median.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_median.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -40,7 +40,7 @@
: accumulator_base
{
// for boost::result_of
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
weighted_median_impl(dont_care) {}
@@ -65,7 +65,7 @@
struct with_density_weighted_median_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef iterator_range<typename histogram_type::iterator> range_type;
// for boost::result_of
@@ -73,7 +73,7 @@
template<typename Args>
with_density_weighted_median_impl(Args const &args)
- : sum(numeric::average(args[sample | Sample()], (std::size_t)1))
+ : sum(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
, is_dirty(true)
{
}
@@ -99,7 +99,7 @@
++it;
}
--it;
- float_type over = numeric::average(this->sum - 0.5 * cnt, it->second * cnt);
+ float_type over = numeric::fdiv(this->sum - 0.5 * cnt, it->second * cnt);
this->median = it->first * over + (it + 1)->first * ( 1. - over );
}
@@ -127,7 +127,7 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef iterator_range<typename histogram_type::iterator> range_type;
// for boost::result_of
@@ -156,7 +156,7 @@
{
++it;
}
- float_type over = numeric::average(it->second - 0.5, it->second - (it - 1)->second);
+ float_type over = numeric::fdiv(it->second - 0.5, it->second - (it - 1)->second);
this->median = it->first * over + (it + 1)->first * ( 1. - over );
}
Modified: branches/release/boost/accumulators/statistics/weighted_moment.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_moment.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_moment.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -40,7 +40,7 @@
BOOST_MPL_ASSERT_RELATION(N::value, >, 0);
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, Weight>::result_type result_type;
template<typename Args>
weighted_moment_impl(Args const &args)
@@ -57,7 +57,7 @@
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(this->sum, sum_of_weights(args));
+ return numeric::fdiv(this->sum, sum_of_weights(args));
}
private:
Modified: branches/release/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -53,7 +53,7 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type float_type;
typedef std::vector<std::pair<float_type, float_type> > histogram_type;
typedef std::vector<float_type> array_type;
// for boost::result_of
@@ -153,7 +153,7 @@
for (std::size_t i = 1; i < b + 1; ++i)
{
this->desired_positions[i] = this->actual_positions[0]
- + numeric::average((i-1) * (sum_of_weights(args) - this->actual_positions[0]), b);
+ + numeric::fdiv((i-1) * (sum_of_weights(args) - this->actual_positions[0]), b);
}
// adjust heights of markers 2 to num_cells if necessary
@@ -214,7 +214,7 @@
for (std::size_t i = 0; i < this->histogram.size(); ++i)
{
- this->histogram[i] = std::make_pair(this->heights[i], numeric::average(this->actual_positions[i], sum_of_weights(args)));
+ this->histogram[i] = std::make_pair(this->heights[i], numeric::fdiv(this->actual_positions[i], sum_of_weights(args)));
}
}
Modified: branches/release/boost/accumulators/statistics/weighted_p_square_quantile.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_p_square_quantile.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_p_square_quantile.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -55,7 +55,7 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type float_type;
typedef array<float_type, 5> array_type;
// for boost::result_of
typedef float_type result_type;
Modified: branches/release/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -56,16 +56,16 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Weight, Sample>::result_type weighted_sample;
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef boost::tuple<float_type, float_type, float_type> result_type;
template<typename Args>
weighted_peaks_over_threshold_impl(Args const &args)
: sign_((is_same<LeftRight, left>::value) ? -1 : 1)
- , mu_(sign_ * numeric::average(args[sample | Sample()], (std::size_t)1))
- , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
- , w_sum_(numeric::average(args[weight | Weight()], (std::size_t)1))
+ , mu_(sign_ * numeric::fdiv(args[sample | Sample()], (std::size_t)1))
+ , sigma2_(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
+ , w_sum_(numeric::fdiv(args[weight | Weight()], (std::size_t)1))
, threshold_(sign_ * args[pot_threshold_value])
, fit_parameters_(boost::make_tuple(0., 0., 0.))
, is_dirty_(true)
@@ -92,13 +92,13 @@
{
this->is_dirty_ = false;
- this->mu_ = this->sign_ * numeric::average(this->mu_, this->w_sum_);
- this->sigma2_ = numeric::average(this->sigma2_, this->w_sum_);
+ this->mu_ = this->sign_ * numeric::fdiv(this->mu_, this->w_sum_);
+ this->sigma2_ = numeric::fdiv(this->sigma2_, this->w_sum_);
this->sigma2_ -= this->mu_ * this->mu_;
- float_type threshold_probability = numeric::average(sum_of_weights(args) - this->w_sum_, sum_of_weights(args));
+ float_type threshold_probability = numeric::fdiv(sum_of_weights(args) - this->w_sum_, sum_of_weights(args));
- float_type tmp = numeric::average(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
+ float_type tmp = numeric::fdiv(( this->mu_ - this->threshold_ )*( this->mu_ - this->threshold_ ), this->sigma2_);
float_type xi_hat = 0.5 * ( 1. - tmp );
float_type beta_hat = 0.5 * ( this->mu_ - this->threshold_ ) * ( 1. + tmp );
float_type beta_bar = beta_hat * std::pow(1. - threshold_probability, xi_hat);
@@ -135,15 +135,15 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Weight, Sample>::result_type weighted_sample;
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type float_type;
// for boost::result_of
typedef boost::tuple<float_type, float_type, float_type> result_type;
template<typename Args>
weighted_peaks_over_threshold_prob_impl(Args const &args)
: sign_((is_same<LeftRight, left>::value) ? -1 : 1)
- , mu_(sign_ * numeric::average(args[sample | Sample()], (std::size_t)1))
- , sigma2_(numeric::average(args[sample | Sample()], (std::size_t)1))
+ , mu_(sign_ * numeric::fdiv(args[sample | Sample()], (std::size_t)1))
+ , sigma2_(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
, threshold_probability_(args[pot_threshold_probability])
, fit_parameters_(boost::make_tuple(0., 0., 0.))
, is_dirty_(true)
@@ -200,14 +200,14 @@
float_type u = *(tail(args).begin() + n - 1) * this->sign_;
- this->mu_ = this->sign_ * numeric::average(this->mu_, sum);
- this->sigma2_ = numeric::average(this->sigma2_, sum);
+ this->mu_ = this->sign_ * numeric::fdiv(this->mu_, sum);
+ this->sigma2_ = numeric::fdiv(this->sigma2_, sum);
this->sigma2_ -= this->mu_ * this->mu_;
if (is_same<LeftRight, left>::value)
this->threshold_probability_ = 1. - this->threshold_probability_;
- float_type tmp = numeric::average(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
+ float_type tmp = numeric::fdiv(( this->mu_ - u )*( this->mu_ - u ), this->sigma2_);
float_type xi_hat = 0.5 * ( 1. - tmp );
float_type beta_hat = 0.5 * ( this->mu_ - u ) * ( 1. + tmp );
float_type beta_bar = beta_hat * std::pow(1. - threshold_probability_, xi_hat);
Modified: branches/release/boost/accumulators/statistics/weighted_skewness.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_skewness.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_skewness.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -51,14 +51,14 @@
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, weighted_sample>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, weighted_sample>::result_type result_type;
weighted_skewness_impl(dont_care) {}
template<typename Args>
result_type result(Args const &args) const
{
- return numeric::average(
+ return numeric::fdiv(
accumulators::weighted_moment<3>(args)
- 3. * accumulators::weighted_moment<2>(args) * weighted_mean(args)
+ 2. * weighted_mean(args) * weighted_mean(args) * weighted_mean(args)
Modified: branches/release/boost/accumulators/statistics/weighted_tail_mean.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_tail_mean.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_tail_mean.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -82,9 +82,9 @@
: accumulator_base
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
- typedef typename numeric::functional::average<Weight, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Weight, std::size_t>::result_type float_type;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, std::size_t>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, std::size_t>::result_type result_type;
non_coherent_weighted_tail_mean_impl(dont_care) {}
@@ -120,7 +120,7 @@
}
}
- return numeric::average(
+ return numeric::fdiv(
std::inner_product(
tail(args).begin()
, tail(args).begin() + n
Modified: branches/release/boost/accumulators/statistics/weighted_tail_quantile.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_tail_quantile.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_tail_quantile.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -66,7 +66,7 @@
struct weighted_tail_quantile_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Weight, std::size_t>::result_type float_type;
+ typedef typename numeric::functional::fdiv<Weight, std::size_t>::result_type float_type;
// for boost::result_of
typedef Sample result_type;
Modified: branches/release/boost/accumulators/statistics/weighted_tail_variate_means.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_tail_variate_means.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_tail_variate_means.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -107,8 +107,8 @@
struct weighted_tail_variate_means_impl
: accumulator_base
{
- typedef typename numeric::functional::average<Weight, Weight>::result_type float_type;
- typedef typename numeric::functional::average<typename numeric::functional::multiplies<VariateType, Weight>::result_type, Weight>::result_type array_type;
+ typedef typename numeric::functional::fdiv<Weight, Weight>::result_type float_type;
+ typedef typename numeric::functional::fdiv<typename numeric::functional::multiplies<VariateType, Weight>::result_type, Weight>::result_type array_type;
// for boost::result_of
typedef iterator_range<typename array_type::iterator> result_type;
Modified: branches/release/boost/accumulators/statistics/weighted_variance.hpp
==============================================================================
--- branches/release/boost/accumulators/statistics/weighted_variance.hpp Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/boost/accumulators/statistics/weighted_variance.hpp 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -41,7 +41,7 @@
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, Weight>::result_type result_type;
lazy_weighted_variance_impl(dont_care) {}
@@ -73,11 +73,11 @@
{
typedef typename numeric::functional::multiplies<Sample, Weight>::result_type weighted_sample;
// for boost::result_of
- typedef typename numeric::functional::average<weighted_sample, Weight>::result_type result_type;
+ typedef typename numeric::functional::fdiv<weighted_sample, Weight>::result_type result_type;
template<typename Args>
weighted_variance_impl(Args const &args)
- : weighted_variance(numeric::average(args[sample | Sample()], numeric::one<Weight>::value))
+ : weighted_variance(numeric::fdiv(args[sample | Sample()], numeric::one<Weight>::value))
{
}
@@ -93,8 +93,8 @@
result_type tmp = args[parameter::keyword<Tag>::get()] - some_mean(args);
this->weighted_variance =
- numeric::average(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args))
- + numeric::average(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] );
+ numeric::fdiv(this->weighted_variance * (sum_of_weights(args) - args[weight]), sum_of_weights(args))
+ + numeric::fdiv(tmp * tmp * args[weight], sum_of_weights(args) - args[weight] );
}
}
Modified: branches/release/libs/accumulators/doc/accumulators.qbk
==============================================================================
--- branches/release/libs/accumulators/doc/accumulators.qbk Thu Aug 22 12:22:53 2013 (r85423)
+++ branches/release/libs/accumulators/doc/accumulators.qbk 2013-08-22 15:39:56 EDT (Thu, 22 Aug 2013) (r85424)
@@ -123,7 +123,7 @@
primitives which fit within the framework.
* Users push data into the _accumulator_set_ object one sample at a time.
* The _accumulator_set_ computes the requested quantities in the most efficient method
- possible, resolving dependencies between requested calculations, possibly cacheing
+ possible, resolving dependencies between requested calculations, possibly caching
intermediate results.
The Accumulators Framework defines the utilities needed for defining primitive
@@ -155,7 +155,7 @@
a sample type and a list of features. The accumulator set uses this
information to generate an ordered set of accumulators depending on
the feature dependency graph. An accumulator set accepts samples one
- datum at a time, propogating them to each accumulator in order. At any
+ datum at a time, propagating them to each accumulator in order. At any
point, results can be extracted from the accumulator set.]]
[[Extractor] [A function or function object that can be used to extract a result
from an _accumulator_set_.]]
@@ -602,7 +602,7 @@
accumulator_set< double, features< tag::sum, droppable<tag::mean> > > acc;
`mean` depends on `sum` and `count`. Since `mean` is droppable, so too is `count`.
-However, we have explictitly requested that `sum` be not droppable, so it isn't. Had
+However, we have explicitly requested that `sum` be not droppable, so it isn't. Had
we left `tag::sum` out of the above declaration, the `sum` accumulator would have
been implicitly droppable.
@@ -735,7 +735,7 @@
Here, `impl` is a binary [@../../libs/mpl/doc/refmanual/metafunction-class.html
MPL Metafunction Class], which is a kind of _mpl_lambda_expression_. The nested
`apply<>` template is part of the metafunction class protocol and tells MPL how
-to to build the accumulator type given the sample and weight types.
+to build the accumulator type given the sample and weight types.
All features must also provide a nested `is_weight_accumulator` typedef. It must
be either `mpl::true_` or `mpl::false_`. _depends_on_ provides a default of
@@ -897,7 +897,7 @@
is possible to assign non-standard meanings to arithmetic operations. For instance, when
calculating an average by dividing two integers, the standard integer division behavior
would be mathematically incorrect for most statistical quantities. So rather than use `x / y`,
-the Accumulators Framework uses `numeric::average(x, y)`, which does floating-point division
+the Accumulators Framework uses `numeric::fdiv(x, y)`, which does floating-point division
even if both `x` and `y` are integers.
Another example where the Numeric Operators Sub-Library is useful is when a type does not
@@ -912,8 +912,8 @@
How are the numeric function object defined by the Numeric Operators Sub-Library made
to work with types such as `std::vector<>`? The free functions in the `boost::numeric` namespace
are implemented in terms of the function objects in the `boost::numeric::functional` namespace,
-so to make `boost::numeric::average()` do something sensible with a `std::vector<>`, for instance,
-we'll need to partially specialize the `boost::numeric::functional::average<>` function object.
+so to make `boost::numeric::fdiv()` do something sensible with a `std::vector<>`, for instance,
+we'll need to partially specialize the `boost::numeric::functional::fdiv<>` function object.
The functional objects make use of a technique known as
[@http://www.boost.org/community/generic_programming.html#tag_dispatching ['tag dispatching]] to
@@ -937,11 +937,11 @@
, typename LeftTag = typename tag<Left>::type
, typename RightTag = typename tag<Right>::type
>
- struct average;
+ struct fdiv;
}}}
-If you have some user-defined type `MyDouble` for which you would like to customimze the behavior
-of `numeric::average()`, you would specialize `numeric::functional::average<>` by
+If you have some user-defined type `MyDouble` for which you would like to customize the behavior
+of `numeric::fdiv()`, you would specialize `numeric::functional::fdiv<>` by
first defining a tag type, as shown below:
namespace boost { namespace numeric { namespace functional
@@ -959,7 +959,7 @@
// Specify how to divide a MyDouble by an integral count
template<typename Left, typename Right>
- struct average<Left, Right, MyDoubleTag, void>
+ struct fdiv<Left, Right, MyDoubleTag, void>
{
// Define the type of the result
typedef ... result_type;
@@ -971,8 +971,8 @@
};
}}}
-Once you have done this, `numeric::average()` will use your specialization
-of `numeric::functional::average<>` when the first argument is a `MyDouble`
+Once you have done this, `numeric::fdiv()` will use your specialization
+of `numeric::functional::fdiv<>` when the first argument is a `MyDouble`
object. All of the function objects in the Numeric Operators Sub-Library can
be customized in a similar fashion.
@@ -1004,11 +1004,11 @@
In the following table, `F` is the type of a feature and `S` is some scalar type.
-[table Featue Requirements
+[table Feature Requirements
[[[*Expression]] [[*Return type]] [[*Assertion / Note /
Pre- / Post-condition]]]
[[`F::dependencies`] [['unspecified]] [An MPL sequence of other features on
- which which `F` depends.]]
+ which `F` depends.]]
[[`F::is_weight_accumulator`] [`mpl::true_` or
`mpl::false_`] [`mpl::true_` if the accumulator for
this feature should be made external
@@ -1027,7 +1027,7 @@
[section The Statistical Accumulators Library]
-The Statistical Accumulators Library defines accumulators for incremental statistial
+The Statistical Accumulators Library defines accumulators for incremental statistical
computations. It is built on top of [link accumulators.user_s_guide.the_accumulators_framework
The Accumulator Framework].
@@ -1076,8 +1076,8 @@
[variablelist
[[Result Type] [``
numeric::functional::outer_product<
- numeric::functional::average<_sample_type_, std::size_t>::result_type
- , numeric::functional::average<_variate_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
+ , numeric::functional::fdiv<_variate_type_, std::size_t>::result_type
>::result_type
``]]
[[Depends On] [`count` \n `mean` \n `mean_of_variates<_variate_type_, _variate_tag_>`]]
@@ -1123,8 +1123,8 @@
iterator_range<
std::vector<
std::pair<
- numeric::functional::average<_sample_type_, std::size_t>::result_type
- , numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
+ , numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
>
>::iterator
>
@@ -1166,7 +1166,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`count` \n `variance`]]
[[Variants] [`error_of<immediate_mean>`]]
@@ -1263,7 +1263,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [weighted variants depend on `weighted_extended_p_square` \n
unweighted variants depend on `extended_p_square`]]
@@ -1356,7 +1356,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, _sample_type_>::result_type
+ numeric::functional::fdiv<_sample_type_, _sample_type_>::result_type
``]]
[[Depends On] [`mean` \n `moment<2>` \n `moment<3>` \n `moment<4>`]]
[[Variants] [['none]]]
@@ -1446,9 +1446,9 @@
[classref boost::accumulators::impl::immediate_mean_impl [^immediate_mean_impl]]
[variablelist
- [[Result Type] [For samples, `numeric::functional::average<_sample_type_, std::size_t>::result_type` \n
- For weights, `numeric::functional::average<_weight_type_, std::size_t>::result_type` \n
- For variates, `numeric::functional::average<_variate_type_, std::size_t>::result_type`]]
+ [[Result Type] [For samples, `numeric::functional::fdiv<_sample_type_, std::size_t>::result_type` \n
+ For weights, `numeric::functional::fdiv<_weight_type_, std::size_t>::result_type` \n
+ For variates, `numeric::functional::fdiv<_variate_type_, std::size_t>::result_type`]]
[[Depends On] [`count` \n
The lazy mean of samples depends on `sum` \n
The lazy mean of weights depends on `sum_of_weights` \n
@@ -1553,7 +1553,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`median` depends on `p_square_quantile_for_median` \n
`with_density_median` depends on `count` and `density` \n
@@ -1659,7 +1659,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`count`]]
[[Variants] [['none]]]
@@ -1714,8 +1714,8 @@
iterator_range<
std::vector<
std::pair<
- numeric::functional::average<_sample_type_, std::size_t>::result_type
- , numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
+ , numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
>
>::iterator
>
@@ -1777,7 +1777,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`count`]]
[[Variants] [`p_square_quantile_for_median`]]
@@ -1859,13 +1859,13 @@
[variablelist
[[Result Type] [``
boost::tuple<
- numeric::functional::average<_sample_type_, std::size_t>::result_type // u_bar
- , numeric::functional::average<_sample_type_, std::size_t>::result_type // beta_bar
- , numeric::functional::average<_sample_type_, std::size_t>::result_type // xi_hat
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type // u_bar
+ , numeric::functional::fdiv<_sample_type_, std::size_t>::result_type // beta_bar
+ , numeric::functional::fdiv<_sample_type_, std::size_t>::result_type // xi_hat
>
``]]
[[Depends On] [`count` \n
- In addtion, `tag::peaks_over_threshold_prob<>` depends on `tail<_left_or_right_>`]]
+ In addition, `tag::peaks_over_threshold_prob<>` depends on `tail<_left_or_right_>`]]
[[Variants] [`peaks_over_threshold_prob<_left_or_right_>`]]
[[Initialization Parameters] [ `tag::peaks_over_threshold::threshold_value` \n
`tag::peaks_over_threshold_prob::threshold_probability` \n
@@ -1906,7 +1906,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`pot_quantile<_left_or_right_>` depends on `peaks_over_threshold<_left_or_right_>` \n
`pot_quantile_prob<_left_or_right_>` depends on `peaks_over_threshold_prob<_left_or_right_>` ]]
@@ -1990,14 +1990,14 @@
[section:pot_tail_mean pot_tail_mean]
Estimation of the (coherent) tail mean based on the peaks over threshold method (for both left and right tails).
-For inplementation details, see [classref boost::accumulators::impl::pot_tail_mean_impl [^pot_tail_mean_impl]].
+For implementation details, see [classref boost::accumulators::impl::pot_tail_mean_impl [^pot_tail_mean_impl]].
Both `tag::pot_tail_mean<_left_or_right_>` and `tag::pot_tail_mean_prob<_left_or_right_>` satisfy the
`tag::tail_mean` feature and can be extracted using the `tail_mean()` extractor.
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`pot_tail_mean<_left_or_right_>` depends on `peaks_over_threshold<_left_or_right_>`
and `pot_quantile<_left_or_right_>` \n
@@ -2131,7 +2131,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`rolling_sum` \n `rolling_count`]]
[[Variants] [['none]]]
@@ -2173,12 +2173,12 @@
[section:skewness skewness]
The skewness of a sample distribution is defined as the ratio of the 3rd central moment and the [^3/2]-th power
-of the 2nd central moment (the variance) of the sampless 3. For implementation details, see
+of the 2nd central moment (the variance) of the samples 3. For implementation details, see
[classref boost::accumulators::impl::skewness_impl [^skewness_impl]].
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, _sample_type_>::result_type
+ numeric::functional::fdiv<_sample_type_, _sample_type_>::result_type
``]]
[[Depends On] [`mean` \n `moment<2>` \n `moment<3>`]]
[[Variants] [['none]]]
@@ -2341,14 +2341,14 @@
[section:coherent_tail_mean coherent_tail_mean]
Estimation of the coherent tail mean based on order statistics (for both left and right tails).
-The left coherent tail mean feature is `tag::coherent_tail_mean<left>`, and the right choherent
+The left coherent tail mean feature is `tag::coherent_tail_mean<left>`, and the right coherent
tail mean feature is `tag::coherent_tail_mean<right>`. They both share the `tag::tail_mean` feature
and can be extracted with the `tail_mean()` extractor. For more implementation details, see
[classref boost::accumulators::impl::coherent_tail_mean_impl [^coherent_tail_mean_impl]]
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`count` \n `quantile` \n `non_coherent_tail_mean<_left_or_right_>`]]
[[Variants] [['none]]]
@@ -2390,7 +2390,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`count` \n `tail<_left_or_right_>`]]
[[Variants] [`abstract_non_coherent_tail_mean`]]
@@ -2637,7 +2637,7 @@
[[Result Type] [``
boost::iterator_range<
std::vector<
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
>::iterator
>
``]]
@@ -2779,7 +2779,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`tag::lazy_variance` depends on `tag::moment<2>` and `tag::mean` \n
`tag::variance` depends on `tag::count` and `tag::immediate_mean`]]
@@ -2848,11 +2848,11 @@
numeric::functional::outer_product<
numeric::functional::multiplies<
_weight_type_
- , numeric::functional::average<_sample_type_, std::size_t>::result_type
+ , numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
>::result_type
, numeric::functional::multiplies<
_weight_type_
- , numeric::functional::average<_variate_type_, std::size_t>::result_type
+ , numeric::functional::fdiv<_variate_type_, std::size_t>::result_type
>::result_type
>
``]]
@@ -2905,8 +2905,8 @@
iterator_range<
std::vector<
std::pair<
- numeric::functional::average<_weight_type_, std::size_t>::result_type
- , numeric::functional::average<_weight_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_weight_type_, std::size_t>::result_type
+ , numeric::functional::fdiv<_weight_type_, std::size_t>::result_type
>
>::iterator
>
@@ -3037,7 +3037,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
>::result_type
@@ -3089,8 +3089,8 @@
[classref boost::accumulators::impl::immediate_weighted_mean_impl [^immediate_weighted_mean_impl]]
[variablelist
- [[Result Type] [For samples, `numeric::functional::average<numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type, _weight_type_>::result_type` \n
- For variates, `numeric::functional::average<numeric::functional::multiplies<_variate_type_, _weight_type_>::result_type, _weight_type_>::result_type`]]
+ [[Result Type] [For samples, `numeric::functional::fdiv<numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type, _weight_type_>::result_type` \n
+ For variates, `numeric::functional::fdiv<numeric::functional::multiplies<_variate_type_, _weight_type_>::result_type, _weight_type_>::result_type`]]
[[Depends On] [`sum_of_weights` \n
The lazy mean of samples depends on `weighted_sum` \n
The lazy mean of variates depends on `weighted_sum_of_variates<>`]]
@@ -3183,7 +3183,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<_sample_type_, std::size_t>::result_type
+ numeric::functional::fdiv<_sample_type_, std::size_t>::result_type
``]]
[[Depends On] [`weighted_median` depends on `weighted_p_square_quantile_for_median` \n
`with_weighted_density_median` depends on `count` and `weighted_density` \n
@@ -3252,7 +3252,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, weight_type
>::result_type
@@ -3306,8 +3306,8 @@
iterator_range<
std::vector<
std::pair<
- numeric::functional::average<weighted_sample, std::size_t>::result_type
- , numeric::functional::average<weighted_sample, std::size_t>::result_type
+ numeric::functional::fdiv<weighted_sample, std::size_t>::result_type
+ , numeric::functional::fdiv<weighted_sample, std::size_t>::result_type
>
>::iterator
>
@@ -3362,7 +3362,7 @@
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 applying 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
@@ -3393,7 +3393,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, std::size_t
>::result_type
@@ -3500,7 +3500,7 @@
[variablelist
[[Result Type] [`tuple<float_type, float_type, float_type>` where `float_type` is
``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, std::size_t
>::result_type
@@ -3536,7 +3536,7 @@
[section:weighted_skewness weighted_skewness]
The skewness of a sample distribution is defined as the ratio of the 3rd central moment and the [^3/2]-th power
-of the 2nd central moment (the variance) of the sampless 3. The skewness estimator for weighted samples
+of the 2nd central moment (the variance) of the samples 3. The skewness estimator for weighted samples
is formally identical to the estimator for unweighted samples, except that the weighted counterparts of
all measures it depends on are to be taken.
@@ -3545,7 +3545,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
>::result_type
@@ -3662,7 +3662,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, std::size_t
>::result_type
@@ -3819,7 +3819,7 @@
[variablelist
[[Result Type] [``
boost::iterator_range<
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_variate_type_, _weight_type_>::result_type
, _weight_type_
>::result_type::iterator
@@ -3953,7 +3953,7 @@
[variablelist
[[Result Type] [``
- numeric::functional::average<
+ numeric::functional::fdiv<
numeric::functional::multiplies<_sample_type_, _weight_type_>::result_type
, std::size_t
>::result_type
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