continuos_covariate_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../utils/Data.hpp"
#include "../../utils/Module.hpp"
#include "Eigen/Dense"
#include <cmath>
#include <vector>

class ContinuosCovariatesModule : public Module {
protected:

    const Data &data;


    const Eigen::VectorXd continuos_covariate_data; 
    const bool fixed_v;                             
    const double m;                                 
    const double B;                                 
    const double v;                                 
    const double nu;                                
    const double S0;                                



    struct ClusterStats {
        int n = 0;
        double sum = 0.0;
        double sumsq = 0.0;
    };

    ClusterStats compute_cluster_statistics(const Eigen::Ref<const Eigen::VectorXi> obs) const;

    double compute_log_marginal_likelihood_NN(const ClusterStats &stats) const __attribute__((hot));

    double compute_log_marginal_likelihood_NNIG(const ClusterStats &stats) const __attribute__((hot));

    double compute_predictive_NN(const ClusterStats &stats, double covariate_val) const;

    double compute_predictive_NNIG(const ClusterStats &stats, double covariate_val) const;

    inline double compute_log_marginal_likelihood(const ClusterStats &stats) const __attribute__((hot)) {
        if (fixed_v) {
            return compute_log_marginal_likelihood_NN(stats);
        } else {
            return compute_log_marginal_likelihood_NNIG(stats);
        }
    }

    inline double compute_log_predictive_likelihood(const ClusterStats &stats, double covariate_val) const
        __attribute__((hot, always_inline)) {
        if (fixed_v) {
            return compute_predictive_NN(stats, covariate_val);
        } else {
            return compute_predictive_NNIG(stats, covariate_val);
        }
    }


 
    const double Bv; 
 
    const double log_B; 
    const double log_v; 
 
    const double const_term; 
 
    const double lgamma_nu; 
    const double nu_logS0;  
 
    std::vector<double> log_v_plus_nB; 
    std::vector<double> lgamma_nu_n;   

 
public:
    ContinuosCovariatesModule(const Data &data_, const Eigen::VectorXd covariates_data_, bool fixed_v_, double m_ = 0,
                              double B_ = 1.0, double v_ = 1.0, double nu_ = 1.0, double S0_ = 1.0,
                              const Eigen::VectorXi *old_alloc_provider = nullptr,
                              const std::unordered_map<int, std::vector<int>> *old_cluster_members_provider_ = nullptr)
        : continuos_covariate_data(covariates_data_), fixed_v(fixed_v_), m(m_), B(B_), v(v_), nu(nu_), S0(S0_),
          data(data_), Module(old_alloc_provider, old_cluster_members_provider_), Bv(B * v), log_B(std::log(B)),
          log_v(std::log(v)), const_term(-0.5 * std::log(2.0 * M_PI)), lgamma_nu(std::lgamma(nu)),
          nu_logS0(nu * std::log(S0)) {
        // Precompute caches for efficiency if needed
        if (fixed_v) {
            log_v_plus_nB.reserve(data_.get_n() + 1);
            for (int n = 0; n <= data_.get_n(); ++n) {
                log_v_plus_nB.push_back(std::log(v + n * B));
            }
        } else {
            lgamma_nu_n.reserve(data_.get_n() + 1);
            for (int n = 0; n <= data_.get_n(); ++n) {
                lgamma_nu_n.push_back(std::lgamma(nu + 0.5 * static_cast<double>(n)));
            }
        }
    }


    double compute_similarity_cls(int cls_idx, bool old_allo = false) const override __attribute__((hot));

    double compute_similarity_obs(int obs_idx, int cls_idx) const override __attribute__((hot));

    Eigen::VectorXd compute_similarity_obs(int obs_idx) const override __attribute__((hot));

};