Logo ROOT   6.18/05
Reference Guide
Classes | Functions
ROOT::VecOps Namespace Reference

Classes

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

Functions

template<typename T >
auto 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 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 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 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 > Argsort (const RVec< T > &v)
 Return an RVec of indices that sort the input RVec. More...
 
template<typename T >
RVec< RVec< typename RVec< T >::size_type > > 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 > > 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 > > 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 > Concatenate (const RVec< T0 > &v0, const RVec< T1 > &v1)
 Return the concatenation of two RVecs. More...
 
template<typename T , typename... Args_t>
RVec< T > 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 > 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 > 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 > 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 >
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 > 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 >
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 > 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 Dot (const RVec< T > &v0, const RVec< V > &v1) -> decltype(v0[0] *v1[0])
 Inner product. More...
 
template<typename T , typename F >
RVec< T > 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 > 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 >
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 > 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 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. More...
 
template<typename T >
Max (const RVec< T > &v)
 Get the greatest element of an RVec. More...
 
template<typename T >
double Mean (const RVec< T > &v)
 Get the mean of the elements of an RVec. More...
 
template<typename T >
Min (const RVec< T > &v)
 Get the smallest element of an RVec. More...
 
template<typename T >
RVec< typename RVec< T >::size_type > Nonzero (const RVec< T > &v)
 Return the indices of the elements which are not zero. More...
 
template<class T >
std::ostream & operator<< (std::ostream &os, const RVec< T > &v)
 Print a RVec at the prompt: More...
 
template<typename T >
RVec< T > Reverse (const RVec< T > &v)
 Return copy of reversed vector. More...
 
template<typename T >
RVec< T > Sort (const RVec< T > &v)
 Return copy of RVec with elements sorted in ascending order. More...
 
template<typename T , typename Compare >
RVec< T > Sort (const RVec< T > &v, Compare &&c)
 Return copy of RVec with elements sorted based on a comparison operator. More...
 
template<typename T >
double StdDev (const RVec< T > &v)
 Get the standard deviation of the elements of an RVec. More...
 
template<typename T >
Sum (const RVec< T > &v)
 Sum elements of an RVec. More...
 
template<typename T >
void swap (RVec< T > &lhs, RVec< T > &rhs)
 
template<typename T >
RVec< T > Take (const RVec< T > &v, const int n)
 Return first or last n elements of an RVec. More...
 
template<typename T >
RVec< T > 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 >
double Var (const RVec< T > &v)
 Get the variance of the elements of an RVec. More...
 
template<typename T >
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. More...
 
template<typename T >
RVec< T > 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. More...
 
template<typename T >
RVec< T > 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. More...
 
template<typename T >
RVec< T > 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...
 

Function Documentation

◆ 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;
RVec<int> v {0, 1, 0};
auto allTrue = All(v);
allTrue
// (bool) false
SVector< double, 2 > v
Definition: Dict.h:5
A "std::vector"-like collection of values implementing handy operation to analyse them.
Definition: RVec.hxx:272
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:978

Definition at line 978 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;
RVec<int> 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:959

Definition at line 959 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;
RVec<float> v {1.f, 2.f, 4.f};
auto v_argmax = ArgMax(v);
v_argmax
// (int) 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:824

Definition at line 824 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;
RVec<float> v {1.f, 2.f, 4.f};
auto v_argmin = ArgMin(v);
v_argmin
// (int) 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:842

Definition at line 842 of file RVec.hxx.

◆ Argsort()

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;
RVec<double> v {2., 3., 1.};
auto sortIndices = Argsort(v);
sortIndices
// (ROOT::VecOps::RVec<unsigned long> &) { 2, 0, 1 }
RVec< typename RVec< T >::size_type > Argsort(const RVec< T > &v)
Return an RVec of indices that sort the input RVec.
Definition: RVec.hxx:1003

Definition at line 1003 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;
RVec<double> v {1., 2., 3., 4.};
auto v_1 = Combinations(v, 1);
v_1
auto v_2 = Combinations(v, 2);
auto v_2
(ROOT::VecOps::RVec<ROOT::VecOps::RVec<ROOT::VecOps::RVec<double>::size_type> >) { { 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<ROOT::VecOps::RVec<double>::size_type> >) { { 0, 0, 0, 1 }, { 1, 1, 2, 2 }, { 2, 3, 3, 3 } }
auto v_4 = Combinations(v, 4);
v_4
typename Impl_t::size_type size_type
Definition: RVec.hxx:281
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:1146

Definition at line 1204 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;
RVec<double> v1 {1., 2., 3.};
RVec<double> v2 {-4., -5.};
auto comb_idx = Combinations(v1, v2);
comb_idx
// (ROOT::VecOps::RVec<ROOT::VecOps::RVec<ROOT::VecOps::RVec<double>::size_type> >) { { 0, 0, 1, 1, 2, 2 }, { 0, 1,
0, 1, 0, 1 } }

Definition at line 1179 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<ROOT::VecOps::RVec<double>::size_type> >) { { 0, 0, 1, 1, 2, 2 }, { 0, 1, 0, 1, 0, 1 } }

Definition at line 1146 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;
RVec<float> rvf {0.f, 1.f, 2.f};
RVec<int> rvi {7, 8, 9};
Concatenate(rvf, rvi);
// (ROOT::VecOps::RVec<float>) { 2.0000000, 4.0000000, 4.0000000 }
RVec< Common_t > Concatenate(const RVec< T0 > &v0, const RVec< T1 > &v1)
Return the concatenation of two RVecs.
Definition: RVec.hxx:1420

Definition at line 1420 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;
RVec<float> etas {.3f, 2.2f, 1.32f};
RVec<float> phis {.1f, 3.02f, 2.2f};
RVec<float> pts {15.5f, 34.32f, 12.95f};
RVec<float> masses {105.65f, 105.65f, 105.65f};
Construct<ROOT::Math::PtEtaPhiMVector> fourVects(etas, phis, pts, masses);
cout << fourVects << 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 1622 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 1460 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 1478 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 1496 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 1439 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 1529 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 1542 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 1515 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.f
auto Dot(const RVec< T > &v0, const RVec< V > &v1) -> decltype(v0[0] *v1[0])
Inner product.
Definition: RVec.hxx:738

Definition at line 738 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;
RVec<int> 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:936

Definition at line 936 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;
RVec<double> v1 {1., 2., 3.};
RVec<double> 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:1281

Definition at line 1281 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 1585 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 1554 of file RVec.hxx.

◆ Map()

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.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVec<float> 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 }
RVec<float> x({1.f, 2.f, 3.f});
RVec<float> y({4.f, 5.f, 6.f});
RVec<float> 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 }
#define f(i)
Definition: RSha256.hxx:104
double sqrt(double)
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
auto 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.
Definition: RVec.hxx:907

Definition at line 907 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;
RVec<float> v {1.f, 2.f, 4.f};
auto v_max = Max(v)
v_max
(float) 4.f
T Max(const RVec< T > &v)
Get the greatest element of an RVec.
Definition: RVec.hxx:790

Definition at line 790 of file RVec.hxx.

◆ Mean()

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;
RVec<float> 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:773

Definition at line 773 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;
RVec<float> v {1.f, 2.f, 4.f};
auto v_min = Min(v)
v_min
(float) 1.f
T Min(const RVec< T > &v)
Get the smallest element of an RVec.
Definition: RVec.hxx:806

Definition at line 806 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;
RVec<double> v {2., 0., 3., 0., 1.};
auto nonzero_idx = Nonzero(v);
nonzero_idx
// (ROOT::VecOps::RVec<ROOT::VecOps::RVec<double>::size_type>) { 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:1250

Definition at line 1250 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 1636 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;
RVec<double> 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:1081

Definition at line 1081 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;
RVec<double> 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:1102

Definition at line 1102 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;
RVec<double> 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 1127 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;
RVec<float> 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:883

Definition at line 883 of file RVec.hxx.

◆ Sum()

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

Sum elements of an RVec.

Example code, at the ROOT prompt:

using namespace ROOT::VecOps;
RVec<float> v {1.f, 2.f, 3.f};
auto v_sum = Sum(v);
v_sum
// (float) 6.f
T Sum(const RVec< T > &v)
Sum elements of an RVec.
Definition: RVec.hxx:756

Definition at line 756 of file RVec.hxx.

◆ swap()

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

Definition at line 987 of file RVec.hxx.

◆ Take() [1/2]

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;
RVec<double> 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 }
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:1023

Definition at line 1049 of file RVec.hxx.

◆ Take() [2/2]

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;
RVec<double> v {2., 3., 1.};
auto vTaken = Take(v, {0,2});
vTaken
// (ROOT::VecOps::RVec<double>) { 2.0000000, 1.0000000 }

Definition at line 1023 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;
RVec<float> 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:859

Definition at line 859 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;
RVec<double> v1 {1., 2., 3.};
RVec<double> 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:1315

Definition at line 1315 of file RVec.hxx.

◆ Where() [2/4]

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

◆ Where() [3/4]

template<typename T >
RVec< T > ROOT::VecOps::Where ( const RVec< int > &  c,
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.;
RVec<double> 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 1371 of file RVec.hxx.

◆ Where() [4/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.;
RVec<int> 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 1397 of file RVec.hxx.