create_analysis_result()

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = Eigen::VectorXd>

StatisticalAnalysis MayaFlux::Yantra::StatisticalAnalyzer< InputType, OutputType >::create_analysis_result ( const std::vector< std::vector< double > > &  stat_values, std::vector< std::span< const double > >  original_data, const auto &    ) const

inlineprivate

Create comprehensive analysis result.

Definition at line 558 of file StatisticalAnalyzer.hpp.

    {
        namespace D = MayaFlux::Kinesis::Discrete;
 
        StatisticalAnalysis result;
        result.method_used = m_method;
        result.window_size = m_window_size;
        result.hop_size = m_hop_size;
 
        if (stat_values.empty()) {
            return result;
        }
 
        result.channel_statistics.resize(stat_values.size());
 
        for (size_t ch = 0; ch < stat_values.size(); ++ch) {
            auto& channel_result = result.channel_statistics[ch];
            const auto& ch_stats = stat_values[ch];
 
            channel_result.statistical_values = ch_stats;
 
            if (ch_stats.empty())
                continue;
 
            const auto [min_it, max_it] = std::ranges::minmax_element(ch_stats);
            channel_result.min_stat = *min_it;
            channel_result.max_stat = *max_it;
 
            const std::span<const double> sp(ch_stats);
            const auto sz = static_cast<uint32_t>(ch_stats.size());
 
            const auto single = [&](auto fn) { return fn(sp, 1, 0, sz)[0]; };
 
            channel_result.mean_stat = single([](auto&&... a) { return D::mean(a...); });
            channel_result.stat_variance = single([&](auto&&... a) { return D::variance(a..., m_sample_variance); });
            channel_result.stat_std_dev = std::sqrt(channel_result.stat_variance);
            channel_result.skewness = single([](auto&&... a) { return D::skewness(a...); });
            channel_result.kurtosis = single([](auto&&... a) { return D::kurtosis(a...); });
            channel_result.median = single([](auto&&... a) { return D::median(a...); });
 
            channel_result.percentiles = {
                D::percentile(sp, 1, 0, sz, 25.0)[0],
                channel_result.median,
                D::percentile(sp, 1, 0, sz, 75.0)[0]
            };
 
            const size_t data_size = (ch < original_data.size()) ? original_data[ch].size() : 0;
            channel_result.window_positions.reserve(ch_stats.size());
            for (size_t i = 0; i < ch_stats.size(); ++i) {
                const size_t start = i * m_hop_size;
                const size_t end = std::min(start + m_window_size, data_size);
                channel_result.window_positions.emplace_back(start, end);
            }
 
            if (m_classification_enabled) {
                channel_result.stat_classifications.reserve(ch_stats.size());
                channel_result.level_counts.fill(0);
 
                for (double value : ch_stats) {
                    const StatisticalLevel level = classify_statistical_level(value);
                    channel_result.stat_classifications.push_back(level);
                    channel_result.level_counts[static_cast<size_t>(level)]++;
                }
            }
        }
 
        return result;
    }

References a, MayaFlux::Yantra::StatisticalAnalysis::channel_statistics, MayaFlux::Yantra::StatisticalAnalysis::hop_size, MayaFlux::Yantra::StatisticalAnalysis::method_used, size, and MayaFlux::Yantra::StatisticalAnalysis::window_size.