chunk_metrics::ChunkQualityAnalyzer< T > Class Template Reference

#include <chunk_metrics.hpp>

Public Member Functions
	ChunkQualityAnalyzer ()=default
	ChunkQualityAnalyzer (ChunkQualityAnalyzer &&)=delete
	ChunkQualityAnalyzer (const ChunkQualityAnalyzer &)=delete
	~ChunkQualityAnalyzer ()=default
void	clear_cache () const
bool	compare_cohesion (const std::vector< std::vector< T > > &well_separated, const std::vector< std::vector< T > > &mixed, double &high_result, double &mixed_result) const
double	compute_cohesion (const std::vector< std::vector< T > > &chunks) const
double	compute_quality_score (const std::vector< std::vector< T > > &chunks) const
double	compute_separation (const std::vector< std::vector< T > > &chunks) const
double	compute_silhouette_score (const std::vector< std::vector< T > > &chunks) const
std::map< std::string, double >	compute_size_metrics (const std::vector< std::vector< T > > &chunks) const
ChunkQualityAnalyzer &	operator= (ChunkQualityAnalyzer &&)=delete
ChunkQualityAnalyzer &	operator= (const ChunkQualityAnalyzer &)=delete

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

Detailed Description

template<typename T>
class chunk_metrics::ChunkQualityAnalyzer< T >

Definition at line 59 of file chunk_metrics.hpp.

Constructor & Destructor Documentation

ChunkQualityAnalyzer() [1/3]

template<typename T >

chunk_metrics::ChunkQualityAnalyzer< T >::ChunkQualityAnalyzer ( )

default

~ChunkQualityAnalyzer()

template<typename T >

chunk_metrics::ChunkQualityAnalyzer< T >::~ChunkQualityAnalyzer ( )

default

ChunkQualityAnalyzer() [2/3]

template<typename T >

chunk_metrics::ChunkQualityAnalyzer< T >::ChunkQualityAnalyzer ( const ChunkQualityAnalyzer< T > &  )

delete

ChunkQualityAnalyzer() [3/3]

template<typename T >

chunk_metrics::ChunkQualityAnalyzer< T >::ChunkQualityAnalyzer ( ChunkQualityAnalyzer< T > &&  )

delete

Member Function Documentation

clear_cache()

template<typename T >

void chunk_metrics::ChunkQualityAnalyzer< T >::clear_cache ( ) const

inline

Definition at line 279 of file chunk_metrics.hpp.

                             {
        // No-op in single-threaded version
    }

compare_cohesion()

template<typename T >

bool chunk_metrics::ChunkQualityAnalyzer< T >::compare_cohesion ( const std::vector< std::vector< T > > &  well_separated, const std::vector< std::vector< T > > &  mixed, double &  high_result, double &  mixed_result  ) const

inline

Definition at line 117 of file chunk_metrics.hpp.

                                                     {
        try {
            if (well_separated.empty() || mixed.empty()) {
                return false;
            }
 
            high_result = compute_cohesion(well_separated);
            mixed_result = compute_cohesion(mixed);
 
            return std::isfinite(high_result) && 
                   std::isfinite(mixed_result) && 
                   high_result > mixed_result;
        } catch (...) {
            return false;
        }
    }

compute_chunk_cohesion()

template<typename T >

double chunk_metrics::ChunkQualityAnalyzer< T >::compute_chunk_cohesion ( const std::vector< T > &  chunk ) const

inlineprivate

Definition at line 61 of file chunk_metrics.hpp.

                                                                   {
        if (chunk.size() < 2) return 0.0;
 
        std::vector<double> distances;
        distances.reserve((chunk.size() * (chunk.size() - 1)) / 2);
 
        for (size_t i = 0; i < chunk.size(); ++i) {
            for (size_t j = i + 1; j < chunk.size(); ++j) {
                double dist = detail::safe_distance(chunk[i], chunk[j]);
                if (dist < std::numeric_limits<double>::max()) {
                    distances.push_back(dist);
                }
            }
        }
 
        if (distances.empty()) return 0.0;
        std::sort(distances.begin(), distances.end());
        return distances[distances.size() / 2];  // Return median distance
    }

compute_cohesion()

template<typename T >

double chunk_metrics::ChunkQualityAnalyzer< T >::compute_cohesion ( const std::vector< std::vector< T > > &  chunks ) const

inline

Definition at line 91 of file chunk_metrics.hpp.

                                                                         {
        if (chunks.empty()) {
            throw std::invalid_argument("Empty chunks");
        }
 
        std::vector<double> cohesion_values;
        cohesion_values.reserve(chunks.size());
 
        for (const auto& chunk : chunks) {
            if (chunk.empty() || chunk.size() > 1000000) {
                throw std::invalid_argument("Invalid chunk size");
            }
            double chunk_cohesion = compute_chunk_cohesion(chunk);
            if (std::isfinite(chunk_cohesion)) {
                cohesion_values.push_back(chunk_cohesion);
            }
        }
 
        if (cohesion_values.empty()) {
            throw std::runtime_error("No valid cohesion values computed");
        }
 
        std::sort(cohesion_values.begin(), cohesion_values.end());
        return cohesion_values[cohesion_values.size() / 2];
    }

Referenced by main().

compute_quality_score()

template<typename T >

double chunk_metrics::ChunkQualityAnalyzer< T >::compute_quality_score ( const std::vector< std::vector< T > > &  chunks ) const

inline

Definition at line 226 of file chunk_metrics.hpp.

                                                                              {
        if (chunks.empty()) {
            throw std::invalid_argument("Empty chunks vector");
        }
 
        try {
            double cohesion = compute_cohesion(chunks);
            double separation = chunks.size() > 1 ? compute_separation(chunks) : 1.0;
 
            if (!std::isfinite(cohesion) || !std::isfinite(separation)) {
                throw std::runtime_error("Invalid metric values computed");
            }
 
            return (cohesion + separation) / 2.0;
        } catch (const std::exception& e) {
            throw std::runtime_error(std::string("Error computing quality score: ") + e.what());
        }
    }

Referenced by main().

compute_separation()

template<typename T >

double chunk_metrics::ChunkQualityAnalyzer< T >::compute_separation ( const std::vector< std::vector< T > > &  chunks ) const

inline

Definition at line 137 of file chunk_metrics.hpp.

                                                                           {
        if (chunks.size() < 2) {
            throw std::invalid_argument("Need at least two chunks for separation");
        }
 
        double total_separation = 0.0;
        size_t valid_pairs = 0;
 
        for (size_t i = 0; i < chunks.size(); ++i) {
            for (size_t j = i + 1; j < chunks.size(); ++j) {
                if (chunks[i].empty() || chunks[j].empty()) continue;
 
                double mean_i = detail::safe_mean(chunks[i]);
                double mean_j = detail::safe_mean(chunks[j]);
 
                if (std::isfinite(mean_i) && std::isfinite(mean_j)) {
                    total_separation += std::abs(mean_i - mean_j);
                    ++valid_pairs;
                }
            }
        }
 
        if (valid_pairs == 0) {
            throw std::runtime_error("No valid separation values computed");
        }
 
        return total_separation / valid_pairs;
    }

Referenced by main().

compute_silhouette_score()

template<typename T >

double chunk_metrics::ChunkQualityAnalyzer< T >::compute_silhouette_score ( const std::vector< std::vector< T > > &  chunks ) const

inline

Definition at line 166 of file chunk_metrics.hpp.

                                                                                 {
        if (chunks.size() < 2) {
            throw std::invalid_argument("Need at least two chunks for silhouette score");
        }
 
        double total_score = 0.0;
        size_t total_points = 0;
 
        for (size_t i = 0; i < chunks.size(); ++i) {
            for (const auto& point : chunks[i]) {
                // Calculate a (average distance to points in same chunk)
                double a = 0.0;
                size_t same_chunk_count = 0;
                for (const auto& other_point : chunks[i]) {
                    if (&point != &other_point) {
                        double dist = detail::safe_distance(point, other_point);
                        if (dist < std::numeric_limits<double>::max()) {
                            a += dist;
                            ++same_chunk_count;
                        }
                    }
                }
                a = same_chunk_count > 0 ? a / same_chunk_count : 0.0;
 
                // Calculate b (minimum average distance to other chunks)
                double b = std::numeric_limits<double>::max();
                for (size_t j = 0; j < chunks.size(); ++j) {
                    if (i != j) {
                        double avg_dist = 0.0;
                        size_t valid_dist = 0;
                        for (const auto& other_point : chunks[j]) {
                            double dist = detail::safe_distance(point, other_point);
                            if (dist < std::numeric_limits<double>::max()) {
                                avg_dist += dist;
                                ++valid_dist;
                            }
                        }
                        if (valid_dist > 0) {
                            b = std::min(b, avg_dist / valid_dist);
                        }
                    }
                }
 
                if (std::isfinite(a) && std::isfinite(b) && b < std::numeric_limits<double>::max()) {
                    double max_ab = std::max(a, b);
                    if (max_ab > 0) {
                        total_score += (b - a) / max_ab;
                        ++total_points;
                    }
                }
            }
        }
 
        if (total_points == 0) {
            throw std::runtime_error("No valid silhouette scores computed");
        }
 
        return total_score / total_points;
    }

Referenced by main().

compute_size_metrics()

template<typename T >

std::map< std::string, double > chunk_metrics::ChunkQualityAnalyzer< T >::compute_size_metrics ( const std::vector< std::vector< T > > &  chunks ) const

inline

Definition at line 245 of file chunk_metrics.hpp.

                                                                                                {
        if (chunks.empty()) {
            throw std::invalid_argument("Empty chunks vector");
        }
 
        std::map<std::string, double> metrics;
        double avg_size = 0.0;
        double max_size = 0.0;
        double min_size = static_cast<double>(chunks[0].size());
 
        for (const auto& chunk : chunks) {
            double size = static_cast<double>(chunk.size());
            avg_size += size;
            max_size = std::max(max_size, size);
            min_size = std::min(min_size, size);
        }
        avg_size /= static_cast<double>(chunks.size());
 
        double variance = 0.0;
        for (const auto& chunk : chunks) {
            double diff = static_cast<double>(chunk.size()) - avg_size;
            variance += diff * diff;
        }
        variance /= static_cast<double>(chunks.size());
 
        metrics["average_size"] = avg_size;
        metrics["max_size"] = max_size;
        metrics["min_size"] = min_size;
        metrics["size_variance"] = variance;
        metrics["size_stddev"] = std::sqrt(variance);
 
        return metrics;
    }

Referenced by main().

operator=() [1/2]

template<typename T >

ChunkQualityAnalyzer & chunk_metrics::ChunkQualityAnalyzer< T >::operator= ( ChunkQualityAnalyzer< T > &&  )

delete

operator=() [2/2]

template<typename T >

ChunkQualityAnalyzer & chunk_metrics::ChunkQualityAnalyzer< T >::operator= ( const ChunkQualityAnalyzer< T > &  )

delete

---

The documentation for this class was generated from the following file:

• chunk_metrics.hpp