TableUtils Namespace Reference

Classes
struct	MultiColumnTable
struct	Range
struct	Range2D
struct	StatTable

Typedefs
using	SummandDefinition = std::pair< std::size_t, int >
using	RatioDefinition = std::pair< std::vector< SummandDefinition >, std::vector< SummandDefinition > >

Functions
template<class T_Stream , typename T_Counter >
T_Stream &	dumpTable (T_Stream &out, Range< T_Counter > counter, const Range< std::string > &label, const std::string &label_prefix, const std::size_t column_width, const std::size_t min_label_width, const bool dump_footer, const bool separate_last_row, const unsigned int precision)
template<class T_Stream , typename T_Counter >
T_Stream &	dumpTable (T_Stream &out, Range2D< T_Counter > counter, const Range< std::string > &row_label, const Range< std::string > &column_label, const std::string &top_left_label, const std::string &label_prefix, const std::size_t column_width, const std::size_t min_label_width, const bool dump_header, const bool dump_footer, const bool separate_last_row, const std::vector< unsigned int > &precision)
template<typename T_index , class T_string >
std::vector< std::string >	makeLabelVector (T_index n_entries, std::initializer_list< std::pair< T_index, T_string > > a_list)
template<class T_Collection >
std::size_t	maxLabelWidth (const T_Collection &col)
constexpr std::size_t	categoryStride ([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::size_t n_counter)
constexpr std::size_t	subCategoryStride ([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::size_t n_counter)
constexpr std::size_t	counterStride ([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::size_t n_counter)
template<typename T_Output , typename T_Input , const std::size_t N>
std::vector< T_Output >	createCounterArrayWithProjections (const std::size_t categories, const std::size_t sub_categories, const std::vector< std::array< T_Input, N > > &input_counts)
template<typename T >
RatioDefinition	defineSimpleRatio (T numerator, T denominator)
template<typename T >
std::tuple< std::string, RatioDefinition >	defineSimpleRatio (std::string &&name, T numerator, T denominator)
template<typename T >
SummandDefinition	defineSummand (T counter_idx, int multiplier)
std::size_t	computeSum (const std::vector< SummandDefinition > &sum_def, std::size_t eta_offset, std::size_t row_stride, std::size_t seed_i, const std::vector< std::size_t > &stat)
float	computeRatio (std::size_t numerator, std::size_t denominator)
float	computeRatio (const RatioDefinition &ratio_def, std::size_t eta_offset, std::size_t row_stride, std::size_t seed_i, const std::vector< std::size_t > &stat)
std::tuple< std::string, RatioDefinition >	makeRatioDefinition (std::string &&name, std::vector< SummandDefinition > &&numerator, std::vector< SummandDefinition > &&denominator)
std::tuple< std::vector< std::string >, std::vector< RatioDefinition > >	splitRatioDefinitionsAndLabels (std::initializer_list< std::tuple< std::string, RatioDefinition > > a_ratio_list)
constexpr std::size_t	categoryStride ([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::vector< RatioDefinition > &ratio_def)
std::size_t	subCategoryStride ([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::vector< RatioDefinition > &ratio_def)
constexpr std::size_t	ratioStride ([[maybe_unused]] const std::size_t categories, [[maybe_unused]] const std::size_t sub_categories, [[maybe_unused]] const std::vector< RatioDefinition > &ratio_def)
std::vector< float >	computeRatios (const std::vector< RatioDefinition > &ratio_def, const std::size_t categories, const std::size_t sub_categories, const std::vector< std::size_t > &counter)
std::string	makeBinLabel (const std::string &variable_name, const std::vector< float > &bins, std::size_t bin_i, bool abs_value=false, int precision=1)
std::string	makeEtaBinLabel (const std::vector< float > &eta_bins, std::size_t eta_bin_i, bool abs_eta=false)

Typedef Documentation

RatioDefinition

using TableUtils::RatioDefinition = typedef std::pair< std::vector< SummandDefinition >, std::vector< SummandDefinition > >

Definition at line 375 of file TableUtils.h.

SummandDefinition

using TableUtils::SummandDefinition = typedef std::pair<std::size_t, int>

Definition at line 374 of file TableUtils.h.

Function Documentation

categoryStride() [1/2]

constexpr std::size_t TableUtils::categoryStride ( [[maybe_unused] ] const std::size_t  categories, [[maybe_unused] ] const std::size_t  sub_categories, [[maybe_unused] ] const std::size_t  n_counter  )

inlineconstexpr

Definition at line 297 of file TableUtils.h.

                                                                                           {
      return 1;
   }

categoryStride() [2/2]

constexpr std::size_t TableUtils::categoryStride ( [[maybe_unused] ] const std::size_t  categories, [[maybe_unused] ] const std::size_t  sub_categories, [[maybe_unused] ] const std::vector< RatioDefinition > &  ratio_def  )

inlineconstexpr

Definition at line 461 of file TableUtils.h.

                                                                                                             {
      return 1;
   }

computeRatio() [1/2]

float TableUtils::computeRatio ( const RatioDefinition &  ratio_def, std::size_t  eta_offset, std::size_t  row_stride, std::size_t  seed_i, const std::vector< std::size_t > &  stat  )

inline

Definition at line 422 of file TableUtils.h.

                                                           {
      std::size_t numerator=computeSum(ratio_def.first, eta_offset, row_stride, seed_i, stat);
      std::size_t denominator=!ratio_def.second.empty()
         ? computeSum(ratio_def.second, eta_offset, row_stride, seed_i, stat)
         : 1;
      return computeRatio(numerator,denominator);
   }

computeRatio() [2/2]

float TableUtils::computeRatio ( std::size_t  numerator, std::size_t  denominator  )

inline

Definition at line 412 of file TableUtils.h.

                                                                         {
      return numerator!=0 ? static_cast<float>(numerator/static_cast<double>(denominator)) : 0.f;
   }

computeRatios()

std::vector< float > TableUtils::computeRatios	(	const std::vector< RatioDefinition > &	ratio_def,
		const std::size_t	categories,
		const std::size_t	sub_categories,
		const std::vector< std::size_t > &	counter
	)

Definition at line 21 of file TableUtils.cxx.

   {
       std::vector<float> ratio;
       if (counter.size() % (categories*sub_categories) ) {
          std::stringstream msg;
          msg << "Category and sub category dimensions " << categories << " * " << sub_categories
              << " not a common factor of the input counter vector "
              << counter.size();
          throw std::logic_error(msg.str());
       }
       std::size_t n_counter = counter.size() / (categories*sub_categories);
       ratio.resize( categories * ratio_def.size() * sub_categories);
 
       std::size_t input_counter_stride=categories;
       std::size_t input_sub_category_stride = categories * n_counter;
       std::size_t ratio_stride = categories;
       std::size_t ratio_sub_category_stride = ratio_stride * ratio_def.size();
 
       for (std::size_t sub_category_i=0; sub_category_i < sub_categories; ++sub_category_i) {
          for (std::size_t ratio_i=0; ratio_i<ratio_def.size(); ++ratio_i) {
             for (std::size_t category_i=0; category_i<categories; ++category_i) {
                std::size_t ratio_dest_idx = sub_category_i * ratio_sub_category_stride + ratio_stride * ratio_i + category_i;
                assert(ratio_dest_idx < ratio.size());
                assert( sub_category_i * input_sub_category_stride < counter.size() );
                assert( sub_category_i * input_sub_category_stride + n_counter * input_counter_stride <= counter.size() );
                ratio[ratio_dest_idx] = computeRatio( ratio_def.at(ratio_i),
                                                      sub_category_i * input_sub_category_stride,
                                                      input_counter_stride,
                                                      category_i,
                                                      counter);
             }
          }
       }
       return ratio;
   }

computeSum()

std::size_t TableUtils::computeSum	(	const std::vector< SummandDefinition > &	sum_def,
		std::size_t	eta_offset,
		std::size_t	row_stride,
		std::size_t	seed_i,
		const std::vector< std::size_t > &	stat
	)

Definition at line 8 of file TableUtils.cxx.

                                                                    {
      std::size_t sum=0;
      for (const SummandDefinition &summand : sum_def ) {
         assert( eta_offset + row_stride * summand.first + seed_i < stat.size() );
         sum += stat[eta_offset + row_stride * summand.first + seed_i ] * summand.second;
      }
      return sum;
   }

counterStride()

constexpr std::size_t TableUtils::counterStride ( [[maybe_unused] ] const std::size_t  categories, [[maybe_unused] ] const std::size_t  sub_categories, [[maybe_unused] ] const std::size_t  n_counter  )

inlineconstexpr

Definition at line 307 of file TableUtils.h.

                                                                                          {
      return (categories+1);
   }

createCounterArrayWithProjections()

template<typename T_Output , typename T_Input , const std::size_t N>

std::vector<T_Output> TableUtils::createCounterArrayWithProjections	(	const std::size_t	categories,
		const std::size_t	sub_categories,
		const std::vector< std::array< T_Input, N > > &	input_counts
	)

Definition at line 320 of file TableUtils.h.

                                                                                                                   {
      if (categories*sub_categories!= input_counts.size()) {
         std::stringstream msg;
         msg << "Category dimensions (" << categories << " * " << sub_categories << "="
             << (categories * sub_categories) << ") and input counter container size "
             << input_counts.size() << " do not match.";
         throw std::logic_error(msg.str());
      }
      std::vector<T_Output> output_counts;
      output_counts.resize((categories+1) * (sub_categories+1) * N);
      const std::size_t sub_category_stride = subCategoryStride(categories, sub_categories, N);
      const std::size_t counter_stride      = counterStride(categories, sub_categories, N);
      const std::size_t category_stride     = categoryStride(categories, sub_categories, N);
      // project seeds
      for (std::size_t sub_category_i=0;
           sub_category_i < sub_categories;
           ++sub_category_i) {
         for (std::size_t category_i=0; category_i<categories; ++category_i) {
            std::size_t src_idx       = category_i     * sub_categories      + sub_category_i;
            std::size_t dest_idx_base = sub_category_i * sub_category_stride + 0 * counter_stride;
            std::size_t dest_idx_project_categories_base = dest_idx_base;
            dest_idx_base += category_i * category_stride;
            dest_idx_project_categories_base += categories * category_stride;
 
            for (std::size_t counter_i=0; counter_i<N; ++counter_i) {
               std::size_t dest_idx=dest_idx_base + counter_i * counter_stride;
               assert( src_idx < input_counts.size() && counter_i < input_counts[src_idx].size());
               assert( dest_idx < output_counts.size());
               output_counts[dest_idx] = input_counts[src_idx][counter_i];
               assert( dest_idx_project_categories_base + counter_i * counter_stride < output_counts.size());
               output_counts[dest_idx_project_categories_base + counter_i * counter_stride] += output_counts[dest_idx];
            }
         }
      }
      // project eta bins
      for (std::size_t category_i=0; category_i<=categories; ++category_i) {
         for (std::size_t counter_i=0; counter_i<N; ++counter_i) {
            std::size_t dest_idx_base  = 0 * sub_category_stride + counter_i * counter_stride + category_i;
            std::size_t dest_idx_project_sub_categories = sub_categories * sub_category_stride + dest_idx_base;
            assert( dest_idx_project_sub_categories < output_counts.size() );
            for (std::size_t sub_category_i=0;
                 sub_category_i<sub_categories;
                 ++sub_category_i) {
               std::size_t sub_category_idx = dest_idx_base + sub_category_i * sub_category_stride;
               assert( sub_category_idx < output_counts.size() );
               output_counts[dest_idx_project_sub_categories] += output_counts[sub_category_idx];
            }
         }
      }
      return output_counts;
   }

defineSimpleRatio() [1/2]

template<typename T >

std::tuple< std::string, RatioDefinition > TableUtils::defineSimpleRatio ( std::string &&  name, T  numerator, T  denominator  )

inline

Definition at line 390 of file TableUtils.h.

                                                                   {
      return std::make_pair( std::move(name), defineSimpleRatio(numerator, denominator) );
   }

defineSimpleRatio() [2/2]

template<typename T >

RatioDefinition TableUtils::defineSimpleRatio ( T  numerator, T  denominator  )

inline

Definition at line 382 of file TableUtils.h.

                                                 {
      return std::make_pair( std::vector< SummandDefinition > { std::make_pair(static_cast<std::size_t>(numerator),1)},
                             std::vector< SummandDefinition > { std::make_pair(static_cast<std::size_t>(denominator),1)});
   }

defineSummand()

template<typename T >

SummandDefinition TableUtils::defineSummand ( T  counter_idx, int  multiplier  )

inline

Definition at line 400 of file TableUtils.h.

                                                                         {
      return std::make_pair(static_cast<std::size_t>(counter_idx), multiplier) ;
   }

dumpTable() [1/2]

template<class T_Stream , typename T_Counter >

T_Stream& TableUtils::dumpTable	(	T_Stream &	out,
		Range2D< T_Counter >	counter,
		const Range< std::string > &	row_label,
		const Range< std::string > &	column_label,
		const std::string &	top_left_label,
		const std::string &	label_prefix,
		const std::size_t	column_width,
		const std::size_t	min_label_width,
		const bool	dump_header,
		const bool	dump_footer,
		const bool	separate_last_row,
		const std::vector< unsigned int > &	precision
	)

Definition at line 151 of file TableUtils.h.

                                                                 {
      if (counter && row_label && column_label
          && counter.equalSize(row_label)
          && counter.nColumns() == column_label.size()) {
         std::size_t max_size =std::max(top_left_label.size(), static_cast<std::size_t>(min_label_width));
         for (const std::string &name : row_label ) {
            max_size = std::max(max_size, name.size() + label_prefix.size());
         }
         std::size_t the_width = column_width;
         for (const std::string &name : column_label ) {
            the_width = std::max(the_width, name.size());
         }
         std::size_t total_size =max_size+2*2;
         for (std::size_t column_i=0; column_i<column_label.size(); ++column_i) {
            total_size += the_width + 3;
         }
         std::string line(total_size, '-');
         std::size_t pos=0;
         line[pos]='|';
         pos += max_size+3;
         for (std::size_t column_i=0; column_i<column_label.size(); ++column_i) {
            line[pos]='|';
            pos += the_width + 3;
         }
         line[line.size()-1]='|';
         if (dump_header) {
            out << line << std::endl << "| " << std::setw(max_size) << top_left_label << " |" << std::left;
            for (const std::string &header : column_label ) {
               out << " " << std::setw(the_width) << header << " |";
            }
            out << std::right << std::endl;
         }
         out << line << std::endl;
         std::size_t idx=0;
         std::string empty;
         auto default_precision = out.precision();
         for (const Range<T_Counter> &a_row : counter) {
            if (separate_last_row && idx+1 == row_label.size()) {
               out << line << std::endl;
            }
            assert( idx < row_label.size());
            out << "| " << (label_prefix.empty() ? std::left : std::right)
                << std::setw(label_prefix.size()) << ( idx==0 ? label_prefix : empty)
                << std::setw(max_size-label_prefix.size()) << row_label[idx] << std::right << " |";
            unsigned int col_i=0;
            for (const T_Counter &a : a_row) {
               out << " "
                   << std::setprecision( (col_i < precision.size()
                                          && precision[col_i] != std::numeric_limits<unsigned int>::max())
                                         ? precision[col_i]
                                         : default_precision)
                   << std::setw(the_width) << a << " |";
               ++col_i;
            }
            out << std::endl;
            ++idx;
         }
         out << std::setprecision(default_precision);
         if (dump_footer) {
            out << line;
         }
      }
      return out;
   }

dumpTable() [2/2]

template<class T_Stream , typename T_Counter >

T_Stream& TableUtils::dumpTable	(	T_Stream &	out,
		Range< T_Counter >	counter,
		const Range< std::string > &	label,
		const std::string &	label_prefix,
		const std::size_t	column_width,
		const std::size_t	min_label_width,
		const bool	dump_footer,
		const bool	separate_last_row,
		const unsigned int	precision
	)

Definition at line 103 of file TableUtils.h.

                                                     {
      if (counter && label && counter.equalSize(label)) {
         std::size_t max_size =min_label_width;
         for (const std::string &name : label ) {
            max_size = std::max(max_size, name.size());
         }
         const std::size_t total_size =max_size+3+2*2+column_width;
         std::string line(total_size, '-');
         std::array<std::size_t,3> vertical_line_pos{0u, max_size+3, line.size()-1};
         for (std::size_t pos : vertical_line_pos) {
            line[pos]='|';
         }
         out << line << std::endl;
         std::size_t idx=0;
         std::string empty;
         auto default_precision = out.precision();
         for (const T_Counter &a : counter) {
            if (separate_last_row && idx+1 == label.size()) {
               out << line << std::endl;
            }
            assert( idx < label.size());
            out << "| " << (label_prefix.empty() ? std::left : std::right)
                << std::setw(label_prefix.size()) << ( idx==0 ? label_prefix : empty)
                << std::setw(max_size-label_prefix.size()) << label[idx] << std::right
                << std::setprecision( precision != std::numeric_limits<unsigned int>::max() ? precision : default_precision)
                << " | " << std::setw(column_width) << a << " |" << std::endl;
            ++idx;
         }
         out << std::setprecision(default_precision);
         if (dump_footer) {
            out << line << std::endl;
         }
      }
      return out;
   }

makeBinLabel()

std::string TableUtils::makeBinLabel ( const std::string &  variable_name, const std::vector< float > &  bins, std::size_t  bin_i, bool  abs_value = false, int  precision = 1  )

inline

Definition at line 483 of file TableUtils.h.

                                                    {
     std::stringstream range_label;
     range_label << std::fixed << std::setprecision(precision);
     if (bin_i==bins.size()+1) {
         range_label << " All " << variable_name;
     }
     else {
         if (bin_i==0) {
            std::stringstream value_str;
            value_str << std::fixed << std::setprecision(precision) << 0.;
            range_label << std::setw(4) <<  (abs_value ? value_str.str().c_str() : "-inf") << "-";
         }
         else {
           range_label << std::setw(4) << bins.at(bin_i-1) <<"-";
         }
         if (bin_i>=bins.size()) {
           range_label << std::setw(4) << "+inf";
         }
         else {
           range_label << std::setw(4) << bins.at(bin_i);
         }
     }
     return range_label.str();
   }

makeEtaBinLabel()

std::string TableUtils::makeEtaBinLabel ( const std::vector< float > &  eta_bins, std::size_t  eta_bin_i, bool  abs_eta = false  )

inline

Definition at line 512 of file TableUtils.h.

                                                       {
      return TableUtils::makeBinLabel("eta",eta_bins, eta_bin_i,abs_eta, 1);
   }

makeLabelVector()

template<typename T_index , class T_string >

std::vector<std::string> TableUtils::makeLabelVector	(	T_index	n_entries,
		std::initializer_list< std::pair< T_index, T_string > >	a_list
	)

Definition at line 273 of file TableUtils.h.

   {
      std::vector<std::string> labels;
      labels.resize( n_entries );
      if (a_list.size() != n_entries) {
         throw std::logic_error("Expected number of entries and elements in the initializer lists do not match.");
      }
      for ( auto elm : a_list) {
         labels.at(elm.first) = std::move(elm.second);
      }
      return labels;
   }

makeRatioDefinition()

std::tuple< std::string, RatioDefinition> TableUtils::makeRatioDefinition ( std::string &&  name, std::vector< SummandDefinition > &&  numerator, std::vector< SummandDefinition > &&  denominator  )

inline

Definition at line 436 of file TableUtils.h.

                                                                                                                     {
      return std::make_tuple(std::move(name),
                             std::make_pair(std::move(numerator),
                                            std::move(denominator)));
   }

maxLabelWidth()

template<class T_Collection >

std::size_t TableUtils::maxLabelWidth

(

const T_Collection &

col

)

Definition at line 288 of file TableUtils.h.

                                                     {
      std::size_t max_width=0u;
      for (const auto &elm : col ) {
         max_width = std::max( max_width, elm.size());
      }
      return max_width;
   }

ratioStride()

constexpr std::size_t TableUtils::ratioStride ( [[maybe_unused] ] const std::size_t  categories, [[maybe_unused] ] const std::size_t  sub_categories, [[maybe_unused] ] const std::vector< RatioDefinition > &  ratio_def  )

inlineconstexpr

Definition at line 471 of file TableUtils.h.

                                                                                                           {
      return (categories);
   }

splitRatioDefinitionsAndLabels()

std::tuple<std::vector<std::string>, std::vector<RatioDefinition> > TableUtils::splitRatioDefinitionsAndLabels ( std::initializer_list< std::tuple< std::string, RatioDefinition > >  a_ratio_list )

inline

Definition at line 446 of file TableUtils.h.

   {
        std::tuple< std::vector<std::string>, std::vector<RatioDefinition> > splitted;
        std::get<0>(splitted).reserve( a_ratio_list.size() );
        for ( auto a_ratio : a_ratio_list) {
            std::get<0>(splitted).emplace_back( std::move(std::get<0>(a_ratio)) );
        }
        std::get<1>(splitted).reserve( a_ratio_list.size() );
        for ( auto a_ratio : a_ratio_list) {
            std::get<1>(splitted).emplace_back( std::move(std::get<1>(a_ratio)) );
        }
        return splitted;
   }

subCategoryStride() [1/2]

constexpr std::size_t TableUtils::subCategoryStride ( [[maybe_unused] ] const std::size_t  categories, [[maybe_unused] ] const std::size_t  sub_categories, [[maybe_unused] ] const std::size_t  n_counter  )

inlineconstexpr

Definition at line 302 of file TableUtils.h.

                                                                                              {
      return (categories+1) * n_counter;
   }

subCategoryStride() [2/2]

std::size_t TableUtils::subCategoryStride ( [[maybe_unused] ] const std::size_t  categories, [[maybe_unused] ] const std::size_t  sub_categories, [[maybe_unused] ] const std::vector< RatioDefinition > &  ratio_def  )

inline

Definition at line 466 of file TableUtils.h.

                                                                                                      {
      return (categories) * ratio_def.size();
   }