Logo ROOT  
Reference Guide
VecOps

A "std::vector"-like collection of values implementing handy operation to analyse them.

Classes

class  ROOT::VecOps::RVec< T >
 A "std::vector"-like collection of values implementing handy operation to analyse them. More...
 
class  ROOT::VecOps::RVecN< T, N >
 

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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
ROOT::VecOps::DeltaPhi (T v1, T v2, const T c=M_PI)
 Return the angle difference \(\Delta \phi\) of two scalars. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T , typename V >
auto ROOT::VecOps::Dot (const RVec< T > &v0, const RVec< V > &v1) -> decltype(v0[0] *v1[0])
 Inner product. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename... Args>
auto ROOT::VecOps::Map (Args &&... args)
 Create new collection applying a callable to the elements of the input collection. More...
 
template<typename T >
ROOT::VecOps::Max (const RVec< T > &v)
 Get the greatest element of an RVec. More...
 
template<typename T >
double ROOT::VecOps::Mean (const RVec< T > &v)
 Get the mean of the elements of an RVec. More...
 
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. More...
 
template<typename T >
ROOT::VecOps::Min (const RVec< T > &v)
 Get the smallest element of an RVec. More...
 
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. More...
 
template<class T >
std::ostream & ROOT::VecOps::operator<< (std::ostream &os, const RVec< T > &v)
 Print a RVec at the prompt: More...
 
template<typename T >
ROOT::VecOps::Product (const RVec< T > &v, const T init=T(1))
 Product method analogous to Sum: Multiply the elements of a vector. More...
 
RVec< std::size_t > ROOT::VecOps::Range (std::size_t length)
 Enumerate method: For any Rvec v produce another RVec with entries starting from 0, and incrementing by 1 until a N = v.size() is reached. More...
 
template<typename T >
RVec< T > ROOT::VecOps::Reverse (const RVec< T > &v)
 Return copy of reversed vector. More...
 
template<typename T >
RVec< T > ROOT::VecOps::Sort (const RVec< T > &v)
 Return copy of RVec with elements sorted in ascending order. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
double ROOT::VecOps::StdDev (const RVec< T > &v)
 Get the standard deviation of the elements of an RVec. More...
 
template<typename T >
ROOT::VecOps::Sum (const RVec< T > &v, const T zero=T(0))
 Sum elements of an RVec. More...
 
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. More...
 
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. More...
 
template<typename T >
RVec< T > ROOT::VecOps::Take (const RVec< T > &v, const RVec< typename RVec< T >::size_type > &i, const T default_val)
 Take version that defaults to (user-specified) output value if some index is out of range. More...
 
template<typename T >
double ROOT::VecOps::Var (const RVec< T > &v)
 Get the variance of the elements of an RVec. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

RVec Unary Arithmetic Operators

template<typename T >
RVec< T > ROOT::VecOps::operator+ (const RVec< T > &v)
 
template<typename T >
RVec< T > ROOT::VecOps::operator- (const RVec< T > &v)
 
template<typename T >
RVec< T > ROOT::VecOps::operator~ (const RVec< T > &v)
 
template<typename T >
RVec< T > ROOT::VecOps::operator! (const RVec< T > &v)
 
#define RVEC_UNARY_OPERATOR(OP)
 

RVec Binary Arithmetic Operators

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator+ (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0]+y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator+ (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x+v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator+ (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0]+v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator- (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0] - y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator- (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x - v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator- (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0] - v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator* (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0] *y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator* (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x *v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator* (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0] *v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator/ (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0]/y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator/ (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x/v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator/ (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0]/v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator% (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0] % y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator% (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x % v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator% (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0] % v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator^ (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0] ^ y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator^ (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x ^ v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator^ (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0] ^ v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator| (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0]|y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator| (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x|v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator| (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0]|v1[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator& (const RVec< T0 > &v, const T1 &y) -> RVec< decltype(v[0] &y)>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator& (const T0 &x, const RVec< T1 > &v) -> RVec< decltype(x &v[0])>
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator& (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< decltype(v0[0] &v1[0])>
 
#define ERROR_MESSAGE(OP)    "Cannot call operator " #OP " on vectors of different sizes."
 
#define RVEC_BINARY_OPERATOR(OP)
 

RVec Assignment Arithmetic Operators

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator+= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator+= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator-= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator-= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator*= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator*= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator/= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator/= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator%= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator%= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator^= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator^= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator|= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator|= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator&= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator&= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator>>= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator>>= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator<<= (RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator<<= (RVec< T0 > &v0, const RVec< T1 > &v1)
 
#define RVEC_ASSIGNMENT_OPERATOR(OP)
 

RVec Comparison and Logical Operators

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator< (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator< (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator< (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator> (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator> (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator> (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator== (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator== (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator== (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator!= (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator!= (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator!= (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator<= (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator<= (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator<= (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator>= (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator>= (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator>= (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator&& (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator&& (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator&& (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator|| (const RVec< T0 > &v, const T1 &y) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator|| (const T0 &x, const RVec< T1 > &v) -> RVec< int >
 
template<typename T0 , typename T1 >
auto ROOT::VecOps::operator|| (const RVec< T0 > &v0, const RVec< T1 > &v1) -> RVec< int >
 
#define RVEC_LOGICAL_OPERATOR(OP)
 

RVec Standard Mathematical Functions

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::abs (const RVec< T > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fdim (const T0 &x, const RVec< T1 > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fdim (const RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fdim (const RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fmod (const T0 &x, const RVec< T1 > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fmod (const RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fmod (const RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::remainder (const T0 &x, const RVec< T1 > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::remainder (const RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::remainder (const RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::exp (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::exp2 (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::expm1 (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log10 (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log2 (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log1p (const RVec< T > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::pow (const T0 &x, const RVec< T1 > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::pow (const RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::pow (const RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::sqrt (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::cbrt (const RVec< T > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::hypot (const T0 &x, const RVec< T1 > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::hypot (const RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::hypot (const RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::sin (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::cos (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::tan (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::asin (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::acos (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::atan (const RVec< T > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::atan2 (const T0 &x, const RVec< T1 > &v)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::atan2 (const RVec< T0 > &v, const T1 &y)
 
template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::atan2 (const RVec< T0 > &v0, const RVec< T1 > &v1)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::sinh (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::cosh (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::tanh (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::asinh (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::acosh (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::atanh (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::floor (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::ceil (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::trunc (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::round (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::lround (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::llround (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::erf (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::erfc (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::lgamma (const RVec< T > &v)
 
template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::tgamma (const RVec< T > &v)
 
#define RVEC_UNARY_FUNCTION(NAME, FUNC)
 
#define RVEC_BINARY_FUNCTION(NAME, FUNC)
 
#define RVEC_STD_UNARY_FUNCTION(F)   RVEC_UNARY_FUNCTION(F, std::F)
 
#define RVEC_STD_BINARY_FUNCTION(F)   RVEC_BINARY_FUNCTION(F, std::F)
 

Macro Definition Documentation

◆ ERROR_MESSAGE

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

Definition at line 1560 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:1560
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
#define T1
Definition: md5.inl:146

Definition at line 1611 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 1722 of file RVec.hxx.

◆ RVEC_BINARY_OPERATOR

#define RVEC_BINARY_OPERATOR (   OP)

Definition at line 1563 of file RVec.hxx.

◆ RVEC_LOGICAL_OPERATOR

#define RVEC_LOGICAL_OPERATOR (   OP)

Definition at line 1647 of file RVec.hxx.

◆ RVEC_STD_BINARY_FUNCTION

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

Definition at line 1754 of file RVec.hxx.

◆ RVEC_STD_UNARY_FUNCTION

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

Definition at line 1753 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; \
}
double T(double x)
Definition: ChebyshevPol.h:34

Definition at line 1712 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 1540 of file RVec.hxx.

Function Documentation

◆ abs()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::abs ( const RVec< T > &  v)

Definition at line 1756 of file RVec.hxx.

◆ acos()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::acos ( const RVec< T > &  v)

Definition at line 1779 of file RVec.hxx.

◆ acosh()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::acosh ( const RVec< T > &  v)

Definition at line 1787 of file RVec.hxx.

◆ All()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecI v {0, 1, 0};
auto allTrue = All(v);
allTrue
// (bool) false
auto All(const RVec< T > &v) -> decltype(v[0]==false)
Return true if all of the elements equate to true, return false otherwise.
Definition: RVec.hxx:2144

Definition at line 2144 of file RVec.hxx.

◆ Any()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecI v {0, 1, 0};
auto anyTrue = Any(v);
anyTrue
// (bool) true
auto Any(const RVec< T > &v) -> decltype(v[0]==true)
Return true if any of the elements equates to true, return false otherwise.
Definition: RVec.hxx:2125

Definition at line 2125 of file RVec.hxx.

◆ ArgMax()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_argmax = ArgMax(v);
v_argmax
// (unsigned long) 2
std::size_t ArgMax(const RVec< T > &v)
Get the index of the greatest element of an RVec In case of multiple occurrences of the maximum value...
Definition: RVec.hxx:1987

Definition at line 1987 of file RVec.hxx.

◆ ArgMin()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_argmin = ArgMin(v);
v_argmin
// (unsigned long) 0
std::size_t ArgMin(const RVec< T > &v)
Get the index of the smallest element of an RVec In case of multiple occurrences of the minimum value...
Definition: RVec.hxx:2005

Definition at line 2005 of file RVec.hxx.

◆ Argsort() [1/2]

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto sortIndices = Argsort(v)
// (ROOT::VecOps::RVec<unsigned long> &) { 2, 0, 1 }
auto values = Take(v, sortIndices)
// (ROOT::VecOps::RVec<double> &) { 1.0000000, 2.0000000, 3.0000000 }
RVec< T > Take(const RVec< T > &v, const RVec< typename RVec< T >::size_type > &i)
Return elements of a vector at given indices.
Definition: RVec.hxx:2259
RVec< typename RVec< T >::size_type > Argsort(const RVec< T > &v)
Return an RVec of indices that sort the input RVec.
Definition: RVec.hxx:2170

Definition at line 2170 of file RVec.hxx.

◆ Argsort() [2/2]

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto sortIndices = Argsort(v, [](double x, double y) {return x > y;})
// (ROOT::VecOps::RVec<unsigned long> &) { 1, 0, 2 }
auto values = Take(v, sortIndices)
// (ROOT::VecOps::RVec<double> &) { 3.0000000, 2.0000000, 1.0000000 }

Definition at line 2191 of file RVec.hxx.

◆ asin()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::asin ( const RVec< T > &  v)

Definition at line 1778 of file RVec.hxx.

◆ asinh()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::asinh ( const RVec< T > &  v)

Definition at line 1786 of file RVec.hxx.

◆ atan()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::atan ( const RVec< T > &  v)

Definition at line 1780 of file RVec.hxx.

◆ atan2() [1/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::atan2 ( const RVec< T0 > &  v,
const T1 y 
)

Definition at line 1781 of file RVec.hxx.

◆ atan2() [2/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::atan2 ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1781 of file RVec.hxx.

◆ atan2() [3/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::atan2 ( const T0 &  x,
const RVec< T1 > &  v 
)

Definition at line 1781 of file RVec.hxx.

◆ atanh()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::atanh ( const RVec< T > &  v)

Definition at line 1788 of file RVec.hxx.

◆ CapacityInBytes()

template<typename T , unsigned N>
size_t ROOT::VecOps::CapacityInBytes ( const RVecN< T, N > &  X)
inline

Definition at line 1532 of file RVec.hxx.

◆ cbrt()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::cbrt ( const RVec< T > &  v)

Definition at line 1772 of file RVec.hxx.

◆ ceil()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::ceil ( const RVec< T > &  v)

Definition at line 1791 of file RVec.hxx.

◆ Combinations() [1/3]

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.

using namespace ROOT::VecOps;
RVecD v {1., 2., 3., 4.};
auto v_1 = Combinations(v, 1);
v_1
auto v_2 = Combinations(v, 2);
v_2
(ROOT::VecOps::RVec<ROOT::VecOps::RVec<unsigned long> > &) { { 0, 0, 0, 1, 1, 2 }, { 1, 2, 3, 2, 3, 3 } }
auto v_3 = Combinations(v, 3);
v_3
(ROOT::VecOps::RVec<ROOT::VecOps::RVec<unsigned long> > &) { { 0, 0, 0, 1 }, { 1, 1, 2, 2 }, { 2, 3, 3, 3 } }
auto v_4 = Combinations(v, 4);
v_4
(ROOT::VecOps::RVec<ROOT::VecOps::RVec<unsigned long> > &) { { 0 }, { 1 }, { 2 }, { 3 } }
RVec< RVec< std::size_t > > Combinations(const std::size_t size1, const std::size_t size2)
Return the indices that represent all combinations of the elements of two RVecs.
Definition: RVec.hxx:2488

Definition at line 2545 of file RVec.hxx.

◆ Combinations() [2/3]

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.

The type of the return value is an RVec of two RVecs containing indices.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v1 {1., 2., 3.};
RVecD v2 {-4., -5.};
auto comb_idx = Combinations(v1, v2);
comb_idx
// (ROOT::VecOps::RVec<ROOT::VecOps::RVec<unsigned long> > &) { { 0, 0, 1, 1, 2, 2 }, { 0, 1, 0, 1, 0, 1 } }

Definition at line 2520 of file RVec.hxx.

◆ Combinations() [3/3]

RVec< RVec< std::size_t > > ROOT::VecOps::Combinations ( const std::size_t  size1,
const std::size_t  size2 
)
inline

Return the indices that represent all combinations of the elements of two RVecs.

The type of the return value is an RVec of two RVecs containing indices.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
auto comb_idx = Combinations(3, 2);
comb_idx
// (ROOT::VecOps::RVec<ROOT::VecOps::RVec<unsigned long> > &) { { 0, 0, 1, 1, 2, 2 }, { 0, 1, 0, 1, 0, 1 } }

Definition at line 2488 of file RVec.hxx.

◆ Concatenate()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF rvf {0.f, 1.f, 2.f};
RVecI rvi {7, 8, 9};
Concatenate(rvf, rvi)
// (ROOT::VecOps::RVec<float>) { 0.00000f, 1.00000f, 2.00000f, 7.00000f, 8.00000f, 9.00000f }
RVec< Common_t > Concatenate(const RVec< T0 > &v0, const RVec< T1 > &v1)
Return the concatenation of two RVecs.
Definition: RVec.hxx:2779

Definition at line 2779 of file RVec.hxx.

◆ Construct()

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 Parameters
TType of the objects contained in the created RVec.
Args_tPack of types templating the input RVecs.
Parameters
[in]argsThe RVecs containing the values used to initialise the output objects.
Returns
The RVec of objects initialised with the input parameters.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF pts = {15.5, 34.32, 12.95};
RVecF etas = {0.3, 2.2, 1.32};
RVecF phis = {0.1, 3.02, 2.2};
RVecF masses = {105.65, 105.65, 105.65};
auto fourVecs = Construct<ROOT::Math::PtEtaPhiMVector>(pts, etas, phis, masses);
cout << fourVecs << endl;
// { (15.5,0.3,0.1,105.65), (34.32,2.2,3.02,105.65), (12.95,1.32,2.2,105.65) }

Definition at line 2998 of file RVec.hxx.

◆ cos()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::cos ( const RVec< T > &  v)

Definition at line 1776 of file RVec.hxx.

◆ cosh()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::cosh ( const RVec< T > &  v)

Definition at line 1784 of file RVec.hxx.

◆ DeltaPhi() [1/4]

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.

The function computes the closest angle from v1 to v2 with sign and is therefore in the range \([-\pi, \pi]\). The computation is done per default in radians \(c = \pi\) but can be switched to degrees \(c = 180\).

Definition at line 2816 of file RVec.hxx.

◆ DeltaPhi() [2/4]

template<typename T >
RVec< T > ROOT::VecOps::DeltaPhi ( const RVec< T > &  v1,
v2,
const T  c = M_PI 
)

Return the angle difference \(\Delta \phi\) in radians of a vector and a scalar.

The function computes the closest angle from v1 to v2 with sign and is therefore in the range \([-\pi, \pi]\). The computation is done per default in radians \(c = \pi\) but can be switched to degrees \(c = 180\).

Definition at line 2834 of file RVec.hxx.

◆ DeltaPhi() [3/4]

template<typename T >
RVec< T > ROOT::VecOps::DeltaPhi ( v1,
const RVec< T > &  v2,
const T  c = M_PI 
)

Return the angle difference \(\Delta \phi\) in radians of a scalar and a vector.

The function computes the closest angle from v1 to v2 with sign and is therefore in the range \([-\pi, \pi]\). The computation is done per default in radians \(c = \pi\) but can be switched to degrees \(c = 180\).

Definition at line 2852 of file RVec.hxx.

◆ DeltaPhi() [4/4]

template<typename T >
T ROOT::VecOps::DeltaPhi ( v1,
v2,
const T  c = M_PI 
)

Return the angle difference \(\Delta \phi\) of two scalars.

The function computes the closest angle from v1 to v2 with sign and is therefore in the range \([-\pi, \pi]\). The computation is done per default in radians \(c = \pi\) but can be switched to degrees \(c = 180\).

Definition at line 2795 of file RVec.hxx.

◆ DeltaR() [1/2]

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.

The function computes \(\Delta R = \sqrt{(\eta_1 - \eta_2)^2 + (\phi_1 - \phi_2)^2}\) of the given collections eta1, eta2, phi1 and phi2. The angle \(\phi\) can be set to radian or degrees using the optional argument c, see the documentation of the DeltaPhi helper.

Definition at line 2885 of file RVec.hxx.

◆ DeltaR() [2/2]

template<typename T >
T ROOT::VecOps::DeltaR ( eta1,
eta2,
phi1,
phi2,
const T  c = M_PI 
)

Return the distance on the \(\eta\)- \(\phi\) plane ( \(\Delta R\)) from the scalars eta1, eta2, phi1 and phi2.

The function computes \(\Delta R = \sqrt{(\eta_1 - \eta_2)^2 + (\phi_1 - \phi_2)^2}\) of the given scalars eta1, eta2, phi1 and phi2. The angle \(\phi\) can be set to radian or degrees using the optional argument c, see the documentation of the DeltaPhi helper.

Definition at line 2898 of file RVec.hxx.

◆ DeltaR2()

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.

The function computes \(\Delta R^2 = (\eta_1 - \eta_2)^2 + (\phi_1 - \phi_2)^2\) of the given collections eta1, eta2, phi1 and phi2. The angle \(\phi\) can be set to radian or degrees using the optional argument c, see the documentation of the DeltaPhi helper.

Definition at line 2871 of file RVec.hxx.

◆ Dot()

template<typename T , typename V >
auto ROOT::VecOps::Dot ( const RVec< T > &  v0,
const RVec< V > &  v1 
) -> decltype(v0[0] * v1[0])

Inner product.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVec<float> v1 {1., 2., 3.};
RVec<float> v2 {4., 5., 6.};
auto v1_dot_v2 = Dot(v1, v2);
v1_dot_v2
// (float) 32.0000f
auto Dot(const RVec< T > &v0, const RVec< V > &v1) -> decltype(v0[0] *v1[0])
Inner product.
Definition: RVec.hxx:1847

Definition at line 1847 of file RVec.hxx.

◆ Drop()

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.

Duplicated and out-of-range indices in idxs are ignored.

Definition at line 2330 of file RVec.hxx.

◆ erf()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::erf ( const RVec< T > &  v)

Definition at line 1797 of file RVec.hxx.

◆ erfc()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::erfc ( const RVec< T > &  v)

Definition at line 1798 of file RVec.hxx.

◆ exp()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::exp ( const RVec< T > &  v)

Definition at line 1761 of file RVec.hxx.

◆ exp2()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::exp2 ( const RVec< T > &  v)

Definition at line 1762 of file RVec.hxx.

◆ expm1()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::expm1 ( const RVec< T > &  v)

Definition at line 1763 of file RVec.hxx.

◆ fdim() [1/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fdim ( const RVec< T0 > &  v,
const T1 y 
)

Definition at line 1757 of file RVec.hxx.

◆ fdim() [2/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fdim ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1757 of file RVec.hxx.

◆ fdim() [3/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fdim ( const T0 &  x,
const RVec< T1 > &  v 
)

Definition at line 1757 of file RVec.hxx.

◆ Filter()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecI v {1, 2, 4};
auto v_even = Filter(v, [](int i){return 0 == i%2;});
v_even
// (ROOT::VecOps::RVec<int> &) { 2, 4 }
RVec< T > Filter(const RVec< T > &v, F &&f)
Create a new collection with the elements passing the filter expressed by the predicate.
Definition: RVec.hxx:2102

Definition at line 2102 of file RVec.hxx.

◆ floor()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::floor ( const RVec< T > &  v)

Definition at line 1790 of file RVec.hxx.

◆ fmod() [1/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fmod ( const RVec< T0 > &  v,
const T1 y 
)

Definition at line 1758 of file RVec.hxx.

◆ fmod() [2/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fmod ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1758 of file RVec.hxx.

◆ fmod() [3/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::fmod ( const T0 &  x,
const RVec< T1 > &  v 
)

Definition at line 1758 of file RVec.hxx.

◆ hypot() [1/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::hypot ( const RVec< T0 > &  v,
const T1 y 
)

Definition at line 1773 of file RVec.hxx.

◆ hypot() [2/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::hypot ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1773 of file RVec.hxx.

◆ hypot() [3/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::hypot ( const T0 &  x,
const RVec< T1 > &  v 
)

Definition at line 1773 of file RVec.hxx.

◆ Intersect()

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.

Each element of v1 is looked up in v2 and added to the returned vector if found. Following, the order of v1 is preserved. If v2 is already sorted, the optional argument v2_is_sorted can be used to toggle of the internal sorting step, therewith optimising runtime.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v1 {1., 2., 3.};
RVecD v2 {-4., -5., 2., 1.};
auto v1_intersect_v2 = Intersect(v1, v2);
v1_intersect_v2
// (ROOT::VecOps::RVec<double> &) { 1.0000000, 2.0000000 }
RVec< T > Intersect(const RVec< T > &v1, const RVec< T > &v2, bool v2_is_sorted=false)
Return the intersection of elements of two RVecs.
Definition: RVec.hxx:2640

Definition at line 2640 of file RVec.hxx.

◆ InvariantMass()

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.

The function computes the invariant mass of multiple particles with the four-vectors (pt, eta, phi, mass).

Definition at line 2952 of file RVec.hxx.

◆ InvariantMasses()

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.

The function computes the invariant mass of two particles with the four-vectors (pt1, eta2, phi1, mass1) and (pt2, eta2, phi2, mass2).

Definition at line 2910 of file RVec.hxx.

◆ lgamma()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::lgamma ( const RVec< T > &  v)

Definition at line 1799 of file RVec.hxx.

◆ llround()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::llround ( const RVec< T > &  v)

Definition at line 1795 of file RVec.hxx.

◆ log()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log ( const RVec< T > &  v)

Definition at line 1765 of file RVec.hxx.

◆ log10()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log10 ( const RVec< T > &  v)

Definition at line 1766 of file RVec.hxx.

◆ log1p()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log1p ( const RVec< T > &  v)

Definition at line 1768 of file RVec.hxx.

◆ log2()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::log2 ( const RVec< T > &  v)

Definition at line 1767 of file RVec.hxx.

◆ lround()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::lround ( const RVec< T > &  v)

Definition at line 1794 of file RVec.hxx.

◆ Map()

template<typename... Args>
auto ROOT::VecOps::Map ( Args &&...  args)

Create new collection applying a callable to the elements of the input collection.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_square = Map(v, [](float f){return f* 2.f;});
v_square
// (ROOT::VecOps::RVec<float> &) { 2.00000f, 4.00000f, 8.00000f }
RVecF x({1.f, 2.f, 3.f});
RVecF y({4.f, 5.f, 6.f});
RVecF z({7.f, 8.f, 9.f});
auto mod = [](float x, float y, float z) { return sqrt(x * x + y * y + z * z); };
auto v_mod = Map(x, y, z, mod);
v_mod
// (ROOT::VecOps::RVec<float> &) { 8.12404f, 9.64365f, 11.2250f }
RVec< PromoteType< T > > sqrt(const RVec< T > &v)
Definition: RVec.hxx:1771
auto Map(Args &&... args)
Create new collection applying a callable to the elements of the input collection.
Definition: RVec.hxx:2070

Definition at line 2070 of file RVec.hxx.

◆ Max()

template<typename T >
T ROOT::VecOps::Max ( const RVec< T > &  v)

Get the greatest element of an RVec.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_max = Max(v);
v_max
(float) 4.00000f
T Max(const RVec< T > &v)
Get the greatest element of an RVec.
Definition: RVec.hxx:1953

Definition at line 1953 of file RVec.hxx.

◆ Mean() [1/2]

template<typename T >
double ROOT::VecOps::Mean ( const RVec< T > &  v)

Get the mean of the elements of an RVec.

The return type is a double precision floating point number.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_mean = Mean(v);
v_mean
// (double) 2.3333333
double Mean(const RVec< T > &v)
Get the mean of the elements of an RVec.
Definition: RVec.hxx:1904

Definition at line 1904 of file RVec.hxx.

◆ Mean() [2/2]

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.

The return type will be deduced from the zero parameter

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_mean_f = Mean(v, 0.f);
v_mean_f
// (float) 2.33333f
auto v_mean_d = Mean(v, 0.);
v_mean_d
// (double) 2.3333333
using namespace ROOT::VecOps;
const ROOT::Math::PtEtaPhiMVector lv0 {15.5f, .3f, .1f, 105.65f},
lv1 {34.32f, 2.2f, 3.02f, 105.65f},
lv2 {12.95f, 1.32f, 2.2f, 105.65f};
auto v_mean_lv = Mean(v, ROOT::Math::PtEtaPhiMVector());
v_mean_lv
// (ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > &) (10.283,2.46534,2.58947,120.361)
Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system ...
Definition: LorentzVector.h:59

Definition at line 1936 of file RVec.hxx.

◆ Min()

template<typename T >
T ROOT::VecOps::Min ( const RVec< T > &  v)

Get the smallest element of an RVec.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_min = Min(v);
v_min
(float) 1.00000f
T Min(const RVec< T > &v)
Get the smallest element of an RVec.
Definition: RVec.hxx:1969

Definition at line 1969 of file RVec.hxx.

◆ Nonzero()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 0., 3., 0., 1.};
auto nonzero_idx = Nonzero(v);
nonzero_idx
// (ROOT::VecOps::RVec<unsigned long> &) { 0, 2, 4 }
RVec< typename RVec< T >::size_type > Nonzero(const RVec< T > &v)
Return the indices of the elements which are not zero.
Definition: RVec.hxx:2609

Definition at line 2609 of file RVec.hxx.

◆ operator!()

template<typename T >
RVec< T > ROOT::VecOps::operator! ( const RVec< T > &  v)

Definition at line 1553 of file RVec.hxx.

◆ operator!=() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator!= ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1684 of file RVec.hxx.

◆ operator!=() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator!= ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1684 of file RVec.hxx.

◆ operator!=() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator!= ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1684 of file RVec.hxx.

◆ operator%() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator% ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] % y)>

Definition at line 1601 of file RVec.hxx.

◆ operator%() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator% ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] % v1[0])>

Definition at line 1601 of file RVec.hxx.

◆ operator%() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator% ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x % v[0])>

Definition at line 1601 of file RVec.hxx.

◆ operator%=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator%= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1635 of file RVec.hxx.

◆ operator%=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator%= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1635 of file RVec.hxx.

◆ operator&() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator& ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] & y)>

Definition at line 1604 of file RVec.hxx.

◆ operator&() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator& ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] & v1[0])>

Definition at line 1604 of file RVec.hxx.

◆ operator&() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator& ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x & v[0])>

Definition at line 1604 of file RVec.hxx.

◆ operator&&() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator&& ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1687 of file RVec.hxx.

◆ operator&&() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator&& ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1687 of file RVec.hxx.

◆ operator&&() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator&& ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1687 of file RVec.hxx.

◆ operator&=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator&= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1638 of file RVec.hxx.

◆ operator&=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator&= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1638 of file RVec.hxx.

◆ operator*() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator* ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] * y)>

Definition at line 1599 of file RVec.hxx.

◆ operator*() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator* ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] * v1[0])>

Definition at line 1599 of file RVec.hxx.

◆ operator*() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator* ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x * v[0])>

Definition at line 1599 of file RVec.hxx.

◆ operator*=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator*= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1633 of file RVec.hxx.

◆ operator*=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator*= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1633 of file RVec.hxx.

◆ operator+() [1/4]

template<typename T >
RVec< T > ROOT::VecOps::operator+ ( const RVec< T > &  v)

Definition at line 1550 of file RVec.hxx.

◆ operator+() [2/4]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator+ ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] + y)>

Definition at line 1597 of file RVec.hxx.

◆ operator+() [3/4]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator+ ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] + v1[0])>

Definition at line 1597 of file RVec.hxx.

◆ operator+() [4/4]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator+ ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x + v[0])>

Definition at line 1597 of file RVec.hxx.

◆ operator+=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator+= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1631 of file RVec.hxx.

◆ operator+=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator+= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1631 of file RVec.hxx.

◆ operator-() [1/4]

template<typename T >
RVec< T > ROOT::VecOps::operator- ( const RVec< T > &  v)

Definition at line 1551 of file RVec.hxx.

◆ operator-() [2/4]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator- ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] - y)>

Definition at line 1598 of file RVec.hxx.

◆ operator-() [3/4]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator- ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] - v1[0])>

Definition at line 1598 of file RVec.hxx.

◆ operator-() [4/4]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator- ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x - v[0])>

Definition at line 1598 of file RVec.hxx.

◆ operator-=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator-= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1632 of file RVec.hxx.

◆ operator-=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator-= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1632 of file RVec.hxx.

◆ operator/() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator/ ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] / y)>

Definition at line 1600 of file RVec.hxx.

◆ operator/() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator/ ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] / v1[0])>

Definition at line 1600 of file RVec.hxx.

◆ operator/() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator/ ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x / v[0])>

Definition at line 1600 of file RVec.hxx.

◆ operator/=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator/= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1634 of file RVec.hxx.

◆ operator/=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator/= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1634 of file RVec.hxx.

◆ operator<() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator< ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1681 of file RVec.hxx.

◆ operator<() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator< ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1681 of file RVec.hxx.

◆ operator<() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator< ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1681 of file RVec.hxx.

◆ operator<<()

template<class T >
std::ostream & ROOT::VecOps::operator<< ( std::ostream &  os,
const RVec< T > &  v 
)

Print a RVec at the prompt:

Definition at line 3049 of file RVec.hxx.

◆ operator<<=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator<<= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1639 of file RVec.hxx.

◆ operator<<=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator<<= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1639 of file RVec.hxx.

◆ operator<=() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator<= ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1685 of file RVec.hxx.

◆ operator<=() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator<= ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1685 of file RVec.hxx.

◆ operator<=() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator<= ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1685 of file RVec.hxx.

◆ operator==() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator== ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1683 of file RVec.hxx.

◆ operator==() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator== ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1683 of file RVec.hxx.

◆ operator==() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator== ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1683 of file RVec.hxx.

◆ operator>() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator> ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1682 of file RVec.hxx.

◆ operator>() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator> ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1682 of file RVec.hxx.

◆ operator>() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator> ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1682 of file RVec.hxx.

◆ operator>=() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator>= ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1686 of file RVec.hxx.

◆ operator>=() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator>= ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1686 of file RVec.hxx.

◆ operator>=() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator>= ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1686 of file RVec.hxx.

◆ operator>>=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator>>= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1639 of file RVec.hxx.

◆ operator>>=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator>>= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1639 of file RVec.hxx.

◆ operator^() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator^ ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] ^ y)>

Definition at line 1602 of file RVec.hxx.

◆ operator^() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator^ ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] ^ v1[0])>

Definition at line 1602 of file RVec.hxx.

◆ operator^() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator^ ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x ^ v[0])>

Definition at line 1602 of file RVec.hxx.

◆ operator^=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator^= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1636 of file RVec.hxx.

◆ operator^=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator^= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1636 of file RVec.hxx.

◆ operator|() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator| ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<decltype(v[0] | y)>

Definition at line 1603 of file RVec.hxx.

◆ operator|() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator| ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<decltype(v0[0] | v1[0])>

Definition at line 1603 of file RVec.hxx.

◆ operator|() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator| ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<decltype(x | v[0])>

Definition at line 1603 of file RVec.hxx.

◆ operator|=() [1/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator|= ( RVec< T0 > &  v,
const T1 y 
)

Definition at line 1637 of file RVec.hxx.

◆ operator|=() [2/2]

template<typename T0 , typename T1 >
RVec< T0 > & ROOT::VecOps::operator|= ( RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1637 of file RVec.hxx.

◆ operator||() [1/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator|| ( const RVec< T0 > &  v,
const T1 y 
) -> RVec<int>

Definition at line 1688 of file RVec.hxx.

◆ operator||() [2/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator|| ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
) -> RVec<int>

Definition at line 1688 of file RVec.hxx.

◆ operator||() [3/3]

template<typename T0 , typename T1 >
auto ROOT::VecOps::operator|| ( const T0 &  x,
const RVec< T1 > &  v 
) -> RVec<int>

Definition at line 1688 of file RVec.hxx.

◆ operator~()

template<typename T >
RVec< T > ROOT::VecOps::operator~ ( const RVec< T > &  v)

Definition at line 1552 of file RVec.hxx.

◆ pow() [1/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::pow ( const RVec< T0 > &  v,
const T1 y 
)

Definition at line 1770 of file RVec.hxx.

◆ pow() [2/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::pow ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1770 of file RVec.hxx.

◆ pow() [3/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::pow ( const T0 &  x,
const RVec< T1 > &  v 
)

Definition at line 1770 of file RVec.hxx.

◆ Product()

template<typename T >
T ROOT::VecOps::Product ( const RVec< T > &  v,
const T  init = T(1) 
)

Product method analogous to Sum: Multiply the elements of a vector.

Definition at line 1886 of file RVec.hxx.

◆ Range()

RVec< std::size_t > ROOT::VecOps::Range ( std::size_t  length)
inline

Enumerate method: For any Rvec v produce another RVec with entries starting from 0, and incrementing by 1 until a N = v.size() is reached.

Example code, at the ROOT prompt: ~~~{.cpp} using namespace ROOT::VecOps; RVecF v = {1., 2., 3.}; cout << Enumerate(v1) << "\n"; // { 0, 1, 2 } */ template <typename T> RVec<typename RVec<T>::size_type> Enumerate(const RVec<T> &v) { const auto size = v.size(); RVec<T> ret; ret.reserve(size); for (auto i = 0UL; i < size; ++i) { ret.emplace_back(i); } return ret; }

/** Range method: Produce RVec with entries starting from 0, and incrementing by 1 until a user-specified N is reached. Example code, at the ROOT prompt: ~~~{.cpp} using namespace ROOT::VecOps; cout << Range(3) << "\n"; // { 0, 1, 2 }

Definition at line 3036 of file RVec.hxx.

◆ remainder() [1/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::remainder ( const RVec< T0 > &  v,
const T1 y 
)

Definition at line 1759 of file RVec.hxx.

◆ remainder() [2/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::remainder ( const RVec< T0 > &  v0,
const RVec< T1 > &  v1 
)

Definition at line 1759 of file RVec.hxx.

◆ remainder() [3/3]

template<typename T0 , typename T1 >
RVec< PromoteTypes< T0, T1 > > ROOT::VecOps::remainder ( const T0 &  x,
const RVec< T1 > &  v 
)

Definition at line 1759 of file RVec.hxx.

◆ Reverse()

template<typename T >
RVec< T > ROOT::VecOps::Reverse ( const RVec< T > &  v)

Return copy of reversed vector.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto v_reverse = Reverse(v);
v_reverse
// (ROOT::VecOps::RVec<double> &) { 1.0000000, 3.0000000, 2.0000000 }
RVec< T > Reverse(const RVec< T > &v)
Return copy of reversed vector.
Definition: RVec.hxx:2363

Definition at line 2363 of file RVec.hxx.

◆ round()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::round ( const RVec< T > &  v)

Definition at line 1793 of file RVec.hxx.

◆ sin()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::sin ( const RVec< T > &  v)

Definition at line 1775 of file RVec.hxx.

◆ sinh()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::sinh ( const RVec< T > &  v)

Definition at line 1783 of file RVec.hxx.

◆ Sort() [1/2]

template<typename T >
RVec< T > ROOT::VecOps::Sort ( const RVec< T > &  v)

Return copy of RVec with elements sorted in ascending order.

This helper is different from Argsort since it does not return an RVec of indices, but an RVec of values.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto v_sorted = Sort(v);
v_sorted
// (ROOT::VecOps::RVec<double> &) { 1.0000000, 2.0000000, 3.0000000 }
RVec< T > Sort(const RVec< T > &v)
Return copy of RVec with elements sorted in ascending order.
Definition: RVec.hxx:2384

Definition at line 2384 of file RVec.hxx.

◆ Sort() [2/2]

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.

The comparison operator has to fullfill the same requirements of the predicate of by std::sort.

This helper is different from Argsort since it does not return an RVec of indices, but an RVec of values.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto v_sorted = Sort(v, [](double x, double y) {return 1/x < 1/y;});
v_sorted
// (ROOT::VecOps::RVec<double> &) { 3.0000000, 2.0000000, 1.0000000 }

Definition at line 2409 of file RVec.hxx.

◆ sqrt()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::sqrt ( const RVec< T > &  v)

Definition at line 1771 of file RVec.hxx.

◆ StableArgsort() [1/2]

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.

This is the stable variant of Argsort.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 2., 1.};
auto sortIndices = StableArgsort(v)
// (ROOT::VecOps::RVec<unsigned long> &) { 3, 0, 2, 1 }
auto values = Take(v, sortIndices)
// (ROOT::VecOps::RVec<double> &) { 1.0000000, 2.0000000, 2.0000000, 3.0000000 }
RVec< typename RVec< T >::size_type > StableArgsort(const RVec< T > &v)
Return an RVec of indices that sort the input RVec while keeping the order of equal elements.
Definition: RVec.hxx:2215

Definition at line 2215 of file RVec.hxx.

◆ StableArgsort() [2/2]

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.

This is the stable variant of Argsort.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 2., 1.};
auto sortIndices = StableArgsort(v, [](double x, double y) {return x > y;})
// (ROOT::VecOps::RVec<unsigned long> &) { 1, 0, 2, 3 }
auto values = Take(v, sortIndices)
// (ROOT::VecOps::RVec<double> &) { 3.0000000, 2.0000000, 2.0000000, 1.0000000 }

Definition at line 2238 of file RVec.hxx.

◆ StableSort() [1/2]

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.

This is the stable variant of Sort.

This helper is different from StableArgsort since it does not return an RVec of indices, but an RVec of values.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 2, 1.};
auto v_sorted = StableSort(v);
v_sorted
// (ROOT::VecOps::RVec<double> &) { 1.0000000, 2.0000000, 2.0000000, 3.0000000 }
RVec< T > StableSort(const RVec< T > &v)
Return copy of RVec with elements sorted in ascending order while keeping the order of equal elements...
Definition: RVec.hxx:2433

Definition at line 2433 of file RVec.hxx.

◆ StableSort() [2/2]

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.

The comparison operator has to fullfill the same requirements of the predicate of std::stable_sort.

This helper is different from StableArgsort since it does not return an RVec of indices, but an RVec of values.

This is the stable variant of Sort.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 2., 1.};
auto v_sorted = StableSort(v, [](double x, double y) {return 1/x < 1/y;});
v_sorted
// (ROOT::VecOps::RVec<double> &) { 3.0000000, 2.0000000, 2.0000000, 1.0000000 }
using namespace ROOT::VecOps;
RVec<RVecD> v {{2., 4.}, {3., 1.}, {2, 1.}, {1., 4.}};
auto v_sorted = StableSort(StableSort(v, [](const RVecD &x, const RVecD &y) {return x[1] < y[1];}), [](const RVecD &x, const RVecD &y) {return x[0] < y[0];});
v_sorted
// (ROOT::VecOps::RVec<ROOT::VecOps::RVec<double> > &) { { 1.0000000, 4.0000000 }, { 2.0000000, 1.0000000 }, { 2.0000000, 4.0000000 }, { 3.0000000, 1.0000000 } }

Definition at line 2469 of file RVec.hxx.

◆ StdDev()

template<typename T >
double ROOT::VecOps::StdDev ( const RVec< T > &  v)

Get the standard deviation of the elements of an RVec.

The return type is a double precision floating point number. Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_sd = StdDev(v);
v_sd
// (double) 1.5275252
double StdDev(const RVec< T > &v)
Get the standard deviation of the elements of an RVec.
Definition: RVec.hxx:2046

Definition at line 2046 of file RVec.hxx.

◆ Sum()

template<typename T >
T ROOT::VecOps::Sum ( const RVec< T > &  v,
const T  zero = T(0) 
)

Sum elements of an RVec.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 3.f};
auto v_sum = Sum(v);
v_sum
// (float) 6.f
auto v_sum_d = Sum(v, 0.);
v_sum_d
// (double) 6.0000000
T Sum(const RVec< T > &v, const T zero=T(0))
Sum elements of an RVec.
Definition: RVec.hxx:1878
using namespace ROOT::VecOps;
const ROOT::Math::PtEtaPhiMVector lv0 {15.5f, .3f, .1f, 105.65f},
lv1 {34.32f, 2.2f, 3.02f, 105.65f},
lv2 {12.95f, 1.32f, 2.2f, 105.65f};
auto v_sum_lv = Sum(v, ROOT::Math::PtEtaPhiMVector());
v_sum_lv
// (ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > &) (30.8489,2.46534,2.58947,361.084)

Definition at line 1878 of file RVec.hxx.

◆ swap()

template<typename T >
void ROOT::VecOps::swap ( RVec< T > &  lhs,
RVec< T > &  rhs 
)

Definition at line 2153 of file RVec.hxx.

◆ Take() [1/3]

template<typename T >
RVec< T > ROOT::VecOps::Take ( const RVec< T > &  v,
const int  n 
)

Return first or last n elements of an RVec.

if n > 0 and last elements if n < 0.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto firstTwo = Take(v, 2);
firstTwo
// (ROOT::VecOps::RVec<double>) { 2.0000000, 3.0000000 }
auto lastOne = Take(v, -1);
lastOne
// (ROOT::VecOps::RVec<double>) { 1.0000000 }

Definition at line 2305 of file RVec.hxx.

◆ Take() [2/3]

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v {2., 3., 1.};
auto vTaken = Take(v, {0,2});
vTaken
// (ROOT::VecOps::RVec<double>) { 2.0000000, 1.0000000 }

Definition at line 2259 of file RVec.hxx.

◆ Take() [3/3]

template<typename T >
RVec< T > ROOT::VecOps::Take ( const RVec< T > &  v,
const RVec< typename RVec< T >::size_type > &  i,
const T  default_val 
)

Take version that defaults to (user-specified) output value if some index is out of range.

Definition at line 2271 of file RVec.hxx.

◆ tan()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::tan ( const RVec< T > &  v)

Definition at line 1777 of file RVec.hxx.

◆ tanh()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::tanh ( const RVec< T > &  v)

Definition at line 1785 of file RVec.hxx.

◆ tgamma()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::tgamma ( const RVec< T > &  v)

Definition at line 1800 of file RVec.hxx.

◆ trunc()

template<typename T >
RVec< PromoteType< T > > ROOT::VecOps::trunc ( const RVec< T > &  v)

Definition at line 1792 of file RVec.hxx.

◆ Var()

template<typename T >
double ROOT::VecOps::Var ( const RVec< T > &  v)

Get the variance of the elements of an RVec.

The return type is a double precision floating point number. Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecF v {1.f, 2.f, 4.f};
auto v_var = Var(v);
v_var
// (double) 2.3333333
double Var(const RVec< T > &v)
Get the variance of the elements of an RVec.
Definition: RVec.hxx:2022

Definition at line 2022 of file RVec.hxx.

◆ Where() [1/4]

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v1 {1., 2., 3.};
RVecD v2 {-1., -2., -3.};
auto c = v1 > 1;
// (ROOT::VecOps::RVec<int> &) { 0, 1, 1 }
auto if_c_v1_else_v2 = Where(c, v1, v2);
if_c_v1_else_v2
// (ROOT::VecOps::RVec<double> &) { -1.0000000, 2.0000000, 3.0000000 }
#define c(i)
Definition: RSha256.hxx:101
RVec< T > 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.
Definition: RVec.hxx:2674

Definition at line 2674 of file RVec.hxx.

◆ Where() [2/4]

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVecD v1 {1., 2., 3.};
double v2 = 4.;
auto c = v1 > 1;
// (ROOT::VecOps::RVec<int> &) { 0, 1, 1 }
auto if_c_v1_else_v2 = Where(c, v1, v2);
if_c_v1_else_v2
// (ROOT::VecOps::RVec<double>) { 4.0000000, 2.0000000, 3.0000000 }

Definition at line 2702 of file RVec.hxx.

◆ Where() [3/4]

template<typename T >
RVec< T > ROOT::VecOps::Where ( const RVec< int > &  c,
v1,
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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
double v1 = 4.;
double v2 = 2.;
RVecI c {0, 1, 1};
auto if_c_v1_else_v2 = Where(c, v1, v2);
if_c_v1_else_v2
// (ROOT::VecOps::RVec<double>) { 2.0000000, 4.0000000, 4.0000000 }

Definition at line 2756 of file RVec.hxx.

◆ Where() [4/4]

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
double v1 = 4.;
RVecD v2 {1., 2., 3.};
auto c = v2 > 1;
// (ROOT::VecOps::RVec<int> &) { 0, 1, 1 }
auto if_c_v1_else_v2 = Where(c, v1, v2);
if_c_v1_else_v2
// (ROOT::VecOps::RVec<double>) { 1.0000000, 4.0000000, 4.0000000 }

Definition at line 2730 of file RVec.hxx.