Dynamic time warping based chunking for sequence alignment. More...

#include <sophisticated_chunking.hpp>

Collaboration diagram for sophisticated_chunking::DTWChunking< T >:

Public Member Functions
	DTWChunking (size_t window_size=10, double dtw_threshold=1.0)
	Constructor for DTW-based chunking.

std::vector< std::vector< T > >	chunk (const std::vector< T > &data) const
	Chunk data based on DTW analysis.

std::string	get_distance_metric () const
	Get the distance metric.

double	get_dtw_threshold () const
	Get the threshold for chunk boundaries.

size_t	get_window_size () const
	Get the size of the warping window.

void	set_distance_metric (const std::string &metric)
	Set the distance metric.

void	set_dtw_threshold (double threshold)
	Set the threshold for chunk boundaries.

void	set_window_size (size_t size)
	Set the size of the warping window.

Private Member Functions
double	calculate_distance (double a, double b) const

double	compute_dtw_core (const std::vector< double > &seq1, const std::vector< double > &seq2) const

double	compute_dtw_distance (const std::vector< T > &seq1, const std::vector< T > &seq2) const

double	computeDTWDistance (const std::vector< T > &seq1, const std::vector< T > &seq2) const
	Compute DTW distance between sequences.

template<typename U >
std::vector< double >	flatten_features (const U &data) const

Private Attributes
std::string	distance_metric_

double	dtw_threshold_

size_t	window_size_

Detailed Description

template<typename T>
class sophisticated_chunking::DTWChunking< T >

Dynamic time warping based chunking for sequence alignment.

Template Parameters

T	The type of elements to be chunked

Definition at line 310 of file sophisticated_chunking.hpp.

Constructor & Destructor Documentation

◆ DTWChunking()

template<typename T >

sophisticated_chunking::DTWChunking< T >::DTWChunking	(	size_t	window_size = `10`,
		double	dtw_threshold = `1.0`
	)

inline

Constructor for DTW-based chunking.

Parameters

window_size	Size of the warping window
dtw_threshold	Threshold for chunk boundaries

Definition at line 408 of file sophisticated_chunking.hpp.

409 : window_size_(window_size), dtw_threshold_(dtw_threshold), distance_metric_("euclidean") {}

sophisticated_chunking::DTWChunking::distance_metric_

std::string distance_metric_

Definition sophisticated_chunking.hpp:314

sophisticated_chunking::DTWChunking::dtw_threshold_

double dtw_threshold_

Definition sophisticated_chunking.hpp:313

sophisticated_chunking::DTWChunking::window_size_

size_t window_size_

Definition sophisticated_chunking.hpp:312

Member Function Documentation

◆ calculate_distance()

template<typename T >

double sophisticated_chunking::DTWChunking< T >::calculate_distance	(	double	a,
		double	b
	)		const

inlineprivate

Definition at line 316 of file sophisticated_chunking.hpp.

                                                        {
        if (distance_metric_ == "manhattan") {
            return std::abs(a - b);
        } else if (distance_metric_ == "cosine") {
            double dot = a * b;
            double norm_a = std::abs(a);
            double norm_b = std::abs(b);
            if (norm_a == 0 || norm_b == 0)
                return 0.0;
            return 1.0 - (dot / (norm_a * norm_b));
        } else {
            double diff = a - b;
            return diff * diff;
        }
    }

References sophisticated_chunking::DTWChunking< T >::distance_metric_.

Referenced by sophisticated_chunking::DTWChunking< T >::compute_dtw_core().

◆ chunk()

template<typename T >

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

inline

Chunk data based on DTW analysis.

Parameters

data	Input data to be chunked

Returns: Vector of chunks

Definition at line 416 of file sophisticated_chunking.hpp.

                                                                  {
        if (data.empty()) {
            return {};
        }
 
        std::vector<std::vector<T>> result;
        std::vector<T> current_chunk;
 
        for (const auto& value : data) {
            if constexpr (chunk_processing::is_vector<T>::value) {
                if (!current_chunk.empty()) {
                    double distance = compute_dtw_distance(value, current_chunk.back());
                    if (distance > dtw_threshold_) {
                        result.push_back(current_chunk);
                        current_chunk.clear();
                    }
                }
            } else {
                // Single-dimension logic
                if (!current_chunk.empty() &&
                    std::abs(static_cast<double>(value - current_chunk.back())) > dtw_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 sophisticated_chunking::DTWChunking< T >::compute_dtw_distance(), and sophisticated_chunking::DTWChunking< T >::dtw_threshold_.

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

◆ compute_dtw_core()

template<typename T >

double sophisticated_chunking::DTWChunking< T >::compute_dtw_core	(	const std::vector< double > &	seq1,
		const std::vector< double > &	seq2
	)		const

inlineprivate

Definition at line 332 of file sophisticated_chunking.hpp.

                                                                 {
        const size_t n = seq1.size();
        const size_t m = seq2.size();
        std::vector<std::vector<double>> dp(
            n + 1, std::vector<double>(m + 1, std::numeric_limits<double>::infinity()));
 
        dp[0][0] = 0.0;
 
        for (size_t i = 1; i <= n; ++i) {
            for (size_t j = std::max(1ul, i - window_size_); j <= std::min(m, i + window_size_);
                 ++j) {
                double cost = calculate_distance(seq1[i - 1], seq2[j - 1]);
                dp[i][j] = cost + std::min({
                                      dp[i - 1][j],    // insertion
                                      dp[i][j - 1],    // deletion
                                      dp[i - 1][j - 1] // match
                                  });
            }
        }
 
        return dp[n][m];
    }

References sophisticated_chunking::DTWChunking< T >::calculate_distance(), and sophisticated_chunking::DTWChunking< T >::window_size_.

Referenced by sophisticated_chunking::DTWChunking< T >::compute_dtw_distance().

◆ compute_dtw_distance()

template<typename T >

double sophisticated_chunking::DTWChunking< T >::compute_dtw_distance	(	const std::vector< T > &	seq1,
		const std::vector< T > &	seq2
	)		const

inlineprivate

Definition at line 377 of file sophisticated_chunking.hpp.

                                                                                          {
        if constexpr (chunk_processing::is_vector<T>::value) {
            if constexpr (chunk_processing::is_vector<typename T::value_type>::value) {
                // For multi-dimensional data, flatten and compare features
                auto features1 = flatten_features(seq1);
                auto features2 = flatten_features(seq2);
                return compute_dtw_core(features1, features2);
            } else {
                // For 1D vector data
                return compute_dtw_core(seq1, seq2);
            }
        } else {
            // For scalar data
            return std::abs(static_cast<double>(seq1[0] - seq2[0]));
        }
    }

References sophisticated_chunking::DTWChunking< T >::compute_dtw_core(), and sophisticated_chunking::DTWChunking< T >::flatten_features().

Referenced by sophisticated_chunking::DTWChunking< T >::chunk().

◆ computeDTWDistance()

template<typename T >

double sophisticated_chunking::DTWChunking< T >::computeDTWDistance	(	const std::vector< T > &	seq1,
		const std::vector< T > &	seq2
	)		const

private

Compute DTW distance between sequences.

Parameters

seq1	First sequence
seq2	Second sequence

Returns: DTW distance

◆ flatten_features()

template<typename T >

template<typename U >

std::vector< double > sophisticated_chunking::DTWChunking< T >::flatten_features ( const U & data ) const

inlineprivate

Definition at line 357 of file sophisticated_chunking.hpp.

                                                            {
        if constexpr (chunk_processing::is_vector<U>::value) {
            if constexpr (chunk_processing::is_vector<typename U::value_type>::value) {
                // Handle 2D arrays
                std::vector<double> flattened;
                for (const auto& inner : data) {
                    auto inner_features = flatten_features(inner);
                    flattened.insert(flattened.end(), inner_features.begin(), inner_features.end());
                }
                return flattened;
            } else {
                // Handle 1D arrays
                return std::vector<double>(data.begin(), data.end());
            }
        } else {
            // Handle scalar values
            return {static_cast<double>(data)};
        }
    }

References sophisticated_chunking::DTWChunking< T >::flatten_features().

Referenced by sophisticated_chunking::DTWChunking< T >::compute_dtw_distance(), and sophisticated_chunking::DTWChunking< T >::flatten_features().

◆ get_distance_metric()

template<typename T >

std::string sophisticated_chunking::DTWChunking< T >::get_distance_metric ( ) const

inline

Get the distance metric.

Returns: Distance metric

Definition at line 489 of file sophisticated_chunking.hpp.

                                          {
        return distance_metric_;
    }

References sophisticated_chunking::DTWChunking< T >::distance_metric_.

◆ get_dtw_threshold()

template<typename T >

double sophisticated_chunking::DTWChunking< T >::get_dtw_threshold ( ) const

inline

Get the threshold for chunk boundaries.

Returns: Threshold for chunk boundaries

Definition at line 463 of file sophisticated_chunking.hpp.

                                     {
        return dtw_threshold_;
    }

References sophisticated_chunking::DTWChunking< T >::dtw_threshold_.

◆ get_window_size()

template<typename T >

size_t sophisticated_chunking::DTWChunking< T >::get_window_size ( ) const

inline

Get the size of the warping window.

Returns: Size of the warping window

Definition at line 455 of file sophisticated_chunking.hpp.

                                   {
        return window_size_;
    }

References sophisticated_chunking::DTWChunking< T >::window_size_.

◆ set_distance_metric()

template<typename T >

void sophisticated_chunking::DTWChunking< T >::set_distance_metric ( const std::string & metric )

inline

Set the distance metric.

Parameters

metric Distance metric

Definition at line 497 of file sophisticated_chunking.hpp.

                                                      {
        if (metric != "euclidean" && metric != "manhattan" && metric != "cosine") {
            throw std::invalid_argument(
                "Invalid distance metric. Supported metrics: euclidean, manhattan, cosine");
        }
        distance_metric_ = metric;
    }

References sophisticated_chunking::DTWChunking< T >::distance_metric_.

◆ set_dtw_threshold()

template<typename T >

void sophisticated_chunking::DTWChunking< T >::set_dtw_threshold ( double threshold )

inline

Set the threshold for chunk boundaries.

Parameters

threshold Threshold for chunk boundaries

Definition at line 481 of file sophisticated_chunking.hpp.

                                             {
        dtw_threshold_ = threshold;
    }

References sophisticated_chunking::DTWChunking< T >::dtw_threshold_.

◆ set_window_size()

template<typename T >

void sophisticated_chunking::DTWChunking< T >::set_window_size ( size_t size )

inline

Set the size of the warping window.

Parameters

size	Size of the warping window

Definition at line 471 of file sophisticated_chunking.hpp.

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