#include <chunk_windows.hpp>

Public Member Functions
	SlidingWindowProcessor (size_t window_size, size_t step_size)

size_t	get_step_size () const

size_t	get_window_size () const

std::vector< T >	process (const std::vector< T > &data, std::function< T(const std::vector< T > &)> window_func)

void	set_step_size (size_t size)

void	set_window_size (size_t size)

Private Member Functions
std::vector< T >	process_multidimensional (const std::vector< T > &data, std::function< T(const std::vector< T > &)> window_func)

std::vector< T >	process_single_dimensional (const std::vector< T > &data, std::function< T(const std::vector< T > &)> window_func)

std::vector< T >	process_window (const std::vector< T > &data, std::function< T(const std::vector< T > &)> window_func)

Static Private Member Functions
template<typename U >
static double	compute_window_feature (const U &window)

Private Attributes
size_t	step_size_

size_t	window_size_

Detailed Description

template<typename T>
class chunk_windows::SlidingWindowProcessor< T >

Definition at line 13 of file chunk_windows.hpp.

Constructor & Destructor Documentation

◆ SlidingWindowProcessor()

template<typename T >

chunk_windows::SlidingWindowProcessor< T >::SlidingWindowProcessor	(	size_t	window_size,
		size_t	step_size
	)

inline

Definition at line 77 of file chunk_windows.hpp.

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

Member Function Documentation

◆ compute_window_feature()

template<typename T >

template<typename U >

static double chunk_windows::SlidingWindowProcessor< T >::compute_window_feature ( const U & window )

inlinestaticprivate

Definition at line 19 of file chunk_windows.hpp.

                                                          {
        if constexpr (chunk_processing::is_vector<U>::value) {
            if constexpr (chunk_processing::is_vector<typename U::value_type>::value) {
                // Handle 2D arrays
                double sum = 0.0;
                for (const auto& inner : window) {
                    sum += compute_window_feature(inner);
                }
                return sum / window.size();
            } else {
                // Handle 1D arrays
                return std::accumulate(window.begin(), window.end(), 0.0) / window.size();
            }
        } else {
            // Handle scalar values
            return static_cast<double>(window);
        }
    }

References chunk_windows::SlidingWindowProcessor< T >::compute_window_feature().

Referenced by chunk_windows::SlidingWindowProcessor< T >::compute_window_feature().

◆ get_step_size()

template<typename T >

size_t chunk_windows::SlidingWindowProcessor< T >::get_step_size ( ) const

inline

Definition at line 98 of file chunk_windows.hpp.

                                 {
        return step_size_;
    }

References chunk_windows::SlidingWindowProcessor< T >::step_size_.

◆ get_window_size()

template<typename T >

size_t chunk_windows::SlidingWindowProcessor< T >::get_window_size ( ) const

inline

Definition at line 95 of file chunk_windows.hpp.

                                   {
        return window_size_;
    }

References chunk_windows::SlidingWindowProcessor< T >::window_size_.

◆ process()

template<typename T >

std::vector< T > chunk_windows::SlidingWindowProcessor< T >::process	(	const std::vector< T > &	data,
		std::function< T(const std::vector< T > &)>	window_func
	)

inline

Definition at line 85 of file chunk_windows.hpp.

                                                                            {
        if (data.size() < window_size_) {
            return {}; // Return empty if data is smaller than window
        }
 
        return process_window(data, window_func);
    }

References chunk_windows::SlidingWindowProcessor< T >::process_window(), and chunk_windows::SlidingWindowProcessor< T >::window_size_.

◆ process_multidimensional()

template<typename T >

std::vector< T > chunk_windows::SlidingWindowProcessor< T >::process_multidimensional	(	const std::vector< T > &	data,
		std::function< T(const std::vector< T > &)>	window_func
	)

inlineprivate

Definition at line 38 of file chunk_windows.hpp.

                                                                                             {
        // Implementation for multi-dimensional data
        std::vector<T> results;
        for (size_t i = 0; i <= data.size() - window_size_; i += step_size_) {
            std::vector<T> window(data.begin() + i, data.begin() + i + window_size_);
            results.push_back(window_func(window));
        }
        return results;
    }

References chunk_windows::SlidingWindowProcessor< T >::step_size_, and chunk_windows::SlidingWindowProcessor< T >::window_size_.

Referenced by chunk_windows::SlidingWindowProcessor< T >::process_window().

◆ process_single_dimensional()

template<typename T >

std::vector< T > chunk_windows::SlidingWindowProcessor< T >::process_single_dimensional	(	const std::vector< T > &	data,
		std::function< T(const std::vector< T > &)>	window_func
	)

inlineprivate

Definition at line 49 of file chunk_windows.hpp.

                                                                                               {
        std::vector<T> results;
        // Create sliding windows of the specified size
        for (size_t i = 0; i <= data.size() - window_size_; i += step_size_) {
            std::vector<T> window(data.begin() + i, data.begin() + i + window_size_);
            results.push_back(window_func(window));
        }
        return results;
    }

References chunk_windows::SlidingWindowProcessor< T >::step_size_, and chunk_windows::SlidingWindowProcessor< T >::window_size_.

Referenced by chunk_windows::SlidingWindowProcessor< T >::process_window().

◆ process_window()

template<typename T >

std::vector< T > chunk_windows::SlidingWindowProcessor< T >::process_window	(	const std::vector< T > &	data,
		std::function< T(const std::vector< T > &)>	window_func
	)

inlineprivate

Definition at line 60 of file chunk_windows.hpp.

                                                                                   {
        if constexpr (chunk_processing::is_vector<T>::value) {
            if constexpr (chunk_processing::is_vector<typename T::value_type>::value) {
                // Handle 2D arrays
                return process_multidimensional(data, window_func);
            } else {
                // Handle 1D arrays
                return process_single_dimensional(data, window_func);
            }
        } else {
            // Handle scalar values
            return process_single_dimensional(data, window_func);
        }
    }

References chunk_windows::SlidingWindowProcessor< T >::process_multidimensional(), and chunk_windows::SlidingWindowProcessor< T >::process_single_dimensional().

Referenced by chunk_windows::SlidingWindowProcessor< T >::process().

◆ set_step_size()

template<typename T >

void chunk_windows::SlidingWindowProcessor< T >::set_step_size ( size_t size )

inline

Definition at line 108 of file chunk_windows.hpp.

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

References chunk_windows::SlidingWindowProcessor< T >::step_size_.

◆ set_window_size()

template<typename T >

void chunk_windows::SlidingWindowProcessor< T >::set_window_size ( size_t size )

inline

Definition at line 103 of file chunk_windows.hpp.

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