descriptive.hpp

Go to the documentation of this file.

// toolboxes/stats/include/nk/stats/descriptive/descriptive.hpp
//
// Descriptive statistics — Phase 1 of the parity expansion plan.
 
#pragma once
 
#include <memory_resource>
#include <nk/value/value.hpp>
 
#include <limits>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
namespace nk::stats {

 


Value var(const Value &x, int normFlag = 0, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value stdev(const Value &x, int normFlag = 0, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value median(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value quantile(const Value &x, const Value &p, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value prctile(const Value &x, const Value &p, int dim = 0, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value>
mode(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);
 
// nan-aware reductions and higher moments moved to companion headers:
//   <nk/stats/nan_aware/nan_aware.hpp>
//   <nk/stats/moments/moments.hpp>

Value cov(const Value &x, int normFlag = 0, std::pmr::memory_resource *mr = nullptr);

Value cov(const Value &x, const Value &y, int normFlag = 0, std::pmr::memory_resource *mr = nullptr);

Value corrcoef(const Value &x, std::pmr::memory_resource *mr = nullptr);

Value corrcoef(const Value &x, const Value &y, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value>
bounds(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value iqr(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value maxk(const Value &x, int k, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value mink(const Value &x, int k, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value rmse(const Value &f, const Value &a, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value mape(const Value &f, const Value &a, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value partialcorr_of(const Value &X, const Value &Y, const Value &Z, std::pmr::memory_resource *mr = nullptr);

Value partialcorr_xx(const Value &X, std::pmr::memory_resource *mr = nullptr);

Value partialcorr_xz(const Value &X, const Value &Z, std::pmr::memory_resource *mr = nullptr);

Value partialcorri(const Value &Y, const Value &X, const Value &Z = {},
                   std::pmr::memory_resource *mr = nullptr);

struct CanoncorrResult {
    Value A;  
    Value B;  
    Value r;  
};

CanoncorrResult canoncorr(const Value &X, const Value &Y,
                           std::pmr::memory_resource *mr = nullptr);

Value corr_xx(const Value &X, std::pmr::memory_resource *mr = nullptr);

Value corr_xy(const Value &X, const Value &Y, std::pmr::memory_resource *mr = nullptr);

Value detrend_of(const Value &x, int order = 1, std::pmr::memory_resource *mr = nullptr);

Value isoutlier_of(const Value &x, std::pmr::memory_resource *mr = nullptr);

Value rmoutliers_of(const Value &x, std::pmr::memory_resource *mr = nullptr);

Value fillmissing_of(const Value &x, const std::string &method, double constVal = 0.0, std::pmr::memory_resource *mr = nullptr);

Value rmmissing_of(const Value &x, std::pmr::memory_resource *mr = nullptr);

Value standardizeMissing_of(const Value &x, double sentinel, std::pmr::memory_resource *mr = nullptr);

Value range_of(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value mad_of(const Value &x, int flag = 0, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value geomean_of(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value harmmean_of(const Value &x, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value moment_of(const Value &x, int order, int dim = 0, std::pmr::memory_resource *mr = nullptr);

Value trimmean_of(const Value &x, double pct, int dim = 0, bool useFloor = false,
                  std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value>
prepareCurveData(const Value &x, const Value &y, const Value &w, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value>
prepareSurfaceData(const Value &x, const Value &y, const Value &z, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value, Value, Value, Value, Value>
datastats(const Value &x, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value>
ecdf(const Value &y, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value>
ksdensity(const Value &x, const Value &pts, double bw_user, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value>
ecdfhist(const Value &f, const Value &x, int m = 10, std::pmr::memory_resource *mr = nullptr);

struct NormalizeResult {
    Value n; 
    Value c; 
    Value s; 
};

NormalizeResult normalize(const Value &A, const std::string &method,
                          const Value &param = Value::Empty,
                          std::pmr::memory_resource *mr = nullptr);

Value rescale(const Value &A, double lo, double hi, std::pmr::memory_resource *mr = nullptr,
              double inputMin = std::numeric_limits<double>::quiet_NaN(),
              double inputMax = std::numeric_limits<double>::quiet_NaN());

Value zscore(const Value &A, std::pmr::memory_resource *mr = nullptr);

std::pair<Value, Value>
tiedrank(const Value &x, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value>
autocorr(const Value &y, int numLags = -1, double numSTD = 2.0,
         std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value>
crosscorr(const Value &y1, const Value &y2, int numLags = -1, double numSTD = 2.0,
          std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value>
parcorr(const Value &y, int numLags = -1, double numSTD = 2.0,
        std::pmr::memory_resource *mr = nullptr);

std::pair<Value, Value>
corrcov(const Value &C, std::pmr::memory_resource *mr = nullptr);

Value tabulate(const Value &x, std::pmr::memory_resource *mr = nullptr);

std::pair<Value, Value>
cholcov(const Value &SIGMA, std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, double, double>
crosstab(const Value &x, const Value &y_opt = Value::Empty,
         std::pmr::memory_resource *mr = nullptr);

std::vector<Value>
grpstats(const Value &X, const Value &group, const std::vector<std::string> &fn_names, std::pmr::memory_resource *mr = nullptr);

Value nearcorr(const Value &A, std::pmr::memory_resource *mr = nullptr);

struct Grp2idxResult {
    Value G;   
    Value GN;  
    Value GL;  
};

Grp2idxResult grp2idx(const Value &s, std::pmr::memory_resource *mr = nullptr);

Value filloutliers(const Value &A, const Value &fillMethod,
                   const std::string &findMethod = "median",
                   double thresholdFactor = std::numeric_limits<double>::quiet_NaN(),
                   std::pmr::memory_resource *mr = nullptr);
 

} // namespace nk::stats