Class template histogram

boost::histogram::histogram — Central class of the histogram library.

Synopsis

// In header: <boost/histogram/histogram.hpp>

template<typename Axes, typename Storage> 
class histogram {
public:
  // types
  typedef Axes                                  axes_type;     
  typedef Storage                               storage_type;  
  typedef typename storage_type::value_type     value_type;    
  typedef typename storage_type::iterator       iterator;      
  typedef typename storage_type::const_iterator const_iterator;

  // construct/copy/destruct
  histogram() = default;
  template<typename A, typename S> explicit histogram(histogram< A, S > &&);
  template<typename A, typename S> 
    explicit histogram(const histogram< A, S > &);
  template<typename A> histogram(A &&, Storage);
  explicit histogram(Axes);
  template<class... As> explicit histogram(As &&...);
  template<typename A, typename S> histogram & operator=(histogram< A, S > &&);
  template<typename A, typename S> 
    histogram & operator=(const histogram< A, S > &);

  // public member functions
  constexpr unsigned rank() const noexcept;
  std::size_t size() const noexcept;
  void reset();
  template<unsigned N = 0> 
    decltype(auto) axis(std::integral_constant< unsigned, N > = {}) const;
  decltype(auto) axis(unsigned) const;
  template<typename Unary> auto for_each_axis(Unary &&) const;
  template<typename Arg0, class... Args> 
    unspecified operator()(const Arg0 &, const Args &...);
  template<class... Ts> iterator operator()(const std::tuple< Ts... > &);
  template<typename Iterable> void fill(const Iterable &);
  template<typename Iterable, typename T> 
    void fill(const Iterable &, const weight_type< T > &);
  template<typename Iterable, typename T> 
    void fill(const weight_type< T > &, const Iterable &);
  template<typename Iterable, class... Ts> 
    void fill(const Iterable &, const sample_type< std::tuple< Ts... >> &);
  template<typename Iterable, typename T> 
    void fill(const sample_type< T > &, const Iterable &);
  template<typename Iterable, typename T, class... Ts> 
    void fill(const Iterable &, const weight_type< T > &, 
              const sample_type< std::tuple< Ts... >> &);
  template<typename Iterable, typename T, typename U> 
    void fill(const sample_type< T > &, const weight_type< U > &, 
              const Iterable &);
  template<typename Iterable, typename T, typename U> 
    void fill(const weight_type< T > &, const sample_type< U > &, 
              const Iterable &);
  template<typename Iterable, typename T, typename U> 
    void fill(const Iterable &, const sample_type< T > &, 
              const weight_type< U > &);
  template<class... Indices> decltype(auto) at(axis::index_type, Indices...);
  template<class... Indices> 
    decltype(auto) at(axis::index_type, Indices...) const;
  template<class... Indices> 
    decltype(auto) at(const std::tuple< Indices... > &);
  template<typename... Indices> 
    decltype(auto) at(const std::tuple< Indices... > &) const;
  template<typename Iterable> decltype(auto) at(const Iterable &);
  template<typename Iterable> decltype(auto) at(const Iterable &) const;
  template<typename Indices> decltype(auto) operator[](const Indices &);
  template<typename Indices> decltype(auto) operator[](const Indices &) const;
  template<typename A, typename S> 
    bool operator==(const histogram< A, S > &) const noexcept;
  template<typename A, typename S> 
    bool operator!=(const histogram< A, S > &) const noexcept;
  template<typename A, typename S> 
    unspecified operator+=(const histogram< A, S > &);
  template<typename A, typename S> 
    unspecified operator-=(const histogram< A, S > &);
  template<typename A, typename S> 
    unspecified operator *=(const histogram< A, S > &);
  template<typename A, typename S> 
    unspecified operator/=(const histogram< A, S > &);
  template<typename V = value_type> unspecified operator *=(const double);
  template<typename V = value_type> unspecified operator *=(const double);
  template<typename V = value_type> unspecified operator/=(const double);
  iterator begin() noexcept;
  iterator end() noexcept;
  const_iterator begin() const noexcept;
  const_iterator end() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
  template<typename Archive> void serialize(Archive &, unsigned);
};

Description

Histogram uses the call operator to insert data, like the Boost.Accumulators.

Use factory functions (see make_histogram.hpp and make_profile.hpp) to conveniently create histograms rather than calling the ctors directly.

Use the indexed range generator to iterate over filled histograms, which is convenient and faster than hand-written loops for multi-dimensional histograms.

Template Parameters

```
typename Axes
```
std::tuple of axis types OR std::vector of an axis type or axis::variant
```
typename Storage
```
class that implements the storage interface

`histogram` public construct/copy/destruct

```
histogram() = default;
```

template<typename A, typename S> explicit histogram(histogram< A, S > && rhs);

template<typename A, typename S> 
  explicit histogram(const histogram< A, S > & rhs);

template<typename A> histogram(A && a, Storage s);

```
explicit histogram(Axes axes);
```

template<class... As> explicit histogram(As &&... as);

template<typename A, typename S> 
  histogram & operator=(histogram< A, S > && rhs);

template<typename A, typename S> 
  histogram & operator=(const histogram< A, S > & rhs);

`histogram` public member functions

constexpr unsigned rank() const noexcept;

Number of axes (dimensions).

```
std::size_t size() const noexcept;
```
Total number of bins (including underflow/overflow).
```
void reset();
```
Reset all bins to default initialized values.
```
template<unsigned N = 0> 
  decltype(auto) axis(std::integral_constant< unsigned, N > = {}) const;
```
Get N-th axis using a compile-time number.
This version is more efficient than the one accepting a run-time number.
```
decltype(auto) axis(unsigned i) const;
```
Get N-th axis with run-time number.
Prefer the version that accepts a compile-time number, if you can use it.

template<typename Unary> auto for_each_axis(Unary && unary) const;

Apply unary functor/function to each axis.

```
template<typename Arg0, class... Args> 
  unspecified operator()(const Arg0 & arg0, const Args &... args);
```
Fill histogram with values, an optional weight, and/or a sample.
Arguments are passed in order to the axis objects. Passing an argument type that is not convertible to the value type accepted by the axis or passing the wrong number of arguments causes a throw of std::invalid_argument.

Optional weight

An optional weight can be passed as the first or last argument with the weight helper function. Compilation fails if the storage elements do not support weights.

Samples

If the storage elements accept samples, pass them with the sample helper function in addition to the axis arguments, which can be the first or last argument. The sample helper function can pass one or more arguments to the storage element. If samples and weights are used together, they can be passed in any order at the beginning or end of the argument list.

Axis with multiple arguments

If the histogram contains an axis which accepts a std::tuple of arguments, the arguments for that axis need to passed as a std::tuple, for example, std::make_tuple(1.2, 2.3). If the histogram contains only this axis and no other, the arguments can be passed directly.

template<class... Ts> iterator operator()(const std::tuple< Ts... > & args);

Fill histogram with values, an optional weight, and/or a sample from a std::tuple.

```
template<typename Iterable> void fill(const Iterable & args);
```
Fill histogram with several values at once.
The argument must be an iterable with a size that matches the rank of the histogram. The element of an iterable may be 1) a value or 2) an iterable with contiguous storage over values or 3) a variant of 1) and 2). Sub-iterables must have the same length.

Values are passed to the corresponding histogram axis in order. If a single value is passed together with an iterable of values, the single value is treated like an iterable with matching length of copies of this value.

If the histogram has only one axis, an iterable of values may be passed directly.

Parameters:

args

iterable as explained in the long description.
```
template<typename Iterable, typename T> 
  void fill(const Iterable & args, const weight_type< T > & weights);
```
Fill histogram with several values and weights at once.

Parameters:

args

iterable of values.

weights

single weight or an iterable of weights.
```
template<typename Iterable, typename T> 
  void fill(const weight_type< T > & weights, const Iterable & args);
```
Fill histogram with several values and weights at once.

Parameters:

args

iterable of values.

weights

single weight or an iterable of weights.

template<typename Iterable, class... Ts> 
  void fill(const Iterable & args, 
            const sample_type< std::tuple< Ts... >> & samples);

Fill histogram with several values and samples at once.

Parameters:

`args`	iterable of values.
`samples`	single sample or an iterable of samples.

```
template<typename Iterable, typename T> 
  void fill(const sample_type< T > & samples, const Iterable & args);
```
Fill histogram with several values and samples at once.

Parameters:

args

iterable of values.

samples

single sample or an iterable of samples.

template<typename Iterable, typename T, class... Ts> 
  void fill(const Iterable & args, const weight_type< T > & weights, 
            const sample_type< std::tuple< Ts... >> & samples);

template<typename Iterable, typename T, typename U> 
  void fill(const sample_type< T > & samples, 
            const weight_type< U > & weights, const Iterable & args);

template<typename Iterable, typename T, typename U> 
  void fill(const weight_type< T > & weights, 
            const sample_type< U > & samples, const Iterable & args);

template<typename Iterable, typename T, typename U> 
  void fill(const Iterable & args, const sample_type< T > & samples, 
            const weight_type< U > & weights);

```
template<class... Indices> 
  decltype(auto) at(axis::index_type i, Indices... is);
```
Access cell value at integral indices.
You can pass indices as individual arguments, as a std::tuple of integers, or as an interable range of integers. Passing the wrong number of arguments causes a throw of std::invalid_argument. Passing an index which is out of bounds causes a throw of std::out_of_range.

Parameters:

i

index of first axis.

is

indices of second, third, ... axes.

Returns:

reference to cell value.

template<class... Indices> 
  decltype(auto) at(axis::index_type i, Indices... is) const;

Access cell value at integral indices (read-only).

template<class... Indices> 
  decltype(auto) at(const std::tuple< Indices... > & is);

Access cell value at integral indices stored in std::tuple.

template<typename... Indices> 
  decltype(auto) at(const std::tuple< Indices... > & is) const;

Access cell value at integral indices stored in std::tuple (read-only).

template<typename Iterable> decltype(auto) at(const Iterable & is);

Access cell value at integral indices stored in iterable.

template<typename Iterable> decltype(auto) at(const Iterable & is) const;

Access cell value at integral indices stored in iterable (read-only).

template<typename Indices> decltype(auto) operator[](const Indices & is);

Access value at index (number for rank = 1, else std::tuple or iterable).

template<typename Indices> decltype(auto) operator[](const Indices & is) const;

Access value at index (read-only).

template<typename A, typename S> 
  bool operator==(const histogram< A, S > & rhs) const noexcept;

Equality operator, tests equality for all axes and the storage.

template<typename A, typename S> 
  bool operator!=(const histogram< A, S > & rhs) const noexcept;

Negation of the equality operator.

template<typename A, typename S> 
  unspecified operator+=(const histogram< A, S > & rhs);

Add values of another histogram.

template<typename A, typename S> 
  unspecified operator-=(const histogram< A, S > & rhs);

Subtract values of another histogram.

template<typename A, typename S> 
  unspecified operator *=(const histogram< A, S > & rhs);

Multiply by values of another histogram.

template<typename A, typename S> 
  unspecified operator/=(const histogram< A, S > & rhs);

Divide by values of another histogram.

template<typename V = value_type> unspecified operator *=(const double x);

Multiply all values with a scalar.

template<typename V = value_type> unspecified operator *=(const double x);

Multiply all values with a scalar.

template<typename V = value_type> unspecified operator/=(const double x);

Divide all values by a scalar.

```
iterator begin() noexcept;
```
Return value iterator to the beginning of the histogram.
```
iterator end() noexcept;
```
Return value iterator to the end in the histogram.
```
const_iterator begin() const noexcept;
```
Return value iterator to the beginning of the histogram (read-only).
```
const_iterator end() const noexcept;
```
Return value iterator to the end in the histogram (read-only).
```
const_iterator cbegin() const noexcept;
```
Return value iterator to the beginning of the histogram (read-only).
```
const_iterator cend() const noexcept;
```
Return value iterator to the end in the histogram (read-only).

template<typename Archive> void serialize(Archive & ar, unsigned);

Boost C++ Libraries