Skip to content

C++20 concept implementations #116

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
dbrundu wants to merge 6 commits into
base: master
Choose a base branch
from
Draft

C++20 concept implementations #116

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
0e3f568
Implemented first concepts for random fill functions
Mar 14, 2025
f77079c
Implemented concepts for functor composition
dbrundu Jun 26, 2026
d7c9056
Implemented iterator concepts header
dbrundu Jun 26, 2026
dde8d64
Merge branch 'MultithreadCorner:master' into devel-concepts
dbrundu Jun 27, 2026
d1adbff
Implemented concepts for hydra Histograms
dbrundu Jun 27, 2026
f8e23bf
Implemented concepts for hydra containers
dbrundu Jun 27, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
129 changes: 70 additions & 59 deletions hydra/DenseHistogram.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,15 +44,17 @@
#include <type_traits>
#include <utility>
#include <array>
#include <hydra/detail/IteratorConcepts.h>
#include <concepts>


namespace hydra {

/**
* \ingroup histogram
*/
template< typename T, std::size_t N, typename BACKEND, typename = typename detail::dimensionality<N>::type,
typename = typename std::enable_if<std::is_arithmetic<T>::value, void>::type>
template< typename T, size_t N, typename BACKEND, typename = typename detail::dimensionality<N>::type>
requires (std::is_arithmetic<T>::value)
class DenseHistogram;

/**
Expand Down Expand Up @@ -107,7 +109,8 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
fContents.resize(fNBins +2);
}

template<typename Int, typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
DenseHistogram( std::array<Int, N> grid, std::array<double, N> const& lowerlimits, std::array<double, N> const& upperlimits):
fNBins(1)
{
Expand All @@ -121,7 +124,8 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
fContents.resize(fNBins +2 );
}

template<typename Int, typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
DenseHistogram( Int (&grid)[N], double (&lowerlimits)[N], double (&upperlimits)[N] ):
fNBins(1)
{
Expand Down Expand Up @@ -268,8 +272,8 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
return bin;
}

template<typename Int,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
inline size_t GetBin( Int (&bins)[N]){

size_t bin=0;
Expand All @@ -279,8 +283,8 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
return bin;
}

template<typename Int,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
inline size_t GetBin( std::array<Int,N> const& bins){

size_t bin=0;
Expand All @@ -300,15 +304,15 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
get_indexes(globalbin, bins);
}

template<typename Int,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
inline void GetIndexes(size_t globalbin, Int (&bins)[N]){

get_indexes(globalbin, bins);
}

template<typename Int,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
inline void GetIndexes(size_t globalbin, std::array<Int,N>& bins){

get_indexes(globalbin, bins);
Expand Down Expand Up @@ -338,8 +342,8 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
std::numeric_limits<double>::max();
}

template<typename Int,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
inline double GetBinContent( Int (&bins)[N]){

size_t bin=0;
Expand All @@ -351,8 +355,8 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
std::numeric_limits<double>::max();
}

template<typename Int,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
template<typename Int>
requires (std::integral<Int>)
inline double GetBinContent( std::array<Int, N> const& bins){

size_t bin=0;
Expand Down Expand Up @@ -412,15 +416,18 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens


template<size_t M=N>
inline typename std::enable_if< M==2, T >::type
requires (M==2)
inline T
Interpolate( std::array<size_t,2> const& point);

template<size_t M=N>
inline typename std::enable_if< M==3, T >::type
requires (M==3)
inline T
Interpolate( std::array<size_t,3> const& point);

template<size_t M=N>
inline typename std::enable_if< M==4, T >::type
requires (M==4)
inline T
Interpolate( std::array<size_t,4> const& point);

//stl range interface
Expand Down Expand Up @@ -467,16 +474,15 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
Fill(Iterator1 begin, Iterator1 end, Iterator2 wbegin);

template<typename Iterable>
inline typename std::enable_if< hydra::detail::is_iterable<Iterable>::value,
DenseHistogram<T,N, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional>&>::type
requires (hydra::detail::Iterable<Iterable>)
inline DenseHistogram<T,N, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional>&
Fill(Iterable& container){
return this->Fill( container.begin(), container.end());
}

template<typename Iterable1, typename Iterable2>
inline typename std::enable_if< hydra::detail::is_iterable<Iterable1>::value
&& hydra::detail::is_iterable<Iterable2>::value,
DenseHistogram<T,N, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional>& >::type
requires (hydra::detail::Iterable<Iterable1> && hydra::detail::Iterable<Iterable2>)
inline DenseHistogram<T,N, hydra::detail::BackendPolicy<BACKEND>, detail::multidimensional>&
Fill(Iterable1& container, Iterable2& wbegin){
return this->Fill( container.begin(), container.end(), wbegin.begin());
}
Expand All @@ -496,11 +502,13 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
//k = i_1*(dim_2*...*dim_n) + i_2*(dim_3*...*dim_n) + ... + i_{n-1}*dim_n + i_n

template<typename Int,size_t I>
typename hydra::thrust::detail::enable_if< (I== N) && std::is_integral<Int>::value, void>::type
requires ((I== N) && std::integral<Int>)
void
get_global_bin(const Int (&)[N], size_t&){ }

template<typename Int,size_t I=0>
typename hydra::thrust::detail::enable_if< (I< N) && std::is_integral<Int>::value, void>::type
requires ((I< N) && std::integral<Int>)
void
get_global_bin(const Int (&indexes)[N], size_t& index)
{
size_t prod =1;
Expand All @@ -512,11 +520,13 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
}

template<typename Int,size_t I>
typename hydra::thrust::detail::enable_if< (I== N) && std::is_integral<Int>::value, void>::type
requires ((I== N) && std::integral<Int>)
void
get_global_bin( std::array<Int,N> const& , size_t&){ }

template<typename Int,size_t I=0>
typename hydra::thrust::detail::enable_if< (I< N) && std::is_integral<Int>::value, void>::type
requires ((I< N) && std::integral<Int>)
void
get_global_bin( std::array<Int,N> const& indexes, size_t& index)
{
size_t prod =1;
Expand All @@ -538,12 +548,14 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
// multiply std::array elements
//----------------------------------------
template<size_t I>
typename std::enable_if< (I==N), void >::type
requires ((I==N))
void
multiply( std::array<size_t, N> const&, size_t& )
{ }

template<size_t I=0>
typename std::enable_if< (I<N), void >::type
requires ((I<N))
void
multiply( std::array<size_t, N> const& obj, size_t& result )
{
result = I==0? 1.0: result;
Expand All @@ -555,12 +567,14 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
// multiply static array elements
//----------------------------------------
template< size_t I>
typename std::enable_if< (I==N), void >::type
requires ((I==N))
void
multiply( size_t (&)[N] , size_t& )
{ }

template<size_t I=0>
typename std::enable_if< (I<N), void >::type
requires ((I<N))
void
multiply( size_t (&obj)[N], size_t& result )
{
result = I==0? 1.0: result;
Expand All @@ -573,16 +587,16 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
// std::array version
//-------------------------
//end of recursion
template<typename Int, size_t I,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
typename std::enable_if< (I==N), void >::type
template<typename Int, size_t I>
requires (std::integral<Int> && (I==N))
void
get_indexes(size_t , std::array<Int,N>& )
{}

//begin of the recursion
template<typename Int, size_t I=0,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
typename std::enable_if< (I<N), void >::type
template<typename Int, size_t I=0>
requires (std::integral<Int> && (I<N))
void
get_indexes(size_t index, std::array<Int,N>& indexes)
{
size_t factor = 1;
Expand All @@ -596,16 +610,16 @@ class DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimens
// static array version
//-------------------------
//end of recursion
template<typename Int, size_t I,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
typename std::enable_if< (I==N), void >::type
template<typename Int, size_t I>
requires (std::integral<Int> && (I==N))
void
get_indexes(size_t, Int (&)[N])
{}

//begin of the recursion
template<typename Int, size_t I=0,
typename = typename std::enable_if<std::is_integral<Int>::value, void>::type>
typename std::enable_if< (I<N), void >::type
template<typename Int, size_t I=0>
requires (std::integral<Int> && (I<N))
void
get_indexes(size_t index, Int (&indexes)[N] )
{
size_t factor = 1;
Expand Down Expand Up @@ -827,16 +841,15 @@ class DenseHistogram<T, 1, hydra::detail::BackendPolicy<BACKEND>, detail::uni
Fill(Iterator1 begin, Iterator1 end, Iterator2 wbegin);

template<typename Iterable>
inline typename std::enable_if< hydra::detail::is_iterable<Iterable>::value,
DenseHistogram<T,1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional>& >::type
requires (hydra::detail::Iterable<Iterable>)
inline DenseHistogram<T,1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional>&
Fill(Iterable&& container){
return this->Fill( std::forward<Iterable>(container).begin(), std::forward<Iterable>(container).end());
}

template<typename Iterable1, typename Iterable2>
inline typename std::enable_if< hydra::detail::is_iterable<Iterable1>::value
&& hydra::detail::is_iterable<Iterable2>::value,
DenseHistogram<T,1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional>& >::type
requires (hydra::detail::Iterable<Iterable1> && hydra::detail::Iterable<Iterable2>)
inline DenseHistogram<T,1, hydra::detail::BackendPolicy<BACKEND>, detail::unidimensional>&
Fill(Iterable1&& container, Iterable2&& wbegin){
return this->Fill( container.begin(), container.end(), wbegin.begin());
}
Expand Down Expand Up @@ -893,8 +906,8 @@ make_dense_histogram( detail::BackendPolicy<BACKEND> backend, std::array<size_t,
* @return
*/
template<typename T, size_t N , hydra::detail::Backend BACKEND, typename Iterable >
inline typename std::enable_if< hydra::detail::is_iterable<Iterable>::value,
DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional>>::type
requires (hydra::detail::Iterable<Iterable>)
inline DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional>
make_dense_histogram( detail::BackendPolicy<BACKEND> backend, std::array<size_t, N> const& grid,
std::array<double, N> const& lowerlimits, std::array<double, N> const& upperlimits, Iterable&& data);

Expand All @@ -911,9 +924,8 @@ make_dense_histogram( detail::BackendPolicy<BACKEND> backend, std::array<size_t,
* @return
*/
template<typename T, size_t N , hydra::detail::Backend BACKEND, typename Iterable1, typename Iterable2 >
inline typename std::enable_if< hydra::detail::is_iterable<Iterable1>::value &&
hydra::detail::is_iterable<Iterable2>::value,
DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional>>::type
requires (hydra::detail::Iterable<Iterable1> && hydra::detail::Iterable<Iterable2>)
inline DenseHistogram< T, N, detail::BackendPolicy<BACKEND>, detail::multidimensional>
make_dense_histogram( detail::BackendPolicy<BACKEND> backend, std::array<size_t, N> const& grid,
std::array<double, N> const& lowerlimits, std::array<double, N> const& upperlimits,
Iterable1&& data, Iterable2&& weight);
Expand Down Expand Up @@ -967,8 +979,8 @@ make_dense_histogram( detail::BackendPolicy<BACKEND> backend, size_t nbins,
* @return
*/
template<typename T, hydra::detail::Backend BACKEND, typename Iterable>
inline typename std::enable_if< hydra::detail::is_iterable<Iterable>::value,
DenseHistogram< T, 1, detail::BackendPolicy<BACKEND>, detail::unidimensional>>::type
requires (hydra::detail::Iterable<Iterable>)
inline DenseHistogram< T, 1, detail::BackendPolicy<BACKEND>, detail::unidimensional>
make_dense_histogram( detail::BackendPolicy<BACKEND> backend, size_t nbins,
double lowerlimits, double upperlimits, Iterable&& data);

Expand All @@ -985,9 +997,8 @@ make_dense_histogram( detail::BackendPolicy<BACKEND> backend, size_t nbins,
* @return
*/
template<typename T, hydra::detail::Backend BACKEND, typename Iterable1, typename Iterable2>
inline typename std::enable_if< hydra::detail::is_iterable<Iterable1>::value&&
hydra::detail::is_iterable<Iterable2>::value,
DenseHistogram< T, 1, detail::BackendPolicy<BACKEND>, detail::unidimensional>>::type
requires (hydra::detail::Iterable<Iterable1>&& hydra::detail::Iterable<Iterable2>)
inline DenseHistogram< T, 1, detail::BackendPolicy<BACKEND>, detail::unidimensional>
make_dense_histogram( detail::BackendPolicy<BACKEND> backend, size_t nbins,
double lowerlimits, double upperlimits, Iterable1&& data, Iterable2&& weight);

Expand Down
Loading