RVec.hxx File Reference

#include <Rtypes.h>
#include <TError.h>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <limits>
#include <new>
#include <numeric>
#include <sstream>
#include <stdexcept>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>

Include dependency graph for RVec.hxx:

This graph shows which files directly or indirectly include this file:

Classes
class	ROOT::VecOps::RVec< T >
	A "std::vector"-like collection of values implementing handy operation to analyse them. More...
class	ROOT::Detail::VecOps::RVecImpl< T >
	This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter. More...
struct	ROOT::Internal::VecOps::RVecInlineStorageSize< T >
	The size of the inline storage of an RVec. More...
class	ROOT::VecOps::RVecN< T, N >
struct	ROOT::Internal::VecOps::SmallVectorAlignmentAndSize< T >
	Used to figure out the offset of the first element of an RVec. More...
class	ROOT::Internal::VecOps::SmallVectorBase
	This is all the stuff common to all SmallVectors. More...
struct	ROOT::Internal::VecOps::SmallVectorStorage< T, N >
	Storage for the SmallVector elements. More...
struct	ROOT::Internal::VecOps::SmallVectorStorage< T, 0 >
	We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined. More...
class	ROOT::Internal::VecOps::SmallVectorTemplateBase< T, bool >
	SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that are designed to work with non-trivial T's. More...
class	ROOT::Internal::VecOps::SmallVectorTemplateBase< T, true >
	SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's. More...
class	ROOT::Internal::VecOps::SmallVectorTemplateCommon< T >
	This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD. More...

Namespaces
namespace	ROOT
	tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tbb::task_arena without forward declaring tbb::interface7
namespace	ROOT::Detail
	Special implementation of ROOT::RRangeCast for TCollection, including a check that the cast target type inherits from TObject and a new constructor that takes the TCollection by pointer.
namespace	ROOT::Detail::VecOps
namespace	ROOT::Internal
namespace	ROOT::Internal::VecOps
namespace	ROOT::VecOps

Macros
#define	_VECOPS_USE_EXTERN_TEMPLATES   true
#define	R__RVEC_NODISCARD
RVec Unary Arithmetic Operators
#define	RVEC_UNARY_OPERATOR(OP)
RVec Binary Arithmetic Operators
#define	ERROR_MESSAGE(OP)    "Cannot call operator " #OP " on vectors of different sizes."
#define	RVEC_BINARY_OPERATOR(OP)
RVec Assignment Arithmetic Operators
#define	RVEC_ASSIGNMENT_OPERATOR(OP)
RVec Comparison and Logical Operators
#define	RVEC_LOGICAL_OPERATOR(OP)
RVec Standard Mathematical Functions
#define	RVEC_BINARY_FUNCTION(NAME, FUNC)
#define	RVEC_STD_BINARY_FUNCTION(F)   RVEC_BINARY_FUNCTION(F, std::F)
#define	RVEC_STD_UNARY_FUNCTION(F)   RVEC_UNARY_FUNCTION(F, std::F)
#define	RVEC_UNARY_FUNCTION(NAME, FUNC)

Typedefs
template<typename T >
using	ROOT::Internal::VecOps::RVec = ROOT::VecOps::RVec< T >
using	ROOT::RVecB = ROOT::VecOps::RVec< bool >
using	ROOT::RVecC = ROOT::VecOps::RVec< char >
using	ROOT::RVecD = ROOT::VecOps::RVec< double >
using	ROOT::RVecF = ROOT::VecOps::RVec< float >
using	ROOT::RVecI = ROOT::VecOps::RVec< int >
using	ROOT::RVecL = ROOT::VecOps::RVec< long int >
using	ROOT::RVecLL = ROOT::VecOps::RVec< long long int >
using	ROOT::RVecU = ROOT::VecOps::RVec< unsigned int >
using	ROOT::RVecUL = ROOT::VecOps::RVec< unsigned long int >
using	ROOT::RVecULL = ROOT::VecOps::RVec< unsigned long long int >

Functions
template<typename T >
auto	ROOT::VecOps::All (const RVec< T > &v) -> decltype(v[0]==false)
	Return true if all of the elements equate to true, return false otherwise.
template<typename T >
auto	ROOT::VecOps::Any (const RVec< T > &v) -> decltype(v[0]==true)
	Return true if any of the elements equates to true, return false otherwise.
template<typename T >
std::size_t	ROOT::VecOps::ArgMax (const RVec< T > &v)
	Get the index of the greatest element of an RVec In case of multiple occurrences of the maximum values, the index corresponding to the first occurrence is returned.
template<typename T >
std::size_t	ROOT::VecOps::ArgMin (const RVec< T > &v)
	Get the index of the smallest element of an RVec In case of multiple occurrences of the minimum values, the index corresponding to the first occurrence is returned.
template<typename T >
RVec< typename RVec< T >::size_type >	ROOT::VecOps::Argsort (const RVec< T > &v)
	Return an RVec of indices that sort the input RVec.
template<typename T , typename Compare >
RVec< typename RVec< T >::size_type >	ROOT::VecOps::Argsort (const RVec< T > &v, Compare &&c)
	Return an RVec of indices that sort the input RVec based on a comparison function.
template<typename T , unsigned N>
size_t	ROOT::VecOps::CapacityInBytes (const RVecN< T, N > &X)
template<typename T >
RVec< RVec< typename RVec< T >::size_type > >	ROOT::VecOps::Combinations (const RVec< T > &v, const typename RVec< T >::size_type n)
	Return the indices that represent all unique combinations of the elements of a given RVec.
template<typename T1 , typename T2 >
RVec< RVec< typename RVec< T1 >::size_type > >	ROOT::VecOps::Combinations (const RVec< T1 > &v1, const RVec< T2 > &v2)
	Return the indices that represent all combinations of the elements of two RVecs.
RVec< RVec< std::size_t > >	ROOT::VecOps::Combinations (const std::size_t size1, const std::size_t size2)
	Return the indices that represent all combinations of the elements of two RVecs.
template<typename T0 , typename T1 , typename Common_t = typename std::common_type<T0, T1>::type>
RVec< Common_t >	ROOT::VecOps::Concatenate (const RVec< T0 > &v0, const RVec< T1 > &v1)
	Return the concatenation of two RVecs.
template<typename T , typename... Args_t>
RVec< T >	ROOT::VecOps::Construct (const RVec< Args_t > &... args)
	Build an RVec of objects starting from RVecs of input to their constructors.
template<typename T >
RVec< T >	ROOT::VecOps::DeltaPhi (const RVec< T > &v1, const RVec< T > &v2, const T c=M_PI)
	Return the angle difference \(\Delta \phi\) in radians of two vectors.
template<typename T >
RVec< T >	ROOT::VecOps::DeltaPhi (const RVec< T > &v1, T v2, const T c=M_PI)
	Return the angle difference \(\Delta \phi\) in radians of a vector and a scalar.
template<typename T >
RVec< T >	ROOT::VecOps::DeltaPhi (T v1, const RVec< T > &v2, const T c=M_PI)
	Return the angle difference \(\Delta \phi\) in radians of a scalar and a vector.
template<typename T >
T	ROOT::VecOps::DeltaPhi (T v1, T v2, const T c=M_PI)
	Return the angle difference \(\Delta \phi\) of two scalars.
template<typename T >
RVec< T >	ROOT::VecOps::DeltaR (const RVec< T > &eta1, const RVec< T > &eta2, const RVec< T > &phi1, const RVec< T > &phi2, const T c=M_PI)
	Return the distance on the \(\eta\)- \(\phi\) plane ( \(\Delta R\)) from the collections eta1, eta2, phi1 and phi2.
template<typename T >
T	ROOT::VecOps::DeltaR (T eta1, T eta2, T phi1, T phi2, const T c=M_PI)
	Return the distance on the \(\eta\)- \(\phi\) plane ( \(\Delta R\)) from the scalars eta1, eta2, phi1 and phi2.
template<typename T >
RVec< T >	ROOT::VecOps::DeltaR2 (const RVec< T > &eta1, const RVec< T > &eta2, const RVec< T > &phi1, const RVec< T > &phi2, const T c=M_PI)
	Return the square of the distance on the \(\eta\)- \(\phi\) plane ( \(\Delta R\)) from the collections eta1, eta2, phi1 and phi2.
template<typename T , typename V >
auto	ROOT::VecOps::Dot (const RVec< T > &v0, const RVec< V > &v1) -> decltype(v0[0] *v1[0])
	Inner product.
template<typename T >
RVec< T >	ROOT::VecOps::Drop (const RVec< T > &v, RVec< typename RVec< T >::size_type > idxs)
	Return a copy of the container without the elements at the specified indices.
template<typename T , typename F >
RVec< T >	ROOT::VecOps::Filter (const RVec< T > &v, F &&f)
	Create a new collection with the elements passing the filter expressed by the predicate.
template<typename... T>
std::size_t	ROOT::Internal::VecOps::GetVectorsSize (const std::string &id, const RVec< T > &... vs)
template<typename T >
RVec< T >	ROOT::VecOps::Intersect (const RVec< T > &v1, const RVec< T > &v2, bool v2_is_sorted=false)
	Return the intersection of elements of two RVecs.
template<typename T >
T	ROOT::VecOps::InvariantMass (const RVec< T > &pt, const RVec< T > &eta, const RVec< T > &phi, const RVec< T > &mass)
	Return the invariant mass of multiple particles given the collections of the quantities transverse momentum (pt), rapidity (eta), azimuth (phi) and mass.
template<typename T >
RVec< T >	ROOT::VecOps::InvariantMasses (const RVec< T > &pt1, const RVec< T > &eta1, const RVec< T > &phi1, const RVec< T > &mass1, const RVec< T > &pt2, const RVec< T > &eta2, const RVec< T > &phi2, const RVec< T > &mass2)
	Return the invariant mass of two particles given the collections of the quantities transverse momentum (pt), rapidity (eta), azimuth (phi) and mass.
template<typename T >
bool	ROOT::Detail::VecOps::IsAdopting (const ROOT::VecOps::RVec< T > &v)
template<typename T >
bool	ROOT::Detail::VecOps::IsSmall (const ROOT::VecOps::RVec< T > &v)
template<typename... Args>
auto	ROOT::VecOps::Map (Args &&... args)
	Create new collection applying a callable to the elements of the input collection.
template<typename Tuple_t , std::size_t... Is>
auto	ROOT::Internal::VecOps::MapFromTuple (Tuple_t &&t, std::index_sequence< Is... >) -> decltype(MapImpl(std::get< std::tuple_size< Tuple_t >::value - 1 >(t), std::get< Is >(t)...))
template<typename F , typename... T>
auto	ROOT::Internal::VecOps::MapImpl (F &&f, const RVec< T > &... vs) -> RVec< decltype(f(vs[0]...))>
template<typename T >
T	ROOT::VecOps::Max (const RVec< T > &v)
	Get the greatest element of an RVec.
template<typename T >
double	ROOT::VecOps::Mean (const RVec< T > &v)
	Get the mean of the elements of an RVec.
template<typename T , typename R = T>
R	ROOT::VecOps::Mean (const RVec< T > &v, const R zero)
	Get the mean of the elements of an RVec with custom initial value.
template<typename T >
T	ROOT::VecOps::Min (const RVec< T > &v)
	Get the smallest element of an RVec.
uint64_t	ROOT::Internal::VecOps::NextPowerOf2 (uint64_t A)
	Return the next power of two (in 64-bits) that is strictly greater than A.
template<typename T >
RVec< typename RVec< T >::size_type >	ROOT::VecOps::Nonzero (const RVec< T > &v)
	Return the indices of the elements which are not zero.
template<class T >
std::ostream &	ROOT::VecOps::operator<< (std::ostream &os, const RVec< T > &v)
	Print a RVec at the prompt:
template<typename T >
RVec< T >	ROOT::VecOps::Reverse (const RVec< T > &v)
	Return copy of reversed vector.
template<typename T >
RVec< T >	ROOT::VecOps::Sort (const RVec< T > &v)
	Return copy of RVec with elements sorted in ascending order.
template<typename T , typename Compare >
RVec< T >	ROOT::VecOps::Sort (const RVec< T > &v, Compare &&c)
	Return copy of RVec with elements sorted based on a comparison operator.
template<typename T >
RVec< typename RVec< T >::size_type >	ROOT::VecOps::StableArgsort (const RVec< T > &v)
	Return an RVec of indices that sort the input RVec while keeping the order of equal elements.
template<typename T , typename Compare >
RVec< typename RVec< T >::size_type >	ROOT::VecOps::StableArgsort (const RVec< T > &v, Compare &&c)
	Return an RVec of indices that sort the input RVec based on a comparison function while keeping the order of equal elements.
template<typename T >
RVec< T >	ROOT::VecOps::StableSort (const RVec< T > &v)
	Return copy of RVec with elements sorted in ascending order while keeping the order of equal elements.
template<typename T , typename Compare >
RVec< T >	ROOT::VecOps::StableSort (const RVec< T > &v, Compare &&c)
	Return copy of RVec with elements sorted based on a comparison operator while keeping the order of equal elements.
template<typename T >
double	ROOT::VecOps::StdDev (const RVec< T > &v)
	Get the standard deviation of the elements of an RVec.
template<typename T , typename R = T>
R	ROOT::VecOps::Sum (const RVec< T > &v, const R zero=R(0))
	Sum elements of an RVec.
template<typename T >
void	ROOT::VecOps::swap (RVec< T > &lhs, RVec< T > &rhs)
template<typename T >
RVec< T >	ROOT::VecOps::Take (const RVec< T > &v, const int n)
	Return first or last n elements of an RVec.
template<typename T >
RVec< T >	ROOT::VecOps::Take (const RVec< T > &v, const RVec< typename RVec< T >::size_type > &i)
	Return elements of a vector at given indices.
template<typename T >
double	ROOT::VecOps::Var (const RVec< T > &v)
	Get the variance of the elements of an RVec.
template<typename T , bool TriviallyCopyable>
	ROOT::Internal::VecOps::void (off) SmallVectorTemplateBase< T
template<typename T >
RVec< T >	ROOT::VecOps::Where (const RVec< int > &c, const RVec< T > &v1, const RVec< T > &v2)
	Return the elements of v1 if the condition c is true and v2 if the condition c is false.
template<typename T >
RVec< T >	ROOT::VecOps::Where (const RVec< int > &c, const RVec< T > &v1, typename RVec< T >::value_type v2)
	Return the elements of v1 if the condition c is true and sets the value v2 if the condition c is false.
template<typename T >
RVec< T >	ROOT::VecOps::Where (const RVec< int > &c, T v1, T v2)
	Return a vector with the value v2 if the condition c is false and sets the value v1 if the condition c is true.
template<typename T >
RVec< T >	ROOT::VecOps::Where (const RVec< int > &c, typename RVec< T >::value_type v1, const RVec< T > &v2)
	Return the elements of v2 if the condition c is false and sets the value v1 if the condition c is true.

Macro Definition Documentation

_VECOPS_USE_EXTERN_TEMPLATES

#define _VECOPS_USE_EXTERN_TEMPLATES   true

Definition at line 32 of file RVec.hxx.

R__RVEC_NODISCARD

#define R__RVEC_NODISCARD

Definition at line 19 of file RVec.hxx.