statistics.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Artificial Intelligence Techniques, S.L. and Roberto López González
 
#pragma once
 
#include "opennn/core/opennn_types.h"
 
namespace opennn
{
 
struct Descriptives
{
    Descriptives(const float = QUIET_NAN, float = QUIET_NAN, float = QUIET_NAN, float = QUIET_NAN);
 
    void set(const float = QUIET_NAN, float = QUIET_NAN, float = QUIET_NAN, float = QUIET_NAN);
 
    float minimum;
 
    float maximum;
 
    float mean;
 
    float standard_deviation;
 
};
 
inline VectorR descriptives_field(const vector<Descriptives>& descriptives,
                                  float Descriptives::* member)
{
    VectorR values(ssize(descriptives));
    for (Index i = 0; i < values.size(); ++i)
        values(i) = descriptives[size_t(i)].*member;
    return values;
}
 
struct BoxPlot
{
    BoxPlot(const float = QUIET_NAN,
            float = QUIET_NAN,
            float = QUIET_NAN,
            float = QUIET_NAN,
            float = QUIET_NAN);
 
    float minimum = QUIET_NAN;
 
    float first_quartile = QUIET_NAN;
 
    float median = QUIET_NAN;
 
    float third_quartile = QUIET_NAN;
 
    float maximum = QUIET_NAN;
};
 
struct Histogram
{
    Histogram(const Index = 0);
 
    VectorR minimums;
 
    VectorR maximums;
 
    VectorR centers;
 
    VectorR frequencies;
 
    Index calculate_minimum_frequency() const
    {
        return frequencies.size() == 0 ? Index(0) : Index(frequencies.minCoeff());
    }
 
    Index calculate_maximum_frequency() const
    {
        return frequencies.size() == 0 ? Index(0) : Index(frequencies.maxCoeff());
    }
 
    VectorR calculate_minimal_centers() const
    {
        return centers_with_frequency(calculate_minimum_frequency());
    }
 
    VectorR calculate_maximal_centers() const
    {
        return centers_with_frequency(calculate_maximum_frequency());
    }
 
private:
 
    VectorR centers_with_frequency(Index frequency) const
    {
        const Index bins_number = frequencies.size();
 
        Index matches_number = 0;
 
        for (Index j = 0; j < bins_number; ++j)
            if (Index(frequencies(j)) == frequency)
                ++matches_number;
 
        VectorR selected_centers(matches_number);
 
        Index position = 0;
 
        for (Index j = 0; j < bins_number; ++j)
            if (Index(frequencies(j)) == frequency)
                selected_centers(position++) = centers.size() > j ? centers(j) : float(j);
 
        return selected_centers;
    }
};
float minimum(const MatrixR&);
float minimum(const VectorR&);
float minimum(const VectorR&, const vector<Index>&);
float maximum(const MatrixR&);
float maximum(const VectorR&);
float maximum(const VectorR&, const vector<Index>&);
float mean(const VectorR&);
float mean(const MatrixR&, Index);
VectorR mean(const MatrixR&);
VectorR mean(const MatrixR&, const vector<Index>&, const vector<Index>&);
float median(const VectorR&);
float median(const MatrixR&, Index);
VectorR median(const MatrixR&, const vector<Index>&, const vector<Index>&);
float variance(const VectorR&);
float variance(const VectorR&, const VectorI&);
float standard_deviation(const VectorR&);
VectorR quartiles(const VectorR&);
VectorR quartiles(const VectorR&, const vector<Index>&);
BoxPlot box_plot(const VectorR&);
BoxPlot box_plot(const VectorR&, const vector<Index>&);
Descriptives vector_descriptives(const VectorR&);
vector<Descriptives> descriptives(const MatrixR&);
vector<Descriptives> descriptives(const MatrixR&, const vector<Index>&, const vector<Index>&);
Histogram histogram(const VectorR&, Index  = 10);
Histogram histogram_centered(const VectorR&, float = 0.0f, Index  = 10);
vector<Histogram> histograms(const MatrixR&, Index = 10);
Index minimal_index(const VectorR&);
Index maximal_index(const VectorR&);
VectorI maximal_indices(const VectorR&, Index);
VectorI maximal_indices(const MatrixR&);
inline bool row_finite(const VectorR& values, Index i) { return isfinite(values(i)); }
inline bool row_finite(const MatrixR& matrix, Index i) { return matrix.row(i).array().isFinite().all(); }
 
VectorR filter_missing_values(const VectorR&);
 
template<typename InputType, typename TargetType>
pair<InputType, TargetType> filter_missing_values(const InputType& x, const TargetType& y)
{
    throw_if(x.rows() != y.rows(),
             "filter_missing_values: row count mismatch");
 
    vector<Index> valid;
    valid.reserve(x.rows());
 
    for (Index i = 0; i < x.rows(); ++i)
        if (row_finite(x, i) && row_finite(y, i))
            valid.push_back(i);
 
    return {x(valid, Eigen::placeholders::all), y(valid, Eigen::placeholders::all)};
}
 
template <typename T>
inline bool is_binary(const T& tensor)
{
    return all_of(tensor.data(), tensor.data() + tensor.size(),
                  [](float value) { return value == 0.0f || value == 1.0f || isnan(value); });
}
 
template <typename T>
inline bool is_constant(const T& tensor)
{
    const float* data = tensor.data();
    const float* end = data + tensor.size();
 
    const float* first = find_if(data, end, [](float value) { return !isnan(value); });
 
    if (first == end)
        return true;
 
    const float reference_value = *first;
 
    return all_of(first + 1, end,
                  [reference_value](float value) { return isnan(value) || abs(reference_value - value) <= numeric_limits<float>::min(); });
}
 
VectorI calculate_rank(const VectorR&, bool ascending = true);
 
vector<Index> ranked_indices(const VectorR&);
 
VectorR minmax_score(const VectorR&, bool invert = false);
MatrixR minmax_score(const MatrixR&);
 
vector<Index> extreme_indices(const MatrixR&);
 
vector<VectorI> nearest_neighbors(const MatrixR&, Index);
VectorR neighbor_distances(const MatrixR&, Index);
VectorR local_outlier_factor(const MatrixR&, Index);
 
void farthest_point_fill(const MatrixR& distances, vector<Index>& selection, Index quota);
 
}