TableUtils.h File Reference

#include <array>
#include <string>
#include <cassert>
#include <iomanip>
#include <ostream>
#include <stdexcept>
#include <vector>
#include <utility>
#include <limits>

Include dependency graph for TableUtils.h:

Go to the source code of this file.

Classes
struct	TableUtils::Range< T >
struct	TableUtils::Range< T >::const_iterator
struct	TableUtils::Range2D< T >
struct	TableUtils::Range2D< T >::const_iterator
struct	TableUtils::StatTable< T >
struct	TableUtils::MultiColumnTable< T >

Namespaces
	TableUtils

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

Functions
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)
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)
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)
template<class T_Collection >
std::size_t	TableUtils::maxLabelWidth (const T_Collection &col)
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)
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)
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)
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)
template<typename T >
RatioDefinition	TableUtils::defineSimpleRatio (T numerator, T denominator)
template<typename T >
std::tuple< std::string, RatioDefinition >	TableUtils::defineSimpleRatio (std::string &&name, T numerator, T denominator)
template<typename T >
SummandDefinition	TableUtils::defineSummand (T counter_idx, int multiplier)
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)
float	TableUtils::computeRatio (std::size_t numerator, std::size_t denominator)
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)
std::tuple< std::string, RatioDefinition >	TableUtils::makeRatioDefinition (std::string &&name, std::vector< SummandDefinition > &&numerator, std::vector< SummandDefinition > &&denominator)
std::tuple< std::vector< std::string >, std::vector< RatioDefinition > >	TableUtils::splitRatioDefinitionsAndLabels (std::initializer_list< std::tuple< std::string, RatioDefinition > > a_ratio_list)
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)
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)
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)
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)
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)
std::string	TableUtils::makeEtaBinLabel (const std::vector< float > &eta_bins, std::size_t eta_bin_i, bool abs_eta=false)
template<typename T , std::size_t N>
TableUtils::StatTable< T >	makeTable (const std::array< T, N > &counter, const std::array< std::string, N > &label)
template<typename T , std::size_t Nrows, std::size_t Ncolumns>
TableUtils::MultiColumnTable< T >	makeTable (const std::array< std::array< T, Ncolumns >, Nrows > &counter, const std::array< std::string, Nrows > &row_label, const std::array< std::string, Ncolumns > &column_label, const std::string &top_left_label="")
template<typename T >
TableUtils::MultiColumnTable< T >	makeTable (const std::vector< T > &counter, std::size_t start_idx, std::size_t row_stride, const std::vector< std::string > &row_label, const std::vector< std::string > &column_label, const std::string &top_left_label="")
template<typename T , std::size_t N>
TableUtils::MultiColumnTable< T >	makeTable (const std::vector< std::array< T, N > > &counter, std::size_t start_row_idx, std::size_t row_stride, std::size_t start_column_idx, std::size_t column_stride, const std::vector< std::string > &row_label, const std::vector< std::string > &column_label, const std::string &top_left_label="")
template<typename T >
TableUtils::MultiColumnTable< T >	makeTable (const std::vector< T > &counter, const std::vector< std::string > &row_label, const std::vector< std::string > &column_label, const std::string &top_left_label="")
template<typename T >
MsgStream &	operator<< (MsgStream &out, const TableUtils::StatTable< T > &stat)
template<typename T >
MsgStream &	operator<< (MsgStream &out, const TableUtils::MultiColumnTable< T > &stat)
template<typename T >
std::ostream &	operator<< (std::ostream &out, const TableUtils::StatTable< T > &stat)
template<typename T >
std::ostream &	operator<< (std::ostream &out, const TableUtils::MultiColumnTable< T > &stat)

Function Documentation

makeTable() [1/5]

template<typename T , std::size_t Nrows, std::size_t Ncolumns>

TableUtils::MultiColumnTable<T> makeTable	(	const std::array< std::array< T, Ncolumns >, Nrows > &	counter,
		const std::array< std::string, Nrows > &	row_label,
		const std::array< std::string, Ncolumns > &	column_label,
		const std::string &	top_left_label = ""
	)

Definition at line 533 of file TableUtils.h.

                                                                              {
   return TableUtils::MultiColumnTable<T> {
      TableUtils::Range2D<T>         {!counter.empty() ? counter[0].data() : nullptr,
                                      counter.size(), column_label.size(),
                                      !counter.empty() ? static_cast<std::size_t>(&counter[1][0] - &counter[0][0]) : 0u,
                                      0u,  // index of first column
                                      1u}, // offset between columns
      TableUtils::Range<std::string> {row_label.data(),    row_label.size(),   1u},
      TableUtils::Range<std::string> {column_label.data(), column_label.size(),1u},
      top_left_label
   };
}

makeTable() [2/5]

template<typename T , std::size_t N>

TableUtils::StatTable<T> makeTable	(	const std::array< T, N > &	counter,
		const std::array< std::string, N > &	label
	)

Definition at line 523 of file TableUtils.h.

                                                                        {
   return TableUtils::StatTable<T> {
      TableUtils::Range<T>           {counter.data(), counter.size()},
      TableUtils::Range<std::string> {label.data(),   label.size()  }
   };
}

makeTable() [3/5]

template<typename T , std::size_t N>

TableUtils::MultiColumnTable<T> makeTable	(	const std::vector< std::array< T, N > > &	counter,
		std::size_t	start_row_idx,
		std::size_t	row_stride,
		std::size_t	start_column_idx,
		std::size_t	column_stride,
		const std::vector< std::string > &	row_label,
		const std::vector< std::string > &	column_label,
		const std::string &	top_left_label = ""
	)

Definition at line 589 of file TableUtils.h.

                                                                              {
   if (start_row_idx + (row_label.size()-1) * row_stride >= counter.size()*N
       || start_column_idx + (column_label.size()-1) * column_stride >= counter.size()*N
       || (row_stride*row_label.size()>column_stride && column_stride*column_label.size()>row_stride) ) {
      std::stringstream msg;
      msg << "Counter dimension and label dimensions (" << row_label.size() << " * " << column_label.size()
          << ") do not match: [" << start_row_idx << ", "
          <<  start_row_idx << " + " << (row_label.size()-1) << " * " << row_stride << " = "
          << (start_row_idx + (row_label.size()-1) * row_stride)
          << " or "
          <<  start_column_idx << " + " << (column_label.size()-1) << " * " << column_stride << " = "
          << (start_column_idx + (column_label.size()-1) * column_stride)
          << " !< " << counter.size()
          << std::endl
          << (start_row_idx + (row_label.size()-1) * row_stride) << "  >= " << (counter.size()*N)
          << " || " << (start_column_idx + (column_label.size()-1) * column_stride) << "  >= " << (counter.size()*N)
          << " || ( " << (row_stride*row_label.size()) << " > " << column_stride << " &&  " << (column_stride*column_label.size()) << " > " << (row_stride)
          << ")";
      msg << " [row_labels:";
      for (const std::string &label : row_label) {
         msg << " " << label;
      }
      msg << "; column_labels:";
      for (const std::string &label : column_label) {
         msg << " " << label;
      }
      msg << "]";
      throw std::logic_error(msg.str());
   }
   return TableUtils::MultiColumnTable<T> {
      TableUtils::Range2D<T>         {!counter.empty() && N>0 ? counter[start_row_idx].data() : nullptr,
                                      row_label.size(),      // n-rows
                                      column_label.size(),   // n-columns
                                      row_stride,            // offset between rows
                                      start_column_idx,                    // first column index
                                      column_stride},                   // offset between columns
      TableUtils::Range<std::string> {row_label.data(),    row_label.size() },
      TableUtils::Range<std::string> {column_label.data(), column_label.size()},
      top_left_label};
}

makeTable() [4/5]

template<typename T >

TableUtils::MultiColumnTable<T> makeTable	(	const std::vector< T > &	counter,
		const std::vector< std::string > &	row_label,
		const std::vector< std::string > &	column_label,
		const std::string &	top_left_label = ""
	)

Definition at line 640 of file TableUtils.h.

                                                                              {
   return makeTable(counter, 0u, column_label.size(), row_label, column_label, top_left_label);
}

makeTable() [5/5]

template<typename T >

TableUtils::MultiColumnTable<T> makeTable	(	const std::vector< T > &	counter,
		std::size_t	start_idx,
		std::size_t	row_stride,
		const std::vector< std::string > &	row_label,
		const std::vector< std::string > &	column_label,
		const std::string &	top_left_label = ""
	)

Definition at line 551 of file TableUtils.h.

                                                                              {
   if (start_idx + (row_label.size()-1) * row_stride >= counter.size() || row_stride < column_label.size()) {
      std::stringstream msg;
      msg << "Counter dimension and label dimensions (" << row_label.size() << " * " << column_label.size()
          << ") do not match: [" << start_idx << ", "
          <<  start_idx << " + " << (row_label.size()-1) << " * " << row_stride << " = "
          << (start_idx + (row_label.size()-1) * row_stride)
          << " !< " << counter.size();
      msg << " [row_labels:";
      for (const std::string &label : row_label) {
         msg << " " << label;
      }
      msg << "; column_labels:";
      for (const std::string &label : column_label) {
         msg << " " << label;
      }
      msg << "]";
      throw std::logic_error(msg.str());
   }
   return TableUtils::MultiColumnTable<T> {
      TableUtils::Range2D<T>         {!counter.empty() ? &counter[start_idx] : nullptr,
                                      row_label.size(),      // n-rows
                                      column_label.size(),   // n-columns
                                      row_stride,            // offset between rows
                                      0u,                    // first column index
                                      1u},                   // offset between columns
      TableUtils::Range<std::string> {row_label.data(),    row_label.size() },
      TableUtils::Range<std::string> {column_label.data(), column_label.size()},
      top_left_label
   };
}

operator<<() [1/4]

template<typename T >

MsgStream& operator<< ( MsgStream &  out, const TableUtils::MultiColumnTable< T > &  stat  )

inline

Definition at line 670 of file TableUtils.h.

{
   return dumpTable(out,
                    stat.m_counter,
                    stat.m_rowLabel,
                    stat.m_columnLabel,
                    stat.m_topLeftLable,
                    stat.m_labelPrefix,
                    stat.m_columnWidth,
                    stat.m_minLabelWidth,
                    stat.m_dumpHeader,
                    stat.m_dumpFooter,
                    stat.m_separateLastRow,
                    stat.m_precision);
}

operator<<() [2/4]

template<typename T >

MsgStream& operator<< ( MsgStream &  out, const TableUtils::StatTable< T > &  stat  )

inline

Definition at line 652 of file TableUtils.h.

{
   return dumpTable(out,
                    stat.m_counter,
                    stat.m_label,
                    stat.m_labelPrefix,
                    stat.m_columnWidth,
                    stat.m_minLabelWidth,
                    stat.m_dumpFooter,
                    stat.m_separateLastRow,
                    stat.m_precision);
}

operator<<() [3/4]

template<typename T >

std::ostream& operator<< ( std::ostream &  out, const TableUtils::MultiColumnTable< T > &  stat  )

inline

Definition at line 708 of file TableUtils.h.

{
   return dumpTable(out,
                    stat.m_counter,
                    stat.m_rowLabel,
                    stat.m_columnLabel,
                    stat.m_topLeftLable,
                    stat.m_labelPrefix,
                    stat.m_columnWidth,
                    stat.m_minLabelWidth,
                    stat.m_dumpHeader,
                    stat.m_dumpFooter,
                    stat.m_separateLastRow,
                    stat.m_precision);
}

operator<<() [4/4]

template<typename T >

std::ostream& operator<< ( std::ostream &  out, const TableUtils::StatTable< T > &  stat  )

inline

Definition at line 691 of file TableUtils.h.

{
   return dumpTable(out,
                    stat.m_counter,
                    stat.m_label,
                    stat.m_labelPrefix,
                    stat.m_columnWidth,
                    stat.m_minLabelWidth,
                    stat.m_dumpFooter,
                    stat.m_separateLastRow,
                    stat.m_precision);
}