16#if __cplusplus > 201402L
17#define R__RVEC_NODISCARD [[nodiscard]]
19#define R__RVEC_NODISCARD
24 #ifndef _USE_MATH_DEFINES
25 #define _USE_MATH_DEFINES
29 #undef _USE_MATH_DEFINES
31 #define _VECOPS_USE_EXTERN_TEMPLATES false
33 #define _VECOPS_USE_EXTERN_TEMPLATES true
56#include <vdt/vdtMath.h>
81constexpr bool All(
const bool *vals, std::size_t
size)
83 for (
auto i = 0
u; i <
size; ++i)
89template <
typename... T>
92 constexpr const auto nArgs =
sizeof...(T);
93 const std::size_t
sizes[] = {
vs.size()...};
95 for (
auto i = 1UL; i <
nArgs; i++) {
99 msg +=
": input RVec instances have different lengths!";
100 throw std::runtime_error(
msg);
106template <
typename F,
typename...
RVecs>
112 for (
auto i = 0
UL; i <
size; i++)
118template <
typename Tuple_t, std::size_t...
Is>
120 ->
decltype(
MapImpl(std::get<std::tuple_size<Tuple_t>::value - 1>(t), std::get<Is>(t)...))
122 constexpr const auto tupleSizeM1 = std::tuple_size<Tuple_t>::value - 1;
123 return MapImpl(std::get<tupleSizeM1>(t), std::get<Is>(t)...);
155 static constexpr size_t SizeTypeMax() {
return std::numeric_limits<Size_T>::max(); }
163 void grow_pod(
void *FirstEl,
size_t MinSize,
size_t TSize);
167 static void report_size_overflow(
size_t MinSize);
170 static void report_at_maximum_capacity();
173 bool Owns()
const {
return fCapacity != -1; }
192 if (
N > capacity()) {
193 throw std::runtime_error(
"Setting size to a value greater than capacity.");
203 alignas(T)
char FirstEl[
sizeof(T)];
216 return const_cast<void *
>(
reinterpret_cast<const void *
>(
reinterpret_cast<const char *
>(
this) +
228 bool isSmall()
const {
return this->fBeginX == getFirstEl(); }
233 this->fBeginX = getFirstEl();
236 this->
fSize = this->fCapacity = 0;
256 using Base::capacity;
289 throw std::runtime_error(
"`front` called on an empty RVec");
297 throw std::runtime_error(
"`front` called on an empty RVec");
305 throw std::runtime_error(
"`back` called on an empty RVec");
313 throw std::runtime_error(
"`back` called on an empty RVec");
327template <
typename T,
bool = (std::is_trivially_copy_constructible<T>::value) &&
328 (std::is_trivially_move_constructible<T>::value) &&
329 std::is_trivially_destructible<T>::value>
344 template <
typename It1,
typename It2>
347 std::uninitialized_copy(std::make_move_iterator(
I), std::make_move_iterator(E),
Dest);
352 template <
typename It1,
typename It2>
355 std::uninitialized_copy(
I, E,
Dest);
369 this->set_size(this->
size() + 1);
376 ::new ((
void *)this->end()) T(::std::move(
Elt));
377 this->set_size(this->
size() + 1);
382 this->set_size(this->
size() - 1);
388template <
typename T,
bool TriviallyCopyable>
393 if (MinSize > this->SizeTypeMax())
394 this->report_size_overflow(MinSize);
400 if (this->capacity() == this->SizeTypeMax())
401 this->report_at_maximum_capacity();
410 this->uninitialized_move(this->begin(), this->end(),
NewElts);
414 destroy_range(this->begin(), this->end());
417 if (!this->isSmall())
441 template <
typename It1,
typename It2>
445 uninitialized_copy(
I, E,
Dest);
450 template <
typename It1,
typename It2>
454 std::uninitialized_copy(
I, E,
Dest);
459 template <
typename T1,
typename T2>
462 typename std::enable_if<std::is_same<
typename std::remove_const<T1>::type,
T2>
::value>
::type * =
nullptr)
469 memcpy(
reinterpret_cast<void *
>(
Dest),
I, (E -
I) *
sizeof(T));
476 this->grow_pod(MinSize,
sizeof(T));
489 memcpy(
reinterpret_cast<void *
>(this->end()), &
Elt,
sizeof(T));
490 this->set_size(this->
size() + 1);
498template <
typename T,
unsigned N>
500 alignas(T)
char InlineElts[
N *
sizeof(T)]{};
517 static constexpr unsigned elementsPerCacheLine = (cacheLineSize -
sizeof(
SmallVectorBase)) /
sizeof(T);
518 static constexpr unsigned maxInlineByteSize = 1024;
522 elementsPerCacheLine >= 8 ? elementsPerCacheLine : (
sizeof(T) * 8 > maxInlineByteSize ? 0 : 8);
526template <
typename ForwardIt>
529#if __cplusplus < 201703L
530 for (; first != last; ++first)
531 new (
static_cast<void *
>(std::addressof(*first)))
typename std::iterator_traits<ForwardIt>::value_type();
533 std::uninitialized_value_construct(first, last);
569 explicit RVecImpl(
unsigned N) :
ROOT::Internal::VecOps::SmallVectorTemplateBase<T>(
N) {}
578 if (!this->isSmall() && this->Owns())
586 this->destroy_range(this->begin(), this->end());
589 this->resetToSmall();
597 this->destroy_range(this->begin() +
N, this->end());
599 }
else if (
N > this->
size()) {
600 if (this->capacity() <
N)
602 for (
auto I = this->end(), E = this->begin() +
N;
I != E; ++
I)
612 this->destroy_range(this->begin() +
N, this->end());
614 }
else if (
N > this->
size()) {
615 if (this->capacity() <
N)
617 std::uninitialized_fill(this->end(), this->begin() +
N,
NV);
624 if (this->capacity() <
N)
630 if (this->
size() < NumItems) {
631 throw std::runtime_error(
"Popping back more elements than those available.");
634 this->destroy_range(this->end() - NumItems, this->end());
635 this->set_size(this->
size() - NumItems);
640 T Result = ::std::move(this->back());
649 typename =
typename std::enable_if<std::is_convertible<
650 typename std::iterator_traits<in_iter>::iterator_category, std::input_iterator_tag>
::value>
::type>
655 this->grow(this->
size() + NumInputs);
658 this->set_size(this->
size() + NumInputs);
665 this->grow(this->
size() + NumInputs);
668 this->set_size(this->
size() + NumInputs);
680 if (this->capacity() <
NumElts)
683 std::uninitialized_fill(this->begin(), this->end(),
Elt);
687 typename =
typename std::enable_if<std::is_convertible<
688 typename std::iterator_traits<in_iter>::iterator_category, std::input_iterator_tag>
::value>
::type>
707 throw std::runtime_error(
"The iterator passed to `erase` is out of bounds.");
712 std::move(
I + 1, this->end(),
I);
724 if (
S < this->begin() || E > this->end() || S > E) {
725 throw std::runtime_error(
"Invalid start/end pair passed to `erase` (out of bounds or start > end).");
730 iterator I = std::move(E, this->end(), S);
733 this->destroy_range(
I, this->end());
734 this->set_size(
I - this->begin());
740 if (
I == this->end()) {
741 this->push_back(::std::move(
Elt));
742 return this->end() - 1;
746 throw std::runtime_error(
"The iterator passed to `insert` is out of bounds.");
749 if (this->
size() >= this->capacity()) {
750 size_t EltNo =
I - this->begin();
752 I = this->begin() +
EltNo;
755 ::new ((
void *)this->end()) T(::std::move(this->back()));
757 std::move_backward(
I, this->end() - 1, this->end());
758 this->set_size(this->
size() + 1);
772 if (
I == this->end()) {
773 this->push_back(
Elt);
774 return this->end() - 1;
778 throw std::runtime_error(
"The iterator passed to `insert` is out of bounds.");
781 if (this->
size() >= this->capacity()) {
782 size_t EltNo =
I - this->begin();
784 I = this->begin() +
EltNo;
786 ::new ((
void *)this->end()) T(std::move(this->back()));
788 std::move_backward(
I, this->end() - 1, this->end());
789 this->set_size(this->
size() + 1);
806 if (
I == this->end()) {
812 throw std::runtime_error(
"The iterator passed to `insert` is out of bounds.");
816 reserve(this->
size() + NumToInsert);
827 append(std::move_iterator<iterator>(this->end() -
NumToInsert), std::move_iterator<iterator>(this->end()));
841 this->set_size(this->
size() + NumToInsert);
853 template <
typename ItTy,
854 typename =
typename std::enable_if<std::is_convertible<
855 typename std::iterator_traits<ItTy>::iterator_category, std::input_iterator_tag>
::value>
::type>
861 if (
I == this->end()) {
867 throw std::runtime_error(
"The iterator passed to `insert` is out of bounds.");
873 reserve(this->
size() + NumToInsert);
884 append(std::move_iterator<iterator>(this->end() -
NumToInsert), std::move_iterator<iterator>(this->end()));
898 this->set_size(this->
size() + NumToInsert);
921 ::new ((
void *)this->end()) T(std::forward<ArgTypes>(Args)...);
922 this->set_size(this->
size() + 1);
938 if (!this->isSmall() && !
RHS.isSmall()) {
939 std::swap(this->fBeginX,
RHS.fBeginX);
940 std::swap(this->
fSize, RHS.fSize);
941 std::swap(this->fCapacity,
RHS.fCapacity);
947 if (this->isSmall() && !
RHS.Owns()) {
949 temp = std::move(
RHS);
950 RHS = std::move(*
this);
951 *
this = std::move(temp);
953 }
else if (
RHS.isSmall() && !
this->Owns()) {
955 temp = std::move(*
this);
956 *
this = std::move(
RHS);
957 RHS = std::move(temp);
961 if (
RHS.size() >
this->capacity())
962 this->grow(
RHS.size());
963 if (this->
size() > RHS.capacity())
968 if (NumShared >
RHS.size())
971 std::iter_swap(this->begin() + i,
RHS.
begin() + i);
974 if (this->
size() > RHS.size()) {
976 this->uninitialized_copy(this->begin() +
NumShared, this->end(),
RHS.
end());
979 this->destroy_range(this->begin() +
NumShared, this->end());
981 }
else if (
RHS.size() >
this->size()) {
984 this->set_size(this->
size() + EltDiff);
1012 this->destroy_range(
NewEnd, this->end());
1023 if (this->capacity() <
RHSSize) {
1026 this->destroy_range(this->begin(), this->end());
1044template <
typename T>
1052 if (!
RHS.isSmall()) {
1054 this->destroy_range(this->begin(), this->end());
1055 if (!this->isSmall())
1056 free(this->begin());
1058 this->fBeginX =
RHS.fBeginX;
1060 this->fCapacity =
RHS.fCapacity;
1077 this->destroy_range(
NewEnd, this->end());
1091 if (this->capacity() <
RHSSize) {
1094 this->destroy_range(this->begin(), this->end());
1114template <
typename T>
1120template <
typename T>
1147template <
typename T,
unsigned int N>
1156 this->destroy_range(this->begin(), this->end());
1160 explicit RVecN(
size_t Size,
const T &
Value) : Detail::VecOps::RVecImpl<T>(
N) { this->assign(Size,
Value); }
1162 explicit RVecN(
size_t Size) : Detail::VecOps::RVecImpl<T>(
N)
1170 template <
typename ItTy,
1171 typename =
typename std::enable_if<std::is_convertible<
1172 typename std::iterator_traits<ItTy>::iterator_category, std::input_iterator_tag>
::value>
::type>
1178 RVecN(std::initializer_list<T>
IL) : Detail::VecOps::RVecImpl<T>(
N) { this->assign(
IL); }
1216 this->fCapacity = -1;
1240 return begin()[idx];
1245 return begin()[idx];
1253 if (
n != this->
size()) {
1254 std::string
msg =
"Cannot index RVecN of size " + std::to_string(this->
size()) +
1255 " with condition vector of different size (" + std::to_string(
n) +
").";
1256 throw std::runtime_error(
msg);
1268 ret.push_back(this->
operator[](i));
1285 std::string
msg =
"RVecN::at: size is " + std::to_string(this->
fSize) +
" but out-of-bounds index " +
1286 std::to_string(pos) +
" was requested.";
1287 throw std::out_of_range(
msg);
1289 return this->operator[](pos);
1295 std::string
msg =
"RVecN::at: size is " + std::to_string(this->
fSize) +
" but out-of-bounds index " +
1296 std::to_string(pos) +
" was requested.";
1297 throw std::out_of_range(
msg);
1299 return this->operator[](pos);
1307 return this->operator[](pos);
1315 return this->operator[](pos);
1525template <
typename T>
1536 using SuperClass::begin;
1537 using SuperClass::size;
1545 template <
typename ItTy,
1546 typename =
typename std::enable_if<std::is_convertible<
1547 typename std::iterator_traits<ItTy>::iterator_category, std::input_iterator_tag>
::value>
::type>
1558 SuperClass::operator=(
RHS);
1566 SuperClass::operator=(std::move(
RHS));
1572 template <
unsigned N>
1575 template <
unsigned N>
1586 return RVec<U>(this->begin(), this->end());
1589 using SuperClass::operator[];
1594 return RVec(SuperClass::operator[](
conds));
1597 using SuperClass::at;
1599 friend bool ROOT::Detail::VecOps::IsSmall<T>(
const RVec<T> &
v);
1601 friend bool ROOT::Detail::VecOps::IsAdopting<T>(
const RVec<T> &
v);
1604template <
typename T,
unsigned N>
1607 return X.capacity_in_bytes();
1613#define RVEC_UNARY_OPERATOR(OP) \
1614template <typename T> \
1615RVec<T> operator OP(const RVec<T> &v) \
1618 for (auto &x : ret) \
1627#undef RVEC_UNARY_OPERATOR
1633#define ERROR_MESSAGE(OP) \
1634 "Cannot call operator " #OP " on vectors of different sizes."
1636#define RVEC_BINARY_OPERATOR(OP) \
1637template <typename T0, typename T1> \
1638auto operator OP(const RVec<T0> &v, const T1 &y) \
1639 -> RVec<decltype(v[0] OP y)> \
1641 RVec<decltype(v[0] OP y)> ret(v.size()); \
1642 auto op = [&y](const T0 &x) { return x OP y; }; \
1643 std::transform(v.begin(), v.end(), ret.begin(), op); \
1647template <typename T0, typename T1> \
1648auto operator OP(const T0 &x, const RVec<T1> &v) \
1649 -> RVec<decltype(x OP v[0])> \
1651 RVec<decltype(x OP v[0])> ret(v.size()); \
1652 auto op = [&x](const T1 &y) { return x OP y; }; \
1653 std::transform(v.begin(), v.end(), ret.begin(), op); \
1657template <typename T0, typename T1> \
1658auto operator OP(const RVec<T0> &v0, const RVec<T1> &v1) \
1659 -> RVec<decltype(v0[0] OP v1[0])> \
1661 if (v0.size() != v1.size()) \
1662 throw std::runtime_error(ERROR_MESSAGE(OP)); \
1664 RVec<decltype(v0[0] OP v1[0])> ret(v0.size()); \
1665 auto op = [](const T0 &x, const T1 &y) { return x OP y; }; \
1666 std::transform(v0.begin(), v0.end(), v1.begin(), ret.begin(), op); \
1678#undef RVEC_BINARY_OPERATOR
1684#define RVEC_ASSIGNMENT_OPERATOR(OP) \
1685template <typename T0, typename T1> \
1686RVec<T0>& operator OP(RVec<T0> &v, const T1 &y) \
1688 auto op = [&y](T0 &x) { return x OP y; }; \
1689 std::transform(v.begin(), v.end(), v.begin(), op); \
1693template <typename T0, typename T1> \
1694RVec<T0>& operator OP(RVec<T0> &v0, const RVec<T1> &v1) \
1696 if (v0.size() != v1.size()) \
1697 throw std::runtime_error(ERROR_MESSAGE(OP)); \
1699 auto op = [](T0 &x, const T1 &y) { return x OP y; }; \
1700 std::transform(v0.begin(), v0.end(), v1.begin(), v0.begin(), op); \
1714#undef RVEC_ASSIGNMENT_OPERATOR
1720#define RVEC_LOGICAL_OPERATOR(OP) \
1721template <typename T0, typename T1> \
1722auto operator OP(const RVec<T0> &v, const T1 &y) \
1725 RVec<int> ret(v.size()); \
1726 auto op = [y](const T0 &x) -> int { return x OP y; }; \
1727 std::transform(v.begin(), v.end(), ret.begin(), op); \
1731template <typename T0, typename T1> \
1732auto operator OP(const T0 &x, const RVec<T1> &v) \
1735 RVec<int> ret(v.size()); \
1736 auto op = [x](const T1 &y) -> int { return x OP y; }; \
1737 std::transform(v.begin(), v.end(), ret.begin(), op); \
1741template <typename T0, typename T1> \
1742auto operator OP(const RVec<T0> &v0, const RVec<T1> &v1) \
1745 if (v0.size() != v1.size()) \
1746 throw std::runtime_error(ERROR_MESSAGE(OP)); \
1748 RVec<int> ret(v0.size()); \
1749 auto op = [](const T0 &x, const T1 &y) -> int { return x OP y; }; \
1750 std::transform(v0.begin(), v0.end(), v1.begin(), ret.begin(), op); \
1762#undef RVEC_LOGICAL_OPERATOR
1777template <
typename T>
1780template <
typename U,
typename V>
1785#define RVEC_UNARY_FUNCTION(NAME, FUNC) \
1786 template <typename T> \
1787 RVec<PromoteType<T>> NAME(const RVec<T> &v) \
1789 RVec<PromoteType<T>> ret(v.size()); \
1790 auto f = [](const T &x) { return FUNC(x); }; \
1791 std::transform(v.begin(), v.end(), ret.begin(), f); \
1795#define RVEC_BINARY_FUNCTION(NAME, FUNC) \
1796 template <typename T0, typename T1> \
1797 RVec<PromoteTypes<T0, T1>> NAME(const T0 &x, const RVec<T1> &v) \
1799 RVec<PromoteTypes<T0, T1>> ret(v.size()); \
1800 auto f = [&x](const T1 &y) { return FUNC(x, y); }; \
1801 std::transform(v.begin(), v.end(), ret.begin(), f); \
1805 template <typename T0, typename T1> \
1806 RVec<PromoteTypes<T0, T1>> NAME(const RVec<T0> &v, const T1 &y) \
1808 RVec<PromoteTypes<T0, T1>> ret(v.size()); \
1809 auto f = [&y](const T0 &x) { return FUNC(x, y); }; \
1810 std::transform(v.begin(), v.end(), ret.begin(), f); \
1814 template <typename T0, typename T1> \
1815 RVec<PromoteTypes<T0, T1>> NAME(const RVec<T0> &v0, const RVec<T1> &v1) \
1817 if (v0.size() != v1.size()) \
1818 throw std::runtime_error(ERROR_MESSAGE(NAME)); \
1820 RVec<PromoteTypes<T0, T1>> ret(v0.size()); \
1821 auto f = [](const T0 &x, const T1 &y) { return FUNC(x, y); }; \
1822 std::transform(v0.begin(), v0.end(), v1.begin(), ret.begin(), f); \
1826#define RVEC_STD_UNARY_FUNCTION(F) RVEC_UNARY_FUNCTION(F, std::F)
1827#define RVEC_STD_BINARY_FUNCTION(F) RVEC_BINARY_FUNCTION(F, std::F)
1874#undef RVEC_STD_UNARY_FUNCTION
1881#define RVEC_VDT_UNARY_FUNCTION(F) RVEC_UNARY_FUNCTION(F, vdt::F)
1900#undef RVEC_VDT_UNARY_FUNCTION
1904#undef RVEC_UNARY_FUNCTION
1919template <
typename T,
typename V>
1922 if (
v0.size() !=
v1.size())
1923 throw std::runtime_error(
"Cannot compute inner product of vectors of different sizes");
1924 return std::inner_product(
v0.begin(),
v0.end(),
v1.begin(),
decltype(
v0[0] *
v1[0])(0));
1950template <
typename T>
1953 return std::accumulate(
v.begin(),
v.end(),
zero);
1958 return std::accumulate(
v.begin(),
v.end(),
zero);
1962template <
typename T>
1965 return std::accumulate(
v.begin(),
v.end(), init, std::multiplies<T>());
1980template <
typename T>
1983 if (
v.empty())
return 0.;
2012template <
typename T,
typename R = T>
2015 if (
v.empty())
return zero;
2029template <
typename T>
2032 return *std::max_element(
v.begin(),
v.end());
2045template <
typename T>
2048 return *std::min_element(
v.begin(),
v.end());
2063template <
typename T>
2066 return std::distance(
v.begin(), std::max_element(
v.begin(),
v.end()));
2081template <
typename T>
2084 return std::distance(
v.begin(), std::min_element(
v.begin(),
v.end()));
2098template <
typename T>
2101 const std::size_t
size =
v.size();
2102 if (
size < std::size_t(2))
return 0.;
2105 std::for_each(
v.begin(),
v.end(),
pred);
2122template <
typename T>
2125 return std::sqrt(Var(
v));
2146template <
typename... Args>
2159 constexpr auto nArgs =
sizeof...(Args);
2162 "Map: the first N-1 arguments must be RVecs or references to RVecs");
2165 std::make_index_sequence<
sizeof...(args) - 1>());
2178template <
typename T,
typename F>
2184 for (
auto &&val :
v) {
2186 w.emplace_back(val);
2201template <
typename T>
2205 if (
static_cast<bool>(
e) ==
true)
2220template <
typename T>
2224 if (
static_cast<bool>(
e) ==
false)
2229template <
typename T>
2246template <
typename T>
2252 std::sort(i.
begin(), i.
end(), [&
v](size_type
i1, size_type
i2) { return v[i1] < v[i2]; });
2267template <
typename T,
typename Compare>
2274 [&
v, &
c](size_type
i1, size_type
i2) { return c(v[i1], v[i2]); });
2291template <
typename T>
2297 std::stable_sort(i.
begin(), i.
end(), [&
v](size_type
i1, size_type
i2) { return v[i1] < v[i2]; });
2314template <
typename T,
typename Compare>
2320 std::stable_sort(i.
begin(), i.
end(), [&
v, &
c](size_type
i1, size_type
i2) { return c(v[i1], v[i2]); });
2335template <
typename T>
2339 const size_type
isize = i.size();
2341 for (size_type k = 0; k <
isize; k++)
2347template <
typename T>
2351 const size_type
isize = i.size();
2353 for (size_type k = 0; k <
isize; k++)
2355 if (i[k] <
v.size() && i[k]>=0){
2378template <
typename T>
2382 const size_type
size =
v.size();
2383 const size_type
absn = std::abs(
n);
2385 const auto msg = std::to_string(
absn) +
" elements requested from Take but input contains only " +
2386 std::to_string(
size) +
" elements.";
2387 throw std::runtime_error(
msg);
2391 for (size_type k = 0; k <
absn; k++)
2394 for (size_type k = 0; k <
absn; k++)
2419template <
typename T>
2423 const size_type
size =
v.size();
2424 const size_type
absn = std::abs(
n);
2444template <
typename T>
2452 if (
v.size() >
idxs.size())
2453 r.reserve(
v.size() -
idxs.size());
2457 for (
sz_t i = 0
u; i <
v.size(); ++i) {
2461 r.emplace_back(
v[i]);
2477template <
typename T>
2481 std::reverse(
r.begin(),
r.end());
2498template <
typename T>
2502 std::sort(
r.begin(),
r.end());
2523template <
typename T,
typename Compare>
2527 std::sort(
r.begin(),
r.end(), std::forward<Compare>(
c));
2547template <
typename T>
2551 std::stable_sort(
r.begin(),
r.end());
2583template <
typename T,
typename Compare>
2587 std::stable_sort(
r.begin(),
r.end(), std::forward<Compare>(
c));
2605 using size_type = std::size_t;
2610 for(size_type i=0; i<
size1; i++) {
2634template <
typename T1,
typename T2>
2659template <
typename T>
2663 const size_type s =
v.size();
2665 throw std::runtime_error(
"Cannot make unique combinations of size " + std::to_string(
n) +
2666 " from vector of size " + std::to_string(s) +
".");
2670 for(size_type k=0; k<s; k++)
2675 for (size_type
m = s -
n + 2;
m <= s; ++
m)
2678 size_type
factn = 1;
2679 for (size_type i = 2; i <=
n; ++i)
2688 for (size_type k = 0; k <
n; k++)
2705 for (
long j=i+1;
j<(long)
n;
j++)
2707 for (size_type k = 0; k <
n; k++)
2723template <
typename T>
2728 const auto size =
v.size();
2730 for(size_type i=0; i<
size; i++) {
2754template <
typename T>
2762 const auto size =
v1.size();
2765 for(size_type i=0; i<
size; i++) {
2767 r.emplace_back(
v1[i]);
2788template <
typename T>
2792 const size_type
size =
c.size();
2795 for (size_type i=0; i<
size; i++) {
2796 r.emplace_back(
c[i] != 0 ?
v1[i] :
v2[i]);
2816template <
typename T>
2820 const size_type
size =
c.size();
2823 for (size_type i=0; i<
size; i++) {
2824 r.emplace_back(
c[i] != 0 ?
v1[i] :
v2);
2844template <
typename T>
2848 const size_type
size =
c.size();
2851 for (size_type i=0; i<
size; i++) {
2852 r.emplace_back(
c[i] != 0 ?
v1 :
v2[i]);
2870template <
typename T>
2874 const size_type
size =
c.size();
2877 for (size_type i=0; i<
size; i++) {
2878 r.emplace_back(
c[i] != 0 ?
v1 :
v2);
2897 res.reserve(
v0.size() +
v1.size());
2898 std::copy(
v0.begin(),
v0.end(), std::back_inserter(res));
2899 std::copy(
v1.begin(),
v1.end(), std::back_inserter(res));
2909template <
typename T0,
typename T1 = T0,
typename Common_t = std::common_type_t<T0, T1>>
2912 static_assert(std::is_floating_point<T0>::value && std::is_floating_point<T1>::value,
2913 "DeltaPhi must be called with floating point values.");
2914 auto r = std::fmod(
v2 -
v1, 2.0 *
c);
2930template <
typename T0,
typename T1 = T0,
typename Common_t =
typename std::common_type_t<T0, T1>>
2934 const size_type
size =
v1.size();
2936 for (size_type i = 0; i <
size; i++) {
2937 r[i] = DeltaPhi(
v1[i],
v2[i],
c);
2948template <
typename T0,
typename T1 = T0,
typename Common_t =
typename std::common_type_t<T0, T1>>
2952 const size_type
size =
v1.size();
2954 for (size_type i = 0; i <
size; i++) {
2955 r[i] = DeltaPhi(
v1[i],
v2,
c);
2966template <
typename T0,
typename T1 = T0,
typename Common_t =
typename std::common_type_t<T0, T1>>
2970 const size_type
size =
v2.size();
2972 for (size_type i = 0; i <
size; i++) {
2973 r[i] = DeltaPhi(
v1,
v2[i],
c);
2985template <
typename T0,
typename T1 = T0,
typename T2 = T0,
typename T3 = T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3>>
2999template <
typename T0,
typename T1 = T0,
typename T2 = T0,
typename T3 = T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3>>
3012template <
typename T0,
typename T1 = T0,
typename T2 = T0,
typename T3 = T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3>>
3024template <
typename T0,
typename T1 =
T0,
typename T2 =
T0,
typename T3 =
T0,
typename T4 =
T0,
3025 typename T5 =
T0,
typename Common_t = std::common_type_t<T0, T1>>
3038 return std::atan2(
c,
d);
3046template <
typename T0,
typename T1 =
T0,
typename T2 =
T0,
typename T3 =
T0,
typename T4 =
T0,
3047 typename T5 =
T0,
typename T6 =
T0,
typename T7 =
T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3, T4, T5, T6, T7>>
3058 return (
mass1 + mass2);
3060 auto mm =
mass1 + std::sqrt(mass2*mass2 +
p2_sq);
3061 auto m2 = mm*mm -
p2_sq;
3063 return std::sqrt( m2 );
3065 return std::sqrt( -m2 );
3069 auto m2 = mm*mm -
p1_sq;
3071 return std::sqrt( m2 );
3073 return std::sqrt( -m2 );
3077 const auto m2_sq = mass2 * mass2;
3083 const auto cos_a = std::cos(
a);
3086 y = (
x + std::sin(
a) * std::sin(
a)) / (std::sqrt(
x + 1) +
cos_a);
3102template <
typename T0,
typename T1 =
T0,
typename T2 =
T0,
typename T3 =
T0,
typename T4 =
T0,
3103 typename T5 =
T0,
typename T6 =
T0,
typename T7 =
T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3, T4, T5, T6, T7>>
3108 std::size_t
size = px1.size();
3115 for (std::size_t i = 0
u; i <
size; ++i) {
3128template <
typename T0,
typename T1 =
T0,
typename T2 =
T0,
typename T3 =
T0,
typename T4 =
T0,
3129 typename T5 =
T0,
typename T6 =
T0,
typename T7 =
T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3, T4, T5, T6, T7>>
3134 std::size_t
size =
pt1.size();
3141 for (std::size_t i = 0
u; i <
size; ++i) {
3143 const auto x1 =
pt1[i] * std::cos(
phi1[i]);
3144 const auto y1 =
pt1[i] * std::sin(
phi1[i]);
3145 const auto z1 =
pt1[i] * std::sinh(
eta1[i]);
3147 const auto x2 =
pt2[i] * std::cos(
phi2[i]);
3148 const auto y2 =
pt2[i] * std::sin(
phi2[i]);
3149 const auto z2 =
pt2[i] * std::sinh(
eta2[i]);
3164template <
typename T0,
typename T1 = T0,
typename T2 = T0,
typename T3 = T0,
typename Common_t = std::common_type_t<T0, T1, T2, T3>>
3167 const std::size_t
size =
pt.size();
3176 for (std::size_t i = 0
u; i <
size; ++ i) {
3178 const auto x =
pt[i] * std::cos(phi[i]);
3180 const auto y =
pt[i] * std::sin(phi[i]);
3182 const auto z =
pt[i] * std::sinh(eta[i]);
3184 const auto e = std::sqrt(
x *
x +
y *
y + z * z + mass[i] * mass[i]);
3210template <
typename T,
typename...
Args_t>
3216 for (
auto i = 0
UL; i <
size; ++i) {
3217 ret.emplace_back(args[i]...);
3230template <
typename T>
3233 const auto size =
v.size();
3236 for (
auto i = 0
UL; i <
size; ++i) {
3237 ret.emplace_back(i);
3253 for (
auto i = 0
UL; i <
length; ++i) {
3254 ret.emplace_back(i);
3264 ret.reserve(begin < end ? end - begin : 0
u);
3265 for (
auto i = begin; i < end; ++i)
3286 throw std::runtime_error(
"Range: the stride must not be zero");
3289 float ret_cap = std::ceil(
static_cast<float>(end-begin) /
stride);
3298 for (
auto i = begin; i < end; i+=
stride)
3303 for (
auto i = begin; i > end; i+=
stride)
3315 constexpr bool mustConvert = std::is_same<char, T>::value || std::is_same<signed char, T>::value ||
3316 std::is_same<unsigned char, T>::value || std::is_same<wchar_t, T>::value ||
3317 std::is_same<char16_t, T>::value || std::is_same<char32_t, T>::value;
3318 using Print_t =
typename std::conditional<mustConvert, long long int, T>::type;
3320 auto size =
v.size();
3322 for (std::size_t i = 0; i <
size - 1; ++i) {
3331#if (_VECOPS_USE_EXTERN_TEMPLATES)
3333#define RVEC_EXTERN_UNARY_OPERATOR(T, OP) \
3334 extern template RVec<T> operator OP<T>(const RVec<T> &);
3336#define RVEC_EXTERN_BINARY_OPERATOR(T, OP) \
3337 extern template auto operator OP<T, T>(const T &x, const RVec<T> &v) \
3338 -> RVec<decltype(x OP v[0])>; \
3339 extern template auto operator OP<T, T>(const RVec<T> &v, const T &y) \
3340 -> RVec<decltype(v[0] OP y)>; \
3341 extern template auto operator OP<T, T>(const RVec<T> &v0, const RVec<T> &v1)\
3342 -> RVec<decltype(v0[0] OP v1[0])>;
3344#define RVEC_EXTERN_ASSIGN_OPERATOR(T, OP) \
3345 extern template RVec<T> &operator OP<T, T>(RVec<T> &, const T &); \
3346 extern template RVec<T> &operator OP<T, T>(RVec<T> &, const RVec<T> &);
3348#define RVEC_EXTERN_LOGICAL_OPERATOR(T, OP) \
3349 extern template RVec<int> operator OP<T, T>(const RVec<T> &, const T &); \
3350 extern template RVec<int> operator OP<T, T>(const T &, const RVec<T> &); \
3351 extern template RVec<int> operator OP<T, T>(const RVec<T> &, const RVec<T> &);
3353#define RVEC_EXTERN_FLOAT_TEMPLATE(T) \
3354 extern template class RVec<T>; \
3355 RVEC_EXTERN_UNARY_OPERATOR(T, +) \
3356 RVEC_EXTERN_UNARY_OPERATOR(T, -) \
3357 RVEC_EXTERN_UNARY_OPERATOR(T, !) \
3358 RVEC_EXTERN_BINARY_OPERATOR(T, +) \
3359 RVEC_EXTERN_BINARY_OPERATOR(T, -) \
3360 RVEC_EXTERN_BINARY_OPERATOR(T, *) \
3361 RVEC_EXTERN_BINARY_OPERATOR(T, /) \
3362 RVEC_EXTERN_ASSIGN_OPERATOR(T, +=) \
3363 RVEC_EXTERN_ASSIGN_OPERATOR(T, -=) \
3364 RVEC_EXTERN_ASSIGN_OPERATOR(T, *=) \
3365 RVEC_EXTERN_ASSIGN_OPERATOR(T, /=) \
3366 RVEC_EXTERN_LOGICAL_OPERATOR(T, <) \
3367 RVEC_EXTERN_LOGICAL_OPERATOR(T, >) \
3368 RVEC_EXTERN_LOGICAL_OPERATOR(T, ==) \
3369 RVEC_EXTERN_LOGICAL_OPERATOR(T, !=) \
3370 RVEC_EXTERN_LOGICAL_OPERATOR(T, <=) \
3371 RVEC_EXTERN_LOGICAL_OPERATOR(T, >=) \
3372 RVEC_EXTERN_LOGICAL_OPERATOR(T, &&) \
3373 RVEC_EXTERN_LOGICAL_OPERATOR(T, ||)
3375#define RVEC_EXTERN_INTEGER_TEMPLATE(T) \
3376 extern template class RVec<T>; \
3377 RVEC_EXTERN_UNARY_OPERATOR(T, +) \
3378 RVEC_EXTERN_UNARY_OPERATOR(T, -) \
3379 RVEC_EXTERN_UNARY_OPERATOR(T, ~) \
3380 RVEC_EXTERN_UNARY_OPERATOR(T, !) \
3381 RVEC_EXTERN_BINARY_OPERATOR(T, +) \
3382 RVEC_EXTERN_BINARY_OPERATOR(T, -) \
3383 RVEC_EXTERN_BINARY_OPERATOR(T, *) \
3384 RVEC_EXTERN_BINARY_OPERATOR(T, /) \
3385 RVEC_EXTERN_BINARY_OPERATOR(T, %) \
3386 RVEC_EXTERN_BINARY_OPERATOR(T, &) \
3387 RVEC_EXTERN_BINARY_OPERATOR(T, |) \
3388 RVEC_EXTERN_BINARY_OPERATOR(T, ^) \
3389 RVEC_EXTERN_ASSIGN_OPERATOR(T, +=) \
3390 RVEC_EXTERN_ASSIGN_OPERATOR(T, -=) \
3391 RVEC_EXTERN_ASSIGN_OPERATOR(T, *=) \
3392 RVEC_EXTERN_ASSIGN_OPERATOR(T, /=) \
3393 RVEC_EXTERN_ASSIGN_OPERATOR(T, %=) \
3394 RVEC_EXTERN_ASSIGN_OPERATOR(T, &=) \
3395 RVEC_EXTERN_ASSIGN_OPERATOR(T, |=) \
3396 RVEC_EXTERN_ASSIGN_OPERATOR(T, ^=) \
3397 RVEC_EXTERN_ASSIGN_OPERATOR(T, >>=) \
3398 RVEC_EXTERN_ASSIGN_OPERATOR(T, <<=) \
3399 RVEC_EXTERN_LOGICAL_OPERATOR(T, <) \
3400 RVEC_EXTERN_LOGICAL_OPERATOR(T, >) \
3401 RVEC_EXTERN_LOGICAL_OPERATOR(T, ==) \
3402 RVEC_EXTERN_LOGICAL_OPERATOR(T, !=) \
3403 RVEC_EXTERN_LOGICAL_OPERATOR(T, <=) \
3404 RVEC_EXTERN_LOGICAL_OPERATOR(T, >=) \
3405 RVEC_EXTERN_LOGICAL_OPERATOR(T, &&) \
3406 RVEC_EXTERN_LOGICAL_OPERATOR(T, ||)
3423#undef RVEC_EXTERN_UNARY_OPERATOR
3424#undef RVEC_EXTERN_BINARY_OPERATOR
3425#undef RVEC_EXTERN_ASSIGN_OPERATOR
3426#undef RVEC_EXTERN_LOGICAL_OPERATOR
3427#undef RVEC_EXTERN_INTEGER_TEMPLATE
3428#undef RVEC_EXTERN_FLOAT_TEMPLATE
3430#define RVEC_EXTERN_UNARY_FUNCTION(T, NAME, FUNC) \
3431 extern template RVec<PromoteType<T>> NAME(const RVec<T> &);
3433#define RVEC_EXTERN_STD_UNARY_FUNCTION(T, F) RVEC_EXTERN_UNARY_FUNCTION(T, F, std::F)
3435#define RVEC_EXTERN_BINARY_FUNCTION(T0, T1, NAME, FUNC) \
3436 extern template RVec<PromoteTypes<T0, T1>> NAME(const RVec<T0> &, const T1 &); \
3437 extern template RVec<PromoteTypes<T0, T1>> NAME(const T0 &, const RVec<T1> &); \
3438 extern template RVec<PromoteTypes<T0, T1>> NAME(const RVec<T0> &, const RVec<T1> &);
3440#define RVEC_EXTERN_STD_BINARY_FUNCTION(T, F) RVEC_EXTERN_BINARY_FUNCTION(T, T, F, std::F)
3442#define RVEC_EXTERN_STD_FUNCTIONS(T) \
3443 RVEC_EXTERN_STD_UNARY_FUNCTION(T, abs) \
3444 RVEC_EXTERN_STD_BINARY_FUNCTION(T, fdim) \
3445 RVEC_EXTERN_STD_BINARY_FUNCTION(T, fmod) \
3446 RVEC_EXTERN_STD_BINARY_FUNCTION(T, remainder) \
3447 RVEC_EXTERN_STD_UNARY_FUNCTION(T, exp) \
3448 RVEC_EXTERN_STD_UNARY_FUNCTION(T, exp2) \
3449 RVEC_EXTERN_STD_UNARY_FUNCTION(T, expm1) \
3450 RVEC_EXTERN_STD_UNARY_FUNCTION(T, log) \
3451 RVEC_EXTERN_STD_UNARY_FUNCTION(T, log10) \
3452 RVEC_EXTERN_STD_UNARY_FUNCTION(T, log2) \
3453 RVEC_EXTERN_STD_UNARY_FUNCTION(T, log1p) \
3454 RVEC_EXTERN_STD_BINARY_FUNCTION(T, pow) \
3455 RVEC_EXTERN_STD_UNARY_FUNCTION(T, sqrt) \
3456 RVEC_EXTERN_STD_UNARY_FUNCTION(T, cbrt) \
3457 RVEC_EXTERN_STD_BINARY_FUNCTION(T, hypot) \
3458 RVEC_EXTERN_STD_UNARY_FUNCTION(T, sin) \
3459 RVEC_EXTERN_STD_UNARY_FUNCTION(T, cos) \
3460 RVEC_EXTERN_STD_UNARY_FUNCTION(T, tan) \
3461 RVEC_EXTERN_STD_UNARY_FUNCTION(T, asin) \
3462 RVEC_EXTERN_STD_UNARY_FUNCTION(T, acos) \
3463 RVEC_EXTERN_STD_UNARY_FUNCTION(T, atan) \
3464 RVEC_EXTERN_STD_BINARY_FUNCTION(T, atan2) \
3465 RVEC_EXTERN_STD_UNARY_FUNCTION(T, sinh) \
3466 RVEC_EXTERN_STD_UNARY_FUNCTION(T, cosh) \
3467 RVEC_EXTERN_STD_UNARY_FUNCTION(T, tanh) \
3468 RVEC_EXTERN_STD_UNARY_FUNCTION(T, asinh) \
3469 RVEC_EXTERN_STD_UNARY_FUNCTION(T, acosh) \
3470 RVEC_EXTERN_STD_UNARY_FUNCTION(T, atanh) \
3471 RVEC_EXTERN_STD_UNARY_FUNCTION(T, floor) \
3472 RVEC_EXTERN_STD_UNARY_FUNCTION(T, ceil) \
3473 RVEC_EXTERN_STD_UNARY_FUNCTION(T, trunc) \
3474 RVEC_EXTERN_STD_UNARY_FUNCTION(T, round) \
3475 RVEC_EXTERN_STD_UNARY_FUNCTION(T, erf) \
3476 RVEC_EXTERN_STD_UNARY_FUNCTION(T, erfc) \
3477 RVEC_EXTERN_STD_UNARY_FUNCTION(T, lgamma) \
3478 RVEC_EXTERN_STD_UNARY_FUNCTION(T, tgamma) \
3482#undef RVEC_EXTERN_STD_UNARY_FUNCTION
3483#undef RVEC_EXTERN_STD_BINARY_FUNCTION
3484#undef RVEC_EXTERN_STD_UNARY_FUNCTIONS
3488#define RVEC_EXTERN_VDT_UNARY_FUNCTION(T, F) RVEC_EXTERN_UNARY_FUNCTION(T, F, vdt::F)
#define R__unlikely(expr)
#define R__RVEC_NODISCARD
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
TBuffer & operator<<(TBuffer &buf, const Tmpl *obj)
#define R__CLING_PTRCHECK(ONOFF)
static Double_t Product(const Double_t *x, const Float_t *y)
Product.
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Double_t Dot(const TGLVector3 &v1, const TGLVector3 &v2)
Int_t Compare(const void *item1, const void *item2)
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char x2
Option_t Option_t TPoint TPoint const char x1
Option_t Option_t TPoint TPoint const char y2
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Option_t Option_t TPoint TPoint const char y1
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void assign(size_type NumElts, const T &Elt)
typename SuperClass::size_type size_type
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
iterator insert(iterator I, T &&Elt)
void assign(std::initializer_list< T > IL)
void resize(size_type N, const T &NV)
void reserve(size_type N)
iterator insert(iterator I, ItTy From, ItTy To)
reference emplace_back(ArgTypes &&...Args)
void assign(in_iter in_start, in_iter in_end)
iterator insert(iterator I, const T &Elt)
iterator insert(iterator I, size_type NumToInsert, const T &Elt)
RVecImpl & operator=(const RVecImpl &RHS)
iterator erase(const_iterator CS, const_iterator CE)
typename SuperClass::reference reference
void append(size_type NumInputs, const T &Elt)
Append NumInputs copies of Elt to the end.
iterator erase(const_iterator CI)
RVecImpl & operator=(RVecImpl &&RHS)
void pop_back_n(size_type NumItems)
RVecImpl(const RVecImpl &)=delete
void append(std::initializer_list< T > IL)
void insert(iterator I, std::initializer_list< T > IL)
This is all the stuff common to all SmallVectors.
SmallVectorBase(void *FirstEl, size_t TotalCapacity)
static constexpr size_t SizeTypeMax()
The maximum value of the Size_T used.
Size_T fCapacity
Always >= -1. fCapacity == -1 indicates the RVec is in "memory adoption" mode.
bool Owns() const
If false, the RVec is in "memory adoption" mode, i.e. it is acting as a view on a memory buffer it do...
size_t capacity() const noexcept
void set_size(size_t N)
Set the array size to N, which the current array must have enough capacity for.
void grow(size_t MinSize=0)
Double the size of the allocated memory, guaranteeing space for at least one more element or MinSize ...
typename SuperClass::size_type size_type
typename SuperClass::reference reference
void push_back(const T &Elt)
static void uninitialized_move(It1 I, It1 E, It2 Dest)
Move the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into ...
SmallVectorTemplateBase(size_t Size)
static void uninitialized_copy(T1 *I, T1 *E, T2 *Dest, typename std::enable_if< std::is_same< typename std::remove_const< T1 >::type, T2 >::value >::type *=nullptr)
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into ...
static void destroy_range(T *, T *)
static void uninitialized_copy(It1 I, It1 E, It2 Dest)
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into ...
SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that...
void push_back(const T &Elt)
void grow(size_t MinSize=0)
Grow the allocated memory (without initializing new elements), doubling the size of the allocated mem...
static void uninitialized_move(It1 I, It1 E, It2 Dest)
Move the range [I, E) into the uninitialized memory starting with "Dest", constructing elements as ne...
SmallVectorTemplateBase(size_t Size)
static void destroy_range(T *S, T *E)
static void uninitialized_copy(It1 I, It1 E, It2 Dest)
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements as ne...
This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD.
size_type max_size() const noexcept
const_iterator cbegin() const noexcept
void grow_pod(size_t MinSize, size_t TSize)
ptrdiff_t difference_type
reverse_iterator rbegin() noexcept
const_iterator cend() const noexcept
const_reference back() const
void resetToSmall()
Put this vector in a state of being small.
iterator begin() noexcept
std::reverse_iterator< iterator > reverse_iterator
const T & const_reference
bool isSmall() const
Return true if this is a smallvector which has not had dynamic memory allocated for it.
const_reverse_iterator crend() const noexcept
const_iterator end() const noexcept
SmallVectorTemplateCommon(size_t Size)
const_reverse_iterator crbegin() const noexcept
pointer data() noexcept
Return a pointer to the vector's buffer, even if empty().
size_t capacity_in_bytes() const
reverse_iterator rend() noexcept
const_reverse_iterator rbegin() const noexcept
const_reference front() const
size_type size_in_bytes() const
std::reverse_iterator< const_iterator > const_reverse_iterator
const_iterator begin() const noexcept
const_pointer data() const noexcept
Return a pointer to the vector's buffer, even if empty().
void * getFirstEl() const
Find the address of the first element.
const_reverse_iterator rend() const noexcept
const_iterator begin() const
const_iterator end() const
RVecN(Detail::VecOps::RVecImpl< T > &&RHS)
reference operator[](size_type idx)
typename Internal::VecOps::SmallVectorTemplateCommon< T >::const_reference const_reference
RVecN operator[](const RVecN< V, M > &conds) const
RVecN(std::initializer_list< T > IL)
const_reference at(size_type pos) const
RVecN & operator=(Detail::VecOps::RVecImpl< T > &&RHS)
RVecN & operator=(RVecN &&RHS)
typename Internal::VecOps::SmallVectorTemplateCommon< T >::size_type size_type
value_type at(size_type pos, value_type fallback) const
No exception thrown. The user specifies the desired value in case the RVecN is shorter than pos.
RVecN & operator=(std::initializer_list< T > IL)
RVecN & operator=(const RVecN &RHS)
RVecN(const std::vector< T > &RHS)
RVecN(size_t Size, const T &Value)
reference at(size_type pos)
value_type at(size_type pos, value_type fallback)
No exception thrown. The user specifies the desired value in case the RVecN is shorter than pos.
typename Internal::VecOps::SmallVectorTemplateCommon< T >::reference reference
typename Internal::VecOps::SmallVectorTemplateCommon< T >::value_type value_type
const_reference operator[](size_type idx) const
A "std::vector"-like collection of values implementing handy operation to analyse them.
RVec(RVecN< T, N > &&RHS)
typename SuperClass::reference reference
RVec(const RVecN< T, N > &RHS)
RVec(size_t Size, const T &Value)
RVec & operator=(RVec &&RHS)
RVec operator[](const RVec< V > &conds) const
RVec(std::initializer_list< T > IL)
typename SuperClass::const_reference const_reference
RVec(const std::vector< T > &RHS)
typename SuperClass::size_type size_type
RVec(Detail::VecOps::RVecImpl< T > &&RHS)
typename SuperClass::value_type value_type
RVec & operator=(const RVec &RHS)
RVec< T > Reverse(const RVec< T > &v)
Return copy of reversed vector.
RVec< T > Intersect(const RVec< T > &v1, const RVec< T > &v2, bool v2_is_sorted=false)
Return the intersection of elements of two RVecs.
RVec< typename RVec< T >::size_type > Nonzero(const RVec< T > &v)
Return the indices of the elements which are not zero.
#define RVEC_UNARY_OPERATOR(OP)
#define RVEC_ASSIGNMENT_OPERATOR(OP)
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.
RVec< Common_t > Concatenate(const RVec< T0 > &v0, const RVec< T1 > &v1)
Return the concatenation of two RVecs.
Common_t InvariantMasses_PxPyPzM(const T0 &x1, const T1 &y1, const T2 &z1, const T3 &mass1, const T4 &x2, const T5 &y2, const T6 &z2, const T7 &mass2)
Return the invariant mass of two particles given x coordinate (px), y coordinate (py),...
T Sum(const RVec< T > &v, const T zero=T(0))
Sum elements of an RVec.
RVec< Common_t > InvariantMasses(const RVec< T0 > &pt1, const RVec< T1 > &eta1, const RVec< T2 > &phi1, const RVec< T3 > &mass1, const RVec< T4 > &pt2, const RVec< T5 > &eta2, const RVec< T6 > &phi2, const RVec< T7 > &mass2)
Return the invariant mass of two particles given the collections of the quantities transverse momentu...
RVec< T > Take(const RVec< T > &v, const RVec< typename RVec< T >::size_type > &i)
Return elements of a vector at given indices.
void swap(RVec< T > &lhs, RVec< T > &rhs)
RVec< T > Construct(const RVec< Args_t > &... args)
Build an RVec of objects starting from RVecs of input to their constructors.
#define RVEC_STD_BINARY_FUNCTION(F)
#define RVEC_BINARY_OPERATOR(OP)
RVec< T > 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.
size_t CapacityInBytes(const RVecN< T, N > &X)
#define RVEC_LOGICAL_OPERATOR(OP)
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.
#define RVEC_STD_UNARY_FUNCTION(F)
RVec< typename RVec< T >::size_type > Enumerate(const RVec< T > &v)
For any Rvec v produce another RVec with entries starting from 0, and incrementing by 1 until a N = v...
auto Map(Args &&... args)
Create new collection applying a callable to the elements of the input collection.
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.
auto Any(const RVec< T > &v) -> decltype(v[0]==true)
Return true if any of the elements equates to true, return false otherwise.
RVec< typename RVec< T >::size_type > Argsort(const RVec< T > &v)
Return an RVec of indices that sort the input RVec.
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...
RVec< T > StableSort(const RVec< T > &v)
Return copy of RVec with elements sorted in ascending order while keeping the order of equal elements...
RVec< T > Filter(const RVec< T > &v, F &&f)
Create a new collection with the elements passing the filter expressed by the predicate.
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...
bool IsSmall(const ROOT::VecOps::RVec< T > &v)
bool IsAdopting(const ROOT::VecOps::RVec< T > &v)
auto MapImpl(F &&f, RVecs &&... vs) -> RVec< decltype(f(vs[0]...))>
void ResetView(RVec< T > &v, T *addr, std::size_t sz)
An unsafe function to reset the buffer for which this RVec is acting as a view.
uint64_t NextPowerOf2(uint64_t A)
Return the next power of two (in 64-bits) that is strictly greater than A.
constexpr bool All(const bool *vals, std::size_t size)
std::size_t GetVectorsSize(const std::string &id, const RVec< T > &... vs)
void UninitializedValueConstruct(ForwardIt first, ForwardIt last)
auto MapFromTuple(Tuple_t &&t, std::index_sequence< Is... >) -> decltype(MapImpl(std::get< std::tuple_size< Tuple_t >::value - 1 >(t), std::get< Is >(t)...))
The size of the inline storage of an RVec.
Used to figure out the offset of the first element of an RVec.
Storage for the SmallVector elements.