Range1D.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Range1D.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2021 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <algorithm>
#include <limits>

namespace Acts {
template <typename Type>
class Range1D {
 public:
  Range1D()
      : m_min(std::numeric_limits<Type>::lowest()),
        m_max(std::numeric_limits<Type>::max()) {}

  Range1D(Type min, Type max) : m_min(min), m_max(max) {}

  Range1D(const std::pair<Type, Type>& p) : m_min(p.first), m_max(p.second) {}

  Range1D(const Range1D<Type>& o) : m_min(o.min()), m_max(o.max()) {}

  void setMin(const Type& v) { m_min = v; }

  void setMax(const Type& v) { m_max = v; }

  void set(const Type& min, const Type& max) {
    m_min = min;
    m_max = max;
  }

  void shrinkMin(const Type& v) { m_min = std::max(m_min, v); }

  void shrinkMax(const Type& v) { m_max = std::min(m_max, v); }

  void shrink(const Type& min, const Type& max) {
    shrinkMin(min);
    shrinkMax(max);
  }

  void expandMin(const Type& v) { m_min = std::min(m_min, v); }

  void expandMax(const Type& v) { m_max = std::max(m_max, v); }

  void expand(const Type& min, const Type& max) {
    expandMin(min);
    expandMax(max);
  }

  Type min(void) const { return m_min; }

  Type max(void) const { return m_max; }

  Type size(void) const {
    return std::max(static_cast<Type>(0), m_max - m_min);
  }

  bool degenerate(void) const { return m_min >= m_max; }

  bool contains(const Type& v) const { return m_min <= v && v < m_max; }

  bool operator&&(const Range1D<Type>& o) const {
    return m_min < o.max() && o.min() < m_max;
  }

  bool operator==(const Range1D<Type>& o) const {
    return min() == o.min() && max() == o.max();
  }

  bool operator<=(const Range1D<Type>& o) const {
    return min() >= o.min() && max() <= o.max();
  }

  bool operator>=(const Range1D<Type>& o) const {
    return min() <= o.min() && max() >= o.max();
  }

  Range1D<Type>& operator=(const Range1D<Type>& o) {
    m_min = o.min();
    m_max = o.max();

    return *this;
  }

  Range1D<Type> operator&(const Range1D<Type>& o) const {
    return Range1D<Type>(std::max(m_min, o.min()), std::min(m_max, o.max()));
  }

  Range1D<Type>& operator&=(const Range1D<Type>& o) {
    m_min = std::max(m_min, o.min());
    m_max = std::min(m_max, o.max());

    return *this;
  }

 private:
  Type m_min, m_max;
};
}  // namespace Acts