1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
///////////////////////////////////////////////////////////////////////////////
// sum_kahan.hpp
//
// Copyright 2010 Gaetano Mendola, 2011 Simon West. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_ACCUMULATORS_STATISTICS_SUM_KAHAN_HPP_EAN_26_07_2010
#define BOOST_ACCUMULATORS_STATISTICS_SUM_KAHAN_HPP_EAN_26_07_2010
#include <boost/accumulators/framework/accumulator_base.hpp>
#include <boost/accumulators/framework/parameters/sample.hpp>
#include <boost/accumulators/statistics_fwd.hpp>
#include <boost/accumulators/statistics/sum.hpp>
#include <boost/accumulators/statistics/weighted_sum_kahan.hpp>
#include <boost/numeric/conversion/cast.hpp>
namespace boost { namespace accumulators
{
namespace impl
{
#if _MSC_VER > 1400
# pragma float_control(push)
# pragma float_control(precise, on)
#endif
template<typename Sample, typename Tag>
struct sum_kahan_impl
: accumulator_base
{
typedef Sample result_type;
////////////////////////////////////////////////////////////////////////////
// sum_kahan_impl
/**
@brief Kahan summation algorithm
The Kahan summation algorithm reduces the numerical error obtained with standard
sequential sum.
*/
template<typename Args>
sum_kahan_impl(Args const & args)
: sum(args[parameter::keyword<Tag>::get() | Sample()]),
compensation(boost::numeric_cast<Sample>(0.0))
{
}
template<typename Args>
void
#if BOOST_ACCUMULATORS_GCC_VERSION > 40305
__attribute__((__optimize__("no-associative-math")))
#endif
operator ()(Args const & args)
{
const Sample myTmp1 = args[parameter::keyword<Tag>::get()] - this->compensation;
const Sample myTmp2 = this->sum + myTmp1;
this->compensation = (myTmp2 - this->sum) - myTmp1;
this->sum = myTmp2;
}
result_type result(dont_care) const
{
return this->sum;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum;
ar & compensation;
}
private:
Sample sum;
Sample compensation;
};
#if _MSC_VER > 1400
# pragma float_control(pop)
#endif
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
// tag::sum_kahan
// tag::sum_of_weights_kahan
// tag::sum_of_variates_kahan
//
namespace tag
{
struct sum_kahan
: depends_on<>
{
/// INTERNAL ONLY
///
typedef impl::sum_kahan_impl< mpl::_1, tag::sample > impl;
};
struct sum_of_weights_kahan
: depends_on<>
{
typedef mpl::true_ is_weight_accumulator;
/// INTERNAL ONLY
///
typedef accumulators::impl::sum_kahan_impl<mpl::_2, tag::weight> impl;
};
template<typename VariateType, typename VariateTag>
struct sum_of_variates_kahan
: depends_on<>
{
/// INTERNAL ONLY
///
typedef mpl::always<accumulators::impl::sum_kahan_impl<VariateType, VariateTag> > impl;
};
} // namespace tag
///////////////////////////////////////////////////////////////////////////////
// extract::sum_kahan
// extract::sum_of_weights_kahan
// extract::sum_of_variates_kahan
//
namespace extract
{
extractor<tag::sum_kahan> const sum_kahan = {};
extractor<tag::sum_of_weights_kahan> const sum_of_weights_kahan = {};
extractor<tag::abstract_sum_of_variates> const sum_of_variates_kahan = {};
BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_kahan)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_of_weights_kahan)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(sum_of_variates_kahan)
} // namespace extract
using extract::sum_kahan;
using extract::sum_of_weights_kahan;
using extract::sum_of_variates_kahan;
// sum(kahan) -> sum_kahan
template<>
struct as_feature<tag::sum(kahan)>
{
typedef tag::sum_kahan type;
};
// sum_of_weights(kahan) -> sum_of_weights_kahan
template<>
struct as_feature<tag::sum_of_weights(kahan)>
{
typedef tag::sum_of_weights_kahan type;
};
// So that sum_kahan can be automatically substituted with
// weighted_sum_kahan when the weight parameter is non-void.
template<>
struct as_weighted_feature<tag::sum_kahan>
{
typedef tag::weighted_sum_kahan type;
};
template<>
struct feature_of<tag::weighted_sum_kahan>
: feature_of<tag::sum>
{};
// for the purposes of feature-based dependency resolution,
// sum_kahan provides the same feature as sum
template<>
struct feature_of<tag::sum_kahan>
: feature_of<tag::sum>
{
};
// for the purposes of feature-based dependency resolution,
// sum_of_weights_kahan provides the same feature as sum_of_weights
template<>
struct feature_of<tag::sum_of_weights_kahan>
: feature_of<tag::sum_of_weights>
{
};
template<typename VariateType, typename VariateTag>
struct feature_of<tag::sum_of_variates_kahan<VariateType, VariateTag> >
: feature_of<tag::abstract_sum_of_variates>
{
};
}} // namespace boost::accumulators
#endif
|
