chunk_processing::Chunk< T >::JaggedVectorHandler< U > Class Template Reference

Static Public Member Functions
static std::vector< std::vector< U > >	normalize (const std::vector< std::vector< U > > &jagged)
static std::vector< std::vector< std::vector< U > > >	normalize_3d (const std::vector< std::vector< std::vector< U > > > &jagged_3d)

Detailed Description

template<typename T>
template<typename U>
class chunk_processing::Chunk< T >::JaggedVectorHandler< U >

Definition at line 24 of file chunk.hpp.

Member Function Documentation

normalize()

template<typename T >

template<typename U >

static std::vector< std::vector< U > > chunk_processing::Chunk< T >::JaggedVectorHandler< U >::normalize ( const std::vector< std::vector< U > > &  jagged )

inlinestatic

Definition at line 26 of file chunk.hpp.

                                                                                        {
            if (jagged.empty())
                return {};
 
            // Find maximum size
            size_t max_size = 0;
            for (const auto& row : jagged) {
                max_size = std::max(max_size, row.size());
            }
 
            // Normalize by padding with default values
            std::vector<std::vector<U>> normalized;
            normalized.reserve(jagged.size());
 
            for (const auto& row : jagged) {
                std::vector<U> normalized_row = row;
                normalized_row.resize(max_size, U{}); // Pad with default values
                normalized.push_back(std::move(normalized_row));
            }
 
            return normalized;
        }

normalize_3d()

template<typename T >

template<typename U >

static std::vector< std::vector< std::vector< U > > > chunk_processing::Chunk< T >::JaggedVectorHandler< U >::normalize_3d ( const std::vector< std::vector< std::vector< U > > > &  jagged_3d )

inlinestatic

Definition at line 50 of file chunk.hpp.

                                                                          {
            if (jagged_3d.empty())
                return {};
 
            // Find maximum sizes
            size_t max_rows = 0, max_cols = 0;
            for (const auto& matrix : jagged_3d) {
                max_rows = std::max(max_rows, matrix.size());
                for (const auto& row : matrix) {
                    max_cols = std::max(max_cols, row.size());
                }
            }
 
            // Normalize by padding
            std::vector<std::vector<std::vector<U>>> normalized;
            normalized.reserve(jagged_3d.size());
 
            for (const auto& matrix : jagged_3d) {
                std::vector<std::vector<U>> norm_matrix;
                norm_matrix.reserve(max_rows);
 
                for (const auto& row : matrix) {
                    std::vector<U> norm_row = row;
                    norm_row.resize(max_cols, U{});
                    norm_matrix.push_back(std::move(norm_row));
                }
 
                while (norm_matrix.size() < max_rows) {
                    norm_matrix.push_back(std::vector<U>(max_cols));
                }
 
                normalized.push_back(std::move(norm_matrix));
            }
 
            return normalized;
        }

---

The documentation for this class was generated from the following file:

• chunk.hpp