#include <chunk_strategies.hpp>

Inheritance diagram for chunk_processing::EntropyStrategy< T >:

Collaboration diagram for chunk_processing::EntropyStrategy< T >:

Public Member Functions
	EntropyStrategy (double threshold)

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

Private Member Functions
double	calculate_entropy (const std::vector< T > &chunk) const

Private Attributes
double	threshold_

Detailed Description

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

Definition at line 140 of file chunk_strategies.hpp.

Constructor & Destructor Documentation

◆ EntropyStrategy()

template<typename T >

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

inlineexplicit

Definition at line 166 of file chunk_strategies.hpp.

166: threshold_(threshold) {}

chunk_processing::EntropyStrategy::threshold_

double threshold_

Definition chunk_strategies.hpp:142

Member Function Documentation

◆ apply()

template<typename T >

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

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 168 of file chunk_strategies.hpp.

                                                                           {
        std::vector<std::vector<T>> result;
        if (data.empty())
            return result;
 
        // If threshold is 0, return the entire data as a single chunk
        if (threshold_ <= 0.0) {
            return {data};
        }
 
        std::vector<T> current_chunk;
        for (const auto& value : data) {
            current_chunk.push_back(value);
 
            if (current_chunk.size() > 1) {
                double entropy = calculate_entropy(current_chunk);
                if (entropy > threshold_) {
                    result.push_back(current_chunk);
                    current_chunk.clear();
                }
            }
        }
 
        if (!current_chunk.empty()) {
            result.push_back(current_chunk);
        }
 
        return result;
    }

References chunk_processing::EntropyStrategy< T >::calculate_entropy(), and chunk_processing::EntropyStrategy< T >::threshold_.

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

◆ calculate_entropy()

template<typename T >

double chunk_processing::EntropyStrategy< T >::calculate_entropy ( const std::vector< T > & chunk ) const

inlineprivate

Definition at line 144 of file chunk_strategies.hpp.

                                                              {
        if (chunk.empty())
            return 0.0;
 
        // Calculate frequency distribution
        std::map<T, double> freq;
        for (const auto& val : chunk) {
            freq[val] += 1.0;
        }
 
        // Calculate entropy
        double entropy = 0.0;
        double n = static_cast<double>(chunk.size());
        for (const auto& pair : freq) {
            double p = pair.second / n;
            entropy -= p * std::log2(p);
        }
 
        return entropy;
    }