regress.hpp

Go to the documentation of this file.

// toolboxes/stats/include/nk/stats/regress/regress.hpp
//
// Linear regression — function form.
 
#pragma once
 
#include <limits>
#include <memory_resource>
#include <nk/value/value.hpp>
#include <nk/value/fn_handle.hpp>
 
#include <tuple>
 
 
namespace nk::stats {

 

std::tuple<Value, Value, Value, Value>
regress(const Value &y, const Value &X, double alpha,
        std::pmr::memory_resource *mr = nullptr);

Value ridge(const Value &y, const Value &X, const Value &k, bool scaled,
            std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value, Value, Value>
lscov(const Value &A, const Value &b, const Value &w,
      std::pmr::memory_resource *mr = nullptr);

struct NlinfitResult {
    Value beta;   
    Value R;      
    Value J;      
    Value CovB;   
    Value MSE;    
};

NlinfitResult nlinfit(const Value &X, const Value &y,
                      FnHandle model, const Value &beta0,
                      std::pmr::memory_resource *mr = nullptr);

Value nlparci(const Value &beta, const Value &R, const Value &J,
              double alpha = 0.05,
              std::pmr::memory_resource *mr = nullptr);

std::tuple<Value, Value>
nlpredci(FnHandle model, const Value &X, const Value &beta,
         const Value &R, const Value &J,
         double alpha,
         std::pmr::memory_resource *mr = nullptr);

enum class RobustWeight {
    Andrews, Bisquare, Cauchy, Fair, Huber,
    Logistic, Ols, Talwar, Welsch
};

struct RobustfitResult {
    Value b; 
    Value s; 
};

RobustfitResult robustfit(const Value &X, const Value &y,
                           RobustWeight weight = RobustWeight::Bisquare,
                           double tune = std::numeric_limits<double>::quiet_NaN(),
                           std::pmr::memory_resource *mr = nullptr);

struct RobustcovResult {
    Value sigma; 
    Value mu;    
};

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

enum class GlmDistribution {
    Normal,
    Binomial,
    Poisson,
    Gamma,
    InverseGaussian,
};

enum class GlmLink {
    Identity,    
    Logit,       
    Log,         
    Reciprocal,  
    Probit,      
};

struct GlmfitResult {
    Value b;     
    Value dev;   
};

GlmfitResult glmfit(const Value &X, const Value &y,
                     GlmDistribution distr,
                     GlmLink link = GlmLink::Identity,
                     std::pmr::memory_resource *mr = nullptr);

Value glmval(const Value &b, const Value &X, GlmLink link,
              std::pmr::memory_resource *mr = nullptr);

struct LassoResult {
    Value B;            
    Value Intercept;    
    Value Lambda;       
};

LassoResult lasso(const Value &X, const Value &y, const Value &lambdas,
                   double alpha = 1.0,
                   std::pmr::memory_resource *mr = nullptr);

LassoResult lassoglm(const Value &X, const Value &y,
                      GlmDistribution distr,
                      const Value &lambdas, double alpha = 1.0,
                      std::pmr::memory_resource *mr = nullptr);
 

} // namespace nk::stats