entropy()

std::vector< double > MayaFlux::Kinesis::Discrete::entropy	(	std::span< const double >	data,
		size_t	n_windows,
		uint32_t	hop_size,
		uint32_t	window_size,
		size_t	num_bins = 0
	)

Shannon entropy per window using Sturges-rule histogram.

Parameters

num_bins

Histogram bin count; 0 = auto via Sturges rule

Definition at line 375 of file Analysis.cpp.

{
    std::vector<double> out(n_windows);
    std::vector<size_t> idx(n_windows);
    std::iota(idx.begin(), idx.end(), 0);
 
    Parallel::for_each(Parallel::par_unseq, idx.begin(), idx.end(),
        [&](size_t i) {
            const size_t start = i * hop_size;
            auto w = data.subspan(start, std::min<size_t>(window_size, data.size() - start));
            if (w.empty()) {
                out[i] = 0.0;
                return;
            }
            size_t bins = num_bins;
            if (bins == 0) {
                bins = std::clamp(
                    static_cast<size_t>(std::ceil(std::log2(static_cast<double>(w.size())) + 1.0)),
                    size_t { 1 }, w.size());
            }
            const auto [mn, mx] = std::ranges::minmax(w);
            if (mx <= mn) {
                out[i] = 0.0;
                return;
            }
            const double bw = (mx - mn) / static_cast<double>(bins);
            std::vector<size_t> counts(bins, 0);
            for (double v : w) {
                auto b = static_cast<size_t>((v - mn) / bw);
                counts[std::min(b, bins - 1)]++;
            }
            double e = 0.0;
            const auto n = static_cast<double>(w.size());
            for (size_t c : counts) {
                if (c > 0) {
                    const double p = static_cast<double>(c) / n;
                    e -= p * std::log2(p);
                }
            }
            out[i] = e;
        });
 
    return out;
}

References b, and entropy().

Referenced by entropy().

Here is the call graph for this function:

Here is the caller graph for this function: