compute_entropy_statistic()

std::vector< double > MayaFlux::Yantra::compute_entropy_statistic	(	std::span< const double >	data,
		const size_t	num_windows,
		const uint32_t	hop_size,
		const uint32_t	window_size,
		size_t	num_bins = 0
	)

Compute entropy statistic using zero-copy processing.

This function computes the Shannon entropy for a given data span. It calculates information content based on value distribution in each window.

Parameters

data	Input data span
num_windows	Number of windows to process
hop_size	Hop size for windowing
window_size	Size of each window
num_bins	Number of histogram bins (0 = auto-detect)

Returns

Vector of entropy values

Definition at line 587 of file AnalysisHelper.cpp.

{
    std::vector<double> entropy_values(num_windows);
 
    std::vector<size_t> indices(num_windows);
    std::iota(indices.begin(), indices.end(), 0);
 
    std::for_each(std::execution::par_unseq, indices.begin(), indices.end(),
        [&](size_t i) {
            const size_t start_idx = i * hop_size;
            const size_t end_idx = std::min(start_idx + window_size, data.size());
            auto window = data.subspan(start_idx, end_idx - start_idx);
 
            if (window.empty()) {
                entropy_values[i] = 0.0;
                return;
            }
 
            size_t bins = num_bins;
            if (bins == 0) {
                bins = static_cast<size_t>(std::ceil(std::log2(window.size()) + 1));
                bins = std::max(bins, static_cast<size_t>(1));
                bins = std::min(bins, window.size());
            }
 
            auto [min_it, max_it] = std::ranges::minmax_element(window);
            double min_val = *min_it;
            double max_val = *max_it;
 
            if (max_val <= min_val) {
                entropy_values[i] = 0.0;
                return;
            }
 
            double bin_width = (max_val - min_val) / static_cast<double>(bins);
 
            std::vector<size_t> bin_counts(bins, 0);
            for (double value : window) {
                auto bin_idx = static_cast<size_t>((value - min_val) / bin_width);
                if (bin_idx >= bins)
                    bin_idx = bins - 1;
                bin_counts[bin_idx]++;
            }
 
            double entropy = 0.0;
            size_t total_count = window.size();
 
            for (size_t count : bin_counts) {
                if (count > 0) {
                    double probability = static_cast<double>(count) / static_cast<double>(total_count);
                    entropy -= probability * std::log2(probability);
                }
            }
 
            entropy_values[i] = entropy;
        });
 
    return entropy_values;
}

References compute_entropy_statistic().

Referenced by compute_entropy_statistic(), and MayaFlux::Yantra::StatisticalAnalyzer< InputType, OutputType >::compute_statistical_values().

Here is the call graph for this function:

Here is the caller graph for this function: