WaveletChunking< T > Class Template Reference

#include <wavelet_chunking.hpp>

Public Member Functions
	WaveletChunking (size_t window_size, double threshold)
std::vector< std::vector< T > >	chunk (const std::vector< T > &data)
void	set_threshold (double new_threshold)
void	set_window_size (size_t new_size)

Private Member Functions
bool	detect_boundary (const std::vector< T > &window)

Private Attributes
double	threshold_
size_t	window_size_

Detailed Description

template<typename T>
class WaveletChunking< T >

Definition at line 2 of file wavelet_chunking.hpp.

Constructor & Destructor Documentation

WaveletChunking()

template<typename T >

WaveletChunking< T >::WaveletChunking ( size_t  window_size, double  threshold  )

inline

Definition at line 4 of file wavelet_chunking.hpp.

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

Member Function Documentation

chunk()

template<typename T >

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

inline

Definition at line 22 of file wavelet_chunking.hpp.

                                                            {
        if (data.empty()) {
            throw std::invalid_argument("Cannot chunk empty data");
        }
 
        std::vector<std::vector<T>> result;
        std::vector<T> current_chunk;
 
        for (size_t i = 0; i < data.size(); ++i) {
            current_chunk.push_back(data[i]);
 
            if (current_chunk.size() >= window_size_) {
                // Perform wavelet analysis to detect boundaries
                if (detect_boundary(current_chunk)) {
                    result.push_back(current_chunk);
                    current_chunk.clear();
                }
            }
        }
 
        if (!current_chunk.empty()) {
            result.push_back(current_chunk);
        }
 
        return result;
    }

detect_boundary()

template<typename T >

bool WaveletChunking< T >::detect_boundary ( const std::vector< T > &  window )

inlineprivate

Definition at line 53 of file wavelet_chunking.hpp.

                                                     {
        if (window.size() < 2)
            return false;
 
        // Simple boundary detection based on value differences
        double max_diff = 0.0;
        for (size_t i = 1; i < window.size(); ++i) {
            max_diff = std::max(max_diff, std::abs(static_cast<double>(window[i] - window[i - 1])));
        }
        return max_diff > threshold_;
    }

set_threshold()

template<typename T >

void WaveletChunking< T >::set_threshold ( double  new_threshold )

inline

Definition at line 18 of file wavelet_chunking.hpp.

                                             {
        threshold_ = new_threshold;
    }

set_window_size()

template<typename T >

void WaveletChunking< T >::set_window_size ( size_t  new_size )

inline

Definition at line 11 of file wavelet_chunking.hpp.

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

Member Data Documentation

threshold_

template<typename T >

double WaveletChunking< T >::threshold_

private

Definition at line 51 of file wavelet_chunking.hpp.

window_size_

template<typename T >

size_t WaveletChunking< T >::window_size_

private

Definition at line 50 of file wavelet_chunking.hpp.

---

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

• wavelet_chunking.hpp