#include <chunk_strategy_implementations.hpp>

Inheritance diagram for chunk_processing::SimilarityChunkingStrategy< T >:

Collaboration diagram for chunk_processing::SimilarityChunkingStrategy< T >:

Public Member Functions
	SimilarityChunkingStrategy (double threshold)

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

Private Member Functions
double	calculate_similarity (const T &a, const T &b) const

Private Attributes
double	similarity_threshold_

Detailed Description

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

Definition at line 38 of file chunk_strategy_implementations.hpp.

Constructor & Destructor Documentation

◆ SimilarityChunkingStrategy()

template<typename T >

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

inlineexplicit

Definition at line 43 of file chunk_strategy_implementations.hpp.

43: similarity_threshold_(threshold) {}

chunk_processing::SimilarityChunkingStrategy::similarity_threshold_

double similarity_threshold_

Definition chunk_strategy_implementations.hpp:40

Member Function Documentation

◆ apply()

template<typename T >

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

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 45 of file chunk_strategy_implementations.hpp.

                                                                           {
        std::vector<std::vector<T>> result;
        if (data.empty())
            return result;
 
        std::vector<T> current_chunk;
        for (const auto& value : data) {
            if (!current_chunk.empty() &&
                calculate_similarity(value, current_chunk.back()) < similarity_threshold_) {
                result.push_back(current_chunk);
                current_chunk.clear();
            }
            current_chunk.push_back(value);
        }
        if (!current_chunk.empty()) {
            result.push_back(current_chunk);
        }
        return result;
    }

References chunk_processing::SimilarityChunkingStrategy< T >::calculate_similarity(), and chunk_processing::SimilarityChunkingStrategy< T >::similarity_threshold_.

◆ calculate_similarity()

template<typename T >

double chunk_processing::SimilarityChunkingStrategy< T >::calculate_similarity	(	const T &	a,
		const T &	b
	)		const

inlineprivate

Definition at line 66 of file chunk_strategy_implementations.hpp.

                                                              {
        return 1.0 / (1.0 + std::abs(static_cast<double>(a) - static_cast<double>(b)));
    }

Referenced by chunk_processing::SimilarityChunkingStrategy< T >::apply().