Class template category

boost::histogram::axis::category — Maps at a set of unique values to bin indices.

Synopsis

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

template<typename Value, typename MetaData, typename Options, 
         typename Allocator> 
class category : public boost::histogram::axis::iterator_mixin< category< Value, MetaData, Options, Allocator > >,
                 public boost::histogram::axis::metadata_base< MetaData >
{
public:
  // construct/copy/destruct
  category() = default;
  explicit category(allocator_type);
  template<typename It> 
    category(It, It, metadata_type = {}, allocator_type = {});
  template<typename C> 
    category(const C &, metadata_type = {}, allocator_type = {});
  template<typename U> 
    category(std::initializer_list< U >, metadata_type = {}, 
             allocator_type = {});

  // public member functions
  index_type index(const value_type &) const noexcept;
  auto update(const value_type &);
  auto value(index_type) const;
  decltype(auto) bin(index_type) const noexcept;
  index_type size() const noexcept;
  template<typename V, typename M, typename O, typename A> 
    bool operator==(const category< V, M, O, A > &) const noexcept;
  template<typename V, typename M, typename O, typename A> 
    bool operator!=(const category< V, M, O, A > &) const noexcept;
  auto get_allocator() const;
  template<typename Archive> void serialize(Archive &, unsigned);

  // public static functions
  static constexpr unsigned options() noexcept;
  static constexpr bool inclusive() noexcept;
};

Description

The axis maps a set of values to bins, following the order of arguments in the constructor. The optional overflow bin for this axis counts input values that are not part of the set. Binning has O(N) complexity, but with a very small factor. For small N (the typical use case) it beats other kinds of lookup.

The options underflow and circular are not allowed. The options growth and overflow are mutually exclusive.

Template Parameters

```
typename Value
```
input value type, must be equal-comparable.
```
typename MetaData
```
type to store meta data.
```
typename Options
```
see boost::histogram::axis::option.
```
typename Allocator
```
allocator to use for dynamic memory management.

`category` public construct/copy/destruct

```
category() = default;
```

explicit category(allocator_type alloc);

```
template<typename It> 
  category(It begin, It end, metadata_type meta = {}, 
           allocator_type alloc = {});
```
Construct from iterator range of unique values.

Parameters:

alloc

allocator instance to use.

begin

begin of category range of unique values.

end

end of category range of unique values.

meta

description of the axis.
```
template<typename C> 
  category(const C & iterable, metadata_type meta = {}, 
           allocator_type alloc = {});
```
Construct axis from iterable sequence of unique values.

Parameters:

alloc

allocator instance to use.

iterable

sequence of unique values.

meta

description of the axis.
```
template<typename U> 
  category(std::initializer_list< U > list, metadata_type meta = {}, 
           allocator_type alloc = {});
```
Construct axis from an initializer list of unique values.

Parameters:

alloc

allocator instance to use.

list

std::initializer_list of unique values.

meta

description of the axis.

`category` public member functions

index_type index(const value_type & x) const noexcept;

Return index for value argument.

```
auto update(const value_type & x);
```
Returns index and shift (if axis has grown) for the passed argument.
```
auto value(index_type idx) const;
```
Return value for index argument.
Throws std::out_of_range if the index is out of bounds.

decltype(auto) bin(index_type idx) const noexcept;

Return value for index argument.

```
index_type size() const noexcept;
```
Returns the number of bins, without over- or underflow.

template<typename V, typename M, typename O, typename A> 
  bool operator==(const category< V, M, O, A > & o) const noexcept;

template<typename V, typename M, typename O, typename A> 
  bool operator!=(const category< V, M, O, A > & o) const noexcept;

```
auto get_allocator() const;
```

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

`category` public static functions

static constexpr unsigned options() noexcept;

Returns the options.

```
static constexpr bool inclusive() noexcept;
```
Whether the axis is inclusive (see axis::traits::is_inclusive).

Boost C++ Libraries