stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
+3
-1
@@ -141,4 +141,6 @@ qrc_*.cpp
|
||||
# Misc
|
||||
# -----------------------------
|
||||
tags
|
||||
TAGS
|
||||
TAGS
|
||||
installer/logs/
|
||||
installer/tests/tmp/
|
||||
|
||||
+532
-532
File diff suppressed because it is too large
Load Diff
+321
-794
File diff suppressed because it is too large
Load Diff
Executable
+2519
File diff suppressed because it is too large
Load Diff
Executable
+10
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
set -e
|
||||
if [ $# -ne 3 ];
|
||||
then echo "usage: $0 <input> <stripped-binary> <debug-binary>"
|
||||
fi
|
||||
|
||||
/usr/bin/objcopy --enable-deterministic-archives -p --only-keep-debug $1 $3
|
||||
/usr/bin/objcopy --enable-deterministic-archives -p --strip-debug $1 $2
|
||||
/usr/bin/strip --enable-deterministic-archives -p -s $2
|
||||
/usr/bin/objcopy --enable-deterministic-archives -p --add-gnu-debuglink=$3 $2
|
||||
+13
-4
@@ -64,7 +64,7 @@ include funcs.mk
|
||||
# --------------------------------------------------------------------
|
||||
|
||||
.PHONY: all
|
||||
all: $(packages)
|
||||
all: install
|
||||
|
||||
# Optional convenience targets (only build what you need)
|
||||
.PHONY: base wallet zmq upnp qt
|
||||
@@ -83,8 +83,10 @@ download: $(addsuffix _fetched,$(all_packages))
|
||||
# and generate share/config.site for top-level ./configure.
|
||||
# --------------------------------------------------------------------
|
||||
|
||||
.PHONY: install install-clean reinstall
|
||||
install: all
|
||||
.PHONY: install install-clean reinstall install-prefix
|
||||
install: install-prefix
|
||||
|
||||
install-prefix: $(packages)
|
||||
@echo "== Installing depends into: $(host_prefix)"
|
||||
@rm -rf "$(host_prefix)"
|
||||
@mkdir -p "$(host_prefix)"
|
||||
@@ -102,10 +104,17 @@ install: all
|
||||
@mkdir -p "$(host_prefix)/share"
|
||||
@{ \
|
||||
echo "# Autoconf site defaults for Agrarian depends (generated)"; \
|
||||
echo "depends_prefix='$(host_prefix)'"; \
|
||||
echo "with_boost='$(host_prefix)'"; \
|
||||
echo "CPPFLAGS='-I$(host_prefix)/include'"; \
|
||||
echo "LDFLAGS='-L$(host_prefix)/lib'"; \
|
||||
echo "BOOST_CPPFLAGS='-I$(host_prefix)/include'"; \
|
||||
echo "BOOST_LDFLAGS='-L$(host_prefix)/lib'"; \
|
||||
echo "PKG_CONFIG='`which pkg-config` --static'"; \
|
||||
echo "PKG_CONFIG_LIBDIR='$(host_prefix)/lib/pkgconfig:$(host_prefix)/share/pkgconfig'"; \
|
||||
echo "PKG_CONFIG_PATH=\"$$PKG_CONFIG_LIBDIR\""; \
|
||||
echo "export PKG_CONFIG_LIBDIR"; \
|
||||
echo "export PKG_CONFIG_PATH"; \
|
||||
echo "BDB_CFLAGS='-I$(host_prefix)/include'"; \
|
||||
echo "BDB_LIBS='-L$(host_prefix)/lib -ldb_cxx-4.8 -ldb-4.8'"; \
|
||||
} > "$(host_prefix)/share/config.site"
|
||||
@@ -131,4 +140,4 @@ clean-cache: clean
|
||||
@rm -rf "$(BASE_CACHE)"
|
||||
|
||||
distclean: clean-cache
|
||||
@rm -rf "$(SOURCES_PATH)" "$(BASEDIR)/SDKs"
|
||||
@rm -rf "$(SOURCES_PATH)" "$(BASEDIR)/SDKs"
|
||||
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
412e5a7ef02f2b543b1c38c9df675b1009de60ecd9012f617d18c2fa1daa4979 bdb-4.8.30-df2bbef2.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
4dd485972c9dce0e3730b51595570e83c9988a4b8022c8b1b20a26410d07255b boost-1_64_0-435c48bb.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
4a9de30729a57712ede52a07eb779c3e5da2565776de22fe6d3b1bb48b24e526 gmp-6.1.2-a0c3cd6c.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
c8bbd13de351dec92df839faa1305ded3cf7cbabd94ddb9b89dfce14cb7f6966 libevent-2.1.8-stable-75430d39.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
ccc3f8517a3a8b40a7f5de62894a8ee2975b3f7586288312a5c41862f462700e miniupnpc-2.0.20180203-4b75ae22.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
e2f67e0ef8a22fdcad4973d4c275ab20eb9e4555210ef7cd4cfca2c5a760f662 openssl-1.0.1k-ad10dd7c.tar.gz
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
45a0fd2bc8dc796cba20bfd517d85225b8d989396026f20e8c3519f28197de51 bdb-4.8.30-245a0c79.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
00d47d8a14f0572c7132d469b74e2bccdfa679772dd4423e60b15dab7b90fdcf bdb-4.8.30-a0854a13.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
73544b5dc96aefbc5ced201b929707d84b5a5e6b8ea2c627a13c5bfbca923b0a boost-1_64_0-264637de.tar.gz
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
f7e3f26cacadb72d09cf76473722490ba3c6bceba23689cad3c42f63c528347d boost-1_64_0-54a38461.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
6db95612ea751fae63a53faaf803afbc2c01b03b07f47025a4ea268f9d9133c6 gmp-6.1.2-5783556c.tar.gz
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
cfd5e217da4a610fc0416a69a0334ca20ccc56705e43636c936a2c31f283db3a gmp-6.1.2-82367848.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
310dbc2e9f5140def1d60cc8395dfd82e85f6701041422d7ba3c1c9a3775afd6 libevent-2.1.8-stable-3b2691a6.tar.gz
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
e2107e41fa8a3c16456b4cfb6dbbb48788d76cdcb325aafeda3859854253ec48 libevent-2.1.8-stable-b0f3c944.tar.gz
|
||||
Binary file not shown.
-1
@@ -1 +0,0 @@
|
||||
165ff9c3683896b847d2f2105d8ad1b787164ed0de7c46ac751823cf906ff4e4 miniupnpc-2.0.20180203-29612468.tar.gz
|
||||
Binary file not shown.
+1
@@ -0,0 +1 @@
|
||||
bfec92e5cd42a4ea43077b99ecd5f5bddedf693277019218b1d714217268f1f6 miniupnpc-2.0.20180203-56020a03.tar.gz
|
||||
Binary file not shown.
@@ -0,0 +1 @@
|
||||
50efbdc75298a4df2db527d44207b2d463c5c1047c83081d5444a58ff16c55f5 openssl-1.0.1k-33f97c13.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
95569fc56cd838cdc5d6076a926017d1359cf8a8e0a358e28c494f66031d62d2 openssl-1.0.1k-5861b390.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
e68ccb227c634a1725d74fd5bc398093503f83b47badb36c7156490ff9d79b63 bdb-4.8.30-22e079e7.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
bacee41e1583a37f61acc9f4a5a449aebba007c61edd78fcca69d67112b52599 boost-1_64_0-0c65b3a0.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
ab3124c21687f21053168f74b1ff43bbe9f4e37e1f83e7041b1d1ebbe2887d3e gmp-6.1.2-0410e67a.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
e2c7bb2365760b5863561dbe5b6b8e32ad2146fdedaea3dfff96b864a55fc53b libevent-2.1.8-stable-3c8fbf74.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
17fbf8c83c57732c7b34283f9356ecd4c18673124d4b8e30e6dc3a42dcd1aac5 miniupnpc-2.0.20180203-07b315a2.tar.gz
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
25f8d118ea6292b8863f7a43387cf92f68d13d61aecdc5b9b1afceee95a65a28 openssl-1.0.1k-49e8f834.tar.gz
|
||||
@@ -10,7 +10,7 @@ $(package)_sha256_hash=7bcc5caace97baa948931d712ea5f37038dbb1c5d89b43ad4def4ed7c
|
||||
define $(package)_set_vars
|
||||
$(package)_config_opts_release=variant=release
|
||||
$(package)_config_opts_debug=variant=debug
|
||||
$(package)_config_opts=--layout=versioned --build-type=complete --user-config=user-config.jam
|
||||
$(package)_config_opts=--layout=system --user-config=user-config.jam
|
||||
$(package)_config_opts+=threading=multi link=static -sNO_BZIP2=1 -sNO_ZLIB=1
|
||||
$(package)_config_opts_linux=threadapi=pthread runtime-link=shared
|
||||
$(package)_config_opts_darwin=--toolset=darwin-4.2.1 runtime-link=shared
|
||||
@@ -45,4 +45,4 @@ endef
|
||||
|
||||
define $(package)_stage_cmds
|
||||
./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install
|
||||
endef
|
||||
endef
|
||||
|
||||
+1728
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,27 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file accumulators.hpp
|
||||
/// Includes all of the Accumulators Framework
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_ACCUMULATORS_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_ACCUMULATORS_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/accumulators/framework/accumulator_set.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_concept.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/external.hpp>
|
||||
#include <boost/accumulators/framework/features.hpp>
|
||||
#include <boost/accumulators/framework/parameters/accumulator.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/parameters/weight.hpp>
|
||||
#include <boost/accumulators/framework/parameters/weights.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/droppable_accumulator.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/reference_accumulator.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/value_accumulator.hpp>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,230 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulators_fwd.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_ACCUMULATORS_FWD_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_ACCUMULATORS_FWD_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/mpl/apply_fwd.hpp> // for mpl::na
|
||||
#include <boost/mpl/limits/vector.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/accumulators/numeric/functional_fwd.hpp>
|
||||
|
||||
#ifndef BOOST_ACCUMULATORS_MAX_FEATURES
|
||||
/// The maximum number of accumulators that may be put in an accumulator_set.
|
||||
/// Defaults to BOOST_MPL_LIMIT_VECTOR_SIZE (which defaults to 20).
|
||||
# define BOOST_ACCUMULATORS_MAX_FEATURES BOOST_MPL_LIMIT_VECTOR_SIZE
|
||||
#endif
|
||||
|
||||
#if BOOST_ACCUMULATORS_MAX_FEATURES > BOOST_MPL_LIMIT_VECTOR_SIZE
|
||||
# error BOOST_ACCUMULATORS_MAX_FEATURES cannot be larger than BOOST_MPL_LIMIT_VECTOR_SIZE
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_ACCUMULATORS_MAX_ARGS
|
||||
/// The maximum number of arguments that may be specified to an accumulator_set's
|
||||
/// accumulation function. Defaults to 15.
|
||||
# define BOOST_ACCUMULATORS_MAX_ARGS 15
|
||||
#endif
|
||||
|
||||
#if BOOST_WORKAROUND(__GNUC__, == 3) \
|
||||
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(306))
|
||||
# define BOOST_ACCUMULATORS_BROKEN_CONST_OVERLOADS
|
||||
#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
|
||||
#else
|
||||
# define BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(T)
|
||||
#endif
|
||||
|
||||
#define BOOST_ACCUMULATORS_GCC_VERSION \
|
||||
(__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Named parameters tags
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct sample;
|
||||
struct weight;
|
||||
struct accumulator;
|
||||
struct weights;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// User-level features
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
template<typename ValueType, typename Tag>
|
||||
struct value;
|
||||
|
||||
template<typename Tag>
|
||||
struct value_tag;
|
||||
|
||||
template<typename Referent, typename Tag>
|
||||
struct reference;
|
||||
|
||||
template<typename Tag>
|
||||
struct reference_tag;
|
||||
|
||||
template<typename Type, typename Tag = void, typename AccumulatorSet = void>
|
||||
struct external;
|
||||
|
||||
template<typename Feature>
|
||||
struct droppable;
|
||||
}
|
||||
|
||||
template<typename Accumulator>
|
||||
struct droppable_accumulator_base;
|
||||
|
||||
template<typename Accumulator>
|
||||
struct droppable_accumulator;
|
||||
|
||||
template<typename Accumulator>
|
||||
struct with_cached_result;
|
||||
|
||||
template<typename Sample, typename Features, typename Weight = void>
|
||||
struct accumulator_set;
|
||||
|
||||
template<typename Feature>
|
||||
struct extractor;
|
||||
|
||||
template<typename Feature>
|
||||
struct feature_of;
|
||||
|
||||
template<typename Feature>
|
||||
struct as_feature;
|
||||
|
||||
template<typename Feature>
|
||||
struct as_weighted_feature;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature, mpl::na)>
|
||||
struct depends_on;
|
||||
|
||||
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature, mpl::na)>
|
||||
struct features;
|
||||
|
||||
template<typename Feature, typename AccumulatorSet>
|
||||
typename mpl::apply<AccumulatorSet, Feature>::type const &
|
||||
find_accumulator(AccumulatorSet const &acc);
|
||||
|
||||
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);
|
||||
|
||||
// ... other overloads generated by Boost.Preprocessor:
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_EXTRACT_RESULT_FWD(z, n, _) \
|
||||
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) \
|
||||
);
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
2
|
||||
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
|
||||
, 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
|
||||
extract_result(AccumulatorSet const &acc, A1 const &a1, A2 const &a2 ...);
|
||||
#endif
|
||||
|
||||
namespace impl
|
||||
{
|
||||
using namespace numeric::operators;
|
||||
|
||||
template<typename Accumulator, typename Tag>
|
||||
struct external_impl;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Accumulator>
|
||||
struct feature_tag;
|
||||
|
||||
template<typename Feature, typename Sample, typename Weight>
|
||||
struct to_accumulator;
|
||||
|
||||
struct accumulator_set_base;
|
||||
|
||||
template<typename T>
|
||||
struct is_accumulator_set;
|
||||
|
||||
inline void ignore_variable(void const *) {}
|
||||
|
||||
#define BOOST_ACCUMULATORS_IGNORE_GLOBAL(X) \
|
||||
namespace detail \
|
||||
{ \
|
||||
struct BOOST_PP_CAT(ignore_, X) \
|
||||
{ \
|
||||
void ignore() \
|
||||
{ \
|
||||
boost::accumulators::detail::ignore_variable(&X); \
|
||||
} \
|
||||
}; \
|
||||
} \
|
||||
/**/
|
||||
}
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
// 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
|
||||
@@ -0,0 +1,65 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulator_base.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_ACCUMULATORS_BASE_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_BASE_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/mpl/joint_view.hpp>
|
||||
#include <boost/mpl/single_view.hpp>
|
||||
#include <boost/mpl/fold.hpp>
|
||||
#include <boost/mpl/contains.hpp>
|
||||
#include <boost/mpl/empty_sequence.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_concept.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
typedef void void_;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// dont_care
|
||||
//
|
||||
struct dont_care
|
||||
{
|
||||
template<typename Args>
|
||||
dont_care(Args const &)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulator_base
|
||||
//
|
||||
struct accumulator_base
|
||||
{
|
||||
// hidden if defined in derived classes
|
||||
detail::void_ operator ()(dont_care)
|
||||
{
|
||||
}
|
||||
|
||||
typedef mpl::false_ is_droppable;
|
||||
|
||||
detail::void_ add_ref(dont_care)
|
||||
{
|
||||
}
|
||||
|
||||
detail::void_ drop(dont_care)
|
||||
{
|
||||
}
|
||||
|
||||
detail::void_ on_drop(dont_care)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulator_concept.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_ACCUMULATOR_CONCEPT_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_CONCEPT_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
template<typename Stat>
|
||||
struct accumulator_concept
|
||||
{
|
||||
void constraints()
|
||||
{
|
||||
// TODO: define the stat concept
|
||||
}
|
||||
|
||||
Stat stat;
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,401 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulator_set.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_ACCUMULATOR_SET_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATOR_SET_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/version.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/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_concept.hpp>
|
||||
#include <boost/accumulators/framework/parameters/accumulator.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/droppable_accumulator.hpp>
|
||||
#include <boost/fusion/include/any.hpp>
|
||||
#include <boost/fusion/include/find_if.hpp>
|
||||
#include <boost/fusion/include/for_each.hpp>
|
||||
#include <boost/fusion/include/filter_view.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulator_visitor
|
||||
// wrap a boost::parameter argument pack in a Fusion extractor object
|
||||
template<typename Args>
|
||||
struct accumulator_visitor
|
||||
{
|
||||
explicit accumulator_visitor(Args const &a)
|
||||
: args(a)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Accumulator>
|
||||
void operator ()(Accumulator &accumulator) const
|
||||
{
|
||||
accumulator(this->args);
|
||||
}
|
||||
|
||||
private:
|
||||
accumulator_visitor &operator =(accumulator_visitor const &);
|
||||
Args const &args;
|
||||
};
|
||||
|
||||
template<typename Args>
|
||||
inline accumulator_visitor<Args> const make_accumulator_visitor(Args const &args)
|
||||
{
|
||||
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
|
||||
{
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// is_accumulator_set
|
||||
template<typename T>
|
||||
struct is_accumulator_set
|
||||
: is_base_and_derived<accumulator_set_base, T>
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \brief A set of accumulators.
|
||||
///
|
||||
/// accumulator_set resolves the dependencies between features and ensures that
|
||||
/// the accumulators in the set are updated in the proper order.
|
||||
///
|
||||
/// acccumulator_set provides a general mechanism to visit the accumulators
|
||||
/// in the set in order, with or without a filter. You can also fetch a reference
|
||||
/// to an accumulator that corresponds to a feature.
|
||||
///
|
||||
template<typename Sample, typename Features, typename Weight>
|
||||
struct accumulator_set
|
||||
: detail::accumulator_set_base
|
||||
{
|
||||
typedef Sample sample_type; ///< The type of the samples that will be accumulated
|
||||
typedef Features features_type; ///< An MPL sequence of the features that should be accumulated.
|
||||
typedef Weight weight_type; ///< The type of the weight parameter. Must be a scalar. Defaults to void.
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef
|
||||
typename detail::make_accumulator_tuple<
|
||||
Features
|
||||
, Sample
|
||||
, Weight
|
||||
>::type
|
||||
accumulators_mpl_vector;
|
||||
|
||||
// generate a fusion::list of accumulators
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef
|
||||
typename detail::meta::make_acc_list<
|
||||
accumulators_mpl_vector
|
||||
>::type
|
||||
accumulators_type;
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
//BOOST_MPL_ASSERT((mpl::is_sequence<accumulators_type>));
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// default-construct all contained accumulators
|
||||
accumulator_set()
|
||||
: accumulators(
|
||||
detail::make_acc_list(
|
||||
accumulators_mpl_vector()
|
||||
, detail::accumulator_params()(*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))
|
||||
);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
/// \param a1 Optional named parameter to be passed to all the accumulators
|
||||
template<typename A1>
|
||||
explicit accumulator_set(A1 const &a1)
|
||||
: accumulators(
|
||||
detail::make_acc_list(
|
||||
accumulators_mpl_vector()
|
||||
, detail::accumulator_params()(*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))
|
||||
);
|
||||
}
|
||||
|
||||
// ... other overloads generated by Boost.Preprocessor:
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#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( \
|
||||
detail::make_acc_list( \
|
||||
accumulators_mpl_vector() \
|
||||
, detail::accumulator_params()( \
|
||||
*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)) \
|
||||
); \
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
2
|
||||
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
|
||||
, BOOST_ACCUMULATORS_ACCUMULATOR_SET_CTOR
|
||||
, _
|
||||
)
|
||||
|
||||
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
||||
/// \overload
|
||||
///
|
||||
template<typename A1, typename A2, ...>
|
||||
accumulator_set(A1 const &a1, A2 const &a2, ...);
|
||||
#endif
|
||||
|
||||
// ... other overloads generated by Boost.Preprocessor below ...
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Visitation
|
||||
/// \param func UnaryFunction which is invoked with each accumulator in turn.
|
||||
template<typename UnaryFunction>
|
||||
void visit(UnaryFunction const &func)
|
||||
{
|
||||
fusion::for_each(this->accumulators, func);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Conditional visitation
|
||||
/// \param func UnaryFunction which is invoked with each accumulator in turn,
|
||||
/// provided the accumulator satisfies the MPL predicate FilterPred.
|
||||
template<typename FilterPred, typename UnaryFunction>
|
||||
void visit_if(UnaryFunction const &func)
|
||||
{
|
||||
fusion::filter_view<accumulators_type, FilterPred> filtered_accs(this->accumulators);
|
||||
fusion::for_each(filtered_accs, func);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// The return type of the operator() overloads is void.
|
||||
typedef void result_type;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Accumulation
|
||||
/// \param a1 Optional named parameter to be passed to all the accumulators
|
||||
void operator ()()
|
||||
{
|
||||
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)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// ... other overloads generated by Boost.Preprocessor:
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#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)) \
|
||||
{ \
|
||||
this->visit( \
|
||||
detail::make_accumulator_visitor( \
|
||||
detail::accumulator_params()( \
|
||||
*this BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
|
||||
) \
|
||||
) \
|
||||
); \
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
2
|
||||
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
|
||||
, BOOST_ACCUMULATORS_ACCUMULATOR_SET_FUN_OP
|
||||
, _
|
||||
)
|
||||
|
||||
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
||||
/// \overload
|
||||
///
|
||||
template<typename A1, typename A2, ...>
|
||||
void operator ()(A1 const &a1, A2 const &a2, ...);
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Extraction
|
||||
template<typename Feature>
|
||||
struct apply
|
||||
: fusion::result_of::value_of<
|
||||
typename fusion::result_of::find_if<
|
||||
accumulators_type
|
||||
, detail::matches_feature<Feature>
|
||||
>::type
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Extraction
|
||||
template<typename Feature>
|
||||
typename apply<Feature>::type &extract()
|
||||
{
|
||||
return *fusion::find_if<detail::matches_feature<Feature> >(this->accumulators);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<typename Feature>
|
||||
typename apply<Feature>::type const &extract() const
|
||||
{
|
||||
return *fusion::find_if<detail::matches_feature<Feature> >(this->accumulators);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Drop
|
||||
template<typename Feature>
|
||||
void drop()
|
||||
{
|
||||
// You can only drop the features that you have specified explicitly
|
||||
typedef typename apply<Feature>::type the_accumulator;
|
||||
BOOST_MPL_ASSERT((detail::contains_feature_of<Features, the_accumulator>));
|
||||
|
||||
typedef
|
||||
typename feature_of<typename as_feature<Feature>::type>::type
|
||||
the_feature;
|
||||
|
||||
(*fusion::find_if<detail::matches_feature<Feature> >(this->accumulators))
|
||||
.drop(detail::accumulator_params()(*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))
|
||||
);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
accumulators_type accumulators;
|
||||
};
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// find_accumulator
|
||||
// find an accumulator in an accumulator_set corresponding to a feature
|
||||
template<typename Feature, typename AccumulatorSet>
|
||||
typename mpl::apply<AccumulatorSet, Feature>::type &
|
||||
find_accumulator(AccumulatorSet &acc BOOST_ACCUMULATORS_PROTO_DISABLE_IF_IS_CONST(AccumulatorSet))
|
||||
{
|
||||
return acc.template extract<Feature>();
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<typename Feature, typename AccumulatorSet>
|
||||
typename mpl::apply<AccumulatorSet, Feature>::type const &
|
||||
find_accumulator(AccumulatorSet const &acc)
|
||||
{
|
||||
return acc.template extract<Feature>();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract_result
|
||||
// extract a result from an accumulator set
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_EXTRACT_RESULT_FUN(z, n, _) \
|
||||
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) \
|
||||
) \
|
||||
{ \
|
||||
return find_accumulator<Feature>(acc).result( \
|
||||
detail::accumulator_params()( \
|
||||
acc \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a) \
|
||||
) \
|
||||
); \
|
||||
}
|
||||
|
||||
BOOST_PP_REPEAT(
|
||||
BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
|
||||
, BOOST_ACCUMULATORS_EXTRACT_RESULT_FUN
|
||||
, _
|
||||
)
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+328
@@ -0,0 +1,328 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// droppable_accumulator.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_ACCUMULATORS_DROPPABLE_ACCUMULATOR_HPP_EAN_13_12_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_DROPPABLE_ACCUMULATOR_HPP_EAN_13_12_2005
|
||||
|
||||
#include <new>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/mpl/apply.hpp>
|
||||
#include <boost/aligned_storage.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp> // for feature_of
|
||||
#include <boost/accumulators/framework/parameters/accumulator.hpp> // for accumulator
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
template<typename Accumulator>
|
||||
struct droppable_accumulator;
|
||||
|
||||
namespace detail
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// add_ref_visitor
|
||||
// a fusion function object for add_ref'ing accumulators
|
||||
template<typename Args>
|
||||
struct add_ref_visitor
|
||||
{
|
||||
explicit add_ref_visitor(Args const &args)
|
||||
: args_(args)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Accumulator>
|
||||
void operator ()(Accumulator &acc) const
|
||||
{
|
||||
typedef typename Accumulator::feature_tag::dependencies dependencies;
|
||||
|
||||
acc.add_ref(this->args_);
|
||||
|
||||
// Also add_ref accumulators that this feature depends on
|
||||
this->args_[accumulator].template
|
||||
visit_if<detail::contains_feature_of_<dependencies> >(
|
||||
*this
|
||||
);
|
||||
}
|
||||
|
||||
private:
|
||||
add_ref_visitor &operator =(add_ref_visitor const &);
|
||||
Args const &args_;
|
||||
};
|
||||
|
||||
template<typename Args>
|
||||
add_ref_visitor<Args> make_add_ref_visitor(Args const &args)
|
||||
{
|
||||
return add_ref_visitor<Args>(args);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// drop_visitor
|
||||
// a fusion function object for dropping accumulators
|
||||
template<typename Args>
|
||||
struct drop_visitor
|
||||
{
|
||||
explicit drop_visitor(Args const &args)
|
||||
: args_(args)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Accumulator>
|
||||
void operator ()(Accumulator &acc) const
|
||||
{
|
||||
if(typename Accumulator::is_droppable())
|
||||
{
|
||||
typedef typename Accumulator::feature_tag::dependencies dependencies;
|
||||
|
||||
acc.drop(this->args_);
|
||||
// Also drop accumulators that this feature depends on
|
||||
this->args_[accumulator].template
|
||||
visit_if<detail::contains_feature_of_<dependencies> >(
|
||||
*this
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
drop_visitor &operator =(drop_visitor const &);
|
||||
Args const &args_;
|
||||
};
|
||||
|
||||
template<typename Args>
|
||||
drop_visitor<Args> make_drop_visitor(Args const &args)
|
||||
{
|
||||
return drop_visitor<Args>(args);
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// droppable_accumulator_base
|
||||
template<typename Accumulator>
|
||||
struct droppable_accumulator_base
|
||||
: Accumulator
|
||||
{
|
||||
typedef droppable_accumulator_base base;
|
||||
typedef mpl::true_ is_droppable;
|
||||
typedef typename Accumulator::result_type result_type;
|
||||
|
||||
template<typename Args>
|
||||
droppable_accumulator_base(Args const &args)
|
||||
: Accumulator(args)
|
||||
, ref_count_(0)
|
||||
{
|
||||
}
|
||||
|
||||
droppable_accumulator_base(droppable_accumulator_base const &that)
|
||||
: Accumulator(*static_cast<Accumulator const *>(&that))
|
||||
, ref_count_(that.ref_count_)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
if(!this->is_dropped())
|
||||
{
|
||||
this->Accumulator::operator ()(args);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void add_ref(Args const &)
|
||||
{
|
||||
++this->ref_count_;
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void drop(Args const &args)
|
||||
{
|
||||
BOOST_ASSERT(0 < this->ref_count_);
|
||||
if(1 == this->ref_count_)
|
||||
{
|
||||
static_cast<droppable_accumulator<Accumulator> *>(this)->on_drop(args);
|
||||
}
|
||||
--this->ref_count_;
|
||||
}
|
||||
|
||||
bool is_dropped() const
|
||||
{
|
||||
return 0 == this->ref_count_;
|
||||
}
|
||||
|
||||
private:
|
||||
int ref_count_;
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// droppable_accumulator
|
||||
// this can be specialized for any type that needs special handling
|
||||
template<typename Accumulator>
|
||||
struct droppable_accumulator
|
||||
: droppable_accumulator_base<Accumulator>
|
||||
{
|
||||
template<typename Args>
|
||||
droppable_accumulator(Args const &args)
|
||||
: droppable_accumulator::base(args)
|
||||
{
|
||||
}
|
||||
|
||||
droppable_accumulator(droppable_accumulator const &that)
|
||||
: droppable_accumulator::base(*static_cast<typename droppable_accumulator::base const *>(&that))
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// with_cached_result
|
||||
template<typename Accumulator>
|
||||
struct with_cached_result
|
||||
: Accumulator
|
||||
{
|
||||
typedef typename Accumulator::result_type result_type;
|
||||
|
||||
template<typename Args>
|
||||
with_cached_result(Args const &args)
|
||||
: Accumulator(args)
|
||||
, cache()
|
||||
{
|
||||
}
|
||||
|
||||
with_cached_result(with_cached_result const &that)
|
||||
: Accumulator(*static_cast<Accumulator const *>(&that))
|
||||
, cache()
|
||||
{
|
||||
if(that.has_result())
|
||||
{
|
||||
this->set(that.get());
|
||||
}
|
||||
}
|
||||
|
||||
~with_cached_result()
|
||||
{
|
||||
// Since this is a base class of droppable_accumulator_base,
|
||||
// this destructor is called before any of droppable_accumulator_base's
|
||||
// members get cleaned up, including is_dropped, so the following
|
||||
// call to has_result() is valid.
|
||||
if(this->has_result())
|
||||
{
|
||||
this->get().~result_type();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void on_drop(Args const &args)
|
||||
{
|
||||
// cache the result at the point this calculation was dropped
|
||||
BOOST_ASSERT(!this->has_result());
|
||||
this->set(this->Accumulator::result(args));
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
return this->has_result() ? this->get() : this->Accumulator::result(args);
|
||||
}
|
||||
|
||||
private:
|
||||
with_cached_result &operator =(with_cached_result const &);
|
||||
|
||||
void set(result_type const &r)
|
||||
{
|
||||
::new(this->cache.address()) result_type(r);
|
||||
}
|
||||
|
||||
result_type const &get() const
|
||||
{
|
||||
return *static_cast<result_type const *>(this->cache.address());
|
||||
}
|
||||
|
||||
bool has_result() const
|
||||
{
|
||||
typedef with_cached_result<Accumulator> this_type;
|
||||
typedef droppable_accumulator_base<this_type> derived_type;
|
||||
return static_cast<derived_type const *>(this)->is_dropped();
|
||||
}
|
||||
|
||||
aligned_storage<sizeof(result_type)> cache;
|
||||
};
|
||||
|
||||
namespace tag
|
||||
{
|
||||
template<typename Feature>
|
||||
struct as_droppable
|
||||
{
|
||||
typedef droppable<Feature> type;
|
||||
};
|
||||
|
||||
template<typename Feature>
|
||||
struct as_droppable<droppable<Feature> >
|
||||
{
|
||||
typedef droppable<Feature> type;
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// droppable
|
||||
template<typename Feature>
|
||||
struct droppable
|
||||
: as_feature<Feature>::type
|
||||
{
|
||||
typedef typename as_feature<Feature>::type feature_type;
|
||||
typedef typename feature_type::dependencies tmp_dependencies_;
|
||||
|
||||
typedef
|
||||
typename mpl::transform<
|
||||
typename feature_type::dependencies
|
||||
, as_droppable<mpl::_1>
|
||||
>::type
|
||||
dependencies;
|
||||
|
||||
struct impl
|
||||
{
|
||||
template<typename Sample, typename Weight>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
droppable_accumulator<
|
||||
typename mpl::apply2<typename feature_type::impl, Sample, Weight>::type
|
||||
>
|
||||
type;
|
||||
};
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
// make droppable<tag::feature(modifier)> work
|
||||
template<typename Feature>
|
||||
struct as_feature<tag::droppable<Feature> >
|
||||
{
|
||||
typedef tag::droppable<typename as_feature<Feature>::type> type;
|
||||
};
|
||||
|
||||
// make droppable<tag::mean> work with non-void weights (should become
|
||||
// droppable<tag::weighted_mean>
|
||||
template<typename Feature>
|
||||
struct as_weighted_feature<tag::droppable<Feature> >
|
||||
{
|
||||
typedef tag::droppable<typename as_weighted_feature<Feature>::type> type;
|
||||
};
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// droppable<Foo> provides the same feature as Foo
|
||||
template<typename Feature>
|
||||
struct feature_of<tag::droppable<Feature> >
|
||||
: feature_of<Feature>
|
||||
{
|
||||
};
|
||||
|
||||
// Note: Usually, the extractor is pulled into the accumulators namespace with
|
||||
// a using directive, not the tag. But the droppable<> feature doesn't have an
|
||||
// extractor, so we can put the droppable tag in the accumulators namespace
|
||||
// without fear of a name conflict.
|
||||
using tag::droppable;
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+108
@@ -0,0 +1,108 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// external_accumulator.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_ACCUMULATORS_EXTERNAL_ACCUMULATOR_HPP_EAN_01_12_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_EXTERNAL_ACCUMULATOR_HPP_EAN_01_12_2005
|
||||
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/reference_accumulator.hpp>
|
||||
|
||||
namespace boost { namespace accumulators { namespace impl
|
||||
{
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// external_impl
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Accumulator, typename Tag>
|
||||
struct external_impl
|
||||
: accumulator_base
|
||||
{
|
||||
typedef typename Accumulator::result_type result_type;
|
||||
typedef typename detail::feature_tag<Accumulator>::type feature_tag;
|
||||
|
||||
external_impl(dont_care) {}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
return this->extract_(args, args[parameter::keyword<Tag>::get() | 0]);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template<typename Args>
|
||||
static result_type extract_(Args const &args, int)
|
||||
{
|
||||
// No named parameter passed to the extractor. Maybe the external
|
||||
// feature is held by reference<>.
|
||||
extractor<feature_tag> extract;
|
||||
return extract(accumulators::reference_tag<Tag>(args));
|
||||
}
|
||||
|
||||
template<typename Args, typename AccumulatorSet>
|
||||
static result_type extract_(Args const &, AccumulatorSet const &acc)
|
||||
{
|
||||
// OK, a named parameter for this external feature was passed to the
|
||||
// extractor, so use that.
|
||||
extractor<feature_tag> extract;
|
||||
return extract(acc);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
namespace tag
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// external
|
||||
template<typename Feature, typename Tag, typename AccumulatorSet>
|
||||
struct external
|
||||
: depends_on<reference<AccumulatorSet, Tag> >
|
||||
{
|
||||
typedef
|
||||
accumulators::impl::external_impl<
|
||||
detail::to_accumulator<Feature, mpl::_1, mpl::_2>
|
||||
, Tag
|
||||
>
|
||||
impl;
|
||||
};
|
||||
|
||||
template<typename Feature, typename Tag>
|
||||
struct external<Feature, Tag, void>
|
||||
: depends_on<>
|
||||
{
|
||||
typedef
|
||||
accumulators::impl::external_impl<
|
||||
detail::to_accumulator<Feature, mpl::_1, mpl::_2>
|
||||
, Tag
|
||||
>
|
||||
impl;
|
||||
};
|
||||
}
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// external_accumulator<Feature, Tag> provides the same feature as Feature
|
||||
template<typename Feature, typename Tag, typename AccumulatorSet>
|
||||
struct feature_of<tag::external<Feature, Tag, AccumulatorSet> >
|
||||
: feature_of<Feature>
|
||||
{
|
||||
};
|
||||
|
||||
// Note: Usually, the extractor is pulled into the accumulators namespace with
|
||||
// a using directive, not the tag. But the external<> feature doesn't have an
|
||||
// extractor, so we can put the external tag in the accumulators namespace
|
||||
// without fear of a name conflict.
|
||||
using tag::external;
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+89
@@ -0,0 +1,89 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// reference_accumulator.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_ACCUMULATORS_REFERENCE_ACCUMULATOR_HPP_EAN_03_23_2006
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_REFERENCE_ACCUMULATOR_HPP_EAN_03_23_2006
|
||||
|
||||
#include <boost/ref.hpp>
|
||||
#include <boost/mpl/always.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// reference_accumulator_impl
|
||||
//
|
||||
template<typename Referent, typename Tag>
|
||||
struct reference_accumulator_impl
|
||||
: accumulator_base
|
||||
{
|
||||
typedef Referent &result_type;
|
||||
|
||||
template<typename Args>
|
||||
reference_accumulator_impl(Args const &args)
|
||||
: ref(args[parameter::keyword<Tag>::get()])
|
||||
{
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->ref;
|
||||
}
|
||||
|
||||
private:
|
||||
reference_wrapper<Referent> ref;
|
||||
};
|
||||
} // namespace impl
|
||||
|
||||
namespace tag
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// reference_tag
|
||||
template<typename Tag>
|
||||
struct reference_tag
|
||||
{
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// reference
|
||||
template<typename Referent, typename Tag>
|
||||
struct reference
|
||||
: depends_on<>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef mpl::always<accumulators::impl::reference_accumulator_impl<Referent, Tag> > impl;
|
||||
};
|
||||
}
|
||||
|
||||
namespace extract
|
||||
{
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference, (typename)(typename))
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference_tag, (typename))
|
||||
}
|
||||
|
||||
using extract::reference;
|
||||
using extract::reference_tag;
|
||||
|
||||
// Map all reference<V,T> features to reference_tag<T> so
|
||||
// that references can be extracted using reference_tag<T>
|
||||
// without specifying the referent type.
|
||||
template<typename ValueType, typename Tag>
|
||||
struct feature_of<tag::reference<ValueType, Tag> >
|
||||
: feature_of<tag::reference_tag<Tag> >
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+89
@@ -0,0 +1,89 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// value_accumulator.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler, Daniel Egloff. 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_FRAMEWORK_ACCUMULATORS_VALUE_ACCUMULATOR_HPP_EAN_03_23_2006
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_VALUE_ACCUMULATOR_HPP_EAN_03_23_2006
|
||||
|
||||
#include <boost/mpl/always.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// value_accumulator_impl
|
||||
template<typename ValueType, typename Tag>
|
||||
struct value_accumulator_impl
|
||||
: accumulator_base
|
||||
{
|
||||
typedef ValueType result_type;
|
||||
|
||||
template<typename Args>
|
||||
value_accumulator_impl(Args const &args)
|
||||
: val(args[parameter::keyword<Tag>::get()])
|
||||
{
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->val;
|
||||
}
|
||||
|
||||
private:
|
||||
ValueType val;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
namespace tag
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// value_tag
|
||||
template<typename Tag>
|
||||
struct value_tag
|
||||
{
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// value
|
||||
template<typename ValueType, typename Tag>
|
||||
struct value
|
||||
: depends_on<>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef mpl::always<accumulators::impl::value_accumulator_impl<ValueType, Tag> > impl;
|
||||
};
|
||||
}
|
||||
|
||||
namespace extract
|
||||
{
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value, (typename)(typename))
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value_tag, (typename))
|
||||
}
|
||||
|
||||
using extract::value;
|
||||
using extract::value_tag;
|
||||
|
||||
// Map all value<V,T> features to value_tag<T> so
|
||||
// that values can be extracted using value_tag<T>
|
||||
// without specifying the value type.
|
||||
template<typename ValueType, typename Tag>
|
||||
struct feature_of<tag::value<ValueType, Tag> >
|
||||
: feature_of<tag::value_tag<Tag> >
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,448 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// depends_on.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_DEPENDS_ON_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_DEPENDS_ON_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/version.hpp>
|
||||
#include <boost/mpl/end.hpp>
|
||||
#include <boost/mpl/map.hpp>
|
||||
#include <boost/mpl/set.hpp>
|
||||
#include <boost/mpl/copy.hpp>
|
||||
#include <boost/mpl/fold.hpp>
|
||||
#include <boost/mpl/size.hpp>
|
||||
#include <boost/mpl/sort.hpp>
|
||||
#include <boost/mpl/insert.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/mpl/remove.hpp>
|
||||
#include <boost/mpl/vector.hpp>
|
||||
#include <boost/mpl/inherit.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/contains.hpp>
|
||||
#include <boost/mpl/transform.hpp>
|
||||
#include <boost/mpl/is_sequence.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/mpl/insert_range.hpp>
|
||||
#include <boost/mpl/back_inserter.hpp>
|
||||
#include <boost/mpl/transform_view.hpp>
|
||||
#include <boost/mpl/inherit_linearly.hpp>
|
||||
#include <boost/type_traits/is_base_and_derived.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
#include <boost/fusion/include/next.hpp>
|
||||
#include <boost/fusion/include/equal_to.hpp>
|
||||
#include <boost/fusion/include/value_of.hpp>
|
||||
#include <boost/fusion/include/mpl.hpp>
|
||||
#include <boost/fusion/include/end.hpp>
|
||||
#include <boost/fusion/include/begin.hpp>
|
||||
#include <boost/fusion/include/cons.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// as_feature
|
||||
template<typename Feature>
|
||||
struct as_feature
|
||||
{
|
||||
typedef Feature type;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// weighted_feature
|
||||
template<typename Feature>
|
||||
struct as_weighted_feature
|
||||
{
|
||||
typedef Feature type;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// feature_of
|
||||
template<typename Feature>
|
||||
struct feature_of
|
||||
{
|
||||
typedef Feature type;
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// feature_tag
|
||||
template<typename Accumulator>
|
||||
struct feature_tag
|
||||
{
|
||||
typedef typename Accumulator::feature_tag type;
|
||||
};
|
||||
|
||||
template<typename Feature>
|
||||
struct undroppable
|
||||
{
|
||||
typedef Feature type;
|
||||
};
|
||||
|
||||
template<typename Feature>
|
||||
struct undroppable<tag::droppable<Feature> >
|
||||
{
|
||||
typedef Feature type;
|
||||
};
|
||||
|
||||
// For the purpose of determining whether one feature depends on another,
|
||||
// disregard whether the feature is droppable or not.
|
||||
template<typename A, typename B>
|
||||
struct is_dependent_on
|
||||
: is_base_and_derived<
|
||||
typename feature_of<typename undroppable<B>::type>::type
|
||||
, typename undroppable<A>::type
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Feature>
|
||||
struct dependencies_of
|
||||
{
|
||||
typedef typename Feature::dependencies type;
|
||||
};
|
||||
|
||||
// Should use mpl::insert_range, but doesn't seem to work with mpl sets
|
||||
template<typename Set, typename Range>
|
||||
struct set_insert_range
|
||||
: mpl::fold<
|
||||
Range
|
||||
, Set
|
||||
, mpl::insert<mpl::_1, mpl::_2>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Features>
|
||||
struct collect_abstract_features
|
||||
: mpl::fold<
|
||||
Features
|
||||
, mpl::set0<>
|
||||
, set_insert_range<
|
||||
mpl::insert<mpl::_1, feature_of<mpl::_2> >
|
||||
, collect_abstract_features<dependencies_of<mpl::_2> >
|
||||
>
|
||||
>
|
||||
{};
|
||||
|
||||
template<typename Features>
|
||||
struct depends_on_base
|
||||
: mpl::inherit_linearly<
|
||||
typename mpl::sort<
|
||||
typename mpl::copy<
|
||||
typename collect_abstract_features<Features>::type
|
||||
, mpl::back_inserter<mpl::vector0<> >
|
||||
>::type
|
||||
, is_dependent_on<mpl::_1, mpl::_2>
|
||||
>::type
|
||||
// Don't inherit multiply from a feature
|
||||
, mpl::if_<
|
||||
is_dependent_on<mpl::_1, mpl::_2>
|
||||
, mpl::_1
|
||||
, mpl::inherit<mpl::_1, mpl::_2>
|
||||
>
|
||||
>::type
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
/// depends_on
|
||||
template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature)>
|
||||
struct depends_on
|
||||
: detail::depends_on_base<
|
||||
typename mpl::transform<
|
||||
mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
|
||||
, as_feature<mpl::_1>
|
||||
>::type
|
||||
>
|
||||
{
|
||||
typedef mpl::false_ is_weight_accumulator;
|
||||
typedef
|
||||
typename mpl::transform<
|
||||
mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
|
||||
, as_feature<mpl::_1>
|
||||
>::type
|
||||
dependencies;
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename Feature>
|
||||
struct matches_feature
|
||||
{
|
||||
template<typename Accumulator>
|
||||
struct apply
|
||||
: is_same<
|
||||
typename feature_of<typename as_feature<Feature>::type>::type
|
||||
, typename feature_of<typename as_feature<typename feature_tag<Accumulator>::type>::type>::type
|
||||
>
|
||||
{};
|
||||
};
|
||||
|
||||
template<typename Features, typename Accumulator>
|
||||
struct contains_feature_of
|
||||
{
|
||||
typedef
|
||||
mpl::transform_view<Features, feature_of<as_feature<mpl::_> > >
|
||||
features_list;
|
||||
|
||||
typedef
|
||||
typename feature_of<typename feature_tag<Accumulator>::type>::type
|
||||
the_feature;
|
||||
|
||||
typedef
|
||||
typename mpl::contains<features_list, the_feature>::type
|
||||
type;
|
||||
};
|
||||
|
||||
// This is to work around a bug in early versions of Fusion which caused
|
||||
// a compile error if contains_feature_of<List, mpl::_> is used as a
|
||||
// predicate to fusion::find_if
|
||||
template<typename Features>
|
||||
struct contains_feature_of_
|
||||
{
|
||||
template<typename Accumulator>
|
||||
struct apply
|
||||
: contains_feature_of<Features, Accumulator>
|
||||
{};
|
||||
};
|
||||
|
||||
template<
|
||||
typename First
|
||||
, typename Last
|
||||
, bool is_empty = fusion::result_of::equal_to<First, Last>::value
|
||||
>
|
||||
struct build_acc_list;
|
||||
|
||||
template<typename First, typename Last>
|
||||
struct build_acc_list<First, Last, true>
|
||||
{
|
||||
typedef fusion::nil_ type;
|
||||
|
||||
template<typename Args>
|
||||
static fusion::nil_
|
||||
call(Args const &, First const&, Last const&)
|
||||
{
|
||||
return fusion::nil_();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename First, typename Last>
|
||||
struct build_acc_list<First, Last, false>
|
||||
{
|
||||
typedef
|
||||
build_acc_list<typename fusion::result_of::next<First>::type, Last>
|
||||
next_build_acc_list;
|
||||
|
||||
typedef fusion::cons<
|
||||
typename fusion::result_of::value_of<First>::type
|
||||
, typename next_build_acc_list::type>
|
||||
type;
|
||||
|
||||
template<typename Args>
|
||||
static type
|
||||
call(Args const &args, First const& f, Last const& l)
|
||||
{
|
||||
return type(args, next_build_acc_list::call(args, fusion::next(f), l));
|
||||
}
|
||||
};
|
||||
|
||||
namespace meta
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct make_acc_list
|
||||
: build_acc_list<
|
||||
typename fusion::result_of::begin<Sequence>::type
|
||||
, typename fusion::result_of::end<Sequence>::type
|
||||
>
|
||||
{};
|
||||
}
|
||||
|
||||
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>::call(args, fusion::begin(seq), fusion::end(seq));
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// checked_as_weighted_feature
|
||||
template<typename Feature>
|
||||
struct checked_as_weighted_feature
|
||||
{
|
||||
typedef typename as_feature<Feature>::type feature_type;
|
||||
typedef typename as_weighted_feature<feature_type>::type type;
|
||||
// weighted and non-weighted flavors should provide the same feature.
|
||||
BOOST_MPL_ASSERT((
|
||||
is_same<
|
||||
typename feature_of<feature_type>::type
|
||||
, typename feature_of<type>::type
|
||||
>
|
||||
));
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// as_feature_list
|
||||
template<typename Features, typename Weight>
|
||||
struct as_feature_list
|
||||
: mpl::transform_view<Features, checked_as_weighted_feature<mpl::_1> >
|
||||
{
|
||||
};
|
||||
|
||||
template<typename Features>
|
||||
struct as_feature_list<Features, void>
|
||||
: mpl::transform_view<Features, as_feature<mpl::_1> >
|
||||
{
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// accumulator_wrapper
|
||||
template<typename Accumulator, typename Feature>
|
||||
struct accumulator_wrapper
|
||||
: Accumulator
|
||||
{
|
||||
typedef Feature feature_tag;
|
||||
|
||||
accumulator_wrapper(accumulator_wrapper const &that)
|
||||
: Accumulator(*static_cast<Accumulator const *>(&that))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
accumulator_wrapper(Args const &args)
|
||||
: Accumulator(args)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// to_accumulator
|
||||
template<typename Feature, typename Sample, typename Weight>
|
||||
struct to_accumulator
|
||||
{
|
||||
typedef
|
||||
accumulator_wrapper<
|
||||
typename mpl::apply2<typename Feature::impl, Sample, Weight>::type
|
||||
, Feature
|
||||
>
|
||||
type;
|
||||
};
|
||||
|
||||
template<typename Feature, typename Sample, typename Weight, typename Tag, typename AccumulatorSet>
|
||||
struct to_accumulator<Feature, Sample, tag::external<Weight, Tag, AccumulatorSet> >
|
||||
{
|
||||
BOOST_MPL_ASSERT((is_same<Tag, void>));
|
||||
BOOST_MPL_ASSERT((is_same<AccumulatorSet, void>));
|
||||
|
||||
typedef
|
||||
accumulator_wrapper<
|
||||
typename mpl::apply2<typename Feature::impl, Sample, Weight>::type
|
||||
, Feature
|
||||
>
|
||||
accumulator_type;
|
||||
|
||||
typedef
|
||||
typename mpl::if_<
|
||||
typename Feature::is_weight_accumulator
|
||||
, accumulator_wrapper<impl::external_impl<accumulator_type, tag::weights>, Feature>
|
||||
, accumulator_type
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
// BUGBUG work around an MPL bug wrt map insertion
|
||||
template<typename FeatureMap, typename Feature>
|
||||
struct insert_feature
|
||||
: mpl::eval_if<
|
||||
mpl::has_key<FeatureMap, typename feature_of<Feature>::type>
|
||||
, mpl::identity<FeatureMap>
|
||||
, mpl::insert<FeatureMap, mpl::pair<typename feature_of<Feature>::type, Feature> >
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template<typename FeatureMap, typename Feature, typename Weight>
|
||||
struct insert_dependencies
|
||||
: mpl::fold<
|
||||
as_feature_list<typename Feature::dependencies, Weight>
|
||||
, FeatureMap
|
||||
, insert_dependencies<
|
||||
insert_feature<mpl::_1, mpl::_2>
|
||||
, mpl::_2
|
||||
, Weight
|
||||
>
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template<typename FeatureMap, typename Features, typename Weight>
|
||||
struct insert_sequence
|
||||
: mpl::fold< // BUGBUG should use insert_range, but doesn't seem to work for maps
|
||||
as_feature_list<Features, Weight>
|
||||
, FeatureMap
|
||||
, insert_feature<mpl::_1, mpl::_2>
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template<typename Features, typename Sample, typename Weight>
|
||||
struct make_accumulator_tuple
|
||||
{
|
||||
typedef
|
||||
typename mpl::fold<
|
||||
as_feature_list<Features, Weight>
|
||||
, mpl::map0<>
|
||||
, mpl::if_<
|
||||
mpl::is_sequence<mpl::_2>
|
||||
, insert_sequence<mpl::_1, mpl::_2, Weight>
|
||||
, insert_feature<mpl::_1, mpl::_2>
|
||||
>
|
||||
>::type
|
||||
feature_map;
|
||||
|
||||
// for each element in the map, add its dependencies also
|
||||
typedef
|
||||
typename mpl::fold<
|
||||
feature_map
|
||||
, feature_map
|
||||
, insert_dependencies<mpl::_1, mpl::second<mpl::_2>, Weight>
|
||||
>::type
|
||||
feature_map_with_dependencies;
|
||||
|
||||
// turn the map into a vector so we can sort it
|
||||
typedef
|
||||
typename mpl::insert_range<
|
||||
mpl::vector<>
|
||||
, mpl::end<mpl::vector<> >::type
|
||||
, mpl::transform_view<feature_map_with_dependencies, mpl::second<mpl::_1> >
|
||||
>::type
|
||||
feature_vector_with_dependencies;
|
||||
|
||||
// sort the features according to which is derived from which
|
||||
typedef
|
||||
typename mpl::sort<
|
||||
feature_vector_with_dependencies
|
||||
, is_dependent_on<mpl::_2, mpl::_1>
|
||||
>::type
|
||||
sorted_feature_vector;
|
||||
|
||||
// From the vector of features, construct a vector of accumulators
|
||||
typedef
|
||||
typename mpl::transform<
|
||||
sorted_feature_vector
|
||||
, to_accumulator<mpl::_1, Sample, Weight>
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,27 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// external.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_EXTERNAL_HPP_EAN_01_12_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_EXTERNAL_HPP_EAN_01_12_2005
|
||||
|
||||
#include <boost/mpl/apply.hpp>
|
||||
#include <boost/accumulators/framework/accumulators/external_accumulator.hpp>
|
||||
|
||||
//namespace boost { namespace accumulators
|
||||
//{
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
//// external
|
||||
////
|
||||
//template<typename Type>
|
||||
//struct external
|
||||
//{
|
||||
//};
|
||||
//
|
||||
//}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,229 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extractor.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_FRAMEWORK_EXTRACTOR_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_FRAMEWORK_EXTRACTOR_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/preprocessor/tuple/rem.hpp>
|
||||
#include <boost/preprocessor/array/size.hpp>
|
||||
#include <boost/preprocessor/array/data.hpp>
|
||||
#include <boost/preprocessor/array/elem.hpp>
|
||||
#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_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/parameter/binding.hpp>
|
||||
#include <boost/mpl/apply.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
#include <boost/accumulators/framework/parameters/accumulator.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename AccumulatorSet, typename Feature>
|
||||
struct accumulator_set_result
|
||||
{
|
||||
typedef typename as_feature<Feature>::type feature_type;
|
||||
typedef typename mpl::apply<AccumulatorSet, 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
|
||||
>::type
|
||||
, Feature
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template<typename A, typename Feature>
|
||||
struct extractor_result
|
||||
: mpl::eval_if<
|
||||
detail::is_accumulator_set<A>
|
||||
, accumulator_set_result<A, Feature>
|
||||
, argument_pack_result<A, Feature>
|
||||
>
|
||||
{
|
||||
};
|
||||
|
||||
template<typename Feature, typename AccumulatorSet>
|
||||
typename extractor_result<AccumulatorSet, Feature>::type
|
||||
do_extract(AccumulatorSet const &acc, mpl::true_)
|
||||
{
|
||||
typedef typename as_feature<Feature>::type feature_type;
|
||||
return extract_result<feature_type>(acc);
|
||||
}
|
||||
|
||||
template<typename Feature, typename Args>
|
||||
typename extractor_result<Args, Feature>::type
|
||||
do_extract(Args const &args, mpl::false_)
|
||||
{
|
||||
typedef typename as_feature<Feature>::type feature_type;
|
||||
return find_accumulator<feature_type>(args[accumulator]).result(args);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Extracts the result associated with Feature from the specified accumulator_set.
|
||||
template<typename Feature>
|
||||
struct extractor
|
||||
{
|
||||
typedef extractor<Feature> this_type;
|
||||
|
||||
/// The result meta-function for determining the return type of the extractor
|
||||
template<typename F>
|
||||
struct result;
|
||||
|
||||
template<typename A1>
|
||||
struct result<this_type(A1)>
|
||||
: detail::extractor_result<A1, Feature>
|
||||
{
|
||||
};
|
||||
|
||||
/// Extract the result associated with Feature from the accumulator set
|
||||
/// \param acc The accumulator set object from which to extract the result
|
||||
template<typename Arg1>
|
||||
typename detail::extractor_result<Arg1, Feature>::type
|
||||
operator ()(Arg1 const &arg1) const
|
||||
{
|
||||
// Arg1 could be an accumulator_set or an argument pack containing
|
||||
// an accumulator_set. Dispatch accordingly.
|
||||
return detail::do_extract<Feature>(arg1, detail::is_accumulator_set<Arg1>());
|
||||
}
|
||||
|
||||
/// \overload
|
||||
///
|
||||
/// \param a1 Optional named parameter to be passed to the accumulator's result() function.
|
||||
template<typename AccumulatorSet, typename A1>
|
||||
typename detail::extractor_result<AccumulatorSet, Feature>::type
|
||||
operator ()(AccumulatorSet const &acc, A1 const &a1) const
|
||||
{
|
||||
BOOST_MPL_ASSERT((detail::is_accumulator_set<AccumulatorSet>));
|
||||
typedef typename as_feature<Feature>::type feature_type;
|
||||
return extract_result<feature_type>(acc, a1);
|
||||
}
|
||||
|
||||
// ... other overloads generated by Boost.Preprocessor:
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_EXTRACTOR_FUN_OP(z, n, _) \
|
||||
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)> \
|
||||
struct result<this_type(BOOST_PP_ENUM_PARAMS_Z(z, n, A))> \
|
||||
: detail::extractor_result<A1, Feature> \
|
||||
{}; \
|
||||
template< \
|
||||
typename AccumulatorSet \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A) \
|
||||
> \
|
||||
typename detail::extractor_result<AccumulatorSet, Feature>::type \
|
||||
operator ()( \
|
||||
AccumulatorSet const &acc \
|
||||
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) \
|
||||
) const \
|
||||
{ \
|
||||
BOOST_MPL_ASSERT((detail::is_accumulator_set<AccumulatorSet>)); \
|
||||
typedef typename as_feature<Feature>::type feature_type; \
|
||||
return extract_result<feature_type>(acc BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a));\
|
||||
}
|
||||
|
||||
BOOST_PP_REPEAT_FROM_TO(
|
||||
2
|
||||
, BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS)
|
||||
, BOOST_ACCUMULATORS_EXTRACTOR_FUN_OP
|
||||
, _
|
||||
)
|
||||
|
||||
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
||||
/// \overload
|
||||
///
|
||||
template<typename AccumulatorSet, typename A1, typename A2, ...>
|
||||
typename detail::extractor_result<AccumulatorSet, Feature>::type
|
||||
operator ()(AccumulatorSet const &acc, A1 const &a1, A2 const &a2, ...);
|
||||
#endif
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_ARRAY_REM(Array) \
|
||||
BOOST_PP_TUPLE_REM_CTOR(BOOST_PP_ARRAY_SIZE(Array), BOOST_PP_ARRAY_DATA(Array))
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_SEQ_REM(Seq) \
|
||||
BOOST_ACCUMULATORS_ARRAY_REM(BOOST_PP_SEQ_TO_ARRAY(Seq))
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_ARGS_OP(s, data, elem) \
|
||||
T ## s
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_PARAMS_OP(s, data, elem) \
|
||||
elem T ## s
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_MAKE_FEATURE(Tag, Feature, ParamsSeq) \
|
||||
Tag::Feature< \
|
||||
BOOST_ACCUMULATORS_SEQ_REM( \
|
||||
BOOST_PP_SEQ_TRANSFORM(BOOST_ACCUMULATORS_ARGS_OP, ~, ParamsSeq) \
|
||||
) \
|
||||
>
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN_IMPL(z, n, Tag, Feature, ParamsSeq) \
|
||||
template< \
|
||||
BOOST_ACCUMULATORS_SEQ_REM( \
|
||||
BOOST_PP_SEQ_TRANSFORM(BOOST_ACCUMULATORS_PARAMS_OP, ~, ParamsSeq) \
|
||||
) \
|
||||
, typename Arg1 \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, typename A) \
|
||||
> \
|
||||
typename boost::accumulators::detail::extractor_result< \
|
||||
Arg1 \
|
||||
, BOOST_ACCUMULATORS_MAKE_FEATURE(Tag, Feature, ParamsSeq) \
|
||||
>::type \
|
||||
Feature(Arg1 const &arg1 BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, A, const &a) ) \
|
||||
{ \
|
||||
typedef BOOST_ACCUMULATORS_MAKE_FEATURE(Tag, Feature, ParamsSeq) feature_type; \
|
||||
return boost::accumulators::extractor<feature_type>()( \
|
||||
arg1 BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a)); \
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN(z, n, _) \
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN_IMPL( \
|
||||
z \
|
||||
, n \
|
||||
, BOOST_PP_ARRAY_ELEM(0, _) \
|
||||
, BOOST_PP_ARRAY_ELEM(1, _) \
|
||||
, BOOST_PP_ARRAY_ELEM(2, _) \
|
||||
)
|
||||
|
||||
#define BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(Tag, Feature, ParamSeq) \
|
||||
BOOST_PP_REPEAT( \
|
||||
BOOST_PP_INC(BOOST_ACCUMULATORS_MAX_ARGS) \
|
||||
, BOOST_ACCUMULATORS_DEFINE_EXTRACTOR_FUN \
|
||||
, (3, (Tag, Feature, ParamSeq)) \
|
||||
)
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,29 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// features.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_STATS_HPP_EAN_08_12_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_STATS_HPP_EAN_08_12_2005
|
||||
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/mpl/vector.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// features
|
||||
//
|
||||
template<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, typename Feature)>
|
||||
struct features
|
||||
: mpl::vector<BOOST_PP_ENUM_PARAMS(BOOST_ACCUMULATORS_MAX_FEATURES, Feature)>
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// accumulator.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_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/accumulators/accumulators_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
BOOST_PARAMETER_KEYWORD(tag, accumulator)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(accumulator)
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// sample.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_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/accumulators/accumulators_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
BOOST_PARAMETER_KEYWORD(tag, sample)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(sample)
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// weight.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_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/accumulators/accumulators_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
// The weight of a single sample
|
||||
BOOST_PARAMETER_KEYWORD(tag, weight)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weight)
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// weights.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_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/accumulators/accumulators_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
// The weight accumulator
|
||||
BOOST_PARAMETER_KEYWORD(tag, weights)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weights)
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,75 @@
|
||||
// Copyright David Abrahams 2006. 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_DETAIL_FUNCTION1_DWA200655_HPP
|
||||
# define BOOST_DETAIL_FUNCTION1_DWA200655_HPP
|
||||
|
||||
# include <boost/concept_check.hpp>
|
||||
# include <boost/type_traits/remove_reference.hpp>
|
||||
# include <boost/type_traits/add_const.hpp>
|
||||
# include <boost/mpl/apply.hpp>
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
// A utility for creating unary function objects that play nicely with
|
||||
// boost::result_of and that handle the forwarding problem.
|
||||
//
|
||||
// mpl::apply<F, A0>::type is expected to be a stateless function
|
||||
// object that accepts an argument of type A0&. It is also expected
|
||||
// to have a nested ::result_type identical to its return type.
|
||||
template<typename F>
|
||||
struct function1
|
||||
{
|
||||
template<typename Signature>
|
||||
struct result
|
||||
{};
|
||||
|
||||
template<typename This, typename A0>
|
||||
struct result<This(A0)>
|
||||
{
|
||||
// How adding const to arguments handles rvalues.
|
||||
//
|
||||
// if A0 is arg0 is represents actual argument
|
||||
// -------- ------- --------------------------
|
||||
// T const & T const const T lvalue
|
||||
// T & T non-const T lvalue
|
||||
// T const T const const T rvalue
|
||||
// T T const non-const T rvalue
|
||||
typedef typename remove_reference<
|
||||
typename add_const< A0 >::type
|
||||
>::type arg0;
|
||||
|
||||
typedef typename mpl::apply1<F, arg0>::type impl;
|
||||
typedef typename impl::result_type type;
|
||||
};
|
||||
|
||||
// Handles mutable lvalues
|
||||
template<typename A0>
|
||||
typename result<function1(A0 &)>::type
|
||||
operator ()(A0 &a0) const
|
||||
{
|
||||
typedef typename result<function1(A0 &)>::impl impl;
|
||||
typedef typename result<function1(A0 &)>::type type;
|
||||
typedef A0 &arg0;
|
||||
BOOST_CONCEPT_ASSERT((UnaryFunction<impl, type, arg0>));
|
||||
//boost::function_requires<UnaryFunctionConcept<impl, type, arg0> >();
|
||||
return impl()(a0);
|
||||
}
|
||||
|
||||
// Handles const lvalues and all rvalues
|
||||
template<typename A0>
|
||||
typename result<function1(A0 const &)>::type
|
||||
operator ()(A0 const &a0) const
|
||||
{
|
||||
typedef typename result<function1(A0 const &)>::impl impl;
|
||||
typedef typename result<function1(A0 const &)>::type type;
|
||||
typedef A0 const &arg0;
|
||||
BOOST_CONCEPT_ASSERT((UnaryFunction<impl, type, arg0>));
|
||||
//boost::function_requires<UnaryFunctionConcept<impl, type, arg0> >();
|
||||
return impl()(a0);
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace boost::detail
|
||||
|
||||
#endif // BOOST_DETAIL_FUNCTION1_DWA200655_HPP
|
||||
@@ -0,0 +1,10 @@
|
||||
// Copyright David Abrahams 2006. 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_DETAIL_FUNCTION2_DWA200655_HPP
|
||||
# define BOOST_DETAIL_FUNCTION2_DWA200655_HPP
|
||||
|
||||
# define args (2)
|
||||
# include <boost/accumulators/numeric/detail/function_n.hpp>
|
||||
|
||||
#endif // BOOST_DETAIL_FUNCTION2_DWA200655_HPP
|
||||
@@ -0,0 +1,10 @@
|
||||
// Copyright David Abrahams 2006. 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_DETAIL_FUNCTION3_DWA2006514_HPP
|
||||
# define BOOST_DETAIL_FUNCTION3_DWA2006514_HPP
|
||||
|
||||
# define args (3)
|
||||
# include <boost/accumulators/numeric/detail/function_n.hpp>
|
||||
|
||||
#endif // BOOST_DETAIL_FUNCTION3_DWA2006514_HPP
|
||||
@@ -0,0 +1,10 @@
|
||||
// Copyright David Abrahams 2006. 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_DETAIL_FUNCTION4_DWA2006514_HPP
|
||||
# define BOOST_DETAIL_FUNCTION4_DWA2006514_HPP
|
||||
|
||||
# define args (4)
|
||||
# include <boost/accumulators/numeric/detail/function_n.hpp>
|
||||
|
||||
#endif // BOOST_DETAIL_FUNCTION4_DWA2006514_HPP
|
||||
@@ -0,0 +1,148 @@
|
||||
// Copyright David Abrahams 2006. 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)
|
||||
//
|
||||
// #include guards intentionally disabled.
|
||||
// #ifndef BOOST_DETAIL_FUNCTION_N_DWA2006514_HPP
|
||||
// # define BOOST_DETAIL_FUNCTION_N_DWA2006514_HPP
|
||||
|
||||
#include <boost/mpl/void.hpp>
|
||||
#include <boost/mpl/apply.hpp>
|
||||
|
||||
#include <boost/preprocessor/control/if.hpp>
|
||||
#include <boost/preprocessor/cat.hpp>
|
||||
#include <boost/preprocessor/punctuation/comma_if.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
||||
#include <boost/preprocessor/seq/fold_left.hpp>
|
||||
#include <boost/preprocessor/seq/seq.hpp>
|
||||
#include <boost/preprocessor/seq/for_each.hpp>
|
||||
#include <boost/preprocessor/seq/for_each_i.hpp>
|
||||
#include <boost/preprocessor/seq/for_each_product.hpp>
|
||||
#include <boost/preprocessor/seq/size.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
# define BOOST_DETAIL_default_arg(z, n, _) \
|
||||
typedef mpl::void_ BOOST_PP_CAT(arg, n);
|
||||
|
||||
# define BOOST_DETAIL_function_arg(z, n, _) \
|
||||
typedef typename remove_reference< \
|
||||
typename add_const< BOOST_PP_CAT(A, n) >::type \
|
||||
>::type BOOST_PP_CAT(arg, n);
|
||||
|
||||
#define BOOST_DETAIL_cat_arg_counts(s, state, n) \
|
||||
BOOST_PP_IF( \
|
||||
n \
|
||||
, BOOST_PP_CAT(state, BOOST_PP_CAT(_, n)) \
|
||||
, state \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define function_name \
|
||||
BOOST_PP_SEQ_FOLD_LEFT( \
|
||||
BOOST_DETAIL_cat_arg_counts \
|
||||
, BOOST_PP_CAT(function, BOOST_PP_SEQ_HEAD(args)) \
|
||||
, BOOST_PP_SEQ_TAIL(args)(0) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
template<typename F>
|
||||
struct function_name
|
||||
{
|
||||
BOOST_PP_REPEAT(
|
||||
BOOST_MPL_LIMIT_METAFUNCTION_ARITY
|
||||
, BOOST_DETAIL_default_arg
|
||||
, ~
|
||||
)
|
||||
|
||||
template<typename Signature>
|
||||
struct result {};
|
||||
|
||||
#define BOOST_DETAIL_function_result(r, _, n) \
|
||||
template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(n, typename A)> \
|
||||
struct result<This(BOOST_PP_ENUM_PARAMS(n, A))> \
|
||||
{ \
|
||||
BOOST_PP_REPEAT(n, BOOST_DETAIL_function_arg, ~) \
|
||||
typedef \
|
||||
typename BOOST_PP_CAT(mpl::apply, BOOST_MPL_LIMIT_METAFUNCTION_ARITY)<\
|
||||
F \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS( \
|
||||
BOOST_MPL_LIMIT_METAFUNCTION_ARITY \
|
||||
, arg \
|
||||
) \
|
||||
>::type \
|
||||
impl; \
|
||||
typedef typename impl::result_type type; \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
BOOST_PP_SEQ_FOR_EACH(BOOST_DETAIL_function_result, _, args)
|
||||
|
||||
# define arg_type(r, _, i, is_const) \
|
||||
BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(A, i) BOOST_PP_CAT(const_if, is_const) &
|
||||
|
||||
# define result_(r, n, constness) \
|
||||
typename result< \
|
||||
function_name( \
|
||||
BOOST_PP_SEQ_FOR_EACH_I_R(r, arg_type, ~, constness) \
|
||||
) \
|
||||
> \
|
||||
/**/
|
||||
|
||||
# define param(r, _, i, is_const) BOOST_PP_COMMA_IF(i) \
|
||||
BOOST_PP_CAT(A, i) BOOST_PP_CAT(const_if, is_const) & BOOST_PP_CAT(x, i)
|
||||
|
||||
# define param_list(r, n, constness) \
|
||||
BOOST_PP_SEQ_FOR_EACH_I_R(r, param, ~, constness)
|
||||
|
||||
# define call_operator(r, constness) \
|
||||
template<BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(constness), typename A)> \
|
||||
result_(r, BOOST_PP_SEQ_SIZE(constness), constness)::type \
|
||||
operator ()( param_list(r, BOOST_PP_SEQ_SIZE(constness), constness) ) const \
|
||||
{ \
|
||||
typedef result_(r, BOOST_PP_SEQ_SIZE(constness), constness)::impl impl; \
|
||||
return impl()(BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(constness), x)); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
# define const_if0
|
||||
# define const_if1 const
|
||||
|
||||
# define bits(z, n, _) ((0)(1))
|
||||
|
||||
# define gen_operator(r, _, n) \
|
||||
BOOST_PP_SEQ_FOR_EACH_PRODUCT_R( \
|
||||
r \
|
||||
, call_operator \
|
||||
, BOOST_PP_REPEAT(n, bits, ~) \
|
||||
) \
|
||||
/**/
|
||||
|
||||
BOOST_PP_SEQ_FOR_EACH(
|
||||
gen_operator
|
||||
, ~
|
||||
, args
|
||||
)
|
||||
|
||||
# undef bits
|
||||
# undef const_if1
|
||||
# undef const_if0
|
||||
# undef call_operator
|
||||
# undef param_list
|
||||
# undef param
|
||||
# undef result_
|
||||
# undef default_
|
||||
# undef arg_type
|
||||
# undef gen_operator
|
||||
# undef function_name
|
||||
|
||||
# undef args
|
||||
};
|
||||
|
||||
}} // namespace boost::detail
|
||||
|
||||
//#endif // BOOST_DETAIL_FUNCTION_N_DWA2006514_HPP
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
// Copyright David Abrahams 2006. 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_DETAIL_POD_SINGLETON_DWA200655_HPP
|
||||
# define BOOST_DETAIL_POD_SINGLETON_DWA200655_HPP
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
template<typename T>
|
||||
struct pod_singleton
|
||||
{
|
||||
static T instance;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
T pod_singleton<T>::instance;
|
||||
|
||||
}} // namespace boost::detail
|
||||
|
||||
#endif // BOOST_DETAIL_POD_SINGLETON_DWA200655_HPP
|
||||
@@ -0,0 +1,521 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file functional.hpp
|
||||
///
|
||||
// Copyright 2005 Eric Niebler. 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_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005
|
||||
|
||||
#include <limits>
|
||||
#include <functional>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <boost/type_traits/is_empty.hpp>
|
||||
#include <boost/type_traits/is_integral.hpp>
|
||||
#include <boost/type_traits/is_floating_point.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
#include <boost/accumulators/numeric/functional_fwd.hpp>
|
||||
#include <boost/accumulators/numeric/detail/function1.hpp>
|
||||
#include <boost/accumulators/numeric/detail/function2.hpp>
|
||||
#include <boost/accumulators/numeric/detail/pod_singleton.hpp>
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT
|
||||
# include <boost/accumulators/numeric/functional/vector.hpp>
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT
|
||||
# include <boost/accumulators/numeric/functional/valarray.hpp>
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT
|
||||
# include <boost/accumulators/numeric/functional/complex.hpp>
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_DOXYGEN_INVOKED
|
||||
// Hack to make Doxygen show the inheritance relationships
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
namespace std
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<class Arg, class Ret> struct unary_function {};
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<class Left, class Right, class Ret> struct binary_function {};
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
namespace functional
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename A0, typename A1>
|
||||
struct are_integral
|
||||
: mpl::and_<is_integral<A0>, is_integral<A1> >
|
||||
{};
|
||||
|
||||
template<typename Left, typename Right>
|
||||
struct left_ref
|
||||
{
|
||||
typedef Left &type;
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
T &lvalue_of();
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: handle complex weight, valarray, MTL vectors
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(Name, Op) \
|
||||
namespace functional \
|
||||
{ \
|
||||
template<typename Arg> \
|
||||
struct result_of_ ## Name \
|
||||
{ \
|
||||
BOOST_TYPEOF_NESTED_TYPEDEF_TPL( \
|
||||
nested \
|
||||
, Op boost::numeric::functional::detail::lvalue_of<Arg>() \
|
||||
) \
|
||||
typedef typename nested::type type; \
|
||||
}; \
|
||||
template<typename Arg, typename EnableIf> \
|
||||
struct Name ## _base \
|
||||
: std::unary_function< \
|
||||
typename remove_const<Arg>::type \
|
||||
, typename result_of_ ## Name<Arg>::type \
|
||||
> \
|
||||
{ \
|
||||
typename result_of_ ## Name<Arg>::type operator ()(Arg &arg) const \
|
||||
{ \
|
||||
return Op arg; \
|
||||
} \
|
||||
}; \
|
||||
template<typename Arg, typename ArgTag> \
|
||||
struct Name \
|
||||
: Name ## _base<Arg, void> \
|
||||
{}; \
|
||||
} \
|
||||
namespace op \
|
||||
{ \
|
||||
struct Name \
|
||||
: boost::detail::function1<functional::Name<_, functional::tag<_> > > \
|
||||
{}; \
|
||||
} \
|
||||
namespace \
|
||||
{ \
|
||||
op::Name const &Name = boost::detail::pod_singleton<op::Name>::instance; \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(Name, Op, RetType) \
|
||||
namespace functional \
|
||||
{ \
|
||||
template<typename Left, typename Right, typename EnableIf> \
|
||||
struct result_of_ ## Name \
|
||||
{ \
|
||||
RetType(Left, Op, Right) \
|
||||
}; \
|
||||
template<typename Left, typename Right, typename EnableIf> \
|
||||
struct Name ## _base \
|
||||
: std::binary_function< \
|
||||
typename remove_const<Left>::type \
|
||||
, typename remove_const<Right>::type \
|
||||
, typename result_of_ ## Name<Left, Right>::type \
|
||||
> \
|
||||
{ \
|
||||
typename result_of_ ## Name<Left, Right>::type \
|
||||
operator ()(Left &left, Right &right) const \
|
||||
{ \
|
||||
return left Op right; \
|
||||
} \
|
||||
}; \
|
||||
template<typename Left, typename Right, typename LeftTag, typename RightTag> \
|
||||
struct Name \
|
||||
: Name ## _base<Left, Right, void> \
|
||||
{}; \
|
||||
} \
|
||||
namespace op \
|
||||
{ \
|
||||
struct Name \
|
||||
: boost::detail::function2< \
|
||||
functional::Name<_1, _2, functional::tag<_1>, functional::tag<_2> > \
|
||||
> \
|
||||
{}; \
|
||||
} \
|
||||
namespace \
|
||||
{ \
|
||||
op::Name const &Name = boost::detail::pod_singleton<op::Name>::instance; \
|
||||
} \
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(Name) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_DEDUCED(Left, Op, Right) \
|
||||
BOOST_TYPEOF_NESTED_TYPEDEF_TPL( \
|
||||
nested \
|
||||
, boost::numeric::functional::detail::lvalue_of<Left>() Op \
|
||||
boost::numeric::functional::detail::lvalue_of<Right>() \
|
||||
) \
|
||||
typedef typename nested::type type; \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_LEFT(Left, Op, Right) \
|
||||
typedef Left &type; \
|
||||
/**/
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus, +, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus, -, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies, *, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides, /, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus, %, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater, >, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater_equal, >=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less, <, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less_equal, <=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(equal_to, ==, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(not_equal_to, !=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(assign, =, BOOST_NUMERIC_FUNCTIONAL_LEFT)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus_assign, +=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus_assign, -=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies_assign, *=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides_assign, /=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus_assign, %=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_plus, +)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_minus, -)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(complement, ~)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(logical_not, !)
|
||||
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_LEFT
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_DEDUCED
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP
|
||||
|
||||
namespace functional
|
||||
{
|
||||
template<typename Left, typename Right, typename EnableIf>
|
||||
struct min_assign_base
|
||||
: std::binary_function<Left, Right, void>
|
||||
{
|
||||
void operator ()(Left &left, Right &right) const
|
||||
{
|
||||
if(numeric::less(right, left))
|
||||
{
|
||||
left = right;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Left, typename Right, typename EnableIf>
|
||||
struct max_assign_base
|
||||
: std::binary_function<Left, Right, void>
|
||||
{
|
||||
void operator ()(Left &left, Right &right) const
|
||||
{
|
||||
if(numeric::greater(right, left))
|
||||
{
|
||||
left = right;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Left, typename Right, typename EnableIf>
|
||||
struct fdiv_base
|
||||
: functional::divides<Left, Right>
|
||||
{};
|
||||
|
||||
// partial specialization that promotes the arguments to double for
|
||||
// integral division.
|
||||
template<typename Left, typename Right>
|
||||
struct fdiv_base<Left, Right, typename enable_if<are_integral<Left, Right> >::type>
|
||||
: functional::divides<double const, double const>
|
||||
{};
|
||||
|
||||
template<typename To, typename From, typename EnableIf>
|
||||
struct promote_base
|
||||
: std::unary_function<From, To>
|
||||
{
|
||||
To operator ()(From &from) const
|
||||
{
|
||||
return from;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename ToFrom>
|
||||
struct promote_base<ToFrom, ToFrom, void>
|
||||
: std::unary_function<ToFrom, ToFrom>
|
||||
{
|
||||
ToFrom &operator ()(ToFrom &tofrom)
|
||||
{
|
||||
return tofrom;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Arg, typename EnableIf>
|
||||
struct as_min_base
|
||||
: std::unary_function<Arg, typename remove_const<Arg>::type>
|
||||
{
|
||||
BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
|
||||
|
||||
typename remove_const<Arg>::type operator ()(Arg &) const
|
||||
{
|
||||
return (std::numeric_limits<typename remove_const<Arg>::type>::min)();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Arg>
|
||||
struct as_min_base<Arg, typename enable_if<is_floating_point<Arg> >::type>
|
||||
: std::unary_function<Arg, typename remove_const<Arg>::type>
|
||||
{
|
||||
BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
|
||||
|
||||
typename remove_const<Arg>::type operator ()(Arg &) const
|
||||
{
|
||||
return -(std::numeric_limits<typename remove_const<Arg>::type>::max)();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Arg, typename EnableIf>
|
||||
struct as_max_base
|
||||
: std::unary_function<Arg, typename remove_const<Arg>::type>
|
||||
{
|
||||
BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
|
||||
|
||||
typename remove_const<Arg>::type operator ()(Arg &) const
|
||||
{
|
||||
return (std::numeric_limits<typename remove_const<Arg>::type>::max)();
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Arg, typename EnableIf>
|
||||
struct as_zero_base
|
||||
: std::unary_function<Arg, typename remove_const<Arg>::type>
|
||||
{
|
||||
typename remove_const<Arg>::type operator ()(Arg &) const
|
||||
{
|
||||
return numeric::zero<typename remove_const<Arg>::type>::value;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Arg, typename EnableIf>
|
||||
struct as_one_base
|
||||
: std::unary_function<Arg, typename remove_const<Arg>::type>
|
||||
{
|
||||
typename remove_const<Arg>::type operator ()(Arg &) const
|
||||
{
|
||||
return numeric::one<typename remove_const<Arg>::type>::value;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename To, typename From, typename ToTag, typename FromTag>
|
||||
struct promote
|
||||
: promote_base<To, From, void>
|
||||
{};
|
||||
|
||||
template<typename Left, typename Right, typename LeftTag, typename RightTag>
|
||||
struct min_assign
|
||||
: min_assign_base<Left, Right, void>
|
||||
{};
|
||||
|
||||
template<typename Left, typename Right, typename LeftTag, typename RightTag>
|
||||
struct max_assign
|
||||
: max_assign_base<Left, Right, void>
|
||||
{};
|
||||
|
||||
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
|
||||
: fdiv<Left, Right, LeftTag, RightTag>
|
||||
{};
|
||||
|
||||
template<typename Arg, typename Tag>
|
||||
struct as_min
|
||||
: as_min_base<Arg, void>
|
||||
{};
|
||||
|
||||
template<typename Arg, typename Tag>
|
||||
struct as_max
|
||||
: as_max_base<Arg, void>
|
||||
{};
|
||||
|
||||
template<typename Arg, typename Tag>
|
||||
struct as_zero
|
||||
: as_zero_base<Arg, void>
|
||||
{};
|
||||
|
||||
template<typename Arg, typename Tag>
|
||||
struct as_one
|
||||
: as_one_base<Arg, void>
|
||||
{};
|
||||
}
|
||||
|
||||
namespace op
|
||||
{
|
||||
template<typename To>
|
||||
struct promote
|
||||
: boost::detail::function1<functional::promote<To, _, typename functional::tag<To>::type, functional::tag<_> > >
|
||||
{};
|
||||
|
||||
struct min_assign
|
||||
: boost::detail::function2<functional::min_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > >
|
||||
{};
|
||||
|
||||
struct max_assign
|
||||
: 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::fdiv<_1, _2, functional::tag<_1>, functional::tag<_2> > >
|
||||
{};
|
||||
|
||||
struct as_min
|
||||
: boost::detail::function1<functional::as_min<_, functional::tag<_> > >
|
||||
{};
|
||||
|
||||
struct as_max
|
||||
: boost::detail::function1<functional::as_max<_, functional::tag<_> > >
|
||||
{};
|
||||
|
||||
struct as_zero
|
||||
: boost::detail::function1<functional::as_zero<_, functional::tag<_> > >
|
||||
{};
|
||||
|
||||
struct as_one
|
||||
: boost::detail::function1<functional::as_one<_, functional::tag<_> > >
|
||||
{};
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
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::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;
|
||||
op::as_one const &as_one = boost::detail::pod_singleton<op::as_one>::instance;
|
||||
|
||||
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)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_zero)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_one)
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// promote
|
||||
template<typename To, typename From>
|
||||
typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
|
||||
promote(From &from)
|
||||
{
|
||||
return functional::promote<To, From>()(from);
|
||||
}
|
||||
|
||||
template<typename To, typename From>
|
||||
typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
|
||||
promote(From const &from)
|
||||
{
|
||||
return functional::promote<To const, From const>()(from);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
struct default_
|
||||
{
|
||||
typedef default_ type;
|
||||
typedef T value_type;
|
||||
static T const value;
|
||||
|
||||
operator T const & () const
|
||||
{
|
||||
return default_::value;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
T const default_<T>::value = T();
|
||||
|
||||
template<typename T>
|
||||
struct one
|
||||
{
|
||||
typedef one type;
|
||||
typedef T value_type;
|
||||
static T const value;
|
||||
|
||||
operator T const & () const
|
||||
{
|
||||
return one::value;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
T const one<T>::value = T(1);
|
||||
|
||||
template<typename T>
|
||||
struct zero
|
||||
{
|
||||
typedef zero type;
|
||||
typedef T value_type;
|
||||
static T const value;
|
||||
|
||||
operator T const & () const
|
||||
{
|
||||
return zero::value;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
T const zero<T>::value = T();
|
||||
|
||||
template<typename T>
|
||||
struct one_or_default
|
||||
: mpl::if_<is_empty<T>, default_<T>, one<T> >::type
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct zero_or_default
|
||||
: mpl::if_<is_empty<T>, default_<T>, zero<T> >::type
|
||||
{};
|
||||
|
||||
}} // namespace boost::numeric
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,82 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file complex.hpp
|
||||
///
|
||||
// Copyright 2005 Eric Niebler. 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_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_COMPLEX_HPP_EAN_01_17_2006
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
|
||||
# error Include this file before boost/accumulators/numeric/functional.hpp
|
||||
#endif
|
||||
|
||||
#include <complex>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/typeof/std/complex.hpp>
|
||||
#include <boost/accumulators/numeric/functional_fwd.hpp>
|
||||
|
||||
namespace boost { namespace numeric { namespace operators
|
||||
{
|
||||
// So that the stats compile when Sample type is std::complex
|
||||
template<typename T, typename U>
|
||||
typename
|
||||
disable_if<
|
||||
mpl::or_<is_same<T, U>, is_same<std::complex<T>, U> >
|
||||
, std::complex<T>
|
||||
>::type
|
||||
operator *(std::complex<T> ri, U const &u)
|
||||
{
|
||||
// BUGBUG promote result to typeof(T()*u) ?
|
||||
return ri *= static_cast<T>(u);
|
||||
}
|
||||
|
||||
template<typename T, typename U>
|
||||
typename
|
||||
disable_if<
|
||||
mpl::or_<is_same<T, U>, is_same<std::complex<T>, U> >
|
||||
, std::complex<T>
|
||||
>::type
|
||||
operator /(std::complex<T> ri, U const &u)
|
||||
{
|
||||
// BUGBUG promote result to typeof(T()*u) ?
|
||||
return ri /= static_cast<T>(u);
|
||||
}
|
||||
|
||||
}}} // namespace boost::numeric::operators
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
namespace detail
|
||||
{
|
||||
template<typename T>
|
||||
struct one_complex
|
||||
{
|
||||
static std::complex<T> const value;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
std::complex<T> const one_complex<T>::value
|
||||
= std::complex<T>(numeric::one<T>::value, numeric::one<T>::value);
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
struct one<std::complex<T> >
|
||||
: detail::one_complex<T>
|
||||
{
|
||||
typedef one type;
|
||||
typedef std::complex<T> value_type;
|
||||
operator value_type const & () const
|
||||
{
|
||||
return detail::one_complex<T>::value;
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace boost::numeric
|
||||
|
||||
#endif
|
||||
+360
@@ -0,0 +1,360 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file valarray.hpp
|
||||
///
|
||||
// Copyright 2005 Eric Niebler. 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_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_VALARRAY_HPP_EAN_12_12_2005
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
|
||||
# error Include this file before boost/accumulators/numeric/functional.hpp
|
||||
#endif
|
||||
|
||||
#include <valarray>
|
||||
#include <functional>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/is_scalar.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/typeof/std/valarray.hpp>
|
||||
#include <boost/accumulators/numeric/functional_fwd.hpp>
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
namespace operators
|
||||
{
|
||||
namespace acc_detail
|
||||
{
|
||||
template<typename Fun>
|
||||
struct make_valarray
|
||||
{
|
||||
typedef std::valarray<typename Fun::result_type> type;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle valarray<Left> / Right where Right is a scalar and Right != Left.
|
||||
template<typename Left, typename Right>
|
||||
typename lazy_enable_if<
|
||||
mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
|
||||
, acc_detail::make_valarray<functional::divides<Left, Right> >
|
||||
>::type
|
||||
operator /(std::valarray<Left> const &left, Right const &right)
|
||||
{
|
||||
typedef typename functional::divides<Left, Right>::result_type value_type;
|
||||
std::valarray<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::divides(left[i], right);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle valarray<Left> * Right where Right is a scalar and Right != Left.
|
||||
template<typename Left, typename Right>
|
||||
typename lazy_enable_if<
|
||||
mpl::and_<is_scalar<Right>, mpl::not_<is_same<Left, Right> > >
|
||||
, acc_detail::make_valarray<functional::multiplies<Left, Right> >
|
||||
>::type
|
||||
operator *(std::valarray<Left> const &left, Right const &right)
|
||||
{
|
||||
typedef typename functional::multiplies<Left, Right>::result_type value_type;
|
||||
std::valarray<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::multiplies(left[i], right);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle valarray<Left> + valarray<Right> where Right != Left.
|
||||
template<typename Left, typename Right>
|
||||
typename lazy_disable_if<
|
||||
is_same<Left, Right>
|
||||
, acc_detail::make_valarray<functional::plus<Left, Right> >
|
||||
>::type
|
||||
operator +(std::valarray<Left> const &left, std::valarray<Right> const &right)
|
||||
{
|
||||
typedef typename functional::plus<Left, Right>::result_type value_type;
|
||||
std::valarray<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::plus(left[i], right[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
struct std_valarray_tag;
|
||||
|
||||
template<typename T>
|
||||
struct tag<std::valarray<T> >
|
||||
{
|
||||
typedef std_valarray_tag type;
|
||||
};
|
||||
|
||||
#ifdef __GLIBCXX__
|
||||
template<typename T, typename U>
|
||||
struct tag<std::_Expr<T, U> >
|
||||
{
|
||||
typedef std_valarray_tag type;
|
||||
};
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
// This is necessary because the GCC stdlib uses expression templates, and
|
||||
// typeof(som-valarray-expression) is not an instance of std::valarray
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(Name, Op) \
|
||||
template<typename Left, typename Right> \
|
||||
struct Name<Left, Right, std_valarray_tag, std_valarray_tag> \
|
||||
: std::binary_function< \
|
||||
Left \
|
||||
, Right \
|
||||
, std::valarray< \
|
||||
typename Name< \
|
||||
typename Left::value_type \
|
||||
, typename Right::value_type \
|
||||
>::result_type \
|
||||
> \
|
||||
> \
|
||||
{ \
|
||||
typedef typename Left::value_type left_value_type; \
|
||||
typedef typename Right::value_type right_value_type; \
|
||||
typedef \
|
||||
std::valarray< \
|
||||
typename Name<left_value_type, right_value_type>::result_type \
|
||||
> \
|
||||
result_type; \
|
||||
result_type \
|
||||
operator ()(Left &left, Right &right) const \
|
||||
{ \
|
||||
return numeric::promote<std::valarray<left_value_type> >(left) \
|
||||
Op numeric::promote<std::valarray<right_value_type> >(right); \
|
||||
} \
|
||||
}; \
|
||||
template<typename Left, typename Right> \
|
||||
struct Name<Left, Right, std_valarray_tag, void> \
|
||||
: std::binary_function< \
|
||||
Left \
|
||||
, Right \
|
||||
, std::valarray< \
|
||||
typename Name<typename Left::value_type, Right>::result_type \
|
||||
> \
|
||||
> \
|
||||
{ \
|
||||
typedef typename Left::value_type left_value_type; \
|
||||
typedef \
|
||||
std::valarray< \
|
||||
typename Name<left_value_type, Right>::result_type \
|
||||
> \
|
||||
result_type; \
|
||||
result_type \
|
||||
operator ()(Left &left, Right &right) const \
|
||||
{ \
|
||||
return numeric::promote<std::valarray<left_value_type> >(left) Op right;\
|
||||
} \
|
||||
}; \
|
||||
template<typename Left, typename Right> \
|
||||
struct Name<Left, Right, void, std_valarray_tag> \
|
||||
: std::binary_function< \
|
||||
Left \
|
||||
, Right \
|
||||
, std::valarray< \
|
||||
typename Name<Left, typename Right::value_type>::result_type \
|
||||
> \
|
||||
> \
|
||||
{ \
|
||||
typedef typename Right::value_type right_value_type; \
|
||||
typedef \
|
||||
std::valarray< \
|
||||
typename Name<Left, right_value_type>::result_type \
|
||||
> \
|
||||
result_type; \
|
||||
result_type \
|
||||
operator ()(Left &left, Right &right) const \
|
||||
{ \
|
||||
return left Op numeric::promote<std::valarray<right_value_type> >(right);\
|
||||
} \
|
||||
};
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(plus, +)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(minus, -)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(multiplies, *)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(divides, /)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP(modulus, %)
|
||||
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_VALARRAY_BIN_OP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// element-wise min of std::valarray
|
||||
template<typename Left, typename Right>
|
||||
struct min_assign<Left, Right, std_valarray_tag, std_valarray_tag>
|
||||
: std::binary_function<Left, Right, void>
|
||||
{
|
||||
void operator ()(Left &left, Right &right) const
|
||||
{
|
||||
BOOST_ASSERT(left.size() == right.size());
|
||||
for(std::size_t i = 0, size = left.size(); i != size; ++i)
|
||||
{
|
||||
if(numeric::less(right[i], left[i]))
|
||||
{
|
||||
left[i] = right[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// element-wise max of std::valarray
|
||||
template<typename Left, typename Right>
|
||||
struct max_assign<Left, Right, std_valarray_tag, std_valarray_tag>
|
||||
: std::binary_function<Left, Right, void>
|
||||
{
|
||||
void operator ()(Left &left, Right &right) const
|
||||
{
|
||||
BOOST_ASSERT(left.size() == right.size());
|
||||
for(std::size_t i = 0, size = left.size(); i != size; ++i)
|
||||
{
|
||||
if(numeric::greater(right[i], left[i]))
|
||||
{
|
||||
left[i] = right[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// partial specialization of numeric::fdiv<> for std::valarray.
|
||||
template<typename Left, typename Right, typename RightTag>
|
||||
struct fdiv<Left, Right, std_valarray_tag, RightTag>
|
||||
: mpl::if_<
|
||||
are_integral<typename Left::value_type, Right>
|
||||
, divides<Left, double const>
|
||||
, divides<Left, Right>
|
||||
>::type
|
||||
{};
|
||||
|
||||
// promote
|
||||
template<typename To, typename From>
|
||||
struct promote<To, From, std_valarray_tag, std_valarray_tag>
|
||||
: std::unary_function<From, To>
|
||||
{
|
||||
To operator ()(From &arr) const
|
||||
{
|
||||
typename remove_const<To>::type res(arr.size());
|
||||
for(std::size_t i = 0, size = arr.size(); i != size; ++i)
|
||||
{
|
||||
res[i] = numeric::promote<typename To::value_type>(arr[i]);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename ToFrom>
|
||||
struct promote<ToFrom, ToFrom, std_valarray_tag, std_valarray_tag>
|
||||
: std::unary_function<ToFrom, ToFrom>
|
||||
{
|
||||
ToFrom &operator ()(ToFrom &tofrom) const
|
||||
{
|
||||
return tofrom;
|
||||
}
|
||||
};
|
||||
|
||||
// for "promoting" a std::valarray<bool> to a bool, useful for
|
||||
// comparing 2 valarrays for equality:
|
||||
// if(numeric::promote<bool>(a == b))
|
||||
template<typename From>
|
||||
struct promote<bool, From, void, std_valarray_tag>
|
||||
: std::unary_function<From, bool>
|
||||
{
|
||||
bool operator ()(From &arr) const
|
||||
{
|
||||
BOOST_MPL_ASSERT((is_same<bool, typename From::value_type>));
|
||||
for(std::size_t i = 0, size = arr.size(); i != size; ++i)
|
||||
{
|
||||
if(!arr[i])
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename From>
|
||||
struct promote<bool const, From, void, std_valarray_tag>
|
||||
: promote<bool, From, void, std_valarray_tag>
|
||||
{};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_min
|
||||
template<typename T>
|
||||
struct as_min<T, std_valarray_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(numeric::as_min(arr[0]), arr.size());
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_max
|
||||
template<typename T>
|
||||
struct as_max<T, std_valarray_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(numeric::as_max(arr[0]), arr.size());
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_zero
|
||||
template<typename T>
|
||||
struct as_zero<T, std_valarray_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(numeric::as_zero(arr[0]), arr.size());
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_one
|
||||
template<typename T>
|
||||
struct as_one<T, std_valarray_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(numeric::as_one(arr[0]), arr.size());
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace functional
|
||||
|
||||
}} // namespace boost::numeric
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,329 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file vector.hpp
|
||||
///
|
||||
// Copyright 2005 Eric Niebler. 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_NUMERIC_FUNCTIONAL_VECTOR_HPP_EAN_12_12_2005
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_VECTOR_HPP_EAN_12_12_2005
|
||||
|
||||
#ifdef BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
|
||||
# error Include this file before boost/accumulators/numeric/functional.hpp
|
||||
#endif
|
||||
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/is_scalar.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/typeof/std/vector.hpp>
|
||||
#include <boost/accumulators/numeric/functional_fwd.hpp>
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
namespace operators
|
||||
{
|
||||
namespace acc_detail
|
||||
{
|
||||
template<typename Fun>
|
||||
struct make_vector
|
||||
{
|
||||
typedef std::vector<typename Fun::result_type> type;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> / Right where Right is a scalar.
|
||||
template<typename Left, typename Right>
|
||||
typename lazy_enable_if<
|
||||
is_scalar<Right>
|
||||
, acc_detail::make_vector<functional::divides<Left, Right> >
|
||||
>::type
|
||||
operator /(std::vector<Left> const &left, Right const &right)
|
||||
{
|
||||
typedef typename functional::divides<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::divides(left[i], right);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> / vector<Right>.
|
||||
template<typename Left, typename Right>
|
||||
std::vector<typename functional::divides<Left, Right>::result_type>
|
||||
operator /(std::vector<Left> const &left, std::vector<Right> const &right)
|
||||
{
|
||||
typedef typename functional::divides<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::divides(left[i], right[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> * Right where Right is a scalar.
|
||||
template<typename Left, typename Right>
|
||||
typename lazy_enable_if<
|
||||
is_scalar<Right>
|
||||
, acc_detail::make_vector<functional::multiplies<Left, Right> >
|
||||
>::type
|
||||
operator *(std::vector<Left> const &left, Right const &right)
|
||||
{
|
||||
typedef typename functional::multiplies<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::multiplies(left[i], right);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle Left * vector<Right> where Left is a scalar.
|
||||
template<typename Left, typename Right>
|
||||
typename lazy_enable_if<
|
||||
is_scalar<Left>
|
||||
, acc_detail::make_vector<functional::multiplies<Left, Right> >
|
||||
>::type
|
||||
operator *(Left const &left, std::vector<Right> const &right)
|
||||
{
|
||||
typedef typename functional::multiplies<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(right.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::multiplies(left, right[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> * vector<Right>
|
||||
template<typename Left, typename Right>
|
||||
std::vector<typename functional::multiplies<Left, Right>::result_type>
|
||||
operator *(std::vector<Left> const &left, std::vector<Right> const &right)
|
||||
{
|
||||
typedef typename functional::multiplies<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::multiplies(left[i], right[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> + vector<Right>
|
||||
template<typename Left, typename Right>
|
||||
std::vector<typename functional::plus<Left, Right>::result_type>
|
||||
operator +(std::vector<Left> const &left, std::vector<Right> const &right)
|
||||
{
|
||||
typedef typename functional::plus<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::plus(left[i], right[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> - vector<Right>
|
||||
template<typename Left, typename Right>
|
||||
std::vector<typename functional::minus<Left, Right>::result_type>
|
||||
operator -(std::vector<Left> const &left, std::vector<Right> const &right)
|
||||
{
|
||||
typedef typename functional::minus<Left, Right>::result_type value_type;
|
||||
std::vector<value_type> result(left.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::minus(left[i], right[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle vector<Left> += vector<Left>
|
||||
template<typename Left>
|
||||
std::vector<Left> &
|
||||
operator +=(std::vector<Left> &left, std::vector<Left> const &right)
|
||||
{
|
||||
BOOST_ASSERT(left.size() == right.size());
|
||||
for(std::size_t i = 0, size = left.size(); i != size; ++i)
|
||||
{
|
||||
numeric::plus_assign(left[i], right[i]);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Handle -vector<Arg>
|
||||
template<typename Arg>
|
||||
std::vector<typename functional::unary_minus<Arg>::result_type>
|
||||
operator -(std::vector<Arg> const &arg)
|
||||
{
|
||||
typedef typename functional::unary_minus<Arg>::result_type value_type;
|
||||
std::vector<value_type> result(arg.size());
|
||||
for(std::size_t i = 0, size = result.size(); i != size; ++i)
|
||||
{
|
||||
result[i] = numeric::unary_minus(arg[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
struct std_vector_tag;
|
||||
|
||||
template<typename T, typename Al>
|
||||
struct tag<std::vector<T, Al> >
|
||||
{
|
||||
typedef std_vector_tag type;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// element-wise min of std::vector
|
||||
template<typename Left, typename Right>
|
||||
struct min_assign<Left, Right, std_vector_tag, std_vector_tag>
|
||||
: std::binary_function<Left, Right, void>
|
||||
{
|
||||
void operator ()(Left &left, Right &right) const
|
||||
{
|
||||
BOOST_ASSERT(left.size() == right.size());
|
||||
for(std::size_t i = 0, size = left.size(); i != size; ++i)
|
||||
{
|
||||
if(numeric::less(right[i], left[i]))
|
||||
{
|
||||
left[i] = right[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// element-wise max of std::vector
|
||||
template<typename Left, typename Right>
|
||||
struct max_assign<Left, Right, std_vector_tag, std_vector_tag>
|
||||
: std::binary_function<Left, Right, void>
|
||||
{
|
||||
void operator ()(Left &left, Right &right) const
|
||||
{
|
||||
BOOST_ASSERT(left.size() == right.size());
|
||||
for(std::size_t i = 0, size = left.size(); i != size; ++i)
|
||||
{
|
||||
if(numeric::greater(right[i], left[i]))
|
||||
{
|
||||
left[i] = right[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// partial specialization for std::vector.
|
||||
template<typename Left, typename Right>
|
||||
struct fdiv<Left, Right, std_vector_tag, void>
|
||||
: mpl::if_<
|
||||
are_integral<typename Left::value_type, Right>
|
||||
, divides<Left, double const>
|
||||
, divides<Left, Right>
|
||||
>::type
|
||||
{};
|
||||
|
||||
// promote
|
||||
template<typename To, typename From>
|
||||
struct promote<To, From, std_vector_tag, std_vector_tag>
|
||||
: std::unary_function<From, To>
|
||||
{
|
||||
To operator ()(From &arr) const
|
||||
{
|
||||
typename remove_const<To>::type res(arr.size());
|
||||
for(std::size_t i = 0, size = arr.size(); i != size; ++i)
|
||||
{
|
||||
res[i] = numeric::promote<typename To::value_type>(arr[i]);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename ToFrom>
|
||||
struct promote<ToFrom, ToFrom, std_vector_tag, std_vector_tag>
|
||||
: std::unary_function<ToFrom, ToFrom>
|
||||
{
|
||||
ToFrom &operator ()(ToFrom &tofrom) const
|
||||
{
|
||||
return tofrom;
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_min
|
||||
template<typename T>
|
||||
struct as_min<T, std_vector_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(arr.size(), numeric::as_min(arr[0]));
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_max
|
||||
template<typename T>
|
||||
struct as_max<T, std_vector_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(arr.size(), numeric::as_max(arr[0]));
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_zero
|
||||
template<typename T>
|
||||
struct as_zero<T, std_vector_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(arr.size(), numeric::as_zero(arr[0]));
|
||||
}
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::as_one
|
||||
template<typename T>
|
||||
struct as_one<T, std_vector_tag>
|
||||
: std::unary_function<T, typename remove_const<T>::type>
|
||||
{
|
||||
typename remove_const<T>::type operator ()(T &arr) const
|
||||
{
|
||||
return 0 == arr.size()
|
||||
? T()
|
||||
: T(arr.size(), numeric::as_one(arr[0]));
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace functional
|
||||
|
||||
}} // namespace boost::numeric
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,221 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file functional_fwd.hpp
|
||||
///
|
||||
// Copyright 2005 Eric Niebler. 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_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
|
||||
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
// For using directives -- this namespace may be re-opened elsewhere
|
||||
namespace operators
|
||||
{}
|
||||
|
||||
namespace op
|
||||
{
|
||||
using mpl::_;
|
||||
using mpl::_1;
|
||||
using mpl::_2;
|
||||
}
|
||||
|
||||
namespace functional
|
||||
{
|
||||
using namespace operators;
|
||||
|
||||
template<typename T>
|
||||
struct tag
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct tag<T const>
|
||||
: tag<T>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct tag<T volatile>
|
||||
: tag<T>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct tag<T const volatile>
|
||||
: tag<T>
|
||||
{};
|
||||
|
||||
template<typename T>
|
||||
struct static_;
|
||||
|
||||
template<typename A0, typename A1>
|
||||
struct are_integral;
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(Name, Op) \
|
||||
namespace functional \
|
||||
{ \
|
||||
template<typename Arg, typename EnableIf = void> \
|
||||
struct Name ## _base; \
|
||||
template<typename Arg, typename ArgTag = typename tag<Arg>::type> \
|
||||
struct Name; \
|
||||
} \
|
||||
namespace op \
|
||||
{ \
|
||||
struct Name; \
|
||||
} \
|
||||
namespace \
|
||||
{ \
|
||||
extern op::Name const &Name; \
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(Name) \
|
||||
namespace functional \
|
||||
{ \
|
||||
template<typename Left, typename Right, typename EnableIf = void> \
|
||||
struct result_of_ ## Name; \
|
||||
template<typename Left, typename Right, typename EnableIf = void> \
|
||||
struct Name ## _base; \
|
||||
template< \
|
||||
typename Left \
|
||||
, typename Right \
|
||||
, typename LeftTag = typename tag<Left>::type \
|
||||
, typename RightTag = typename tag<Right>::type \
|
||||
> \
|
||||
struct Name; \
|
||||
} \
|
||||
namespace op \
|
||||
{ \
|
||||
struct Name; \
|
||||
} \
|
||||
namespace \
|
||||
{ \
|
||||
extern op::Name const &Name; \
|
||||
}
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater_equal)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less_equal)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(equal_to)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(not_equal_to)
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(assign)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus_assign)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus_assign)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies_assign)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides_assign)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus_assign)
|
||||
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_plus, +)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_minus, -)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(complement, ~)
|
||||
BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(logical_not, !)
|
||||
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP
|
||||
#undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP
|
||||
|
||||
|
||||
namespace functional
|
||||
{
|
||||
template<typename To, typename From, typename EnableIf = void>
|
||||
struct promote_base;
|
||||
template<typename Left, typename Right, typename EnableIf = void>
|
||||
struct min_assign_base;
|
||||
template<typename Left, typename Right, typename EnableIf = void>
|
||||
struct max_assign_base;
|
||||
template<typename Left, typename Right, typename EnableIf = void>
|
||||
struct fdiv_base;
|
||||
template<typename Arg, typename EnableIf = void>
|
||||
struct as_min_base;
|
||||
template<typename Arg, typename EnableIf = void>
|
||||
struct as_max_base;
|
||||
template<typename Arg, typename EnableIf = void>
|
||||
struct as_zero_base;
|
||||
template<typename Arg, typename EnableIf = void>
|
||||
struct as_one_base;
|
||||
|
||||
template<typename To, typename From, typename ToTag = typename tag<To>::type, typename FromTag = typename tag<From>::type>
|
||||
struct promote;
|
||||
template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
|
||||
struct min_assign;
|
||||
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 fdiv;
|
||||
template<typename Arg, typename Tag = typename tag<Arg>::type>
|
||||
struct as_min;
|
||||
template<typename Arg, typename Tag = typename tag<Arg>::type>
|
||||
struct as_max;
|
||||
template<typename Arg, typename Tag = typename tag<Arg>::type>
|
||||
struct as_zero;
|
||||
template<typename Arg, typename Tag = typename tag<Arg>::type>
|
||||
struct as_one;
|
||||
}
|
||||
|
||||
namespace op
|
||||
{
|
||||
template<typename To>
|
||||
struct promote;
|
||||
struct min_assign;
|
||||
struct max_assign;
|
||||
struct fdiv;
|
||||
struct as_min;
|
||||
struct as_max;
|
||||
struct as_zero;
|
||||
struct as_one;
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
extern op::min_assign const &min_assign;
|
||||
extern op::max_assign const &max_assign;
|
||||
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;
|
||||
extern op::as_one const &as_one;
|
||||
}
|
||||
|
||||
template<typename To, typename From>
|
||||
typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
|
||||
promote(From &from);
|
||||
|
||||
template<typename To, typename From>
|
||||
typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
|
||||
promote(From const &from);
|
||||
|
||||
template<typename T>
|
||||
struct default_;
|
||||
|
||||
template<typename T>
|
||||
struct one;
|
||||
|
||||
template<typename T>
|
||||
struct zero;
|
||||
|
||||
template<typename T>
|
||||
struct one_or_default;
|
||||
|
||||
template<typename T>
|
||||
struct zero_or_default;
|
||||
|
||||
}} // namespace boost::numeric
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,61 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file statistics.hpp
|
||||
/// Includes all of the Statistical Accumulators Library
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_HPP_EAN_01_17_2006
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_HPP_EAN_01_17_2006
|
||||
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/covariance.hpp>
|
||||
#include <boost/accumulators/statistics/density.hpp>
|
||||
#include <boost/accumulators/statistics/error_of.hpp>
|
||||
#include <boost/accumulators/statistics/error_of_mean.hpp>
|
||||
#include <boost/accumulators/statistics/extended_p_square.hpp>
|
||||
#include <boost/accumulators/statistics/extended_p_square_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/kurtosis.hpp>
|
||||
#include <boost/accumulators/statistics/max.hpp>
|
||||
#include <boost/accumulators/statistics/mean.hpp>
|
||||
#include <boost/accumulators/statistics/median.hpp>
|
||||
#include <boost/accumulators/statistics/min.hpp>
|
||||
#include <boost/accumulators/statistics/moment.hpp>
|
||||
#include <boost/accumulators/statistics/peaks_over_threshold.hpp>
|
||||
#include <boost/accumulators/statistics/pot_tail_mean.hpp>
|
||||
#include <boost/accumulators/statistics/pot_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/p_square_cumul_dist.hpp>
|
||||
#include <boost/accumulators/statistics/p_square_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/skewness.hpp>
|
||||
#include <boost/accumulators/statistics/stats.hpp>
|
||||
#include <boost/accumulators/statistics/sum.hpp>
|
||||
#include <boost/accumulators/statistics/sum_kahan.hpp>
|
||||
#include <boost/accumulators/statistics/tail.hpp>
|
||||
#include <boost/accumulators/statistics/tail_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/tail_mean.hpp>
|
||||
#include <boost/accumulators/statistics/tail_variate.hpp>
|
||||
#include <boost/accumulators/statistics/tail_variate_means.hpp>
|
||||
#include <boost/accumulators/statistics/variance.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_covariance.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_density.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_kurtosis.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_extended_p_square.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_mean.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_median.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_moment.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_peaks_over_threshold.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_p_square_cumul_dist.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_p_square_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_skewness.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_sum.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_sum_kahan.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_tail_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_tail_mean.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_tail_variate_means.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_variance.hpp>
|
||||
#include <boost/accumulators/statistics/with_error.hpp>
|
||||
#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
|
||||
#include <boost/accumulators/statistics/variates/covariate.hpp>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,80 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// count.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_COUNT_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_COUNT_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/mpl/always.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// count_impl
|
||||
struct count_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef std::size_t result_type;
|
||||
|
||||
count_impl(dont_care)
|
||||
: cnt(0)
|
||||
{
|
||||
}
|
||||
|
||||
void operator ()(dont_care)
|
||||
{
|
||||
++this->cnt;
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->cnt;
|
||||
}
|
||||
|
||||
private:
|
||||
std::size_t cnt;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::count
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct count
|
||||
: depends_on<>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef mpl::always<accumulators::impl::count_impl> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::count
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::count> const count = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(count)
|
||||
}
|
||||
|
||||
using extract::count;
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,220 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// covariance.hpp
|
||||
//
|
||||
// Copyright 2006 Daniel Egloff, Olivier Gygi. 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_COVARIANCE_HPP_DE_01_01_2006
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_COVARIANCE_HPP_DE_01_01_2006
|
||||
|
||||
#include <vector>
|
||||
#include <limits>
|
||||
#include <numeric>
|
||||
#include <functional>
|
||||
#include <complex>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/range.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/numeric/ublas/io.hpp>
|
||||
#include <boost/numeric/ublas/matrix.hpp>
|
||||
#include <boost/type_traits/is_scalar.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/mean.hpp>
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
namespace functional
|
||||
{
|
||||
struct std_vector_tag;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// functional::outer_product
|
||||
template<typename Left, typename Right, typename EnableIf = void>
|
||||
struct outer_product_base
|
||||
: functional::multiplies<Left, Right>
|
||||
{};
|
||||
|
||||
template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
|
||||
struct outer_product
|
||||
: outer_product_base<Left, Right, void>
|
||||
{};
|
||||
|
||||
template<typename Left, typename Right>
|
||||
struct outer_product<Left, Right, std_vector_tag, std_vector_tag>
|
||||
: std::binary_function<
|
||||
Left
|
||||
, Right
|
||||
, ublas::matrix<
|
||||
typename functional::multiplies<
|
||||
typename Left::value_type
|
||||
, typename Right::value_type
|
||||
>::result_type
|
||||
>
|
||||
>
|
||||
{
|
||||
typedef
|
||||
ublas::matrix<
|
||||
typename functional::multiplies<
|
||||
typename Left::value_type
|
||||
, typename Right::value_type
|
||||
>::result_type
|
||||
>
|
||||
result_type;
|
||||
|
||||
result_type
|
||||
operator ()(Left & left, Right & right) const
|
||||
{
|
||||
std::size_t left_size = left.size();
|
||||
std::size_t right_size = right.size();
|
||||
result_type result(left_size, right_size);
|
||||
for (std::size_t i = 0; i < left_size; ++i)
|
||||
for (std::size_t j = 0; j < right_size; ++j)
|
||||
result(i,j) = numeric::multiplies(left[i], right[j]);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
namespace op
|
||||
{
|
||||
struct outer_product
|
||||
: boost::detail::function2<functional::outer_product<_1, _2, functional::tag<_1>, functional::tag<_2> > >
|
||||
{};
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
op::outer_product const &outer_product = boost::detail::pod_singleton<op::outer_product>::instance;
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// covariance_impl
|
||||
//
|
||||
/**
|
||||
@brief Covariance Estimator
|
||||
|
||||
An iterative Monte Carlo estimator for the covariance \f$\mathrm{Cov}(X,X')\f$, where \f$X\f$ is a sample
|
||||
and \f$X'\f$ is a variate, is given by:
|
||||
|
||||
\f[
|
||||
\hat{c}_n = \frac{n-1}{n} \hat{c}_{n-1} + \frac{1}{n-1}(X_n - \hat{\mu}_n)(X_n' - \hat{\mu}_n'),\quad n\ge2,\quad\hat{c}_1 = 0,
|
||||
\f]
|
||||
|
||||
\f$\hat{\mu}_n\f$ and \f$\hat{\mu}_n'\f$ being the means of the samples and variates.
|
||||
*/
|
||||
template<typename Sample, typename VariateType, typename VariateTag>
|
||||
struct covariance_impl
|
||||
: accumulator_base
|
||||
{
|
||||
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;
|
||||
|
||||
template<typename Args>
|
||||
covariance_impl(Args const &args)
|
||||
: cov_(
|
||||
numeric::outer_product(
|
||||
numeric::fdiv(args[sample | Sample()], (std::size_t)1)
|
||||
, numeric::fdiv(args[parameter::keyword<VariateTag>::get() | VariateType()], (std::size_t)1)
|
||||
)
|
||||
)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
std::size_t cnt = count(args);
|
||||
|
||||
if (cnt > 1)
|
||||
{
|
||||
extractor<tag::mean_of_variates<VariateType, VariateTag> > const some_mean_of_variates = {};
|
||||
|
||||
this->cov_ = this->cov_*(cnt-1.)/cnt
|
||||
+ numeric::outer_product(
|
||||
some_mean_of_variates(args) - args[parameter::keyword<VariateTag>::get()]
|
||||
, mean(args) - args[sample]
|
||||
) / (cnt-1.);
|
||||
}
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->cov_;
|
||||
}
|
||||
|
||||
private:
|
||||
result_type cov_;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::covariance
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct covariance
|
||||
: depends_on<count, mean, mean_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
typedef accumulators::impl::covariance_impl<mpl::_1, VariateType, VariateTag> impl;
|
||||
};
|
||||
|
||||
struct abstract_covariance
|
||||
: depends_on<>
|
||||
{
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::covariance
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::abstract_covariance> const covariance = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(covariance)
|
||||
}
|
||||
|
||||
using extract::covariance;
|
||||
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct feature_of<tag::covariance<VariateType, VariateTag> >
|
||||
: feature_of<tag::abstract_covariance>
|
||||
{
|
||||
};
|
||||
|
||||
// So that covariance can be automatically substituted with
|
||||
// weighted_covariance when the weight parameter is non-void.
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct as_weighted_feature<tag::covariance<VariateType, VariateTag> >
|
||||
{
|
||||
typedef tag::weighted_covariance<VariateType, VariateTag> type;
|
||||
};
|
||||
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct feature_of<tag::weighted_covariance<VariateType, VariateTag> >
|
||||
: feature_of<tag::covariance<VariateType, VariateTag> >
|
||||
{};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,250 @@
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// density.hpp
|
||||
//
|
||||
// Copyright 2006 Daniel Egloff, Olivier Gygi. 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_DENSITY_HPP_DE_01_01_2006
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_DENSITY_HPP_DE_01_01_2006
|
||||
|
||||
#include <vector>
|
||||
#include <limits>
|
||||
#include <functional>
|
||||
#include <boost/range.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/max.hpp>
|
||||
#include <boost/accumulators/statistics/min.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// cache_size and num_bins named parameters
|
||||
//
|
||||
BOOST_PARAMETER_NESTED_KEYWORD(tag, density_cache_size, cache_size)
|
||||
BOOST_PARAMETER_NESTED_KEYWORD(tag, density_num_bins, num_bins)
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(density_cache_size)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(density_num_bins)
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// density_impl
|
||||
// density histogram
|
||||
/**
|
||||
@brief Histogram density estimator
|
||||
|
||||
The histogram density estimator returns a histogram of the sample distribution. The positions and sizes of the bins
|
||||
are determined using a specifiable number of cached samples (cache_size). The range between the minimum and the
|
||||
maximum of the cached samples is subdivided into a specifiable number of bins (num_bins) of same size. Additionally,
|
||||
an under- and an overflow bin is added to capture future under- and overflow samples. Once the bins are determined,
|
||||
the cached samples and all subsequent samples are added to the correct bins. At the end, a range of std::pair is
|
||||
return, where each pair contains the position of the bin (lower bound) and the samples count (normalized with the
|
||||
total number of samples).
|
||||
|
||||
@param density_cache_size Number of first samples used to determine min and max.
|
||||
@param density_num_bins Number of bins (two additional bins collect under- and overflow samples).
|
||||
*/
|
||||
template<typename Sample>
|
||||
struct density_impl
|
||||
: accumulator_base
|
||||
{
|
||||
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
|
||||
typedef iterator_range<typename histogram_type::iterator> result_type;
|
||||
|
||||
template<typename Args>
|
||||
density_impl(Args const &args)
|
||||
: cache_size(args[density_cache_size])
|
||||
, cache(cache_size)
|
||||
, num_bins(args[density_num_bins])
|
||||
, samples_in_bin(num_bins + 2, 0.)
|
||||
, bin_positions(num_bins + 2)
|
||||
, histogram(
|
||||
num_bins + 2
|
||||
, std::make_pair(
|
||||
numeric::fdiv(args[sample | Sample()],(std::size_t)1)
|
||||
, numeric::fdiv(args[sample | Sample()],(std::size_t)1)
|
||||
)
|
||||
)
|
||||
, is_dirty(true)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
this->is_dirty = true;
|
||||
|
||||
std::size_t cnt = count(args);
|
||||
|
||||
// Fill up cache with cache_size first samples
|
||||
if (cnt <= this->cache_size)
|
||||
{
|
||||
this->cache[cnt - 1] = args[sample];
|
||||
}
|
||||
|
||||
// Once cache_size samples have been accumulated, create num_bins bins of same size between
|
||||
// the minimum and maximum of the cached samples as well as under and overflow bins.
|
||||
// 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::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)
|
||||
{
|
||||
this->bin_positions[i] = minimum + (i - 1.) * bin_size;
|
||||
}
|
||||
|
||||
for (typename array_type::const_iterator iter = this->cache.begin(); iter != this->cache.end(); ++iter)
|
||||
{
|
||||
if (*iter < this->bin_positions[1])
|
||||
{
|
||||
++(this->samples_in_bin[0]);
|
||||
}
|
||||
else if (*iter >= this->bin_positions[this->num_bins + 1])
|
||||
{
|
||||
++(this->samples_in_bin[this->num_bins + 1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
typename array_type::iterator it = std::upper_bound(
|
||||
this->bin_positions.begin()
|
||||
, this->bin_positions.end()
|
||||
, *iter
|
||||
);
|
||||
|
||||
std::size_t d = std::distance(this->bin_positions.begin(), it);
|
||||
++(this->samples_in_bin[d - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Add each subsequent sample to the correct bin
|
||||
else if (cnt > this->cache_size)
|
||||
{
|
||||
if (args[sample] < this->bin_positions[1])
|
||||
{
|
||||
++(this->samples_in_bin[0]);
|
||||
}
|
||||
else if (args[sample] >= this->bin_positions[this->num_bins + 1])
|
||||
{
|
||||
++(this->samples_in_bin[this->num_bins + 1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
typename array_type::iterator it = std::upper_bound(
|
||||
this->bin_positions.begin()
|
||||
, this->bin_positions.end()
|
||||
, args[sample]
|
||||
);
|
||||
|
||||
std::size_t d = std::distance(this->bin_positions.begin(), it);
|
||||
++(this->samples_in_bin[d - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@pre The number of samples must meet or exceed the cache size
|
||||
*/
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
if (this->is_dirty)
|
||||
{
|
||||
this->is_dirty = false;
|
||||
|
||||
// creates a vector of std::pair where each pair i holds
|
||||
// the values bin_positions[i] (x-axis of histogram) and
|
||||
// samples_in_bin[i] / cnt (y-axis of histogram).
|
||||
|
||||
for (std::size_t i = 0; i < this->num_bins + 2; ++i)
|
||||
{
|
||||
this->histogram[i] = std::make_pair(this->bin_positions[i], numeric::fdiv(this->samples_in_bin[i], count(args)));
|
||||
}
|
||||
}
|
||||
// returns a range of pairs
|
||||
return make_iterator_range(this->histogram);
|
||||
}
|
||||
|
||||
private:
|
||||
std::size_t cache_size; // number of cached samples
|
||||
array_type cache; // cache to store the first cache_size samples
|
||||
std::size_t num_bins; // number of bins
|
||||
array_type samples_in_bin; // number of samples in each bin
|
||||
array_type bin_positions; // lower bounds of bins
|
||||
mutable histogram_type histogram; // histogram
|
||||
mutable bool is_dirty;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::density
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct density
|
||||
: depends_on<count, min, max>
|
||||
, density_cache_size
|
||||
, density_num_bins
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::density_impl<mpl::_1> impl;
|
||||
|
||||
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
||||
/// tag::density::cache_size named parameter
|
||||
/// tag::density::num_bins named parameter
|
||||
static boost::parameter::keyword<density_cache_size> const cache_size;
|
||||
static boost::parameter::keyword<density_num_bins> const num_bins;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::density
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::density> const density = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(density)
|
||||
}
|
||||
|
||||
using extract::density;
|
||||
|
||||
// So that density can be automatically substituted
|
||||
// with weighted_density when the weight parameter is non-void.
|
||||
template<>
|
||||
struct as_weighted_feature<tag::density>
|
||||
{
|
||||
typedef tag::weighted_density type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::weighted_density>
|
||||
: feature_of<tag::density>
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,99 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// error_of.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_ERROR_OF_HPP_EAN_29_11_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_ERROR_OF_HPP_EAN_29_11_2005
|
||||
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Feature>
|
||||
struct this_feature_has_no_error_calculation
|
||||
: mpl::false_
|
||||
{
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// error_of_impl
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename Sample, typename Feature>
|
||||
struct error_of_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// TODO: specialize this on the specific features that have errors we're
|
||||
// interested in.
|
||||
BOOST_MPL_ASSERT((this_feature_has_no_error_calculation<Feature>));
|
||||
|
||||
// for boost::result_of
|
||||
typedef int result_type;
|
||||
|
||||
error_of_impl(dont_care)
|
||||
{
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::error_of
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
template<typename Feature>
|
||||
struct error_of
|
||||
: depends_on<Feature>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::error_of_impl<mpl::_1, Feature> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::error_of
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, error_of, (typename))
|
||||
}
|
||||
|
||||
using extract::error_of;
|
||||
|
||||
// make tag::error_of<tag::feature(modifier)> work
|
||||
template<typename Feature>
|
||||
struct as_feature<tag::error_of<Feature> >
|
||||
{
|
||||
typedef tag::error_of<typename as_feature<Feature>::type> type;
|
||||
};
|
||||
|
||||
// make error_of<tag::mean> work with non-void weights (should become
|
||||
// error_of<tag::weighted_mean>
|
||||
template<typename Feature>
|
||||
struct as_weighted_feature<tag::error_of<Feature> >
|
||||
{
|
||||
typedef tag::error_of<typename as_weighted_feature<Feature>::type> type;
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,73 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// error_of.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_ERROR_OF_MEAN_HPP_EAN_27_03_2006
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_ERROR_OF_MEAN_HPP_EAN_27_03_2006
|
||||
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/error_of.hpp>
|
||||
#include <boost/accumulators/statistics/variance.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// error_of_mean_impl
|
||||
template<typename Sample, typename Variance>
|
||||
struct error_of_mean_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
|
||||
|
||||
error_of_mean_impl(dont_care) {}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
using namespace std;
|
||||
extractor<Variance> const variance = {};
|
||||
return sqrt(numeric::fdiv(variance(args), count(args) - 1));
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::error_of
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
template<>
|
||||
struct error_of<mean>
|
||||
: depends_on<lazy_variance, count>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::error_of_mean_impl<mpl::_1, lazy_variance> impl;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct error_of<immediate_mean>
|
||||
: depends_on<variance, count>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::error_of_mean_impl<mpl::_1, variance> impl;
|
||||
};
|
||||
}
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+295
@@ -0,0 +1,295 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extended_p_square.hpp
|
||||
//
|
||||
// Copyright 2005 Daniel Egloff. 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_EXTENDED_SINGLE_HPP_DE_01_01_2006
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_EXTENDED_SINGLE_HPP_DE_01_01_2006
|
||||
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
#include <boost/range/begin.hpp>
|
||||
#include <boost/range/end.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/iterator/counting_iterator.hpp>
|
||||
#include <boost/iterator/permutation_iterator.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/accumulators_fwd.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/times2_iterator.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// probabilities named parameter
|
||||
//
|
||||
BOOST_PARAMETER_NESTED_KEYWORD(tag, extended_p_square_probabilities, probabilities)
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square_probabilities)
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extended_p_square_impl
|
||||
// multiple quantile estimation
|
||||
/**
|
||||
@brief Multiple quantile estimation with the extended \f$P^2\f$ algorithm
|
||||
|
||||
Extended \f$P^2\f$ algorithm for estimation of several quantiles without storing samples.
|
||||
Assume that \f$m\f$ quantiles \f$\xi_{p_1}, \ldots, \xi_{p_m}\f$ are to be estimated.
|
||||
Instead of storing the whole sample cumulative distribution, the algorithm maintains only
|
||||
\f$m+2\f$ principal markers and \f$m+1\f$ middle markers, whose positions are updated
|
||||
with each sample and whose heights are adjusted (if necessary) using a piecewise-parablic
|
||||
formula. The heights of these central markers are the current estimates of the quantiles
|
||||
and returned as an iterator range.
|
||||
|
||||
For further details, see
|
||||
|
||||
K. E. E. Raatikainen, Simultaneous estimation of several quantiles, Simulation, Volume 49,
|
||||
Number 4 (October), 1986, p. 159-164.
|
||||
|
||||
The extended \f$ P^2 \f$ algorithm generalizes the \f$ P^2 \f$ algorithm of
|
||||
|
||||
R. Jain and I. Chlamtac, The P^2 algorithm for dynamic calculation of quantiles and
|
||||
histograms without storing observations, Communications of the ACM,
|
||||
Volume 28 (October), Number 10, 1985, p. 1076-1085.
|
||||
|
||||
@param extended_p_square_probabilities A vector of quantile probabilities.
|
||||
*/
|
||||
template<typename Sample>
|
||||
struct extended_p_square_impl
|
||||
: accumulator_base
|
||||
{
|
||||
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<
|
||||
detail::lvalue_index_iterator<
|
||||
permutation_iterator<
|
||||
typename array_type::const_iterator
|
||||
, detail::times2_iterator
|
||||
>
|
||||
>
|
||||
> result_type;
|
||||
|
||||
template<typename Args>
|
||||
extended_p_square_impl(Args const &args)
|
||||
: probabilities(
|
||||
boost::begin(args[extended_p_square_probabilities])
|
||||
, boost::end(args[extended_p_square_probabilities])
|
||||
)
|
||||
, heights(2 * probabilities.size() + 3)
|
||||
, actual_positions(heights.size())
|
||||
, desired_positions(heights.size())
|
||||
, positions_increments(heights.size())
|
||||
{
|
||||
std::size_t num_quantiles = this->probabilities.size();
|
||||
std::size_t num_markers = this->heights.size();
|
||||
|
||||
for(std::size_t i = 0; i < num_markers; ++i)
|
||||
{
|
||||
this->actual_positions[i] = i + 1;
|
||||
}
|
||||
|
||||
this->positions_increments[0] = 0.;
|
||||
this->positions_increments[num_markers - 1] = 1.;
|
||||
|
||||
for(std::size_t i = 0; i < num_quantiles; ++i)
|
||||
{
|
||||
this->positions_increments[2 * i + 2] = probabilities[i];
|
||||
}
|
||||
|
||||
for(std::size_t i = 0; i <= num_quantiles; ++i)
|
||||
{
|
||||
this->positions_increments[2 * i + 1] =
|
||||
0.5 * (this->positions_increments[2 * i] + this->positions_increments[2 * i + 2]);
|
||||
}
|
||||
|
||||
for(std::size_t i = 0; i < num_markers; ++i)
|
||||
{
|
||||
this->desired_positions[i] = 1. + 2. * (num_quantiles + 1.) * this->positions_increments[i];
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
std::size_t cnt = count(args);
|
||||
|
||||
// m+2 principal markers and m+1 middle markers
|
||||
std::size_t num_markers = 2 * this->probabilities.size() + 3;
|
||||
|
||||
// first accumulate num_markers samples
|
||||
if(cnt <= num_markers)
|
||||
{
|
||||
this->heights[cnt - 1] = args[sample];
|
||||
|
||||
// complete the initialization of heights by sorting
|
||||
if(cnt == num_markers)
|
||||
{
|
||||
std::sort(this->heights.begin(), this->heights.end());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
std::size_t sample_cell = 1;
|
||||
|
||||
// find cell k = sample_cell such that heights[k-1] <= sample < heights[k]
|
||||
if(args[sample] < this->heights[0])
|
||||
{
|
||||
this->heights[0] = args[sample];
|
||||
sample_cell = 1;
|
||||
}
|
||||
else if(args[sample] >= this->heights[num_markers - 1])
|
||||
{
|
||||
this->heights[num_markers - 1] = args[sample];
|
||||
sample_cell = num_markers - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
typedef typename array_type::iterator iterator;
|
||||
iterator it = std::upper_bound(
|
||||
this->heights.begin()
|
||||
, this->heights.end()
|
||||
, args[sample]
|
||||
);
|
||||
|
||||
sample_cell = std::distance(this->heights.begin(), it);
|
||||
}
|
||||
|
||||
// update actual positions of all markers above sample_cell index
|
||||
for(std::size_t i = sample_cell; i < num_markers; ++i)
|
||||
{
|
||||
++this->actual_positions[i];
|
||||
}
|
||||
|
||||
// update desired positions of all markers
|
||||
for(std::size_t i = 0; i < num_markers; ++i)
|
||||
{
|
||||
this->desired_positions[i] += this->positions_increments[i];
|
||||
}
|
||||
|
||||
// adjust heights and actual positions of markers 1 to num_markers-2 if necessary
|
||||
for(std::size_t i = 1; i <= num_markers - 2; ++i)
|
||||
{
|
||||
// offset to desired position
|
||||
float_type d = this->desired_positions[i] - this->actual_positions[i];
|
||||
|
||||
// offset to next position
|
||||
float_type dp = this->actual_positions[i+1] - this->actual_positions[i];
|
||||
|
||||
// offset to previous position
|
||||
float_type dm = this->actual_positions[i-1] - this->actual_positions[i];
|
||||
|
||||
// height ds
|
||||
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))
|
||||
{
|
||||
short sign_d = static_cast<short>(d / std::abs(d));
|
||||
|
||||
float_type h = this->heights[i] + sign_d / (dp - dm) * ((sign_d - dm)*hp
|
||||
+ (dp - sign_d) * hm);
|
||||
|
||||
// try adjusting heights[i] using p-squared formula
|
||||
if(this->heights[i - 1] < h && h < this->heights[i + 1])
|
||||
{
|
||||
this->heights[i] = h;
|
||||
}
|
||||
else
|
||||
{
|
||||
// use linear formula
|
||||
if(d > 0)
|
||||
{
|
||||
this->heights[i] += hp;
|
||||
}
|
||||
if(d < 0)
|
||||
{
|
||||
this->heights[i] -= hm;
|
||||
}
|
||||
}
|
||||
this->actual_positions[i] += sign_d;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
// for i in [1,probabilities.size()], return heights[i * 2]
|
||||
detail::times2_iterator idx_begin = detail::make_times2_iterator(1);
|
||||
detail::times2_iterator idx_end = detail::make_times2_iterator(this->probabilities.size() + 1);
|
||||
|
||||
return result_type(
|
||||
make_permutation_iterator(this->heights.begin(), idx_begin)
|
||||
, make_permutation_iterator(this->heights.begin(), idx_end)
|
||||
);
|
||||
}
|
||||
|
||||
private:
|
||||
array_type probabilities; // the quantile probabilities
|
||||
array_type heights; // q_i
|
||||
array_type actual_positions; // n_i
|
||||
array_type desired_positions; // d_i
|
||||
array_type positions_increments; // f_i
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::extended_p_square
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct extended_p_square
|
||||
: depends_on<count>
|
||||
, extended_p_square_probabilities
|
||||
{
|
||||
typedef accumulators::impl::extended_p_square_impl<mpl::_1> impl;
|
||||
|
||||
#ifdef BOOST_ACCUMULATORS_DOXYGEN_INVOKED
|
||||
/// tag::extended_p_square::probabilities named parameter
|
||||
static boost::parameter::keyword<tag::probabilities> const probabilities;
|
||||
#endif
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::extended_p_square
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::extended_p_square> const extended_p_square = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square)
|
||||
}
|
||||
|
||||
using extract::extended_p_square;
|
||||
|
||||
// So that extended_p_square can be automatically substituted with
|
||||
// weighted_extended_p_square when the weight parameter is non-void
|
||||
template<>
|
||||
struct as_weighted_feature<tag::extended_p_square>
|
||||
{
|
||||
typedef tag::weighted_extended_p_square type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::weighted_extended_p_square>
|
||||
: feature_of<tag::extended_p_square>
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
+320
@@ -0,0 +1,320 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extended_p_square_quantile.hpp
|
||||
//
|
||||
// Copyright 2005 Daniel Egloff. 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_EXTENDED_SINGLE_QUANTILE_HPP_DE_01_01_2006
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_EXTENDED_SINGLE_QUANTILE_HPP_DE_01_01_2006
|
||||
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
#include <boost/throw_exception.hpp>
|
||||
#include <boost/range/begin.hpp>
|
||||
#include <boost/range/end.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
#include <boost/iterator/transform_iterator.hpp>
|
||||
#include <boost/iterator/counting_iterator.hpp>
|
||||
#include <boost/iterator/permutation_iterator.hpp>
|
||||
#include <boost/parameter/keyword.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/parameters/quantile_probability.hpp>
|
||||
#include <boost/accumulators/statistics/extended_p_square.hpp>
|
||||
#include <boost/accumulators/statistics/weighted_extended_p_square.hpp>
|
||||
#include <boost/accumulators/statistics/times2_iterator.hpp>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4127) // conditional expression is constant
|
||||
#endif
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extended_p_square_quantile_impl
|
||||
// single quantile estimation
|
||||
/**
|
||||
@brief Quantile estimation using the extended \f$P^2\f$ algorithm for weighted and unweighted samples
|
||||
|
||||
Uses the quantile estimates calculated by the extended \f$P^2\f$ algorithm to compute
|
||||
intermediate quantile estimates by means of quadratic interpolation.
|
||||
|
||||
@param quantile_probability The probability of the quantile to be estimated.
|
||||
*/
|
||||
template<typename Sample, typename Impl1, typename Impl2> // Impl1: weighted/unweighted // Impl2: linear/quadratic
|
||||
struct extended_p_square_quantile_impl
|
||||
: accumulator_base
|
||||
{
|
||||
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<
|
||||
permutation_iterator<
|
||||
typename array_type::const_iterator
|
||||
, detail::times2_iterator
|
||||
>
|
||||
>
|
||||
> range_type;
|
||||
// for boost::result_of
|
||||
typedef float_type result_type;
|
||||
|
||||
template<typename Args>
|
||||
extended_p_square_quantile_impl(Args const &args)
|
||||
: probabilities(
|
||||
boost::begin(args[extended_p_square_probabilities])
|
||||
, boost::end(args[extended_p_square_probabilities])
|
||||
)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
typedef
|
||||
typename mpl::if_<
|
||||
is_same<Impl1, weighted>
|
||||
, tag::weighted_extended_p_square
|
||||
, tag::extended_p_square
|
||||
>::type
|
||||
extended_p_square_tag;
|
||||
|
||||
extractor<extended_p_square_tag> const some_extended_p_square = {};
|
||||
|
||||
array_type heights(some_extended_p_square(args).size());
|
||||
std::copy(some_extended_p_square(args).begin(), some_extended_p_square(args).end(), heights.begin());
|
||||
|
||||
this->probability = args[quantile_probability];
|
||||
|
||||
typename array_type::const_iterator iter_probs = std::lower_bound(this->probabilities.begin(), this->probabilities.end(), this->probability);
|
||||
std::size_t dist = std::distance(this->probabilities.begin(), iter_probs);
|
||||
typename array_type::const_iterator iter_heights = heights.begin() + dist;
|
||||
|
||||
// If this->probability is not in a valid range return NaN or throw exception
|
||||
if (this->probability < *this->probabilities.begin() || this->probability > *(this->probabilities.end() - 1))
|
||||
{
|
||||
if (std::numeric_limits<result_type>::has_quiet_NaN)
|
||||
{
|
||||
return std::numeric_limits<result_type>::quiet_NaN();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::ostringstream msg;
|
||||
msg << "probability = " << this->probability << " is not in valid range (";
|
||||
msg << *this->probabilities.begin() << ", " << *(this->probabilities.end() - 1) << ")";
|
||||
boost::throw_exception(std::runtime_error(msg.str()));
|
||||
return Sample(0);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (*iter_probs == this->probability)
|
||||
{
|
||||
return heights[dist];
|
||||
}
|
||||
else
|
||||
{
|
||||
result_type res;
|
||||
|
||||
if (is_same<Impl2, linear>::value)
|
||||
{
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
// LINEAR INTERPOLATION
|
||||
//
|
||||
float_type p1 = *iter_probs;
|
||||
float_type p0 = *(iter_probs - 1);
|
||||
float_type h1 = *iter_heights;
|
||||
float_type h0 = *(iter_heights - 1);
|
||||
|
||||
float_type a = numeric::fdiv(h1 - h0, p1 - p0);
|
||||
float_type b = h1 - p1 * a;
|
||||
|
||||
res = a * this->probability + b;
|
||||
}
|
||||
else
|
||||
{
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
// QUADRATIC INTERPOLATION
|
||||
//
|
||||
float_type p0, p1, p2;
|
||||
float_type h0, h1, h2;
|
||||
|
||||
if ( (dist == 1 || *iter_probs - this->probability <= this->probability - *(iter_probs - 1) ) && dist != this->probabilities.size() - 1 )
|
||||
{
|
||||
p0 = *(iter_probs - 1);
|
||||
p1 = *iter_probs;
|
||||
p2 = *(iter_probs + 1);
|
||||
h0 = *(iter_heights - 1);
|
||||
h1 = *iter_heights;
|
||||
h2 = *(iter_heights + 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
p0 = *(iter_probs - 2);
|
||||
p1 = *(iter_probs - 1);
|
||||
p2 = *iter_probs;
|
||||
h0 = *(iter_heights - 2);
|
||||
h1 = *(iter_heights - 1);
|
||||
h2 = *iter_heights;
|
||||
}
|
||||
|
||||
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::fdiv(hp21 - hp10, p21 - p10);
|
||||
float_type b = hp21 - a * p21;
|
||||
float_type c = h2 - a * p2 * p2 - b * p2;
|
||||
|
||||
res = a * this->probability * this-> probability + b * this->probability + c;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
}
|
||||
private:
|
||||
|
||||
array_type probabilities;
|
||||
mutable float_type probability;
|
||||
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::extended_p_square_quantile
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct extended_p_square_quantile
|
||||
: depends_on<extended_p_square>
|
||||
{
|
||||
typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, unweighted, linear> impl;
|
||||
};
|
||||
struct extended_p_square_quantile_quadratic
|
||||
: depends_on<extended_p_square>
|
||||
{
|
||||
typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, unweighted, quadratic> impl;
|
||||
};
|
||||
struct weighted_extended_p_square_quantile
|
||||
: depends_on<weighted_extended_p_square>
|
||||
{
|
||||
typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, weighted, linear> impl;
|
||||
};
|
||||
struct weighted_extended_p_square_quantile_quadratic
|
||||
: depends_on<weighted_extended_p_square>
|
||||
{
|
||||
typedef accumulators::impl::extended_p_square_quantile_impl<mpl::_1, weighted, quadratic> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::extended_p_square_quantile
|
||||
// extract::weighted_extended_p_square_quantile
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::extended_p_square_quantile> const extended_p_square_quantile = {};
|
||||
extractor<tag::extended_p_square_quantile_quadratic> const extended_p_square_quantile_quadratic = {};
|
||||
extractor<tag::weighted_extended_p_square_quantile> const weighted_extended_p_square_quantile = {};
|
||||
extractor<tag::weighted_extended_p_square_quantile_quadratic> const weighted_extended_p_square_quantile_quadratic = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square_quantile)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(extended_p_square_quantile_quadratic)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_extended_p_square_quantile)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(weighted_extended_p_square_quantile_quadratic)
|
||||
}
|
||||
|
||||
using extract::extended_p_square_quantile;
|
||||
using extract::extended_p_square_quantile_quadratic;
|
||||
using extract::weighted_extended_p_square_quantile;
|
||||
using extract::weighted_extended_p_square_quantile_quadratic;
|
||||
|
||||
// extended_p_square_quantile(linear) -> extended_p_square_quantile
|
||||
template<>
|
||||
struct as_feature<tag::extended_p_square_quantile(linear)>
|
||||
{
|
||||
typedef tag::extended_p_square_quantile type;
|
||||
};
|
||||
|
||||
// extended_p_square_quantile(quadratic) -> extended_p_square_quantile_quadratic
|
||||
template<>
|
||||
struct as_feature<tag::extended_p_square_quantile(quadratic)>
|
||||
{
|
||||
typedef tag::extended_p_square_quantile_quadratic type;
|
||||
};
|
||||
|
||||
// weighted_extended_p_square_quantile(linear) -> weighted_extended_p_square_quantile
|
||||
template<>
|
||||
struct as_feature<tag::weighted_extended_p_square_quantile(linear)>
|
||||
{
|
||||
typedef tag::weighted_extended_p_square_quantile type;
|
||||
};
|
||||
|
||||
// weighted_extended_p_square_quantile(quadratic) -> weighted_extended_p_square_quantile_quadratic
|
||||
template<>
|
||||
struct as_feature<tag::weighted_extended_p_square_quantile(quadratic)>
|
||||
{
|
||||
typedef tag::weighted_extended_p_square_quantile_quadratic type;
|
||||
};
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// extended_p_square_quantile and weighted_extended_p_square_quantile
|
||||
// provide the same feature as quantile
|
||||
template<>
|
||||
struct feature_of<tag::extended_p_square_quantile>
|
||||
: feature_of<tag::quantile>
|
||||
{
|
||||
};
|
||||
template<>
|
||||
struct feature_of<tag::extended_p_square_quantile_quadratic>
|
||||
: feature_of<tag::quantile>
|
||||
{
|
||||
};
|
||||
// So that extended_p_square_quantile can be automatically substituted with
|
||||
// weighted_extended_p_square_quantile when the weight parameter is non-void
|
||||
template<>
|
||||
struct as_weighted_feature<tag::extended_p_square_quantile>
|
||||
{
|
||||
typedef tag::weighted_extended_p_square_quantile type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::weighted_extended_p_square_quantile>
|
||||
: feature_of<tag::extended_p_square_quantile>
|
||||
{
|
||||
};
|
||||
|
||||
// So that extended_p_square_quantile_quadratic can be automatically substituted with
|
||||
// weighted_extended_p_square_quantile_quadratic when the weight parameter is non-void
|
||||
template<>
|
||||
struct as_weighted_feature<tag::extended_p_square_quantile_quadratic>
|
||||
{
|
||||
typedef tag::weighted_extended_p_square_quantile_quadratic type;
|
||||
};
|
||||
template<>
|
||||
struct feature_of<tag::weighted_extended_p_square_quantile_quadratic>
|
||||
: feature_of<tag::extended_p_square_quantile_quadratic>
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,112 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// kurtosis.hpp
|
||||
//
|
||||
// Copyright 2006 Olivier Gygi, Daniel Egloff. 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_KURTOSIS_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_KURTOSIS_HPP_EAN_28_10_2005
|
||||
|
||||
#include <limits>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics/mean.hpp>
|
||||
#include <boost/accumulators/statistics/moment.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// kurtosis_impl
|
||||
/**
|
||||
@brief Kurtosis estimation
|
||||
|
||||
The kurtosis of a sample distribution is defined as the ratio of the 4th central moment and the square of the 2nd central
|
||||
moment (the variance) of the samples, minus 3. The term \f$ -3 \f$ is added in order to ensure that the normal distribution
|
||||
has zero kurtosis. The kurtosis can also be expressed by the simple moments:
|
||||
|
||||
\f[
|
||||
\hat{g}_2 =
|
||||
\frac
|
||||
{\widehat{m}_n^{(4)}-4\widehat{m}_n^{(3)}\hat{\mu}_n+6\widehat{m}_n^{(2)}\hat{\mu}_n^2-3\hat{\mu}_n^4}
|
||||
{\left(\widehat{m}_n^{(2)} - \hat{\mu}_n^{2}\right)^2} - 3,
|
||||
\f]
|
||||
|
||||
where \f$ \widehat{m}_n^{(i)} \f$ are the \f$ i \f$-th moment and \f$ \hat{\mu}_n \f$ the mean (first moment) of the
|
||||
\f$ n \f$ samples.
|
||||
*/
|
||||
template<typename Sample>
|
||||
struct kurtosis_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
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::fdiv(
|
||||
accumulators::moment<4>(args)
|
||||
- 4. * accumulators::moment<3>(args) * mean(args)
|
||||
+ 6. * accumulators::moment<2>(args) * mean(args) * mean(args)
|
||||
- 3. * mean(args) * mean(args) * mean(args) * mean(args)
|
||||
, ( accumulators::moment<2>(args) - mean(args) * mean(args) )
|
||||
* ( accumulators::moment<2>(args) - mean(args) * mean(args) )
|
||||
) - 3.;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::kurtosis
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct kurtosis
|
||||
: depends_on<mean, moment<2>, moment<3>, moment<4> >
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::kurtosis_impl<mpl::_1> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::kurtosis
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::kurtosis> const kurtosis = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(kurtosis)
|
||||
}
|
||||
|
||||
using extract::kurtosis;
|
||||
|
||||
// So that kurtosis can be automatically substituted with
|
||||
// weighted_kurtosis when the weight parameter is non-void
|
||||
template<>
|
||||
struct as_weighted_feature<tag::kurtosis>
|
||||
{
|
||||
typedef tag::weighted_kurtosis type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::weighted_kurtosis>
|
||||
: feature_of<tag::kurtosis>
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,85 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// max.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_MAX_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_MAX_HPP_EAN_28_10_2005
|
||||
|
||||
#include <limits>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// max_impl
|
||||
template<typename Sample>
|
||||
struct max_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef Sample result_type;
|
||||
|
||||
template<typename Args>
|
||||
max_impl(Args const &args)
|
||||
: max_(numeric::as_min(args[sample | Sample()]))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
numeric::max_assign(this->max_, args[sample]);
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->max_;
|
||||
}
|
||||
|
||||
private:
|
||||
Sample max_;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::max
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct max
|
||||
: depends_on<>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::max_impl<mpl::_1> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::max
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::max> const max = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(max)
|
||||
}
|
||||
|
||||
using extract::max;
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,298 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// mean.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_MEAN_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_MEAN_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/sum.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// mean_impl
|
||||
// lazy, by default
|
||||
template<typename Sample, typename SumFeature>
|
||||
struct mean_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
|
||||
|
||||
mean_impl(dont_care) {}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
extractor<SumFeature> sum;
|
||||
return numeric::fdiv(sum(args), count(args));
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Sample, typename Tag>
|
||||
struct immediate_mean_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
|
||||
|
||||
template<typename Args>
|
||||
immediate_mean_impl(Args const &args)
|
||||
: mean(numeric::fdiv(args[sample | Sample()], numeric::one<std::size_t>::value))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
std::size_t cnt = count(args);
|
||||
this->mean = numeric::fdiv(
|
||||
(this->mean * (cnt - 1)) + args[parameter::keyword<Tag>::get()]
|
||||
, cnt
|
||||
);
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->mean;
|
||||
}
|
||||
|
||||
private:
|
||||
result_type mean;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::mean
|
||||
// tag::immediate_mean
|
||||
// tag::mean_of_weights
|
||||
// tag::immediate_mean_of_weights
|
||||
// tag::mean_of_variates
|
||||
// tag::immediate_mean_of_variates
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct mean
|
||||
: depends_on<count, sum>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::mean_impl<mpl::_1, sum> impl;
|
||||
};
|
||||
struct immediate_mean
|
||||
: depends_on<count>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::immediate_mean_impl<mpl::_1, tag::sample> impl;
|
||||
};
|
||||
struct mean_of_weights
|
||||
: depends_on<count, sum_of_weights>
|
||||
{
|
||||
typedef mpl::true_ is_weight_accumulator;
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::mean_impl<mpl::_2, sum_of_weights> impl;
|
||||
};
|
||||
struct immediate_mean_of_weights
|
||||
: depends_on<count>
|
||||
{
|
||||
typedef mpl::true_ is_weight_accumulator;
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::immediate_mean_impl<mpl::_2, tag::weight> impl;
|
||||
};
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct mean_of_variates
|
||||
: depends_on<count, sum_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef mpl::always<accumulators::impl::mean_impl<VariateType, sum_of_variates<VariateType, VariateTag> > > impl;
|
||||
};
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct immediate_mean_of_variates
|
||||
: depends_on<count>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef mpl::always<accumulators::impl::immediate_mean_impl<VariateType, VariateTag> > impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::mean
|
||||
// extract::mean_of_weights
|
||||
// extract::mean_of_variates
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::mean> const mean = {};
|
||||
extractor<tag::mean_of_weights> const mean_of_weights = {};
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, mean_of_variates, (typename)(typename))
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(mean)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(mean_of_weights)
|
||||
}
|
||||
|
||||
using extract::mean;
|
||||
using extract::mean_of_weights;
|
||||
using extract::mean_of_variates;
|
||||
|
||||
// mean(lazy) -> mean
|
||||
template<>
|
||||
struct as_feature<tag::mean(lazy)>
|
||||
{
|
||||
typedef tag::mean type;
|
||||
};
|
||||
|
||||
// mean(immediate) -> immediate_mean
|
||||
template<>
|
||||
struct as_feature<tag::mean(immediate)>
|
||||
{
|
||||
typedef tag::immediate_mean type;
|
||||
};
|
||||
|
||||
// mean_of_weights(lazy) -> mean_of_weights
|
||||
template<>
|
||||
struct as_feature<tag::mean_of_weights(lazy)>
|
||||
{
|
||||
typedef tag::mean_of_weights type;
|
||||
};
|
||||
|
||||
// mean_of_weights(immediate) -> immediate_mean_of_weights
|
||||
template<>
|
||||
struct as_feature<tag::mean_of_weights(immediate)>
|
||||
{
|
||||
typedef tag::immediate_mean_of_weights type;
|
||||
};
|
||||
|
||||
// mean_of_variates<VariateType, VariateTag>(lazy) -> mean_of_variates<VariateType, VariateTag>
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct as_feature<tag::mean_of_variates<VariateType, VariateTag>(lazy)>
|
||||
{
|
||||
typedef tag::mean_of_variates<VariateType, VariateTag> type;
|
||||
};
|
||||
|
||||
// mean_of_variates<VariateType, VariateTag>(immediate) -> immediate_mean_of_variates<VariateType, VariateTag>
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct as_feature<tag::mean_of_variates<VariateType, VariateTag>(immediate)>
|
||||
{
|
||||
typedef tag::immediate_mean_of_variates<VariateType, VariateTag> type;
|
||||
};
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// immediate_mean provides the same feature as mean
|
||||
template<>
|
||||
struct feature_of<tag::immediate_mean>
|
||||
: feature_of<tag::mean>
|
||||
{
|
||||
};
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// immediate_mean provides the same feature as mean
|
||||
template<>
|
||||
struct feature_of<tag::immediate_mean_of_weights>
|
||||
: feature_of<tag::mean_of_weights>
|
||||
{
|
||||
};
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// immediate_mean provides the same feature as mean
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct feature_of<tag::immediate_mean_of_variates<VariateType, VariateTag> >
|
||||
: feature_of<tag::mean_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
};
|
||||
|
||||
// So that mean can be automatically substituted with
|
||||
// weighted_mean when the weight parameter is non-void.
|
||||
template<>
|
||||
struct as_weighted_feature<tag::mean>
|
||||
{
|
||||
typedef tag::weighted_mean type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::weighted_mean>
|
||||
: feature_of<tag::mean>
|
||||
{};
|
||||
|
||||
// So that immediate_mean can be automatically substituted with
|
||||
// immediate_weighted_mean when the weight parameter is non-void.
|
||||
template<>
|
||||
struct as_weighted_feature<tag::immediate_mean>
|
||||
{
|
||||
typedef tag::immediate_weighted_mean type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::immediate_weighted_mean>
|
||||
: feature_of<tag::immediate_mean>
|
||||
{};
|
||||
|
||||
// So that mean_of_weights<> can be automatically substituted with
|
||||
// weighted_mean_of_variates<> when the weight parameter is non-void.
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct as_weighted_feature<tag::mean_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
typedef tag::weighted_mean_of_variates<VariateType, VariateTag> type;
|
||||
};
|
||||
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct feature_of<tag::weighted_mean_of_variates<VariateType, VariateTag> >
|
||||
: feature_of<tag::mean_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
};
|
||||
|
||||
// So that immediate_mean_of_weights<> can be automatically substituted with
|
||||
// immediate_weighted_mean_of_variates<> when the weight parameter is non-void.
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct as_weighted_feature<tag::immediate_mean_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
typedef tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> type;
|
||||
};
|
||||
|
||||
template<typename VariateType, typename VariateTag>
|
||||
struct feature_of<tag::immediate_weighted_mean_of_variates<VariateType, VariateTag> >
|
||||
: feature_of<tag::immediate_mean_of_variates<VariateType, VariateTag> >
|
||||
{
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
//// droppable_accumulator<mean_impl>
|
||||
//// need to specialize droppable lazy mean to cache the result at the
|
||||
//// point the accumulator is dropped.
|
||||
///// INTERNAL ONLY
|
||||
/////
|
||||
//template<typename Sample, typename SumFeature>
|
||||
//struct droppable_accumulator<impl::mean_impl<Sample, SumFeature> >
|
||||
// : droppable_accumulator_base<
|
||||
// with_cached_result<impl::mean_impl<Sample, SumFeature> >
|
||||
// >
|
||||
//{
|
||||
// template<typename Args>
|
||||
// droppable_accumulator(Args const &args)
|
||||
// : droppable_accumulator::base(args)
|
||||
// {
|
||||
// }
|
||||
//};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,301 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// median.hpp
|
||||
//
|
||||
// Copyright 2006 Eric Niebler, Olivier Gygi. 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_MEDIAN_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_MEDIAN_HPP_EAN_28_10_2005
|
||||
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
#include <boost/accumulators/statistics/p_square_quantile.hpp>
|
||||
#include <boost/accumulators/statistics/density.hpp>
|
||||
#include <boost/accumulators/statistics/p_square_cumul_dist.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// median_impl
|
||||
//
|
||||
/**
|
||||
@brief Median estimation based on the \f$P^2\f$ quantile estimator
|
||||
|
||||
The \f$P^2\f$ algorithm is invoked with a quantile probability of 0.5.
|
||||
*/
|
||||
template<typename Sample>
|
||||
struct median_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
|
||||
|
||||
median_impl(dont_care) {}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
return p_square_quantile_for_median(args);
|
||||
}
|
||||
};
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// with_density_median_impl
|
||||
//
|
||||
/**
|
||||
@brief Median estimation based on the density estimator
|
||||
|
||||
The algorithm determines the bin in which the \f$0.5*cnt\f$-th sample lies, \f$cnt\f$ being
|
||||
the total number of samples. It returns the approximate horizontal position of this sample,
|
||||
based on a linear interpolation inside the bin.
|
||||
*/
|
||||
template<typename Sample>
|
||||
struct with_density_median_impl
|
||||
: accumulator_base
|
||||
{
|
||||
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
|
||||
typedef float_type result_type;
|
||||
|
||||
template<typename Args>
|
||||
with_density_median_impl(Args const &args)
|
||||
: sum(numeric::fdiv(args[sample | Sample()], (std::size_t)1))
|
||||
, is_dirty(true)
|
||||
{
|
||||
}
|
||||
|
||||
void operator ()(dont_care)
|
||||
{
|
||||
this->is_dirty = true;
|
||||
}
|
||||
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
if (this->is_dirty)
|
||||
{
|
||||
this->is_dirty = false;
|
||||
|
||||
std::size_t cnt = count(args);
|
||||
range_type histogram = density(args);
|
||||
typename range_type::iterator it = histogram.begin();
|
||||
while (this->sum < 0.5 * cnt)
|
||||
{
|
||||
this->sum += it->second * cnt;
|
||||
++it;
|
||||
}
|
||||
--it;
|
||||
float_type over = numeric::fdiv(this->sum - 0.5 * cnt, it->second * cnt);
|
||||
this->median = it->first * over + (it + 1)->first * (1. - over);
|
||||
}
|
||||
|
||||
return this->median;
|
||||
}
|
||||
|
||||
private:
|
||||
mutable float_type sum;
|
||||
mutable bool is_dirty;
|
||||
mutable float_type median;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// with_p_square_cumulative_distribution_median_impl
|
||||
//
|
||||
/**
|
||||
@brief Median estimation based on the \f$P^2\f$ cumulative distribution estimator
|
||||
|
||||
The algorithm determines the first (leftmost) bin with a height exceeding 0.5. It
|
||||
returns the approximate horizontal position of where the cumulative distribution
|
||||
equals 0.5, based on a linear interpolation inside the bin.
|
||||
*/
|
||||
template<typename Sample>
|
||||
struct with_p_square_cumulative_distribution_median_impl
|
||||
: accumulator_base
|
||||
{
|
||||
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
|
||||
typedef float_type result_type;
|
||||
|
||||
with_p_square_cumulative_distribution_median_impl(dont_care)
|
||||
: is_dirty(true)
|
||||
{
|
||||
}
|
||||
|
||||
void operator ()(dont_care)
|
||||
{
|
||||
this->is_dirty = true;
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
if (this->is_dirty)
|
||||
{
|
||||
this->is_dirty = false;
|
||||
|
||||
range_type histogram = p_square_cumulative_distribution(args);
|
||||
typename range_type::iterator it = histogram.begin();
|
||||
while (it->second < 0.5)
|
||||
{
|
||||
++it;
|
||||
}
|
||||
float_type over = numeric::fdiv(it->second - 0.5, it->second - (it - 1)->second);
|
||||
this->median = it->first * over + (it + 1)->first * ( 1. - over );
|
||||
}
|
||||
|
||||
return this->median;
|
||||
}
|
||||
private:
|
||||
|
||||
mutable bool is_dirty;
|
||||
mutable float_type median;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::median
|
||||
// tag::with_densisty_median
|
||||
// tag::with_p_square_cumulative_distribution_median
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct median
|
||||
: depends_on<p_square_quantile_for_median>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::median_impl<mpl::_1> impl;
|
||||
};
|
||||
struct with_density_median
|
||||
: depends_on<count, density>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::with_density_median_impl<mpl::_1> impl;
|
||||
};
|
||||
struct with_p_square_cumulative_distribution_median
|
||||
: depends_on<p_square_cumulative_distribution>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::with_p_square_cumulative_distribution_median_impl<mpl::_1> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::median
|
||||
// extract::with_density_median
|
||||
// extract::with_p_square_cumulative_distribution_median
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::median> const median = {};
|
||||
extractor<tag::with_density_median> const with_density_median = {};
|
||||
extractor<tag::with_p_square_cumulative_distribution_median> const with_p_square_cumulative_distribution_median = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(median)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(with_density_median)
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(with_p_square_cumulative_distribution_median)
|
||||
}
|
||||
|
||||
using extract::median;
|
||||
using extract::with_density_median;
|
||||
using extract::with_p_square_cumulative_distribution_median;
|
||||
|
||||
// median(with_p_square_quantile) -> median
|
||||
template<>
|
||||
struct as_feature<tag::median(with_p_square_quantile)>
|
||||
{
|
||||
typedef tag::median type;
|
||||
};
|
||||
|
||||
// median(with_density) -> with_density_median
|
||||
template<>
|
||||
struct as_feature<tag::median(with_density)>
|
||||
{
|
||||
typedef tag::with_density_median type;
|
||||
};
|
||||
|
||||
// median(with_p_square_cumulative_distribution) -> with_p_square_cumulative_distribution_median
|
||||
template<>
|
||||
struct as_feature<tag::median(with_p_square_cumulative_distribution)>
|
||||
{
|
||||
typedef tag::with_p_square_cumulative_distribution_median type;
|
||||
};
|
||||
|
||||
// for the purposes of feature-based dependency resolution,
|
||||
// with_density_median and with_p_square_cumulative_distribution_median
|
||||
// provide the same feature as median
|
||||
template<>
|
||||
struct feature_of<tag::with_density_median>
|
||||
: feature_of<tag::median>
|
||||
{
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::with_p_square_cumulative_distribution_median>
|
||||
: feature_of<tag::median>
|
||||
{
|
||||
};
|
||||
|
||||
// So that median can be automatically substituted with
|
||||
// weighted_median when the weight parameter is non-void.
|
||||
template<>
|
||||
struct as_weighted_feature<tag::median>
|
||||
{
|
||||
typedef tag::weighted_median type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::weighted_median>
|
||||
: feature_of<tag::median>
|
||||
{
|
||||
};
|
||||
|
||||
// So that with_density_median can be automatically substituted with
|
||||
// with_density_weighted_median when the weight parameter is non-void.
|
||||
template<>
|
||||
struct as_weighted_feature<tag::with_density_median>
|
||||
{
|
||||
typedef tag::with_density_weighted_median type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::with_density_weighted_median>
|
||||
: feature_of<tag::with_density_median>
|
||||
{
|
||||
};
|
||||
|
||||
// So that with_p_square_cumulative_distribution_median can be automatically substituted with
|
||||
// with_p_square_cumulative_distribution_weighted_median when the weight parameter is non-void.
|
||||
template<>
|
||||
struct as_weighted_feature<tag::with_p_square_cumulative_distribution_median>
|
||||
{
|
||||
typedef tag::with_p_square_cumulative_distribution_weighted_median type;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct feature_of<tag::with_p_square_cumulative_distribution_weighted_median>
|
||||
: feature_of<tag::with_p_square_cumulative_distribution_median>
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,85 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// min.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_MIN_HPP_EAN_28_10_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_MIN_HPP_EAN_28_10_2005
|
||||
|
||||
#include <limits>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// min_impl
|
||||
template<typename Sample>
|
||||
struct min_impl
|
||||
: accumulator_base
|
||||
{
|
||||
// for boost::result_of
|
||||
typedef Sample result_type;
|
||||
|
||||
template<typename Args>
|
||||
min_impl(Args const &args)
|
||||
: min_(numeric::as_max(args[sample | Sample()]))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
numeric::min_assign(this->min_, args[sample]);
|
||||
}
|
||||
|
||||
result_type result(dont_care) const
|
||||
{
|
||||
return this->min_;
|
||||
}
|
||||
|
||||
private:
|
||||
Sample min_;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::min
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
struct min
|
||||
: depends_on<>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::min_impl<mpl::_1> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::min
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
extractor<tag::min> const min = {};
|
||||
|
||||
BOOST_ACCUMULATORS_IGNORE_GLOBAL(min)
|
||||
}
|
||||
|
||||
using extract::min;
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,125 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// moment.hpp
|
||||
//
|
||||
// Copyright 2005 Eric Niebler. 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_MOMENT_HPP_EAN_15_11_2005
|
||||
#define BOOST_ACCUMULATORS_STATISTICS_MOMENT_HPP_EAN_15_11_2005
|
||||
|
||||
#include <boost/config/no_tr1/cmath.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/accumulators/framework/accumulator_base.hpp>
|
||||
#include <boost/accumulators/framework/extractor.hpp>
|
||||
#include <boost/accumulators/numeric/functional.hpp>
|
||||
#include <boost/accumulators/framework/parameters/sample.hpp>
|
||||
#include <boost/accumulators/framework/depends_on.hpp>
|
||||
#include <boost/accumulators/statistics_fwd.hpp>
|
||||
#include <boost/accumulators/statistics/count.hpp>
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T>
|
||||
T const &pow(T const &x, mpl::int_<1>)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename T, int N>
|
||||
T pow(T const &x, mpl::int_<N>)
|
||||
{
|
||||
using namespace operators;
|
||||
T y = numeric::pow(x, mpl::int_<N/2>());
|
||||
T z = y * y;
|
||||
return (N % 2) ? (z * x) : z;
|
||||
}
|
||||
}}
|
||||
|
||||
namespace boost { namespace accumulators
|
||||
{
|
||||
|
||||
namespace impl
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// moment_impl
|
||||
template<typename N, typename Sample>
|
||||
struct moment_impl
|
||||
: accumulator_base // TODO: also depends_on sum of powers
|
||||
{
|
||||
BOOST_MPL_ASSERT_RELATION(N::value, >, 0);
|
||||
// for boost::result_of
|
||||
typedef typename numeric::functional::fdiv<Sample, std::size_t>::result_type result_type;
|
||||
|
||||
template<typename Args>
|
||||
moment_impl(Args const &args)
|
||||
: sum(args[sample | Sample()])
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
void operator ()(Args const &args)
|
||||
{
|
||||
this->sum += numeric::pow(args[sample], N());
|
||||
}
|
||||
|
||||
template<typename Args>
|
||||
result_type result(Args const &args) const
|
||||
{
|
||||
return numeric::fdiv(this->sum, count(args));
|
||||
}
|
||||
|
||||
private:
|
||||
Sample sum;
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// tag::moment
|
||||
//
|
||||
namespace tag
|
||||
{
|
||||
template<int N>
|
||||
struct moment
|
||||
: depends_on<count>
|
||||
{
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
typedef accumulators::impl::moment_impl<mpl::int_<N>, mpl::_1> impl;
|
||||
};
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// extract::moment
|
||||
//
|
||||
namespace extract
|
||||
{
|
||||
BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, moment, (int))
|
||||
}
|
||||
|
||||
using extract::moment;
|
||||
|
||||
// So that moment<N> can be automatically substituted with
|
||||
// weighted_moment<N> when the weight parameter is non-void
|
||||
template<int N>
|
||||
struct as_weighted_feature<tag::moment<N> >
|
||||
{
|
||||
typedef tag::weighted_moment<N> type;
|
||||
};
|
||||
|
||||
template<int N>
|
||||
struct feature_of<tag::weighted_moment<N> >
|
||||
: feature_of<tag::moment<N> >
|
||||
{
|
||||
};
|
||||
|
||||
}} // namespace boost::accumulators
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user