YODA::Axis< T, typename > Class Template Reference

Discrete axis with edges of non-floating-point-type. More...

#include <BinnedAxis.h>

Public Types
using	EdgeT = T
using	ContainerT = std::vector< T >
using	const_iterator = typename ContainerT::const_iterator

Public Member Functions
Constructors
	Axis ()
	Nullary constructor for unique pointers etc.
	Axis (const std::vector< T > &edges)
	Constructs discrete Axis from edges vector.
	Axis (std::vector< T > &&edges)
	Constructs discrete Axis from edges vector (rvalue).
	Axis (std::initializer_list< T > &&edges)
	Constructs discrete Axis from an initializer list.
	Axis (Axis< T > &&other)
	Move constructs Axis.
	Axis (const Axis< T > &other)
	Copy constructs Axis.
Axis &	operator= (const Axis &other)
Axis &	operator= (Axis &&other)
I/O
std::string	type () const noexcept
	Returns a string representation of EdgeT.
int	maxEdgeWidth () const noexcept
size_t	index (const T &x) const
	Returns index of edge x.
EdgeT	edge (const size_t i) const
	Returns edge corresponding to index i.
std::vector< EdgeT >	edges () const noexcept
	Returns a copy of the container of edges.
const_iterator	begin () const
	Returns the const begin iterator for the edges container.
const_iterator	end () const
	Returns the const end iterator for the edges container.
size_t	size () const noexcept
	Returns number of edges + 1 for this Axis.
size_t	numBins (const bool includeOverflows=false) const noexcept
	Returns number of bins of this axis.
bool	hasSameEdges (const Axis< T > &other) const noexcept
	Checks if two axes have exactly the same edges.
std::vector< T >	sharedEdges (const Axis< T > &other) const noexcept
	Finds shared between Axes edges.
bool	isSubsetEdges (const Axis< T > &other) const noexcept
	Check if other axis edges are a subset of edges of this one.

Protected Member Functions
Utility
void	fillEdges (std::vector< EdgeT > &&edges) noexcept
	Fills edge storage. Used in constructors.

Detailed Description

template<typename T, typename = void>
class YODA::Axis< T, typename >

Discrete axis with edges of non-floating-point-type.

Note

Based on unsorted std::vector<T>

Definition at line 91 of file BinnedAxis.h.

Member Typedef Documentation

const_iterator

template<typename T , typename = void>

using YODA::Axis< T, typename >::const_iterator = typename ContainerT::const_iterator

Definition at line 95 of file BinnedAxis.h.

ContainerT

template<typename T , typename = void>

using YODA::Axis< T, typename >::ContainerT = std::vector<T>

Definition at line 94 of file BinnedAxis.h.

EdgeT

template<typename T , typename = void>

using YODA::Axis< T, typename >::EdgeT = T

Definition at line 93 of file BinnedAxis.h.

Constructor & Destructor Documentation

Axis() [1/6]

template<typename T , typename = void>

YODA::Axis< T, typename >::Axis ( )

inline

Nullary constructor for unique pointers etc.

Definition at line 101 of file BinnedAxis.h.

{ }

Axis() [2/6]

template<typename T , typename U >

YODA::Axis< T, U >::Axis

(

const std::vector< T > &

edges

)

Constructs discrete Axis from edges vector.

Note

Vector is not sorted by constructor.

Concept check shall appear inside body of type's member function or outside of type, since otherwise type is considered incomplete.

Definition at line 223 of file BinnedAxis.h.

                                            : Axis(std::vector<T>(edges)) {
      static_assert(MetaUtils::checkConcept<Axis<EdgeT>, YODAConcepts::AxisImpl>(),
        "Axis<T> should implement Axis concept.");
  }

Axis() [3/6]

template<typename T , typename U >

YODA::Axis< T, U >::Axis

(

std::vector< T > &&

edges

)

Constructs discrete Axis from edges vector (rvalue).

Note

Vector is not sorted by constructor.

Definition at line 231 of file BinnedAxis.h.

                                       {
    fillEdges(std::move(edges));
  }

Axis() [4/6]

template<typename T , typename U >

YODA::Axis< T, U >::Axis

(

std::initializer_list< T > &&

edges

)

Constructs discrete Axis from an initializer list.

Note

Vector is not sorted by constructor.

Definition at line 236 of file BinnedAxis.h.

                                                 {
    fillEdges(std::vector<T>{edges});
  }

Axis() [5/6]

template<typename T , typename = void>

YODA::Axis< T, typename >::Axis ( Axis< T > &&  other )

inline

Move constructs Axis.

Definition at line 119 of file BinnedAxis.h.

: _edges(std::move(other._edges)) {}

Axis() [6/6]

template<typename T , typename = void>

YODA::Axis< T, typename >::Axis ( const Axis< T > &  other )

inline

Copy constructs Axis.

Definition at line 122 of file BinnedAxis.h.

: _edges(other._edges) {}

Member Function Documentation

begin()

template<typename T , typename = void>

const_iterator YODA::Axis< T, typename >::begin ( ) const

inline

Returns the const begin iterator for the edges container.

Definition at line 182 of file BinnedAxis.h.

{ return _edges.cbegin(); }

Referenced by YODA::Axis< T, typename >::sharedEdges().

edge()

template<typename T , typename U >

Axis< T, U >::EdgeT YODA::Axis< T, U >::edge

(

const size_t

i

)

const

Returns edge corresponding to index i.

Definition at line 248 of file BinnedAxis.h.

                                                                {
    if (this->_edges.empty()) {
      throw RangeError("Axis has no edges!");
     }
    if (!i || i > this->_edges.size()) {
      throw RangeError("Invalid index, must be in range 1.." + std::to_string(this->_edges.size()));
    }
    return this->_edges.at(i-1);
  }

edges()

template<typename T , typename U >

std::vector< typename Axis< T, U >::EdgeT > YODA::Axis< T, U >::edges ( ) const

noexcept

Returns a copy of the container of edges.

Definition at line 259 of file BinnedAxis.h.

                                                                       {
    return this->_edges;
  }

end()

template<typename T , typename = void>

const_iterator YODA::Axis< T, typename >::end ( ) const

inline

Returns the const end iterator for the edges container.

Definition at line 185 of file BinnedAxis.h.

{ return _edges.cend(); }

fillEdges()

template<typename T , typename U >

void YODA::Axis< T, U >::fillEdges ( std::vector< EdgeT > &&  edges )

protectednoexcept

Fills edge storage. Used in constructors.

Definition at line 309 of file BinnedAxis.h.

                                                              {
    for (auto& edge : edges) {
      if (std::find(this->_edges.begin(),
                    this->_edges.end(), edge) == this->_edges.end()) // no duplicate edges allowed
        _edges.emplace_back(std::move(edge));
    }
  }

hasSameEdges()

template<typename T , typename U >

bool YODA::Axis< T, U >::hasSameEdges ( const Axis< T > &  other ) const

noexcept

Checks if two axes have exactly the same edges.

Definition at line 276 of file BinnedAxis.h.

                                                                   {
    return _edges.size() == other._edges.size() &&
           std::equal(_edges.begin(), _edges.end(), other._edges.begin());
  }

References YODA::Axis< T, typename >::size().

index()

template<typename T , typename U >

size_t YODA::Axis< T, U >::index

(

const T &

x

)

const

Returns index of edge x.

Note

Returns 0 if there is no x on this axis.

Definition at line 241 of file BinnedAxis.h.

                                           {
    auto it = std::find(this->_edges.begin(), this->_edges.end(), x);
    if (it == this->_edges.end())  return 0; // otherflow
    return it - this->_edges.begin() + 1;
  }

isSubsetEdges()

template<typename T , typename U >

bool YODA::Axis< T, U >::isSubsetEdges ( const Axis< T > &  other ) const

noexcept

Check if other axis edges are a subset of edges of this one.

Remarks

Should it be symmetrical? E.g. ax1.subsetEdges(ax2) == ax2.subsetEdges(ax1)?

Note

std::includes demands sorted ranges

Definition at line 294 of file BinnedAxis.h.

                                                                    {
    if (_edges.size() == other._edges.size()) return hasSameEdges(other);
 
    std::vector<T> edgesLhs(edges());
    std::vector<T> edgesRhs(other.edges());
 
    std::sort(edgesLhs.begin(), edgesLhs.end());
    std::sort(edgesRhs.begin(), edgesRhs.end());
 
    return std::includes(edgesLhs.begin(), edgesLhs.end(),
                         edgesRhs.begin(), edgesRhs.end());
  }

maxEdgeWidth()

template<typename T , typename = void>

int YODA::Axis< T, typename >::maxEdgeWidth ( ) const

inlinenoexcept

Definition at line 156 of file BinnedAxis.h.

                                      {
      int maxwidth = 0;
      if constexpr (hasWidth<EdgeT>::value) {
        auto it = std::max_element(_edges.begin(), _edges.end(),
                                   [](const auto& a, const auto& b) {
                                      return a.size() < b.size();
        });
        maxwidth = (*it).size();
      }
      return maxwidth;
    }

numBins()

template<typename T , typename U >

size_t YODA::Axis< T, U >::numBins ( const bool  includeOverflows = false ) const

noexcept

Returns number of bins of this axis.

Includes +1 for the otherflow bin.

Definition at line 271 of file BinnedAxis.h.

                                                                       {
    return _edges.size() + (includeOverflows? 1 : 0);
  }

References YODA::Axis< T, typename >::size().

operator=() [1/2]

template<typename T , typename = void>

Axis & YODA::Axis< T, typename >::operator= ( Axis< T, typename > &&  other )

inline

Definition at line 129 of file BinnedAxis.h.

                                  {
      if (this != &other)  _edges = std::move(other._edges);
      return *this;
    }

operator=() [2/2]

template<typename T , typename = void>

Axis & YODA::Axis< T, typename >::operator= ( const Axis< T, typename > &  other )

inline

Definition at line 124 of file BinnedAxis.h.

                                       {
      if (this != &other)  _edges = other._edges;
      return *this;
    }

sharedEdges()

template<typename T , typename U >

std::vector< T > YODA::Axis< T, U >::sharedEdges ( const Axis< T > &  other ) const

noexcept

Finds shared between Axes edges.

Note

Not sorted, order similar to initial (in constructor) not guaranteed.

Definition at line 282 of file BinnedAxis.h.

                                                                          {
    std::vector<EdgeT> res;
    const auto& otherBegin = other._edges.begin();
    const auto& otherEnd = other._edges.end();
    for (const T& edge : this->_edges) {
      if (std::find(otherBegin, otherEnd, edge) != otherEnd)
        res.emplace_back(std::move(edge));
    }
    return res;
  }

References YODA::Axis< T, typename >::begin().

size()

template<typename T , typename U >

size_t YODA::Axis< T, U >::size ( ) const

noexcept

Returns number of edges + 1 for this Axis.

Includes +1 for the otherflow bin.

Definition at line 265 of file BinnedAxis.h.

                                         {
    return numBins(true);
  }

Referenced by YODA::Axis< T, typename >::hasSameEdges(), YODA::Axis< T, typename >::numBins(), and YODA::Axis< T, isCAxis< T > >::numBins().

type()

template<typename T , typename = void>

std::string YODA::Axis< T, typename >::type ( ) const

inlinenoexcept

Returns a string representation of EdgeT.

Definition at line 154 of file BinnedAxis.h.

{ return TypeID<EdgeT>::name(); }

---

The documentation for this class was generated from the following file:

• include/YODA/BinnedAxis.h