Наша экскурсия по шаблону<accumulator_set<>>класса начинается с форвардной декларации:

template< typename Sample, typename Features, typename Weight = void >
struct accumulator_set;

Параметры шаблона имеют следующее значение:

Например, следующая строка объявляет<accumulator_set<>>, которая будет принимать последовательность удваивается по одному за раз и вычислять мин и среднее:

accumulator_set< double, features< tag::min, tag::mean > > acc;

Обратите внимание, что мы используем шаблон<features<>>, чтобы указать список функций для расчета.<features<>>является последовательность признаков MPL.

	Note
	<features<>>является синонимом<mpl::vector<>>. На самом деле, мы могли бы использовать<mpl::vector<>>или любую последовательность MPL, если бы мы предпочли, и значение было бы одинаковым.

После того, как мы определили<accumulator_set<>>, мы можем ввести в него данные, и он рассчитает запрошенные вами количества, как показано ниже.

// push some data into the accumulator_set ...
acc(1.2);
acc(2.3);
acc(3.4);

Поскольку<accumulator_set<>>определяет свою накопительную функцию как оператор вызова функции, у нас может возникнуть соблазн использовать<accumulator_set<>>в качестве унарной функции для стандартного алгоритма, такого как<std::for_each>. Это нормально, если учесть, что стандартные алгоритмы принимают объекты UnaryFunction по значению, которое включает в себя создание копии объекта<accumulator_set<>>. Рассмотрим следующее:

// The data for which we wish to calculate statistical properties:
std::vector< double > data( /* stuff */ );
// The accumulator set which will calculate the properties for us:    
accumulator_set< double, features< tag::min, tag::mean > > acc;
// Use std::for_each to accumulate the statistical properties:
acc = std::for_each( data.begin(), data.end(), acc );

Обратите внимание, как мы должны присвоить значение возврата<std::for_each><accumulator_set<>>. Это работает, но некоторые аккумуляторы не дешевы для копирования. Например,<tail>и<tail_variate<>>аккумуляторы должны хранить<std::vector<>>, поэтому копирование этих аккумуляторов предполагает динамическое распределение. В этом случае мы могли бы лучше передать аккумулятор по ссылке с помощью<boost::bind()>и<boost::ref()>. См. ниже:

// The data for which we wish to calculate statistical properties:
std::vector< double > data( /* stuff */ );
// The accumulator set which will calculate the properties for us:
accumulator_set< double, features< tag::tail<left> > > acc(
    tag::tail<left>::cache_size = 4 );
// Use std::for_each to accumulate the statistical properties:
std::for_each( data.begin(), data.end(), bind<void>( ref(acc), _1 ) );

Обратите внимание, что мы больше не заботимся о возвратном значении<std::for_each()>, потому что<std::for_each()>напрямую изменяет<acc>.

	Note
	Чтобы использовать<boost::bind()>и<boost::ref()>, вы должны<#include><<boost/bind.hpp>>и<<boost/ref.hpp>>.

Как только мы объявим<accumulator_set<>>и введем в него данные, мы должны быть в состоянии извлечь из него результаты. Для каждой функции, которую мы можем добавить к<accumulator_set<>>, есть соответствующий экстрактор для получения его результата. Обычно экстрактор имеет то же название, что и функция, но в другом пространстве имен. Например, если мы накапливаем<tag::min>и<tag::max>признаки, мы можем извлечь результаты с помощью<min>и<max>экстракторов следующим образом:

// Calculate the minimum and maximum for a sequence of integers.
accumulator_set< int, features< tag::min, tag::max > > acc;
acc( 2 );
acc( -1 );
acc( 1 );
// This displays "(-1, 2)"
std::cout << '(' << min( acc ) << ", " << max( acc ) << ")\n";

Все вытяжки объявлены в пространстве имен<boost::accumulators::extract>, но они приведены в пространстве имен<boost::accumulators>с декларацией<using>.

	Tip
	На платформе Windows<min>и<max>являются препроцессорными макросами, определенными в<WinDef.h>. Чтобы использовать<min>и<max>экстракторы, вы должны либо составить<NOMINMAX>определено, или вы должны вызвать экстракторы, как:<(min)(acc)>и<(max)(acc)>. Скобки удерживают макрос от вызова.

Другой способ извлечь результат из<accumulator_set<>>— это<extract_result()>функция. Это может быть более удобно, если нет объекта-экстрактора, удобного для определенной функции. Линия, выше которой отображаются результаты, может быть написана следующим образом:

// This displays "(-1, 2)"
std::cout << '('  << extract_result< tag::min >( acc )
          << ", " << extract_result< tag::max >( acc ) << ")\n";

Наконец, мы можем определить наш собственный экстрактор, используя шаблон класса<extractor<>>. Например, еще один способ избежать макробизнеса<min>/<max>- это определить экстракторы с именами, которые не конфликтуют с макросами.

extractor< tag::min > min_;
extractor< tag::min > max_;
// This displays "(-1, 2)"
std::cout << '(' << min_( acc ) << ", " << max_( acc ) << ")\n";

Некоторые аккумуляторы нуждаются в параметрах инициализации. Кроме того, возможно, некоторая вспомогательная информация должна быть передана в<accumulator_set<>>вместе с каждым образцом. Повышаю. Накопители обрабатывают эти случаи с помощью названных параметров из библиотекиBoost.Parameter.

Рассмотрим, например,<tail>и<tail_variate<>>особенности.<tail>ведет упорядоченный список крупнейших<N>образцов, где<N>может быть указан в момент строительства. Кроме того, функция<tail_variate<>>, которая зависит от<tail>, отслеживает некоторые данные, которые ковариатны с образцами<N>, отслеживаемыми<tail>. Код ниже показывает, как все это работает, и более подробно описано ниже.

// Define a feature for tracking covariate data
typedef tag::tail_variate< int, tag::covariate1, left > my_tail_variate_tag;
// This will calculate the left tail and my_tail_variate_tag for N == 2
// using the tag::tail<left>::cache_size named parameter
accumulator_set< double, features< my_tail_variate_tag > > acc(
    tag::tail<left>::cache_size = 2 );
// push in some samples and some covariates by using 
// the covariate1 named parameter
acc( 1.2, covariate1 =  12 );
acc( 2.3, covariate1 = -23 );
acc( 3.4, covariate1 =  34 );
acc( 4.5, covariate1 = -45 );
// Define an extractor for the my_tail_variate_tag feature
extractor< my_tail_variate_tag > my_tail_variate;
// Write the tail statistic to std::cout. This will print "4.5, 3.4, "
std::ostream_iterator< double > dout( std::cout, ", " );
std::copy( tail( acc ).begin(), tail( acc ).end(), dout );
// Write the tail_variate statistic to std::cout. This will print "-45, 34, "
std::ostream_iterator< int > iout( std::cout, ", " );
std::copy( my_tail_variate( acc ).begin(), my_tail_variate( acc ).end(), iout );

Есть несколько вещей, чтобы отметить о коде выше. Во-первых, обратите внимание, что нам не нужно было просить, чтобы функция<tail>была рассчитана. Это объясняется тем, что<tail_variate<>>зависит от<tail>признака. Далее обратите внимание, как инициализируется<acc>объект:<acc( tag::tail<left>::cache_size= 2)>. Здесь<cache_size>— названный параметр. Он используется для определения<tail>и<tail_variate<>>аккумуляторов, сколько образцов и ковариатов хранить. Концептуально каждый параметр конструкции доступен для каждого аккумулятора в наборе аккумуляторов.

Мы также используем названный параметр для передачи ковариативных данных в аккумулятор, установленный вместе с образцами. Как и в случае с параметрами конструктора, все параметры накопительной функции доступны для всех аккумуляторов в наборе. В этом случае только аккумулятор для характеристики<my_tail_variate>будет заинтересован в значении названного параметра<covariate1>.

Мы можем сделать одно заключительное замечание о примере выше. Поскольку<tail>и<tail_variate<>>являются многозначными признаками, то результат, который мы для них извлекаем, представлен в виде диапазона итераторов. Вот почему мы можем сказать<tail(acc).begin()>и<tail(acc).end()>.

Даже экстракторы могут принимать названные параметры. Через некоторое время мы увидим ситуацию, в которой это будет полезно.

Некоторые аккумуляторы, в частности, статистические аккумуляторы, имеют дело с данными, которыевзвешены. Каждый образец, вдавленный в аккумулятор, имеет соответствующий вес, с помощью которого образец концептуально умножается. Библиотека статистических накопителей предоставляет ассортимент этих взвешенных статистических накопителей. И многие невзвешенные статистические аккумуляторы имеют взвешенные варианты. Например, взвешенный вариант аккумулятора<sum>называется<weighted_sum>и рассчитывается путем накопления всех образцов, умноженных на их веса.

Чтобы объявить<accumulator_set<>>, который принимает взвешенные образцы, вы должны указать тип параметра веса в качестве 3-го шаблонного параметра следующим образом:

// 3rd template parameter 'int' means this is a weighted
// accumulator set where the weights have type 'int'
accumulator_set< int, features< tag::sum >, int > acc;

При указании веса все аккумуляторы в комплекте заменяются на их взвешенные эквиваленты. Например, приведенное выше<accumulator_set<>>заявление эквивалентно следующему:

// Since we specified a weight, tag::sum becomes tag::weighted_sum
accumulator_set< int, features< tag::weighted_sum >, int > acc;

При передаче образцов в комплект аккумулятора необходимо также указать вес каждого образца. Вы можете сделать это с помощью параметра<weight>:

acc(1, weight = 2); //   1 * 2
acc(2, weight = 4); //   2 * 4
acc(3, weight = 6); // + 3 * 6
                    // -------
                    // =    28

Затем вы можете извлечь результат с помощью экстрактора<sum()>следующим образом:

// This prints "28"
std::cout << sum(acc) << std::endl;

	Note
	При работе с взвешенными статистическими аккумуляторами из Библиотеки статистических накопителей обязательно включите соответствующий заголовок. Например,<weighted_sum>определено в<<boost/accumulators/statistics/weighted_sum.hpp>>.

Этот раздел описывает объекты функций в пространстве имен<boost::numeric>, которое представляет собой подбиблиотеку, которая предоставляет объекты функций и мета-функции, соответствующие операторам исправления в C++.

В пространстве имен<boost::numeric::operators>имеются дополнительные операторские перегрузки для некоторых полезных операций, не предусмотренных стандартной библиотекой, таких как умножение<std::complex<>>на скаляр.

В<boost::numeric::functional>пространстве имен находятся эквиваленты объектов функций операторов фиксации. Эти типы функциональных объектов неоднородны, и поэтому являются более общими, чем стандартные, найденные в заголовке<<functional>>. Они используют буст. Тип библиотеки для вывода типов возврата выражений исправления, которые они оценивают. Кроме того, они смотрят в пространстве имен<boost::numeric::operators>, чтобы рассмотреть любые дополнительные перегрузки, которые могут быть определены там.

В пространстве имен<boost::numeric>находятся глобальные полиморфные объекты функций, соответствующие типам объектов функций, определенным в пространстве имен<boost::numeric::functional>. Например,<boost::numeric::plus(a,b)>эквивалентно<boost::numeric::functional::plus<A,B>()(a,b)>, и оба эквивалентны<usingnamespace boost::numeric::operators; a+ b;>.

Подбиблиотека числовых операторов также дает несколько способов подкласса и способ подкласса и специализации операций. Один из способов использует отправку тегов по типам операндов. Другой путь основан на свойствах времени компиляции операндов.

В этом разделе описывается, как расширить структуру аккумуляторов путем определения новых аккумуляторов, функций и экстракторов. Также рассматриваются способы контроля разрешения зависимостей функций в наборе аккумуляторов.

Defining a New Accumulator

Все новые аккумуляторы должны удовлетворятьКонцепции аккумулятора. Ниже приведен класс выборки, который удовлетворяет концепции аккумулятора, который просто суммирует значения всех образцов, переданных в него.

#include <boost/accumulators/framework/accumulator_base.hpp>
#include <boost/accumulators/framework/parameters/sample.hpp>
namespace boost {                           // Putting your accumulators in the
namespace accumulators {                    // impl namespace has some
namespace impl {                            // advantages. See below.
template<typename Sample>
struct sum_accumulator                      // All accumulators should inherit from
  : accumulator_base                        // accumulator_base.
{
    typedef Sample result_type;             // The type returned by result() below.
    template<typename Args>                 // The constructor takes an argument pack.
    sum_accumulator(Args const & args)
      : sum(args[sample | Sample()])        // Maybe there is an initial value in the
    {                                       // argument pack. ('sample' is defined in
    }                                       // sample.hpp, included above.)
    template<typename Args>                 // The accumulate function is the function
    void operator ()(Args const & args)     // call operator, and it also accepts an
    {                                       // argument pack.
        this->sum += args[sample];
    }
    result_type result(dont_care) const     // The result function will also be passed
    {                                       // an argument pack, but we don't use it here,
        return this->sum;                   // so we use "dont_care" as the argument type.
    }
private:
    Sample sum;
};
}}}

Большая часть вышесказанного должна быть довольно понятной, за исключением использования пакетов аргументов, которые могут сбивать с толку, если вы никогда раньше не использовали библиотекуBoost.Parameter. Пакет аргументов представляет собой кластер значений, к каждому из которых можно получить доступ с помощью ключа. Так<args[sample]>извлекает из упаковки значение, связанное с<sample>ключом. И загадочный<args[sample|Sample()]>оценивает значение, связанное с<sample>ключом, если он существует, или построенным по умолчанию<Sample>, если он не существует.

Приведенный выше пример демонстрирует наиболее распространенные атрибуты аккумулятора. Есть и другие необязательные членские функции, которые имеют особое значение. В частности:

Optional Accumulator Member Functions

on_drop(Args)

Определяет действие, которое необходимо предпринять при сбросе этого аккумулятора. См. разделОслабляемые аккумуляторы.

Accessing Other Accumulators in the Set

Некоторые аккумуляторы зависят от других аккумуляторов в том же наборе аккумуляторов. В этих случаях необходимо иметь доступ к другим аккумуляторам. Чтобы сделать это возможным,<accumulator_set<>>передает ссылку на себя при вызове функций члена содержащихся в нем аккумуляторов. К нему можно получить доступ, используя специальный ключ<accumulator>с пакетом аргументов. Рассмотрим, как мы можем реализовать<mean_accumulator>:

// Mean == (Sum / Count)
template<typename Sample>
struct mean_accumulator : accumulator_base
{
    typedef Sample result_type;
    mean_accumulator(dont_care) {}
    template<typename Args>
    result_type result(Args const &args) const
    {
        return sum(args[accumulator]) / count(args[accumulator]);
    }
};

<mean>зависит от<sum>и<count>аккумуляторов. (В следующем разделе мы рассмотрим, как определить эти зависимости.) Результат среднего аккумулятора - это просто результат суммарного аккумулятора, деленного на результат счетного аккумулятора. Рассмотрим, как мы это пишем<sum(args[accumulator]) /count(args[accumulator])>. Выражение<args[accumulator]>оценивает со ссылкой на<accumulator_set<>>, содержащее это<mean_accumulator>. Он также содержит<sum>и<count>аккумуляторы, и мы можем получить доступ к их результатам с помощью экстракторов, определенных для этих функций:<sum>и<count>.

	Note
	Накопители, которые наследуют от<accumulator_base>, получают пустые<operator()>, поэтому аккумуляторы, подобные<mean_accumulator>выше, не должны определять один.

Все функции-члены, принимающие пакет аргументов, имеют доступ к прилагаемому<accumulator_set<>>через<accumulator>ключ, включая конструктор. Аккумуляторы внутри набора построены в порядке, определяемом их взаимозависимостью. В результате аккумулятору безопасно получить доступ к тому, от которого он зависит во время строительства.

Infix Notation and the Numeric Operators Sub-Library

Несмотря на то, что в этом нет необходимости, может быть хорошей идеей разместить ваши реализации аккумуляторов в пространстве имен<boost::accumulators::impl>. Это пространство имен привлекает любых операторов, определенных в пространстве имен<boost::numeric::operators>, с помощью директивы. Подбиблиотека числовых операторов определяет некоторые дополнительные перегрузки, которые заставят ваши аккумуляторы работать со всеми типами данных.

Рассмотрим<mean_accumulator>выше. Он делит сумму образцов на количество. Тип счета<std::size_t>. Что, если тип выборки не определяет деление на<std::size_t>? Таково положение<std::complex<>>. Вы можете подумать, что если тип выборки<std::complex<>>, код не будет работать, но на самом деле он работает. Это потому, что подбиблиотека числовых операторов определяет перегруженную<operator/>для<std::complex<>>и<std::size_t>. Этот оператор определен в пространстве имен<boost::numeric::operators>и будет найден в пространстве имен<boost::accumulators::impl>. Вот почему это хорошая идея, чтобы поставить свои аккумуляторы там.

Droppable Accumulators

Термин «удаляемый» относится к аккумулятору, который может быть удален из<accumulator_set<>>. Вы можете запросить, чтобы аккумулятор стал капельным, используя шаблон класса<droppable<>>.

// calculate sum and count, make sum droppable:
accumulator_set< double, features< tag::count, droppable<tag::sum> > > acc;
// add some data
acc(3.0);
acc(2.0);
// drop the sum (sum is 5 here)
acc.drop<tag::sum>();
// add more data
acc(1.0);
// This will display "3" and "5"
std::cout << count(acc) << ' ' << sum(acc);

Любые аккумуляторы, которые добавляются в набор аккумуляторов для удовлетворения зависимостей от капельных аккумуляторов, сами по себе являются капельными. Рассмотрим следующий аккумулятор:

// Sum is not droppable. Mean is droppable. Count, brought in to 
// satisfy mean's dependencies, is implicitly droppable, too.
accumulator_set< double, features< tag::sum, droppable<tag::mean> > > acc;

<mean>зависит от<sum>и<count>. Так как<mean>опущено, то и<count>тоже. Тем не менее, мы явно просили, чтобы<sum>не опускались, поэтому это не так. Если бы мы оставили<tag::sum>из вышеприведенной декларации,<sum>аккумулятор был бы неявно опускаемым.

Опускаемый аккумулятор считается эталоном и действительно сбрасывается только после того, как все аккумуляторы, которые зависят от него, были сброшены. Это может привести к неожиданному поведению в некоторых ситуациях.

// calculate sum and mean, make mean droppable. 
accumulator_set< double, features< tag::sum, droppable<tag::mean> > > acc;
// add some data
acc(1.0);
acc(2.0);
// drop the mean. mean's reference count
// drops to 0, so it's really dropped. So
// too, count's reference count drops to 0
// and is really dropped.
acc.drop<tag::mean>();
// add more data. Sum continues to accumulate!
acc(3.0);
// This will display "6 2 3"
std::cout << sum(acc) << ' '
          << count(acc) << ' '
          << mean(acc);

Обратите внимание, что в точке, в которой<mean>падает,<sum>составляет 3,<count>- 2, и, следовательно,<mean>- 1,5. Но поскольку<sum>продолжает накапливаться даже после того, как<mean>было сброшено, значение<mean>продолжает меняться. Если вы хотите запомнить значение<mean>в точке его падения, вы должны сохранить его значение в локальную переменную.

Следующие правила более точно определяют, как капельные и нераскачивающиеся аккумуляторы ведут себя в наборе аккумуляторов.

• Существует два типа аккумуляторов: дроппинговые и не дроппинговые. Дефолт является неустранимым.
• Для любого признака<X>оба<X>и<droppable<X>>удовлетворяют<X>зависимости.
• Если<X>зависит от<Y>и<Z>, то<droppable<X>>зависит от<droppable<Y>>и<droppable<Z>>.
• Все аккумуляторы имеют функции<add_ref()>и<drop()>.
• Для нераскачиваемых аккумуляторов<drop()>представляет собой no-op, а<add_ref()>вызывает<add_ref()>на всех аккумуляторах, соответствующих признакам, от которых зависит ток аккумулятора.
• Деппируемые аккумуляторы имеют счетчик отсчета и определяют<add_ref()>и<drop()>для управления счетчиком отсчета.
• Для капельных аккумуляторов<add_ref()>увеличивается исходное количество аккумулятора, а также<add_ref()>аккумуляторов, соответствующих особенностям, от которых зависит текущий аккумулятор.
• Для капельных аккумуляторов<drop()>сокращает исходное количество аккумулятора, а также<drop()>аккумуляторов, соответствующих особенностям, от которых зависит текущий аккумулятор.
• Конструктор набора аккумуляторов содержит списокфункций, определенных пользователем, и<add_ref()>аккумулятора, который соответствует каждому из них. (Примечание: это означает, что аккумулятор, который не определен пользователем, а находится в наборе только для удовлетворения зависимости, будет сброшен, как только все его зависимости будут сброшены. Те, которые были указаны пользователем, не сбрасываются до тех пор, пока их зависимости не будут сброшеныи.
• Деппируемые аккумуляторы проверяют свой контрольный показатель в функции накопителя. Если число ссылок равно 0, то функция является no-op.
• Пользователям не разрешается удалять функцию, которая не указана пользователем и помечена как опускаемая.

В качестве оптимизации:

• Если пользователь указывает функцию<X>, которая зависит от<Y>и<Z>, то аккумуляторы для<Y>и<Z>могут быть безопасно сделаны не сбрасываемыми, а также любые аккумуляторы, от которых они зависят.

namespace boost { namespace accumulators { namespace tag {
struct mean                         // Features should inherit from
  : depends_on< count, sum >        // depends_on<> to specify dependencies
{
    // Define a nested typedef called 'impl' that specifies which
    // accumulator implements this feature. 
    typedef accumulators::impl::mean_accumulator< mpl::_1 > impl;
};
}}}

// An MPL lambda expression that always evaluates to
// foo_accumulator:
typedef mpl::always< foo_accumulator > impl;

// Same as 'typedef mpl::always< foo_accumulator > impl;'
struct impl
{
    template< typename Sample, typename Weight >
    struct apply
    {
        typedef foo_accumulator type;
    };
};

namespace boost {
namespace accumulators {                // By convention, we put extractors
namespace extract {                     // in the 'extract' namespace
extractor< tag::mean > const mean = {}; // Simply define our extractor with
                                        // our feature tag, like this.
}
using extract::mean;                    // Pull the extractor into the
                                        // enclosing namespace.
}}

// An accumulator set for calculating the N-th moment, for N == 2 ...
accumulator_set< double, features< tag::moment<2> > > acc;
// ... add some data ...
// Display the 2nd moment ...
std::cout << "2nd moment is " << accumulators::moment<2>(acc) << std::endl;

namespace boost {
namespace accumulators {                // By convention, we put extractors
namespace extract {                     // in the 'extract' namespace
template<int N, typename AccumulatorSet>
typename mpl::apply<AccumulatorSet, tag::moment<N> >::type::result_type
moment(AccumulatorSet const &acc)
{
    return extract_result<tag::moment<N> >(acc);
}
}
using extract::moment;                  // Pull the extractor into the
                                        // enclosing namespace.
}}

namespace boost { namespace accumulators
{
    // For the purposes of feature-based dependency resolution,
    // fast_fubar provides the same feature as fubar
    template<>
    struct feature_of<tag::fast_fubar>
      : feature_of<tag::fubar>
    {
    };
}}

namespace boost { namespace accumulators
{
    struct fast {};     // OK to leave these tags empty
    struct accurate {};
    template<>
    struct as_feature<tag::fubar(accurate)>
    {
        typedef tag::fubar type;
    };
    template<>
    struct as_feature<tag::fubar(fast)>
    {
        typedef tag::fast_fubar type;
    };
}}

namespace boost { namespace numeric { namespace functional
{
    // Metafunction for looking up the tag associated with
    // a given numeric type T.
    template<typename T>
    struct tag
    {
        // by default, all types have void as a tag type
        typedef void type;
    };
    // Forward declaration looks up the tag types of each operand
    template<
        typename Left
      , typename Right
      , typename LeftTag = typename tag<Left>::type
      , typename RightTag = typename tag<Right>::type
    >
    struct fdiv;
}}}

namespace boost { namespace numeric { namespace functional
{
    // Tag type for MyDouble
    struct MyDoubleTag {};
    // Specialize tag<> for MyDouble.
    // This only needs to be done once.
    template<>
    struct tag<MyDouble>
    {
        typedef MyDoubleTag type;
    };
    // Specify how to divide a MyDouble by an integral count
    template<typename Left, typename Right>
    struct fdiv<Left, Right, MyDoubleTag, void>
    {
        // Define the type of the result
        typedef ... result_type;
        result_type operator()(Left & left, Right & right) const
        {
            return ...;
        }
    };
}}}

Accumulator Concept

В следующей таблице<Acc>является типом аккумулятора,<acc>и<acc2>являются объектами типа<Acc>, а<args>является названием набора аргументов из библиотекиBoost.Parameter.

Feature Concept

В следующей таблице<F>— тип признака, а<S>— некоторый скалярный тип.

Функция<count>представляет собой простой счетчик, который отслеживает количество образцов, выталкиваемых в набор аккумулятора.

Заголовок

#include <boost/accumulators/statistics/count.hpp>

Пример

accumulator_set<int, features<tag::count> > acc;
acc(0);
acc(0);
acc(0);
assert(3 == count(acc));

См. также

Функция<covariance>является итеративной оценкой Монте-Карло для ковариации. Он указан как<tag::covariance<variate-type>,<variate-tag>>.

Заголовки

#include <boost/accumulators/statistics/covariance.hpp>
#include <boost/accumulators/statistics/variates/covariate.hpp>

Пример

accumulator_set<double, stats<tag::covariance<double, tag::covariate1> > > acc;
acc(1., covariate1 = 2.);
acc(1., covariate1 = 4.);
acc(2., covariate1 = 3.);
acc(6., covariate1 = 1.);
assert(covariance(acc) == -1.75);

См. также

Функция<tag::density>возвращает гистограмму распределения образца. Подробнее о реализации см.<density_impl>.

Заголовок

#include <boost/accumulators/statistics/density.hpp>

Примечание

Результаты от<density>аккумулятора могут быть извлечены только после того, как количество образцов соответствует или превышает размер кэша.

См. также

Функция<error_of<mean>>вычисляет погрешность средней функции. Она равна<sqrt(variance/ (count -1))>.

Заголовок

#include <boost/accumulators/statistics/error_of.hpp>
#include <boost/accumulators/statistics/error_of_mean.hpp>

Пример

accumulator_set<double, stats<tag::error_of<tag::mean> > > acc;
acc(1.1);
acc(1.2);
acc(1.3);
assert(0.057735 == error_of<tag::mean>(acc));

См. также

Оценка множественного квантиля с помощью расширенного алгоритма<P^2>. Подробнее см.<extended_p_square_impl>.

Заголовок

#include <boost/accumulators/statistics/extended_p_square.hpp>

Пример

boost::array<double> probs = {0.001,0.01,0.1,0.25,0.5,0.75,0.9,0.99,0.999};
accumulator_set<double, stats<tag::extended_p_square> >
    acc(tag::extended_p_square::probabilities = probs);
boost::lagged_fibonacci607 rng; // a random number generator
for (int i=0; i<10000; ++i)
    acc(rng());
BOOST_CHECK_CLOSE(extended_p_square(acc)[0], probs[0], 25);
BOOST_CHECK_CLOSE(extended_p_square(acc)[1], probs[1], 10);
BOOST_CHECK_CLOSE(extended_p_square(acc)[2], probs[2], 5);
for (std::size_t i=3; i < probs.size(); ++i)
{
    BOOST_CHECK_CLOSE(extended_p_square(acc)[i], probs[i], 2);
}

См. также

Количественная оценка с использованием расширенного алгоритма<P^2>для взвешенных и невзвешенных образцов. По умолчанию расчет линейный и невзвешенный, но также предусмотрены квадратичные и взвешенные варианты. Подробнее о реализации см.<extended_p_square_quantile_impl>.

Все варианты имеют общую функцию<tag::quantile>и могут быть извлечены с помощью экстрактора<quantile()>.

Заголовок

#include <boost/accumulators/statistics/extended_p_square_quantile.hpp>

Пример

typedef accumulator_set<double, stats<tag::extended_p_square_quantile> >
    accumulator_t;
typedef accumulator_set<double, stats<tag::weighted_extended_p_square_quantile>, double >
    accumulator_t_weighted;
typedef accumulator_set<double, stats<tag::extended_p_square_quantile(quadratic)> >
    accumulator_t_quadratic;
typedef accumulator_set<double, stats<tag::weighted_extended_p_square_quantile(quadratic)>, double >
    accumulator_t_weighted_quadratic;
// tolerance
double epsilon = 1;
// a random number generator
boost::lagged_fibonacci607 rng;
boost::array<double> probs = { 0.990, 0.991, 0.992, 0.993, 0.994,
                               0.995, 0.996, 0.997, 0.998, 0.999 };
accumulator_t acc(extended_p_square_probabilities = probs);
accumulator_t_weighted acc_weighted(extended_p_square_probabilities = probs);
accumulator_t_quadratic acc2(extended_p_square_probabilities = probs);
accumulator_t_weighted_quadratic acc_weighted2(extended_p_square_probabilities = probs);
for (int i=0; i<10000; ++i)
{
    double sample = rng();
    acc(sample);
    acc2(sample);
    acc_weighted(sample, weight = 1.);
    acc_weighted2(sample, weight = 1.);
}
for (std::size_t i = 0; i < probs.size() - 1; ++i)
{
    BOOST_CHECK_CLOSE(
        quantile(acc, quantile_probability = 0.99025 + i*0.001)
      , 0.99025 + i*0.001
      , epsilon
    );
    BOOST_CHECK_CLOSE(
        quantile(acc2, quantile_probability = 0.99025 + i*0.001)
      , 0.99025 + i*0.001
      , epsilon
    );
    BOOST_CHECK_CLOSE(
        quantile(acc_weighted, quantile_probability = 0.99025 + i*0.001)
      , 0.99025 + i*0.001
      , epsilon
    );
    BOOST_CHECK_CLOSE(
        quantile(acc_weighted2, quantile_probability = 0.99025 + i*0.001)
      , 0.99025 + i*0.001
      , epsilon
    );
}

См. также

Заголовок

#include <boost/accumulators/statistics/kurtosis.hpp>

Пример

accumulator_set<int, stats<tag::kurtosis > > acc;
acc(2);
acc(7);
acc(4);
acc(9);
acc(3);
BOOST_CHECK_EQUAL( mean(acc), 5 );
BOOST_CHECK_EQUAL( accumulators::moment<2>(acc), 159./5. );
BOOST_CHECK_EQUAL( accumulators::moment<3>(acc), 1171./5. );
BOOST_CHECK_EQUAL( accumulators::moment<4>(acc), 1863 );
BOOST_CHECK_CLOSE( kurtosis(acc), -1.39965397924, 1e-6 );

См. также

Вычисляет максимальное значение всех образцов.

Заголовок

#include <boost/accumulators/statistics/max.hpp>

Пример

accumulator_set<int, stats<tag::max> > acc;
acc(1);
BOOST_CHECK_EQUAL(1, (max)(acc));
acc(0);
BOOST_CHECK_EQUAL(1, (max)(acc));
acc(2);
BOOST_CHECK_EQUAL(2, (max)(acc));

См. также

Вычисляет среднее значение образцов, весов или вариаций. Расчет либо ленивый (в результате экстрактор), либо немедленный (в аккумуляторе). Ленивая реализация — это дефолт. Более подробную информацию о реализации см. в<mean_impl>или<immediate_mean_impl>.

Заголовок

#include <boost/accumulators/statistics/mean.hpp>

Пример

accumulator_set<
    int
  , stats<
        tag::mean
      , tag::mean_of_weights
      , tag::mean_of_variates<int, tag::covariate1>
    >
  , int
> acc;
acc(1, weight = 2, covariate1 = 3);
BOOST_CHECK_CLOSE(1., mean(acc), 1e-5);
BOOST_CHECK_EQUAL(1u, count(acc));
BOOST_CHECK_EQUAL(2, sum(acc));
BOOST_CHECK_CLOSE(2., mean_of_weights(acc), 1e-5);
BOOST_CHECK_CLOSE(3., (accumulators::mean_of_variates<int, tag::covariate1>(acc)), 1e-5);
acc(0, weight = 4, covariate1 = 4);
BOOST_CHECK_CLOSE(0.33333333333333333, mean(acc), 1e-5);
BOOST_CHECK_EQUAL(2u, count(acc));
BOOST_CHECK_EQUAL(2, sum(acc));
BOOST_CHECK_CLOSE(3., mean_of_weights(acc), 1e-5);
BOOST_CHECK_CLOSE(3.5, (accumulators::mean_of_variates<int, tag::covariate1>(acc)), 1e-5);
acc(2, weight = 9, covariate1 = 8);
BOOST_CHECK_CLOSE(1.33333333333333333, mean(acc), 1e-5);
BOOST_CHECK_EQUAL(3u, count(acc));
BOOST_CHECK_EQUAL(20, sum(acc));
BOOST_CHECK_CLOSE(5., mean_of_weights(acc), 1e-5);
BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc)), 1e-5);
accumulator_set<
    int
  , stats<
        tag::mean(immediate)
      , tag::mean_of_weights(immediate)
      , tag::mean_of_variates<int, tag::covariate1>(immediate)
    >
  , int
> acc2;
acc2(1, weight = 2, covariate1 = 3);
BOOST_CHECK_CLOSE(1., mean(acc2), 1e-5);
BOOST_CHECK_EQUAL(1u, count(acc2));
BOOST_CHECK_CLOSE(2., mean_of_weights(acc2), 1e-5);
BOOST_CHECK_CLOSE(3., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5);
acc2(0, weight = 4, covariate1 = 4);
BOOST_CHECK_CLOSE(0.33333333333333333, mean(acc2), 1e-5);
BOOST_CHECK_EQUAL(2u, count(acc2));
BOOST_CHECK_CLOSE(3., mean_of_weights(acc2), 1e-5);
BOOST_CHECK_CLOSE(3.5, (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5);
acc2(2, weight = 9, covariate1 = 8);
BOOST_CHECK_CLOSE(1.33333333333333333, mean(acc2), 1e-5);
BOOST_CHECK_EQUAL(3u, count(acc2));
BOOST_CHECK_CLOSE(5., mean_of_weights(acc2), 1e-5);
BOOST_CHECK_CLOSE(5., (accumulators::mean_of_variates<int, tag::covariate1>(acc2)), 1e-5);

См. также

Медианная оценка на основе<P^2>квантильной оценки, оценки плотности или<P^2>кумулятивной оценки распределения. Более подробную информацию о реализации см.<median_impl>,<with_density_median_impl>и<with_p_square_cumulative_distribution_median_impl>.

Все три средних аккумулятора удовлетворяют характеристике<tag::median>и могут быть извлечены с помощью<median()>экстрактора.

Заголовок

#include <boost/accumulators/statistics/median.hpp>

Пример

// two random number generators
double mu = 1.;
boost::lagged_fibonacci607 rng;
boost::normal_distribution<> mean_sigma(mu,1);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> >
    normal(rng, mean_sigma);
accumulator_set<double, stats<tag::median(with_p_square_quantile) > > acc;
accumulator_set<double, stats<tag::median(with_density) > >
    acc_dens( density_cache_size = 10000, density_num_bins = 1000 );
accumulator_set<double, stats<tag::median(with_p_square_cumulative_distribution) > >
    acc_cdist( p_square_cumulative_distribution_num_cells = 100 );
for (std::size_t i=0; i<100000; ++i)
{
    double sample = normal();
    acc(sample);
    acc_dens(sample);
    acc_cdist(sample);
}
BOOST_CHECK_CLOSE(1., median(acc), 1.);
BOOST_CHECK_CLOSE(1., median(acc_dens), 1.);
BOOST_CHECK_CLOSE(1., median(acc_cdist), 3.);

См. также

Вычисляет минимальное значение всех образцов.

Заголовок

#include <boost/accumulators/statistics/min.hpp>

Пример

accumulator_set<int, stats<tag::min> > acc;
acc(1);
BOOST_CHECK_EQUAL(1, (min)(acc));
acc(0);
BOOST_CHECK_EQUAL(0, (min)(acc));
acc(2);
BOOST_CHECK_EQUAL(0, (min)(acc));

См. также

Вычисляет N-й момент образцов, который определяется как сумма N-й мощности образцов над количеством образцов.

Заголовок

#include <boost/accumulators/statistics/moment.hpp>

Пример

accumulator_set<int, stats<tag::moment<2> > > acc1;
acc1(2); //    4
acc1(4); //   16
acc1(5); // + 25
         // = 45 / 3 = 15
BOOST_CHECK_CLOSE(15., accumulators::moment<2>(acc1), 1e-5);
accumulator_set<int, stats<tag::moment<5> > > acc2;
acc2(2); //     32
acc2(3); //    243
acc2(4); //   1024
acc2(5); // + 3125
         // = 4424 / 4 = 1106
BOOST_CHECK_CLOSE(1106., accumulators::moment<5>(acc2), 1e-5);

См. также

Расчет гистограммы кумулятивного распределения с помощью алгоритма<P^2>. Подробнее о реализации см.<p_square_cumulative_distribution_impl>

Заголовок

#include <boost/accumulators/statistics/p_square_cumul_dist.hpp>

Пример

// tolerance in %
double epsilon = 3;
typedef accumulator_set<double, stats<tag::p_square_cumulative_distribution> > accumulator_t;
accumulator_t acc(tag::p_square_cumulative_distribution::num_cells = 100);
// two random number generators
boost::lagged_fibonacci607 rng;
boost::normal_distribution<> mean_sigma(0,1);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
for (std::size_t i=0; i<100000; ++i)
{
    acc(normal());
}
typedef iterator_range<std::vector<std::pair<double, double> >::iterator > histogram_type;
histogram_type histogram = p_square_cumulative_distribution(acc);
for (std::size_t i = 0; i < histogram.size(); ++i)
{
    // problem with small results: epsilon is relative (in percent), not absolute!
    if ( histogram[i].second > 0.001 )
        BOOST_CHECK_CLOSE( 0.5 * (1.0 + erf( histogram[i].first / sqrt(2.0) )), histogram[i].second, epsilon );
}

См. также

Единый квантиль с алгоритмом<P^2>. Подробнее о реализации см.<p_square_quantile_impl>

Заголовок

#include <boost/accumulators/statistics/p_square_quantile.hpp>

Пример

typedef accumulator_set<double, stats<tag::p_square_quantile> > accumulator_t;
// tolerance in %
double epsilon = 1;
// a random number generator
boost::lagged_fibonacci607 rng;
accumulator_t acc0(quantile_probability = 0.001);
accumulator_t acc1(quantile_probability = 0.01 );
accumulator_t acc2(quantile_probability = 0.1  );
accumulator_t acc3(quantile_probability = 0.25 );
accumulator_t acc4(quantile_probability = 0.5  );
accumulator_t acc5(quantile_probability = 0.75 );
accumulator_t acc6(quantile_probability = 0.9  );
accumulator_t acc7(quantile_probability = 0.99 );
accumulator_t acc8(quantile_probability = 0.999);
for (int i=0; i<100000; ++i)
{
    double sample = rng();
    acc0(sample);
    acc1(sample);
    acc2(sample);
    acc3(sample);
    acc4(sample);
    acc5(sample);
    acc6(sample);
    acc7(sample);
    acc8(sample);
}
BOOST_CHECK_CLOSE( p_square_quantile(acc0), 0.001, 15*epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc1), 0.01 , 5*epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc2), 0.1  , epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc3), 0.25 , epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc4), 0.5  , epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc5), 0.75 , epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc6), 0.9  , epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc7), 0.99 , epsilon );
BOOST_CHECK_CLOSE( p_square_quantile(acc8), 0.999, epsilon );

См. также

Метод Peaks Over Threshold для квантиля и хвоста означает оценку. Подробности реализации см. в<peaks_over_threshold_impl>и<peaks_over_threshold_prob_impl>.

Как<tag::peaks_over_threshold>, так и<tag::peaks_over_threshold_prob<>>удовлетворяют<tag::abstract_peaks_over_threshold>признаку и могут быть извлечены с помощью<peaks_over_threshold()>экстрактора. В результате получается 3-х трубка, представляющая параметры соответствия<u_bar>,<beta_bar>и<xi_hat>.

Заголовок

#include <boost/accumulators/statistics/peaks_over_threshold.hpp>

Пример

См. пример<pot_quantile>.

См. также

Количественная оценка основана на методе Peaks over Threshold (как для левого, так и для правого хвоста). Подробности реализации см.<pot_quantile_impl>.

Оба<tag::pot_quantile<left-or-right>>и<tag::pot_quantile_prob<left-or-right>>удовлетворяют<tag::quantile>признаку и могут быть извлечены с помощью<quantile()>экстрактора.

Заголовок

#include <boost/accumulators/statistics/pot_quantile.hpp>

Пример

// tolerance in %
double epsilon = 1.;
double alpha = 0.999;
double threshold_probability = 0.99;
double threshold = 3.;
// two random number generators
boost::lagged_fibonacci607 rng;
boost::normal_distribution<> mean_sigma(0,1);
boost::exponential_distribution<> lambda(1);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal(rng, mean_sigma);
boost::variate_generator<boost::lagged_fibonacci607&, boost::exponential_distribution<> > exponential(rng, lambda);
accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc1(
    tag::peaks_over_threshold::threshold_value = threshold
);
accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_probability)> > acc2(
    tag::tail<right>::cache_size = 2000
  , tag::peaks_over_threshold_prob::threshold_probability = threshold_probability
);
threshold_probability = 0.995;
threshold = 5.;
accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_value)> > acc3(
    tag::peaks_over_threshold::threshold_value = threshold
);
accumulator_set<double, stats<tag::pot_quantile<right>(with_threshold_probability)> > acc4(
    tag::tail<right>::cache_size = 2000
  , tag::peaks_over_threshold_prob::threshold_probability = threshold_probability
);
for (std::size_t i = 0; i < 100000; ++i)
{
    double sample = normal();
    acc1(sample);
    acc2(sample);
}
for (std::size_t i = 0; i < 100000; ++i)
{
    double sample = exponential();
    acc3(sample);
    acc4(sample);
}
BOOST_CHECK_CLOSE( quantile(acc1, quantile_probability = alpha), 3.090232, epsilon );
BOOST_CHECK_CLOSE( quantile(acc2, quantile_probability = alpha), 3.090232, epsilon );
BOOST_CHECK_CLOSE( quantile(acc3, quantile_probability = alpha), 6.908, epsilon );
BOOST_CHECK_CLOSE( quantile(acc4, quantile_probability = alpha), 6.908, epsilon );

См. также

Оценка (когерентного) хвостового среднего на основе метода пиков над порогом (как для левого, так и для правого хвоста). Подробности реализации см.<pot_tail_mean_impl>.

Оба<tag::pot_tail_mean<left-or-right>>и<tag::pot_tail_mean_prob<left-or-right>>удовлетворяют<tag::tail_mean>признаку и могут быть извлечены с помощью<tail_mean()>экстрактора.

Заголовок

#include <boost/accumulators/statistics/pot_tail_mean.hpp>

Пример

// TODO

См. также

Подсчет качения - это текущее количество элементов в окне качения.

Заголовок

#include <boost/accumulators/statistics/rolling_count.hpp>

Пример

accumulator_set<int, stats<tag::rolling_count> > acc(tag::rolling_window::window_size = 3);
BOOST_CHECK_EQUAL(0u, rolling_count(acc));
acc(1);
BOOST_CHECK_EQUAL(1u, rolling_count(acc));
acc(1);
BOOST_CHECK_EQUAL(2u, rolling_count(acc));
acc(1);
BOOST_CHECK_EQUAL(3u, rolling_count(acc));
acc(1);
BOOST_CHECK_EQUAL(3u, rolling_count(acc));
acc(1);
BOOST_CHECK_EQUAL(3u, rolling_count(acc));

См. также

Сумма качения является суммой последнихNобразцов.

Заголовок

#include <boost/accumulators/statistics/rolling_sum.hpp>

Пример

accumulator_set<int, stats<tag::rolling_sum> > acc(tag::rolling_window::window_size = 3);
BOOST_CHECK_EQUAL(0, rolling_sum(acc));
acc(1);
BOOST_CHECK_EQUAL(1, rolling_sum(acc));
acc(2);
BOOST_CHECK_EQUAL(3, rolling_sum(acc));
acc(3);
BOOST_CHECK_EQUAL(6, rolling_sum(acc));
acc(4);
BOOST_CHECK_EQUAL(9, rolling_sum(acc));
acc(5);
BOOST_CHECK_EQUAL(12, rolling_sum(acc));