Wavelet-based chunking strategy using signal processing principles. More...

#include <sophisticated_chunking.hpp>

Collaboration diagram for sophisticated_chunking::WaveletChunking< T >:

Public Member Functions
	WaveletChunking (size_t window_size=8, double threshold=0.5)
	Constructor for wavelet-based chunking.

std::vector< std::vector< T > >	chunk (const std::vector< T > &data) const
	Chunk data based on wavelet transform analysis.

double	get_threshold () const
	Get the coefficient threshold for chunk boundaries.

std::string	get_wavelet_type () const
	Get the current wavelet type.

size_t	get_window_size () const
	Get the size of the sliding window.

void	set_threshold (double threshold)
	Set the coefficient threshold for chunk boundaries.

void	set_wavelet_type (const std::string &type)
	Set the wavelet type.

void	set_window_size (size_t size)
	Set the size of the sliding window.

Private Member Functions
std::vector< double >	computeWaveletCoefficients (const std::vector< T > &data) const
	Compute discrete wavelet transform coefficients.

Private Attributes
double	threshold_

std::string	wavelet_type_

size_t	window_size_

Detailed Description

template<typename T>
class sophisticated_chunking::WaveletChunking< T >

Wavelet-based chunking strategy using signal processing principles.

Template Parameters

T	The type of elements to be chunked

Definition at line 22 of file sophisticated_chunking.hpp.

Constructor & Destructor Documentation

◆ WaveletChunking()

template<typename T >

sophisticated_chunking::WaveletChunking< T >::WaveletChunking	(	size_t	window_size = `8`,
		double	threshold = `0.5`
	)

inline

Constructor for wavelet-based chunking.

Parameters

window_size	Size of the sliding window
threshold	Coefficient threshold for chunk boundaries

Definition at line 79 of file sophisticated_chunking.hpp.

80 : window_size_(window_size), threshold_(threshold), wavelet_type_("haar") {}

sophisticated_chunking::WaveletChunking::wavelet_type_

std::string wavelet_type_

Definition sophisticated_chunking.hpp:26

sophisticated_chunking::WaveletChunking::window_size_

size_t window_size_

Definition sophisticated_chunking.hpp:24

sophisticated_chunking::WaveletChunking::threshold_

double threshold_

Definition sophisticated_chunking.hpp:25

Member Function Documentation

◆ chunk()

template<typename T >

std::vector< std::vector< T > > sophisticated_chunking::WaveletChunking< T >::chunk ( const std::vector< T > & data ) const

inline

Chunk data based on wavelet transform analysis.

Parameters

data	Input data to be chunked

Returns: Vector of chunks

Definition at line 87 of file sophisticated_chunking.hpp.

                                                                  {
        if (data.empty()) {
            return {};
        }
 
        auto coefficients = computeWaveletCoefficients(data);
        std::vector<std::vector<T>> chunks;
        std::vector<T> current_chunk;
 
        size_t i = 0;
        for (const T& value : data) {
            current_chunk.push_back(value);
 
            if (i < coefficients.size() && coefficients[i] > threshold_) {
                if (!current_chunk.empty()) {
                    chunks.push_back(current_chunk);
                    current_chunk.clear();
                }
            }
            ++i;
        }
 
        if (!current_chunk.empty()) {
            chunks.push_back(current_chunk);
        }
 
        return chunks;
    }

References sophisticated_chunking::WaveletChunking< T >::computeWaveletCoefficients(), and sophisticated_chunking::WaveletChunking< T >::threshold_.

Referenced by demonstrate_wavelet_chunking(), TEST_F(), and TEST_F().

◆ computeWaveletCoefficients()

template<typename T >

std::vector< double > sophisticated_chunking::WaveletChunking< T >::computeWaveletCoefficients ( const std::vector< T > & data ) const

inlineprivate

Compute discrete wavelet transform coefficients.

Parameters

data	Input data sequence

Returns: Vector of wavelet coefficients

Definition at line 33 of file sophisticated_chunking.hpp.

                                                                                 {
        if (data.size() < window_size_) {
            return std::vector<double>();
        }
 
        std::vector<double> coefficients;
        coefficients.reserve(data.size() - window_size_ + 1);
 
        // Different wavelet implementations
        if (wavelet_type_ == "haar" || wavelet_type_ == "db1") {
            // Haar wavelet transform
            for (size_t i = 0; i <= data.size() - window_size_; ++i) {
                double sum = 0.0;
                for (size_t j = 0; j < window_size_ / 2; ++j) {
                    double diff = static_cast<double>(data[i + j]) -
                                  static_cast<double>(data[i + window_size_ - 1 - j]);
                    sum += diff * diff;
                }
                coefficients.push_back(std::sqrt(sum / window_size_));
            }
        } else if (wavelet_type_ == "sym2") {
            // Symlet 2 wavelet transform
            const std::vector<double> h = {-0.1294, 0.2241, 0.8365,
                                           0.4830}; // Symlet 2 coefficients
            for (size_t i = 0; i <= data.size() - window_size_; ++i) {
                double sum = 0.0;
                for (size_t j = 0; j < std::min(window_size_, size_t(4)); ++j) {
                    if (i + j < data.size()) {
                        sum += h[j] * static_cast<double>(data[i + j]);
                    }
                }
                coefficients.push_back(std::abs(sum));
            }
        } else {
            throw std::invalid_argument("Unsupported wavelet type: " + wavelet_type_);
        }
 
        return coefficients;
    }

References sophisticated_chunking::WaveletChunking< T >::wavelet_type_, and sophisticated_chunking::WaveletChunking< T >::window_size_.

Referenced by sophisticated_chunking::WaveletChunking< T >::chunk().

◆ get_threshold()

template<typename T >

double sophisticated_chunking::WaveletChunking< T >::get_threshold ( ) const

inline

Get the coefficient threshold for chunk boundaries.

Returns: Coefficient threshold for chunk boundaries

Definition at line 128 of file sophisticated_chunking.hpp.

                                 {
        return threshold_;
    }

References sophisticated_chunking::WaveletChunking< T >::threshold_.

◆ get_wavelet_type()

template<typename T >

std::string sophisticated_chunking::WaveletChunking< T >::get_wavelet_type ( ) const

inline

Get the current wavelet type.

Returns: Current wavelet type

Definition at line 154 of file sophisticated_chunking.hpp.

                                       {
        return wavelet_type_;
    }

References sophisticated_chunking::WaveletChunking< T >::wavelet_type_.

◆ get_window_size()

template<typename T >

size_t sophisticated_chunking::WaveletChunking< T >::get_window_size ( ) const

inline

Get the size of the sliding window.

Returns: Size of the sliding window

Definition at line 120 of file sophisticated_chunking.hpp.

                                   {
        return window_size_;
    }

References sophisticated_chunking::WaveletChunking< T >::window_size_.

◆ set_threshold()

template<typename T >

void sophisticated_chunking::WaveletChunking< T >::set_threshold ( double threshold )

inline

Set the coefficient threshold for chunk boundaries.

Parameters

threshold Coefficient threshold for chunk boundaries

Definition at line 146 of file sophisticated_chunking.hpp.

                                         {
        threshold_ = threshold;
    }

References sophisticated_chunking::WaveletChunking< T >::threshold_.

◆ set_wavelet_type()

template<typename T >

void sophisticated_chunking::WaveletChunking< T >::set_wavelet_type ( const std::string & type )

inline

Set the wavelet type.

Parameters

type	Wavelet type ("haar", "db1", or "sym2")

Definition at line 162 of file sophisticated_chunking.hpp.

                                                 {
        if (type != "haar" && type != "db1" && type != "sym2") {
            throw std::invalid_argument("Invalid wavelet type. Supported types: haar, db1, sym2");
        }
        wavelet_type_ = type;
    }

References sophisticated_chunking::WaveletChunking< T >::wavelet_type_.

◆ set_window_size()

template<typename T >

void sophisticated_chunking::WaveletChunking< T >::set_window_size ( size_t size )

inline

Set the size of the sliding window.

Parameters

size	Size of the sliding window

Definition at line 136 of file sophisticated_chunking.hpp.

                                      {
        if (size == 0)
            throw std::invalid_argument("Window size cannot be zero");
        window_size_ = size;
    }