Boost C++ Libraries

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() = 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);

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;

This version is more efficient than the one accepting a run-time number.

decltype(auto) axis(unsigned i) const;

Prefer the version that accepts a compile-time number, if you can use it.

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

template<typename T0, class... Ts> 
  iterator operator()(const T0 & arg0, const Ts &... args);

Returns iterator to located cell.

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 be passed as astd::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);

template<typename Iterable> void fill(const Iterable & args);

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 over a contiguous sequence of values or 3) a variant of 1) and 2). Sub-iterables must have the same length.

Warning: std::vector<bool> is not a contiguous sequence over boolean values because of the infamous vector specialization for booleans. It cannot be used as an argument, but any truely contiguous sequence of boolean values can (std::array<bool, N> orstd::valarray<bool>, for example).

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.

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

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

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

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

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... Is> decltype(auto) at(axis::index_type i, Is... is);

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.

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

decltype(auto) at(const multi_index_type & is);

decltype(auto) at(const multi_index_type & is) const;

decltype(auto) operator[](axis::index_type i);

decltype(auto) operator[](axis::index_type i) const;

decltype(auto) operator[](const multi_index_type & is);

decltype(auto) operator[](const multi_index_type & is) const;

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

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

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

This operator is only available if the value_type supports operator+=.

Both histograms must be compatible to be addable. The histograms are compatible, if the axes are either all identical. If the axes only differ in the states of their discrete growing axis types, then they are also compatible. The discrete growing axes are merged in this case.

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

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

This operator is only available if the value_type supports operator-=.

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

This operator is only available if the value_type supports operator*=.

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

This operator is only available if the value_type supports operator/=.

histogram & operator *=(const double x);

This operator is only available if the value_type supports operator*=.

histogram & operator/=(const double x);

This operator is only available if operator*= is available.

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 & ar, unsigned);