Class circular

include/boost/histogram/axis/types.hpp:200–257

 */
template <typename RealType, typename Allocator>
class circular : public labeled_base<Allocator>,
                 public iterator_mixin<circular<RealType, Allocator>> {
  using base_type = labeled_base<Allocator>;

public:
  using allocator_type = typename base_type::allocator_type;
  using value_type = RealType;
  using bin_type = interval_view<circular>;

  // two_pi can be found in boost/math, but it is defined here to reduce deps
  static value_type two_pi() { return 6.283185307179586; }

  /** Constructor for n bins with an optional offset.
   *
   * \param n         number of bins.
   * \param phase     starting phase.
   * \param perimeter range after which value wraps around.
   * \param label     description of the axis.
   */
  explicit circular(unsigned n, value_type phase = 0.0, value_type perimeter = two_pi(),
                    string_view label = {}, const allocator_type& a = allocator_type())
      : base_type(n, uoflow_type::off, label, a), phase_(phase), perimeter_(perimeter) {}

  circular() = default;
  circular(const circular&) = default;
  circular& operator=(const circular&) = default;
  circular(circular&&) = default;
  circular& operator=(circular&&) = default;

  /// Returns the bin index for the passed argument.
  int index(value_type x) const noexcept {
    const value_type z = (x - phase_) / perimeter_;
    const int i = static_cast<int>(std::floor(z * base_type::size())) % base_type::size();
    return i + (i < 0) * base_type::size();
  }

  /// Returns lower edge of bin.
  value_type lower(int i) const noexcept {
    const value_type z = value_type(i) / base_type::size();
    return z * perimeter_ + phase_;
  }

  bin_type operator[](int idx) const noexcept { return bin_type(idx, *this); }

  bool operator==(const circular& o) const noexcept {
    return base_type::operator==(o) && phase_ == o.phase_ && perimeter_ == o.perimeter_;
  }

  value_type perimeter() const { return perimeter_; }
  value_type phase() const { return phase_; }

private:
  value_type phase_ = 0.0, perimeter_ = 1.0;

  friend class ::boost::serialization::access;
  template <class Archive>
  void serialize(Archive&, unsigned);
};