bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update boost

Browse Source
This commit is contained in:
Bassem Girgis
2023-11-24 12:56:13 -06:00
parent cfc99971af
commit 19d727037a
9260 changed files with 849256 additions and 299957 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
linx64/include/boost/accumulators/accumulators_fwd.hpp
View File

@@ -9,6 +9,8 @@
#define BOOST_ACCUMULATORS_ACCUMULATORS_FWD_HPP_EAN_28_10_2005
#include <boost/config.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/parameter/is_argument_pack.hpp>
#include <boost/mpl/apply_fwd.hpp> // for mpl::na
#include <boost/mpl/limits/vector.hpp>
#include <boost/preprocessor/cat.hpp>
@@ -41,7 +43,6 @@
#endif
#ifdef BOOST_ACCUMULATORS_BROKEN_CONST_OVERLOADS
# include <boost/utility/enable_if.hpp>
# include <boost/type_traits/is_const.hpp>
# define BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)\
, typename boost::disable_if<boost::is_const<T> >::type * = 0
@@ -128,9 +129,12 @@ template<typename Feature, typename AccumulatorSet>
typename mpl::apply<AccumulatorSet, Feature>::type::result_type
extract_result(AccumulatorSet const &acc);
template<typename Feature, typename AccumulatorSet, typename A1>
typename mpl::apply<AccumulatorSet, Feature>::type::result_type
extract_result(AccumulatorSet const &acc, A1 const &a1);
namespace detail
{
struct _enabler
{
};
}
// ... other overloads generated by Boost.Preprocessor:
@@ -146,17 +150,37 @@ extract_result(AccumulatorSet const &acc, A1 const &a1);
extract_result( \
AccumulatorSet const &acc \
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::enable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type = detail::_enabler() \
); \
template< \
typename Feature \
, typename AccumulatorSet \
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A) \
> \
typename mpl::apply<AccumulatorSet, Feature>::type::result_type \
extract_result( \
AccumulatorSet const &acc \
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::disable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type = detail::_enabler() \
);
/// INTERNAL ONLY
///
BOOST_PP_REPEAT_FROM_TO(
2
1
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
, BOOST_ACCUMULATORS_EXTRACT_RESULT_FWD
, _
)
#undef BOOST_ACCUMULATORS_EXTRACT_RESULT_FWD
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
template<typename Feature, typename AccumulatorSet, typename A1, typename A2 ...>
typename mpl::apply<AccumulatorSet, Feature>::type::result_type
@@ -185,6 +209,9 @@ namespace detail
struct is_accumulator_set;
inline void ignore_variable(void const *) {}
}
}} // namespace boost::accumulators
#define BOOST_ACCUMULATORS_IGNORE_GLOBAL(X) \
namespace detail \
@@ -198,33 +225,8 @@ namespace detail
}; \
} \
/**/
}
}} // namespace boost::accumulators
#include <boost/parameter/nested_keyword.hpp>
// For defining boost::parameter keywords that can be inherited from to
// get a nested, class-scoped keyword with the requested alias
#define BOOST_PARAMETER_NESTED_KEYWORD(tag_namespace, name, alias) \
namespace tag_namespace \
{ \
template<int Dummy = 0> \
struct name ## _ \
{ \
static char const* keyword_name() \
{ \
return #name; \
} \
static ::boost::parameter::keyword<name ## _<Dummy> > &alias; \
}; \
template<int Dummy> \
::boost::parameter::keyword<name ## _<Dummy> > &name ## _<Dummy>::alias = \
::boost::parameter::keyword<name ## _<Dummy> >::get(); \
typedef name ## _ <> name; \
} \
namespace \
{ \
::boost::parameter::keyword<tag_namespace::name> &name = \
::boost::parameter::keyword<tag_namespace::name>::get(); \
}
#endif // include guard
#endif

229
linx64/include/boost/accumulators/framework/accumulator_set.hpp
View File

@@ -9,16 +9,23 @@
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_SET_HPP_EAN_28_10_2005
#include <boost/version.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/protect.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/parameter/parameters.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/parameter/is_argument_pack.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/accumulators/accumulators_fwd.hpp>
#include <boost/accumulators/framework/depends_on.hpp>
#include <boost/accumulators/framework/accumulator_concept.hpp>
@@ -64,14 +71,6 @@ namespace detail
return accumulator_visitor<Args>(args);
}
typedef
parameter::parameters<
parameter::required<tag::accumulator>
, parameter::optional<tag::sample>
// ... and others which are not specified here...
>
accumulator_params;
///////////////////////////////////////////////////////////////////////////////
// accumulator_set_base
struct accumulator_set_base
@@ -82,10 +81,38 @@ namespace detail
// is_accumulator_set
template<typename T>
struct is_accumulator_set
: is_base_and_derived<accumulator_set_base, T>
: mpl::if_<
boost::is_base_of<
accumulator_set_base
, typename boost::remove_const<
typename boost::remove_reference<T>::type
>::type
>
, mpl::true_
, mpl::false_
>::type
{
};
// function object that serialize an accumulator
template<typename Archive>
struct serialize_accumulator
{
serialize_accumulator(Archive & _ar, const unsigned int _file_version) :
ar(_ar), file_version(_file_version)
{}
template<typename Accumulator>
void operator ()(Accumulator &accumulator)
{
accumulator.serialize(ar, file_version);
}
private:
Archive& ar;
const unsigned int file_version;
};
} // namespace detail
#ifdef _MSC_VER
@@ -140,13 +167,13 @@ struct accumulator_set
: accumulators(
detail::make_acc_list(
accumulators_mpl_vector()
, detail::accumulator_params()(*this)
, (boost::accumulators::accumulator = *this)
)
)
{
// Add-ref the Features that the user has specified
this->template visit_if<detail::contains_feature_of_<Features> >(
detail::make_add_ref_visitor(detail::accumulator_params()(*this))
detail::make_add_ref_visitor(boost::accumulators::accumulator = *this)
);
}
@@ -154,17 +181,48 @@ struct accumulator_set
///
/// \param a1 Optional named parameter to be passed to all the accumulators
template<typename A1>
explicit accumulator_set(A1 const &a1)
: accumulators(
explicit accumulator_set(
A1 const &a1
, typename boost::enable_if<
parameter::is_argument_pack<A1>
, detail::_enabler
>::type = detail::_enabler()
) : accumulators(
detail::make_acc_list(
accumulators_mpl_vector()
, detail::accumulator_params()(*this, a1)
, (boost::accumulators::accumulator = *this, a1)
)
)
{
// Add-ref the Features that the user has specified
this->template visit_if<detail::contains_feature_of_<Features> >(
detail::make_add_ref_visitor(detail::accumulator_params()(*this))
detail::make_add_ref_visitor(boost::accumulators::accumulator = *this)
);
}
/// \overload
///
/// \param a1 Optional sample parameter to be passed to all the accumulators
template<typename A1>
explicit accumulator_set(
A1 const &a1
, typename boost::disable_if<
parameter::is_argument_pack<A1>
, detail::_enabler
>::type = detail::_enabler()
) : accumulators(
detail::make_acc_list(
accumulators_mpl_vector()
, (
boost::accumulators::accumulator = *this
, boost::accumulators::sample = a1
)
)
)
{
// Add-ref the Features that the user has specified
this->template visit_if<detail::contains_feature_of_<Features> >(
detail::make_add_ref_visitor(boost::accumulators::accumulator = *this)
);
}
@@ -174,19 +232,47 @@ struct accumulator_set
///
#define BOOST_ACCUMULATORS_ACCUMULATOR_SET_CTOR(z, n, _) \
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
accumulator_set(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a)) \
: accumulators( \
accumulator_set( \
BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::enable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type = detail::_enabler() \
) : accumulators( \
detail::make_acc_list( \
accumulators_mpl_vector() \
, detail::accumulator_params()( \
*this BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
, ( \
boost::accumulators::accumulator = *this \
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
) \
) \
) \
{ \
/* Add-ref the Features that the user has specified */ \
this->template visit_if<detail::contains_feature_of_<Features> >( \
detail::make_add_ref_visitor(detail::accumulator_params()(*this)) \
detail::make_add_ref_visitor(boost::accumulators::accumulator = *this) \
); \
} \
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
accumulator_set( \
BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::disable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type = detail::_enabler() \
) : accumulators( \
detail::make_acc_list( \
accumulators_mpl_vector() \
, ( \
boost::accumulators::accumulator = *this \
, boost::accumulators::sample = BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
) \
) \
) \
{ \
/* Add-ref the Features that the user has specified */ \
this->template visit_if<detail::contains_feature_of_<Features> >( \
detail::make_add_ref_visitor(boost::accumulators::accumulator = *this) \
); \
}
@@ -239,17 +325,7 @@ struct accumulator_set
{
this->visit(
detail::make_accumulator_visitor(
detail::accumulator_params()(*this)
)
);
}
template<typename A1>
void operator ()(A1 const &a1)
{
this->visit(
detail::make_accumulator_visitor(
detail::accumulator_params()(*this, a1)
boost::accumulators::accumulator = *this
)
);
}
@@ -260,12 +336,37 @@ struct accumulator_set
///
#define BOOST_ACCUMULATORS_ACCUMULATOR_SET_FUN_OP(z, n, _) \
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
void operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a)) \
void operator ()( \
BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::enable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type = detail::_enabler() \
) \
{ \
this->visit( \
detail::make_accumulator_visitor( \
detail::accumulator_params()( \
*this BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
( \
boost::accumulators::accumulator = *this \
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
) \
) \
); \
} \
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
void operator ()( \
BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::disable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type = detail::_enabler() \
) \
{ \
this->visit( \
detail::make_accumulator_visitor( \
( \
boost::accumulators::accumulator = *this \
, boost::accumulators::sample = BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
) \
) \
); \
@@ -274,7 +375,7 @@ struct accumulator_set
/// INTERNAL ONLY
///
BOOST_PP_REPEAT_FROM_TO(
2
1
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
, BOOST_ACCUMULATORS_ACCUMULATOR_SET_FUN_OP
, _
@@ -329,15 +430,23 @@ struct accumulator_set
the_feature;
(*fusion::find_if<detail::matches_feature<Feature> >(this->accumulators))
.drop(detail::accumulator_params()(*this));
.drop(boost::accumulators::accumulator = *this);
// Also drop accumulators that this feature depends on
typedef typename the_feature::dependencies dependencies;
this->template visit_if<detail::contains_feature_of_<dependencies> >(
detail::make_drop_visitor(detail::accumulator_params()(*this))
detail::make_drop_visitor(boost::accumulators::accumulator = *this)
);
}
// make the accumulator set serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
detail::serialize_accumulator<Archive> serializer(ar, file_version);
fusion::for_each(this->accumulators, serializer);
}
private:
accumulators_type accumulators;
@@ -365,6 +474,15 @@ find_accumulator(AccumulatorSet const &acc)
return acc.template extract<Feature>();
}
template<typename Feature, typename AccumulatorSet>
typename mpl::apply<AccumulatorSet, Feature>::type::result_type
extract_result(AccumulatorSet const &acc)
{
return find_accumulator<Feature>(acc).result(
boost::accumulators::accumulator = acc
);
}
///////////////////////////////////////////////////////////////////////////////
// extract_result
// extract a result from an accumulator set
@@ -380,18 +498,43 @@ find_accumulator(AccumulatorSet const &acc)
extract_result( \
AccumulatorSet const &acc \
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::enable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type \
) \
{ \
return find_accumulator<Feature>(acc).result( \
detail::accumulator_params()( \
acc \
( \
boost::accumulators::accumulator = acc \
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
) \
); \
} \
template< \
typename Feature \
, typename AccumulatorSet \
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A) \
> \
typename mpl::apply<AccumulatorSet, Feature>::type::result_type \
extract_result( \
AccumulatorSet const &acc \
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) \
, typename boost::disable_if< \
parameter::is_argument_pack<A0> \
, detail::_enabler \
>::type \
) \
{ \
return find_accumulator<Feature>(acc).result(( \
boost::accumulators::accumulator = acc \
, boost::accumulators::sample = BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
)); \
}
BOOST_PP_REPEAT(
BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
BOOST_PP_REPEAT_FROM_TO(
1
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
, BOOST_ACCUMULATORS_EXTRACT_RESULT_FUN
, _
)

2
linx64/include/boost/accumulators/framework/accumulators/external_accumulator.hpp
View File

@@ -34,7 +34,7 @@ namespace boost { namespace accumulators { namespace impl
template<typename Args>
result_type result(Args const &args) const
{
return this->extract_(args, args[parameter::keyword<Tag>::get() | 0]);
return this->extract_(args, args[parameter::keyword<Tag>::instance | 0]);
}
private:

2
linx64/include/boost/accumulators/framework/accumulators/reference_accumulator.hpp
View File

@@ -31,7 +31,7 @@ namespace impl
template<typename Args>
reference_accumulator_impl(Args const &args)
: ref(args[parameter::keyword<Tag>::get()])
: ref(args[parameter::keyword<Tag>::instance])
{
}

2
linx64/include/boost/accumulators/framework/accumulators/value_accumulator.hpp
View File

@@ -30,7 +30,7 @@ namespace impl
template<typename Args>
value_accumulator_impl(Args const &args)
: val(args[parameter::keyword<Tag>::get()])
: val(args[parameter::keyword<Tag>::instance])
{
}

9
linx64/include/boost/accumulators/framework/depends_on.hpp
View File

@@ -266,11 +266,18 @@ namespace boost { namespace accumulators
template<typename Sequence, typename Args>
typename meta::make_acc_list<Sequence>::type
make_acc_list(Sequence const &seq, Args const &args)
make_acc_list(Sequence &seq, Args const &args)
{
return meta::make_acc_list<Sequence>::call(args, fusion::begin(seq), fusion::end(seq));
}
template<typename Sequence, typename Args>
typename meta::make_acc_list<Sequence>::type
make_acc_list(Sequence const &seq, Args const &args)
{
return meta::make_acc_list<Sequence const>::call(args, fusion::begin(seq), fusion::end(seq));
}
///////////////////////////////////////////////////////////////////////////
// checked_as_weighted_feature
template<typename Feature>

31
linx64/include/boost/accumulators/framework/extractor.hpp
View File

@@ -8,6 +8,7 @@
#ifndef BOOST_ACCUMULATORS_FRAMEWORK_EXTRACTOR_HPP_EAN_28_10_2005
#define BOOST_ACCUMULATORS_FRAMEWORK_EXTRACTOR_HPP_EAN_28_10_2005
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/tuple/rem.hpp>
#include <boost/preprocessor/array/size.hpp>
#include <boost/preprocessor/array/data.hpp>
@@ -15,11 +16,17 @@
#include <boost/preprocessor/seq/to_array.hpp>
#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/parameter/binding.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/accumulators/accumulators_fwd.hpp>
#include <boost/accumulators/framework/parameters/accumulator.hpp>
@@ -33,14 +40,24 @@ namespace detail
struct accumulator_set_result
{
typedef typename as_feature<Feature>::type feature_type;
typedef typename mpl::apply<AccumulatorSet, feature_type>::type::result_type type;
typedef typename mpl::apply<
typename boost::remove_const<
typename boost::remove_reference<AccumulatorSet>::type
>::type
, feature_type
>::type::result_type type;
};
template<typename Args, typename Feature>
struct argument_pack_result
: accumulator_set_result<
typename remove_reference<
typename parameter::binding<Args, tag::accumulator>::type
typename boost::remove_reference<
typename parameter::binding<
typename boost::remove_const<
typename boost::remove_reference<Args>::type
>::type
, tag::accumulator
>::type
>::type
, Feature
>
@@ -147,6 +164,8 @@ struct extractor
, _
)
#undef BOOST_ACCUMULATORS_EXTRACTOR_FUN_OP
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
/// \overload
///
@@ -156,6 +175,8 @@ struct extractor
#endif
};
}} // namespace boost::accumulators
/// INTERNAL ONLY
///
#define BOOST_ACCUMULATORS_ARRAY_REM(Array) \
@@ -224,6 +245,4 @@ struct extractor
, (3, (Tag, Feature, ParamSeq)) \
)
}} // namespace boost::accumulators
#endif

4
linx64/include/boost/accumulators/framework/parameters/accumulator.hpp
View File

@@ -8,13 +8,13 @@
#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_ACCUMULATOR_HPP_EAN_31_10_2005
#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_ACCUMULATOR_HPP_EAN_31_10_2005
#include <boost/parameter/keyword.hpp>
#include <boost/parameter/name.hpp>
#include <boost/accumulators/accumulators_fwd.hpp>
namespace boost { namespace accumulators
{
BOOST_PARAMETER_KEYWORD(tag, accumulator)
BOOST_PARAMETER_NAME((accumulator, tag) accumulator)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(accumulator)
}} // namespace boost::accumulators

4
linx64/include/boost/accumulators/framework/parameters/sample.hpp
View File

@@ -8,13 +8,13 @@
#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_SAMPLE_HPP_EAN_31_10_2005
#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_SAMPLE_HPP_EAN_31_10_2005
#include <boost/parameter/keyword.hpp>
#include <boost/parameter/name.hpp>
#include <boost/accumulators/accumulators_fwd.hpp>
namespace boost { namespace accumulators
{
BOOST_PARAMETER_KEYWORD(tag, sample)
BOOST_PARAMETER_NAME((sample, tag) sample)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(sample)
}} // namespace boost::accumulators

4
linx64/include/boost/accumulators/framework/parameters/weight.hpp
View File

@@ -8,14 +8,14 @@
#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHT_HPP_EAN_31_10_2005
#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHT_HPP_EAN_31_10_2005
#include <boost/parameter/keyword.hpp>
#include <boost/parameter/name.hpp>
#include <boost/accumulators/accumulators_fwd.hpp>
namespace boost { namespace accumulators
{
// The weight of a single sample
BOOST_PARAMETER_KEYWORD(tag, weight)
BOOST_PARAMETER_NAME((weight, tag) weight)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weight)
}} // namespace boost::accumulators

4
linx64/include/boost/accumulators/framework/parameters/weights.hpp
View File

@@ -8,14 +8,14 @@
#ifndef BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHTS_HPP_EAN_28_10_2005
#define BOOST_ACCUMULATORS_FRAMEWORK_PARAMETERS_WEIGHTS_HPP_EAN_28_10_2005
#include <boost/parameter/keyword.hpp>
#include <boost/parameter/name.hpp>
#include <boost/accumulators/accumulators_fwd.hpp>
namespace boost { namespace accumulators
{
// The weight accumulator
BOOST_PARAMETER_KEYWORD(tag, weights)
BOOST_PARAMETER_NAME((weights, tag) weights)
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weights)
}} // namespace boost::accumulators

7
linx64/include/boost/accumulators/statistics/count.hpp
View File

@@ -43,6 +43,13 @@ namespace impl
return this->cnt;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & cnt;
}
private:
std::size_t cnt;
};

7
linx64/include/boost/accumulators/statistics/covariance.hpp
View File

@@ -152,6 +152,13 @@ namespace impl
return this->cov_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & cov_;
}
private:
result_type cov_;
};

16
linx64/include/boost/accumulators/statistics/density.hpp
View File

@@ -25,6 +25,8 @@
#include <boost/accumulators/statistics/count.hpp>
#include <boost/accumulators/statistics/max.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/utility.hpp>
namespace boost { namespace accumulators
{
@@ -184,6 +186,20 @@ namespace impl
return make_iterator_range(this->histogram);
}
// make this accumulator serializeable
// TODO split to save/load and check on parameters provided in ctor
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & cache_size;
ar & cache;
ar & num_bins;
ar & samples_in_bin;
ar & bin_positions;
ar & histogram;
ar & is_dirty;
}
private:
std::size_t cache_size; // number of cached samples
array_type cache; // cache to store the first cache_size samples

14
linx64/include/boost/accumulators/statistics/extended_p_square.hpp
View File

@@ -26,6 +26,7 @@
#include <boost/accumulators/statistics_fwd.hpp>
#include <boost/accumulators/statistics/count.hpp>
#include <boost/accumulators/statistics/times2_iterator.hpp>
#include <boost/serialization/vector.hpp>
namespace boost { namespace accumulators
{
@@ -236,6 +237,19 @@ namespace impl
);
}
public:
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that the parameters did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & probabilities;
ar & heights;
ar & actual_positions;
ar & desired_positions;
ar & positions_increments;
}
private:
array_type probabilities; // the quantile probabilities
array_type heights; // q_i

12
linx64/include/boost/accumulators/statistics/extended_p_square_quantile.hpp
View File

@@ -76,6 +76,7 @@ namespace impl
boost::begin(args[extended_p_square_probabilities])
, boost::end(args[extended_p_square_probabilities])
)
, probability()
{
}
@@ -185,6 +186,17 @@ namespace impl
}
}
public:
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that the parameters did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & probabilities;
ar & probability;
}
private:
array_type probabilities;

4
linx64/include/boost/accumulators/statistics/kurtosis.hpp
View File

@@ -63,6 +63,10 @@ namespace impl
* ( accumulators::moment<2>(args) - mean(args) * mean(args) )
) - 3.;
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
} // namespace impl

7
linx64/include/boost/accumulators/statistics/max.hpp
View File

@@ -48,6 +48,13 @@ namespace impl
return this->max_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & max_;
}
private:
Sample max_;
};

10
linx64/include/boost/accumulators/statistics/mean.hpp
View File

@@ -41,6 +41,10 @@ namespace impl
extractor<SumFeature> sum;
return numeric::fdiv(sum(args), count(args));
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
template<typename Sample, typename Tag>
@@ -71,6 +75,12 @@ namespace impl
return this->mean;
}
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & mean;
}
private:
result_type mean;
};

23
linx64/include/boost/accumulators/statistics/median.hpp
View File

@@ -48,6 +48,10 @@ namespace impl
{
return p_square_quantile_for_median(args);
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
///////////////////////////////////////////////////////////////////////////////
// with_density_median_impl
@@ -105,6 +109,16 @@ namespace impl
return this->median;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum;
ar & is_dirty;
ar & median;
}
private:
mutable float_type sum;
mutable bool is_dirty;
@@ -160,6 +174,15 @@ namespace impl
return this->median;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & is_dirty;
ar & median;
}
private:
mutable bool is_dirty;

7
linx64/include/boost/accumulators/statistics/min.hpp
View File

@@ -48,6 +48,13 @@ namespace impl
return this->min_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & min_;
}
private:
Sample min_;
};

7
linx64/include/boost/accumulators/statistics/moment.hpp
View File

@@ -75,6 +75,13 @@ namespace impl
return numeric::fdiv(this->sum, count(args));
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum;
}
private:
Sample sum;
};

16
linx64/include/boost/accumulators/statistics/p_square_cumul_dist.hpp
View File

@@ -20,6 +20,8 @@
#include <boost/accumulators/framework/parameters/sample.hpp>
#include <boost/accumulators/statistics_fwd.hpp>
#include <boost/accumulators/statistics/count.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/utility.hpp>
namespace boost { namespace accumulators
{
@@ -204,6 +206,20 @@ namespace impl
//return histogram;
return make_iterator_range(this->histogram);
}
// make this accumulator serializeable
// TODO split to save/load and check on parameters provided in ctor
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & num_cells;
ar & heights;
ar & actual_positions;
ar & desired_positions;
ar & positions_increments;
ar & histogram;
ar & is_dirty;
}
private:
std::size_t num_cells; // number of cells b

4
linx64/include/boost/accumulators/statistics/p_square_cumulative_distribution.hpp
View File

@@ -8,9 +8,9 @@
#ifndef BOOST_ACCUMULATORS_STATISTICS_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_03_19_2012
#define BOOST_ACCUMULATORS_STATISTICS_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_03_19_2012
#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
#if defined(_MSC_VER) || defined(__BORLANDC__) && !defined(__clang__) || defined(__DMC__)
# pragma message ("Warning: This header is deprecated. Please use: boost/accumulators/statistics/p_square_cumul_dist.hpp")
#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__) || defined(__BORLANDC__)
# warning "This header is deprecated. Please use: boost/accumulators/statistics/p_square_cumul_dist.hpp"
#endif

42
linx64/include/boost/accumulators/statistics/p_square_quantile.hpp
View File

@@ -22,6 +22,7 @@
#include <boost/accumulators/statistics_fwd.hpp>
#include <boost/accumulators/statistics/count.hpp>
#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
#include <boost/serialization/boost_array.hpp>
namespace boost { namespace accumulators
{
@@ -61,7 +62,7 @@ namespace impl
template<typename Args>
p_square_quantile_impl(Args const &args)
: p(is_same<Impl, for_median>::value ? 0.5 : args[quantile_probability | 0.5])
: p(is_same<Impl, for_median>::value ? float_type(0.5) : args[quantile_probability | float_type(0.5)])
, heights()
, actual_positions()
, desired_positions()
@@ -69,20 +70,21 @@ namespace impl
{
for(std::size_t i = 0; i < 5; ++i)
{
this->actual_positions[i] = i + 1.;
this->actual_positions[i] = i + float_type(1.);
}
this->desired_positions[0] = 1.;
this->desired_positions[1] = 1. + 2. * this->p;
this->desired_positions[2] = 1. + 4. * this->p;
this->desired_positions[3] = 3. + 2. * this->p;
this->desired_positions[4] = 5.;
this->desired_positions[0] = float_type(1.);
this->desired_positions[1] = float_type(1.) + float_type(2.) * this->p;
this->desired_positions[2] = float_type(1.) + float_type(4.) * this->p;
this->desired_positions[3] = float_type(3.) + float_type(2.) * this->p;
this->desired_positions[4] = float_type(5.);
this->positions_increments[0] = 0.;
this->positions_increments[1] = this->p / 2.;
this->positions_increments[0] = float_type(0.);
this->positions_increments[1] = this->p / float_type(2.);
this->positions_increments[2] = this->p;
this->positions_increments[3] = (1. + this->p) / 2.;
this->positions_increments[4] = 1.;
this->positions_increments[3] = (float_type(1.) + this->p) / float_type(2.);
this->positions_increments[4] = float_type(1.);
}
template<typename Args>
@@ -156,7 +158,7 @@ namespace impl
float_type hp = (this->heights[i + 1] - this->heights[i]) / dp;
float_type hm = (this->heights[i - 1] - this->heights[i]) / dm;
if((d >= 1. && dp > 1.) || (d <= -1. && dm < -1.))
if((d >= float_type(1.) && dp > float_type(1.)) || (d <= float_type(-1.) && dm < float_type(-1.)))
{
short sign_d = static_cast<short>(d / std::abs(d));
@@ -171,11 +173,11 @@ namespace impl
else
{
// use linear formula
if(d > 0)
if(d > float_type(0))
{
this->heights[i] += hp;
}
if(d < 0)
if(d < float_type(0))
{
this->heights[i] -= hm;
}
@@ -191,6 +193,18 @@ namespace impl
return this->heights[2];
}
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that P did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & p;
ar & heights;
ar & actual_positions;
ar & desired_positions;
ar & positions_increments;
}
private:
float_type p; // the quantile probability p
array_type heights; // q_i

29
linx64/include/boost/accumulators/statistics/peaks_over_threshold.hpp
View File

@@ -181,6 +181,21 @@ namespace impl
return this->fit_parameters_;
}
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that threshold did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & Nu_;
ar & mu_;
ar & sigma2_;
ar & threshold_;
ar & get<0>(fit_parameters_);
ar & get<1>(fit_parameters_);
ar & get<2>(fit_parameters_);
ar & is_dirty_;
}
private:
std::size_t Nu_; // number of samples larger than threshold
mutable float_type mu_; // mean of Nu_ largest samples
@@ -291,6 +306,20 @@ namespace impl
return this->fit_parameters_;
}
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that threshold did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & mu_;
ar & sigma2_;
ar & threshold_probability_;
ar & get<0>(fit_parameters_);
ar & get<1>(fit_parameters_);
ar & get<2>(fit_parameters_);
ar & is_dirty_;
}
private:
mutable float_type mu_; // mean of samples above threshold u
mutable float_type sigma2_; // variance of samples above threshold u

7
linx64/include/boost/accumulators/statistics/pot_quantile.hpp
View File

@@ -80,6 +80,13 @@ namespace impl
, -xi_hat
) - 1.));
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sign_;
}
private:
short sign_; // if the fit parameters from the mirrored left tail extreme values are used, mirror back the result

8
linx64/include/boost/accumulators/statistics/pot_tail_mean.hpp
View File

@@ -90,6 +90,14 @@ namespace impl
is_same<LeftRight, left>::value ? args[quantile_probability] : 1. - args[quantile_probability]
, -xi_hat);
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sign_;
}
private:
short sign_; // if the fit parameters from the mirrored left tail extreme values are used, mirror back the result
};

4
linx64/include/boost/accumulators/statistics/rolling_count.hpp
View File

@@ -40,6 +40,10 @@ namespace impl
{
return static_cast<std::size_t>(rolling_window_plus1(args).size()) - is_rolling_window_plus1_full(args);
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
} // namespace impl

23
linx64/include/boost/accumulators/statistics/rolling_mean.hpp
View File

@@ -43,6 +43,10 @@ namespace boost { namespace accumulators
{
return numeric::fdiv(rolling_sum(args), rolling_count(args));
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
///////////////////////////////////////////////////////////////////////////////
@@ -67,12 +71,18 @@ namespace boost { namespace accumulators
{
if(is_rolling_window_plus1_full(args))
{
mean_ += numeric::fdiv(args[sample]-rolling_window_plus1(args).front(),rolling_count(args));
if (rolling_window_plus1(args).front() > args[sample])
mean_ -= numeric::fdiv(rolling_window_plus1(args).front()-args[sample],rolling_count(args));
else if (rolling_window_plus1(args).front() < args[sample])
mean_ += numeric::fdiv(args[sample]-rolling_window_plus1(args).front(),rolling_count(args));
}
else
{
result_type prev_mean = mean_;
mean_ += numeric::fdiv(args[sample]-prev_mean,rolling_count(args));
if (prev_mean > args[sample])
mean_ -= numeric::fdiv(prev_mean-args[sample],rolling_count(args));
else if (prev_mean < args[sample])
mean_ += numeric::fdiv(args[sample]-prev_mean,rolling_count(args));
}
}
@@ -81,6 +91,13 @@ namespace boost { namespace accumulators
{
return mean_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & mean_;
}
private:
@@ -176,4 +193,4 @@ namespace boost { namespace accumulators
};
}} // namespace boost::accumulators
#endif
#endif

7
linx64/include/boost/accumulators/statistics/rolling_moment.hpp
View File

@@ -58,6 +58,13 @@ namespace impl
return numeric::fdiv(this->sum_, rolling_count(args));
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum_;
}
private:
result_type sum_;
};

7
linx64/include/boost/accumulators/statistics/rolling_sum.hpp
View File

@@ -51,6 +51,13 @@ namespace impl
return this->sum_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum_;
}
private:
Sample sum_;
};

12
linx64/include/boost/accumulators/statistics/rolling_variance.hpp
View File

@@ -62,6 +62,10 @@ namespace impl
if (nr_samples < 2) return result_type();
return nr_samples*(rolling_moment<2>(args) - mean*mean)/(nr_samples-1);
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
//! Iterative calculation of the rolling variance.
@@ -138,6 +142,14 @@ namespace impl
if (nr_samples < 2) return result_type();
return numeric::fdiv(sum_of_squares_,(nr_samples-1));
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & previous_mean_;
ar & sum_of_squares_;
}
private:

49
linx64/include/boost/accumulators/statistics/rolling_window.hpp
View File

@@ -21,6 +21,45 @@
#include <boost/accumulators/framework/parameters/accumulator.hpp>
#include <boost/accumulators/numeric/functional.hpp>
#include <boost/accumulators/statistics_fwd.hpp>
#include <boost/serialization/split_free.hpp>
namespace boost { namespace serialization {
// implement serialization for boost::circular_buffer
template <class Archive, class T>
void save(Archive& ar, const circular_buffer<T>& b, const unsigned int /* version */)
{
typename circular_buffer<T>::size_type size = b.size();
ar << b.capacity();
ar << size;
const typename circular_buffer<T>::const_array_range one = b.array_one();
const typename circular_buffer<T>::const_array_range two = b.array_two();
ar.save_binary(one.first, one.second*sizeof(T));
ar.save_binary(two.first, two.second*sizeof(T));
}
template <class Archive, class T>
void load(Archive& ar, circular_buffer<T>& b, const unsigned int /* version */)
{
typename circular_buffer<T>::capacity_type capacity;
typename circular_buffer<T>::size_type size;
ar >> capacity;
b.set_capacity(capacity);
ar >> size;
b.clear();
const typename circular_buffer<T>::pointer buff = new T[size*sizeof(T)];
ar.load_binary(buff, size*sizeof(T));
b.insert(b.begin(), buff, buff+size);
delete[] buff;
}
template<class Archive, class T>
inline void serialize(Archive & ar, circular_buffer<T>& b, const unsigned int version)
{
split_free(ar, b, version);
}
} } // end namespace boost::serialization
namespace boost { namespace accumulators
{
@@ -83,6 +122,12 @@ namespace impl
return result_type(this->buffer_.begin(), this->buffer_.end());
}
template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
ar & buffer_;
}
private:
circular_buffer<Sample> buffer_;
};
@@ -112,6 +157,10 @@ namespace impl
{
return rolling_window_plus1(args).advance_begin(is_rolling_window_plus1_full(args));
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
} // namespace impl

4
linx64/include/boost/accumulators/statistics/skewness.hpp
View File

@@ -65,6 +65,10 @@ namespace impl
* std::sqrt( accumulators::moment<2>(args) - mean(args) * mean(args) )
);
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
} // namespace impl

7
linx64/include/boost/accumulators/statistics/sum.hpp
View File

@@ -51,8 +51,13 @@ namespace impl
return this->sum;
}
private:
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum;
}
private:
Sample sum;
};

8
linx64/include/boost/accumulators/statistics/sum_kahan.hpp
View File

@@ -66,6 +66,14 @@ struct sum_kahan_impl
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;

11
linx64/include/boost/accumulators/statistics/tail.hpp
View File

@@ -268,6 +268,17 @@ namespace impl
std::vector<Sample> const &samples;
};
public:
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & is_sorted;
ar & indices;
ar & samples;
}
private:
mutable bool is_sorted;
mutable std::vector<std::size_t> indices;
std::vector<Sample> samples;

8
linx64/include/boost/accumulators/statistics/tail_mean.hpp
View File

@@ -88,6 +88,10 @@ namespace impl
- numeric::fdiv(n, count(args))
);
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
///////////////////////////////////////////////////////////////////////////////
@@ -159,6 +163,10 @@ namespace impl
}
}
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
} // namespace impl

4
linx64/include/boost/accumulators/statistics/tail_quantile.hpp
View File

@@ -98,6 +98,10 @@ namespace impl
}
}
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
} // namespace impl

9
linx64/include/boost/accumulators/statistics/tail_variate.hpp
View File

@@ -18,6 +18,7 @@
#include <boost/accumulators/framework/depends_on.hpp>
#include <boost/accumulators/statistics_fwd.hpp>
#include <boost/accumulators/statistics/tail.hpp>
#include <boost/serialization/vector.hpp>
namespace boost { namespace accumulators
{
@@ -69,6 +70,14 @@ namespace impl
);
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & variates;
}
private:
std::vector<VariateType> variates;
};

8
linx64/include/boost/accumulators/statistics/tail_variate_means.hpp
View File

@@ -27,6 +27,7 @@
#include <boost/accumulators/statistics/tail_variate.hpp>
#include <boost/accumulators/statistics/tail_mean.hpp>
#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
#include <boost/serialization/vector.hpp>
#ifdef _MSC_VER
# pragma warning(push)
@@ -145,6 +146,13 @@ namespace impl
return make_iterator_range(this->tail_means_);
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & tail_means_;
}
private:
mutable array_type tail_means_;

11
linx64/include/boost/accumulators/statistics/variance.hpp
View File

@@ -53,6 +53,10 @@ namespace impl
result_type tmp = mean(args);
return accumulators::moment<2>(args) - tmp * tmp;
}
// serialization is done by accumulators it depends on
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version) {}
};
//! Iterative calculation of variance.
@@ -113,6 +117,13 @@ namespace impl
return this->variance;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & variance;
}
private:
result_type variance;
};

7
linx64/include/boost/accumulators/statistics/weighted_covariance.hpp
View File

@@ -97,6 +97,13 @@ namespace impl
return this->cov_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & cov_;
}
private:
result_type cov_;
};

16
linx64/include/boost/accumulators/statistics/weighted_density.hpp
View File

@@ -23,6 +23,8 @@
#include <boost/accumulators/statistics/max.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/density.hpp> // for named parameters density_cache_size and density_num_bins
#include <boost/serialization/vector.hpp>
#include <boost/serialization/utility.hpp>
namespace boost { namespace accumulators
{
@@ -171,6 +173,20 @@ namespace impl
return make_iterator_range(this->histogram);
}
// make this accumulator serializeable
// TODO split to save/load and check on parameters provided in ctor
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & cache_size;
ar & cache;
ar & num_bins;
ar & samples_in_bin;
ar & bin_positions;
ar & histogram;
ar & is_dirty;
}
private:
std::size_t cache_size; // number of cached samples
histogram_type cache; // cache to store the first cache_size samples with their weights as std::pair

12
linx64/include/boost/accumulators/statistics/weighted_extended_p_square.hpp
View File

@@ -28,6 +28,7 @@
#include <boost/accumulators/statistics/sum.hpp>
#include <boost/accumulators/statistics/times2_iterator.hpp>
#include <boost/accumulators/statistics/extended_p_square.hpp>
#include <boost/serialization/vector.hpp>
namespace boost { namespace accumulators
{
@@ -251,6 +252,17 @@ namespace impl
);
}
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that the parameters did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & probabilities;
ar & heights;
ar & actual_positions;
ar & desired_positions;
}
private:
array_type probabilities; // the quantile probabilities
array_type heights; // q_i

7
linx64/include/boost/accumulators/statistics/weighted_mean.hpp
View File

@@ -97,6 +97,13 @@ namespace impl
return this->mean;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & mean;
}
private:
result_type mean;
};

18
linx64/include/boost/accumulators/statistics/weighted_median.hpp
View File

@@ -106,6 +106,15 @@ namespace impl
return this->median;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum;
ar & is_dirty;
ar & median;
}
private:
mutable float_type sum;
mutable bool is_dirty;
@@ -162,6 +171,15 @@ namespace impl
return this->median;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & is_dirty;
ar & median;
}
private:
mutable bool is_dirty;
mutable float_type median;

7
linx64/include/boost/accumulators/statistics/weighted_moment.hpp
View File

@@ -60,6 +60,13 @@ namespace impl
return numeric::fdiv(this->sum, sum_of_weights(args));
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sum;
}
private:
weighted_sample sum;
};

13
linx64/include/boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp
View File

@@ -221,6 +221,19 @@ namespace impl
return make_iterator_range(this->histogram);
}
// make this accumulator serializeable
// TODO split to save/load and check on parameters provided in ctor
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & num_cells;
ar & heights;
ar & actual_positions;
ar & desired_positions;
ar & histogram;
ar & is_dirty;
}
private:
std::size_t num_cells; // number of cells b
array_type heights; // q_i

4
linx64/include/boost/accumulators/statistics/weighted_p_square_cumulative_distribution.hpp
View File

@@ -8,9 +8,9 @@
#ifndef BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_03_19_2012
#define BOOST_ACCUMULATORS_STATISTICS_WEIGHTED_P_SQUARE_CUMULATIVE_DISTRIBUTION_HPP_03_19_2012
#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
#if defined(_MSC_VER) || defined(__BORLANDC__) && !defined(__clang__) || defined(__DMC__)
# pragma message ("Warning: This header is deprecated. Please use: boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp")
#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__) || defined(__BORLANDC__)
# warning "This header is deprecated. Please use: boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp"
#endif

11
linx64/include/boost/accumulators/statistics/weighted_p_square_quantile.hpp
View File

@@ -208,6 +208,17 @@ namespace impl {
return this->heights[2];
}
// make this accumulator serializeable
// TODO split to save/load and check on parameters provided in ctor
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & p;
ar & heights;
ar & actual_positions;
ar & desired_positions;
}
private:
float_type p; // the quantile probability p
array_type heights; // q_i

13
linx64/include/boost/accumulators/statistics/weighted_peaks_over_threshold.hpp
View File

@@ -109,6 +109,19 @@ namespace impl
return this->fit_parameters_;
}
// make this accumulator serializeable
// TODO: do we need to split to load/save and verify that threshold did not change?
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & sign_;
ar & mu_;
ar & sigma2_;
ar & threshold_;
ar & fit_parameters_;
ar & is_dirty_;
}
private:
short sign_; // for left tail fitting, mirror the extreme values
mutable float_type mu_; // mean of samples above threshold

7
linx64/include/boost/accumulators/statistics/weighted_sum.hpp
View File

@@ -55,6 +55,13 @@ namespace impl
return this->weighted_sum_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & weighted_sum_;
}
private:
weighted_sample weighted_sum_;

8
linx64/include/boost/accumulators/statistics/weighted_sum_kahan.hpp
View File

@@ -68,6 +68,14 @@ namespace impl
return this->weighted_sum_;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & weighted_sum_;
ar & compensation;
}
private:
weighted_sample weighted_sum_;
weighted_sample compensation;

7
linx64/include/boost/accumulators/statistics/weighted_tail_variate_means.hpp
View File

@@ -179,6 +179,13 @@ namespace impl
return make_iterator_range(this->tail_means_);
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & tail_means_;
}
private:
mutable array_type tail_means_;

7
linx64/include/boost/accumulators/statistics/weighted_variance.hpp
View File

@@ -103,6 +103,13 @@ namespace impl
return this->weighted_variance;
}
// make this accumulator serializeable
template<class Archive>
void serialize(Archive & ar, const unsigned int file_version)
{
ar & weighted_variance;
}
private:
result_type weighted_variance;
};