continuos_covariate_module_cache.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../utils/Data.hpp"
#include "../caches/continuos_cache.hpp"
#include "../../utils/Module.hpp"
#include <cmath>
#include <vector>

class ContinuosCovariatesModuleCache : public Module {
protected:
    const Data &data;
 
    const ContinuosCache &continuos_cache; 


    const bool fixed_v; 
    const double m;     
    const double B;     
    const double v;     
    const double nu;    
    const double S0;    



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

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

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

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

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

    inline double compute_log_marginal_likelihood(const ContinuosCache::ClusterStats &stats) const __attribute__((hot, always_inline)) {
        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 ContinuosCache::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:
    ContinuosCovariatesModuleCache(const Data &data_, const ContinuosCache &continuos_cache_, 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 = {},
                                   const std::unordered_map<int, std::vector<int>> *old_cluster_members_provider_ = {})
        : data(data_), continuos_cache(continuos_cache_), fixed_v(fixed_v_), m(m_), B(B_), v(v_), nu(nu_), S0(S0_),
          Module(old_alloc_provider, old_cluster_members_provider_),
          // Initialize constants here in the list
          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;

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

    Eigen::VectorXd compute_similarity_obs(int obs_idx) const;

};