#include <chunk_strategies.hpp>

Inheritance diagram for chunk_processing::VarianceStrategy< T >:

Collaboration diagram for chunk_processing::VarianceStrategy< T >:

Public Member Functions
	VarianceStrategy (double threshold)

std::vector< std::vector< T > >	apply (const std::vector< T > &data) const override

Private Member Functions
double	calculate_rolling_variance (const T &new_value, double prev_mean, double &mean, size_t n) const

Private Attributes
double	threshold_

Detailed Description

template<typename T>
class chunk_processing::VarianceStrategy< T >

Definition at line 82 of file chunk_strategies.hpp.

Constructor & Destructor Documentation

◆ VarianceStrategy()

template<typename T >

chunk_processing::VarianceStrategy< T >::VarianceStrategy ( double threshold )

inlineexplicit

Definition at line 97 of file chunk_strategies.hpp.

97: threshold_(threshold) {}

chunk_processing::VarianceStrategy::threshold_

double threshold_

Definition chunk_strategies.hpp:84

Member Function Documentation

◆ apply()

template<typename T >

std::vector< std::vector< T > > chunk_processing::VarianceStrategy< T >::apply ( const std::vector< T > & data ) const

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 99 of file chunk_strategies.hpp.

                                                                           {
        std::vector<std::vector<T>> result;
        if (data.empty())
            return result;
 
        std::vector<T> current_chunk;
        double mean = 0.0;
        size_t count = 0;
 
        for (const auto& value : data) {
            count++;
            current_chunk.push_back(value);
 
            if (count > 1) {
                double new_mean = 0.0;
                double variance = calculate_rolling_variance(value, mean, new_mean, count);
                mean = new_mean;
 
                if (variance > threshold_) {
                    if (current_chunk.size() > 1) {
                        result.push_back(current_chunk);
                        current_chunk.clear();
                        current_chunk.push_back(value);
                        count = 1;
                        mean = static_cast<double>(value);
                    }
                }
            } else {
                mean = static_cast<double>(value);
            }
        }
 
        if (!current_chunk.empty()) {
            result.push_back(current_chunk);
        }
 
        return result;
    }

References chunk_processing::VarianceStrategy< T >::calculate_rolling_variance(), and chunk_processing::VarianceStrategy< T >::threshold_.

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

◆ calculate_rolling_variance()

template<typename T >

double chunk_processing::VarianceStrategy< T >::calculate_rolling_variance	(	const T &	new_value,
		double	prev_mean,
		double &	mean,
		size_t	n
	)		const

inlineprivate

Definition at line 86 of file chunk_strategies.hpp.

                                                      {
        mean = prev_mean + (static_cast<double>(new_value) - prev_mean) / n;
        double variance = 0.0;
        if (n > 1) {
            variance = std::pow(static_cast<double>(new_value) - mean, 2.0) / (n - 1);
        }
        return variance;
    }