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 545 of file StatisticalAnalyzer.hpp.

    {
        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;
 
            auto mean_result = compute_mean_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size());
            channel_result.mean_stat = mean_result.empty() ? 0.0 : mean_result[0];
 
            auto variance_result = compute_variance_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size(), m_sample_variance);
            channel_result.stat_variance = variance_result.empty() ? 0.0 : variance_result[0];
            channel_result.stat_std_dev = std::sqrt(channel_result.stat_variance);
 
            auto skew_result = compute_skewness_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size());
            channel_result.skewness = skew_result.empty() ? 0.0 : skew_result[0];
 
            auto kurt_result = compute_kurtosis_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size());
            channel_result.kurtosis = kurt_result.empty() ? 0.0 : kurt_result[0];
 
            auto median_result = compute_median_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size());
            channel_result.median = median_result.empty() ? 0.0 : median_result[0];
 
            auto q25_result = compute_percentile_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size(), 25.0);
            auto q75_result = compute_percentile_statistic(std::span<const double>(ch_stats), 1, 0, ch_stats.size(), 75.0);
            channel_result.percentiles = {
                q25_result.empty() ? 0.0 : q25_result[0], // Q1
                channel_result.median, // Q2
                q75_result.empty() ? 0.0 : q75_result[0] // Q3
            };
 
            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 MayaFlux::Yantra::StatisticalAnalysis::channel_statistics, MayaFlux::Yantra::compute_kurtosis_statistic(), MayaFlux::Yantra::compute_mean_statistic(), MayaFlux::Yantra::compute_median_statistic(), MayaFlux::Yantra::compute_percentile_statistic(), MayaFlux::Yantra::compute_skewness_statistic(), MayaFlux::Yantra::compute_variance_statistic(), MayaFlux::Yantra::StatisticalAnalysis::hop_size, MayaFlux::Yantra::StatisticalAnalysis::method_used, and MayaFlux::Yantra::StatisticalAnalysis::window_size.

Here is the call graph for this function: