Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RVec.hxx File Reference
#include <ROOT/RAdoptAllocator.hxx>
#include <ROOT/RIntegerSequence.hxx>
#include <ROOT/RStringView.hxx>
#include <TError.h>
#include <ROOT/TypeTraits.hxx>
#include <algorithm>
#include <cmath>
#include <numeric>
#include <sstream>
#include <stdexcept>
#include <type_traits>
#include <vector>
#include <utility>
#include <tuple>
#include <map>
#include <string>
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...
 

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
 
namespace  ROOT::Detail::VecOps
 
namespace  ROOT::Internal
 
namespace  ROOT::Internal::RDF
 
namespace  ROOT::Internal::VecOps
 
namespace  ROOT::VecOps
 

Macros

#define _VECOPS_USE_EXTERN_TEMPLATES   true
 
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

using ROOT::Internal::RDF::BoolArrayMap = std::map< std::string, BoolArray >
 
template<typename T >
using ROOT::Detail::VecOps::RVec = ROOT::VecOps::RVec< T >
 

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 >
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 >
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 >
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... Args>
void ROOT::Internal::VecOps::EmplaceBack (std::vector< bool > &v, Args &&... args)
 
template<typename T , typename... Args>
void ROOT::Internal::VecOps::EmplaceBack (T &v, Args &&... args)
 
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::Detail::VecOps::GetVectorsSize (std::string_view 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 >
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... Args>
auto ROOT::VecOps::Map (Args &&... args) -> decltype(ROOT::Detail::VecOps::MapFromTuple(std::forward_as_tuple(args...), std::make_index_sequence< sizeof...(args) - 1 >()))
 Create new collection applying a callable to the elements of the input collection.
 
template<typename Tuple_t , std::size_t... Is>
auto ROOT::Detail::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::Detail::VecOps::MapImpl (F &&f, const RVec< T > &... vs) -> RVec< decltype(f(vs[0]...))>
 
template<typename 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 >
ROOT::VecOps::Min (const RVec< T > &v)
 Get the smallest element of an RVec.
 
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 >
void ROOT::Internal::RDF::SetBranchesHelper (BoolArrayMap &boolArrays, TTree *inputTree, TTree &outputTree, const std::string &inName, const std::string &outName, TBranch *&branch, void *&branchAddress, ROOT::VecOps::RVec< T > *ab, RBranchSet &outputBranches)
 
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 >
double ROOT::VecOps::StdDev (const RVec< T > &v)
 Get the standard deviation of the elements of an RVec.
 
template<typename T >
ROOT::VecOps::Sum (const RVec< T > &v)
 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 >
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, T 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, 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.
 
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.
 

Macro Definition Documentation

◆ _VECOPS_USE_EXTERN_TEMPLATES

#define _VECOPS_USE_EXTERN_TEMPLATES   true

Definition at line 28 of file RVec.hxx.

◆ ERROR_MESSAGE

#define ERROR_MESSAGE (   OP)     "Cannot call operator " #OP " on vectors of different sizes."

Definition at line 486 of file RVec.hxx.

◆ RVEC_ASSIGNMENT_OPERATOR

#define RVEC_ASSIGNMENT_OPERATOR (   OP)
Value:
template <typename T0, typename T1> \
RVec<T0>& operator OP(RVec<T0> &v, const T1 &y) \
{ \
auto op = [&y](T0 &x) { return x OP y; }; \
std::transform(v.begin(), v.end(), v.begin(), op); \
return v; \
} \
\
template <typename T0, typename T1> \
RVec<T0>& operator OP(RVec<T0> &v0, const RVec<T1> &v1) \
{ \
if (v0.size() != v1.size()) \
throw std::runtime_error(ERROR_MESSAGE(OP)); \
\
auto op = [](T0 &x, const T1 &y) { return x OP y; }; \
std::transform(v0.begin(), v0.end(), v1.begin(), v0.begin(), op); \
return v0; \
} \
#define ERROR_MESSAGE(OP)
Definition RVec.hxx:486
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
#define T1
Definition md5.inl:145

Definition at line 537 of file RVec.hxx.

◆ RVEC_BINARY_FUNCTION

#define RVEC_BINARY_FUNCTION (   NAME,
  FUNC 
)
Value:
template <typename T0, typename T1> \
RVec<PromoteTypes<T0, T1>> NAME(const T0 &x, const RVec<T1> &v) \
{ \
RVec<PromoteTypes<T0, T1>> ret(v.size()); \
auto f = [&x](const T1 &y) { return FUNC(x, y); }; \
std::transform(v.begin(), v.end(), ret.begin(), f); \
return ret; \
} \
\
template <typename T0, typename T1> \
RVec<PromoteTypes<T0, T1>> NAME(const RVec<T0> &v, const T1 &y) \
{ \
RVec<PromoteTypes<T0, T1>> ret(v.size()); \
auto f = [&y](const T1 &x) { return FUNC(x, y); }; \
std::transform(v.begin(), v.end(), ret.begin(), f); \
return ret; \
} \
\
template <typename T0, typename T1> \
RVec<PromoteTypes<T0, T1>> NAME(const RVec<T0> &v0, const RVec<T1> &v1) \
{ \
if (v0.size() != v1.size()) \
throw std::runtime_error(ERROR_MESSAGE(NAME)); \
\
RVec<PromoteTypes<T0, T1>> ret(v0.size()); \
auto f = [](const T0 &x, const T1 &y) { return FUNC(x, y); }; \
std::transform(v0.begin(), v0.end(), v1.begin(), ret.begin(), f); \
return ret; \
} \
#define f(i)
Definition RSha256.hxx:104

Definition at line 648 of file RVec.hxx.

◆ RVEC_BINARY_OPERATOR

#define RVEC_BINARY_OPERATOR (   OP)

Definition at line 489 of file RVec.hxx.

◆ RVEC_LOGICAL_OPERATOR

#define RVEC_LOGICAL_OPERATOR (   OP)

Definition at line 573 of file RVec.hxx.

◆ RVEC_STD_BINARY_FUNCTION

#define RVEC_STD_BINARY_FUNCTION (   F)    RVEC_BINARY_FUNCTION(F, std::F)

Definition at line 680 of file RVec.hxx.

◆ RVEC_STD_UNARY_FUNCTION

#define RVEC_STD_UNARY_FUNCTION (   F)    RVEC_UNARY_FUNCTION(F, std::F)

Definition at line 679 of file RVec.hxx.

◆ RVEC_UNARY_FUNCTION

#define RVEC_UNARY_FUNCTION (   NAME,
  FUNC 
)
Value:
template <typename T> \
RVec<PromoteType<T>> NAME(const RVec<T> &v) \
{ \
RVec<PromoteType<T>> ret(v.size()); \
auto f = [](const T &x) { return FUNC(x); }; \
std::transform(v.begin(), v.end(), ret.begin(), f); \
return ret; \
}

Definition at line 638 of file RVec.hxx.

◆ RVEC_UNARY_OPERATOR

#define RVEC_UNARY_OPERATOR (   OP)
Value:
template <typename T> \
RVec<T> operator OP(const RVec<T> &v) \
{ \
RVec<T> ret(v); \
for (auto &x : ret) \
x = OP x; \
return ret; \
} \

Definition at line 466 of file RVec.hxx.