model-bones.hpp

Go to the documentation of this file.

#ifndef BARRY_MODEL_BONES_HPP 
#define BARRY_MODEL_BONES_HPP 1
 
template<
    typename Array_Type = BArray<>,
    typename Data_Counter_Type = bool,
    typename Data_Rule_Type  = bool,
    typename Data_Rule_Dyn_Type = bool
    >
class Model {
 
protected:
    std::mt19937 * rengine = nullptr;
    bool delete_rengine    = false;
 
    std::vector< double >                stats_support;           
    std::vector< size_t >                stats_support_sizes;     
    std::vector< size_t >                stats_support_sizes_acc; 
    std::vector< size_t >                stats_support_n_arrays;  
    std::vector< std::vector< double > > stats_target;            
    std::vector< double >                stats_likelihood;
    std::vector< size_t >                arrays2support;
 
    MapVec_type< double, size_t > keys2support;
 
    bool with_pset = false;
    std::vector< std::vector< Array_Type > > pset_arrays; 
    std::vector< double > pset_stats;     
    std::vector< double > pset_probs;     
    std::vector< size_t > pset_sizes;     
    std::vector< size_t > pset_locations; 
    
    Counters<Array_Type,Data_Counter_Type> *                                counters;
    Rules<Array_Type,Data_Rule_Type> *                                      rules;
    Rules<Array_Type,Data_Rule_Dyn_Type> *                                  rules_dyn;
    Support<Array_Type,Data_Counter_Type,Data_Rule_Type,Data_Rule_Dyn_Type> support_fun;
    StatsCounter<Array_Type,Data_Counter_Type>                              counter_fun;
    
    std::vector< std::vector<double> > params_last;
    std::vector< double > normalizing_constants;
    std::vector< bool > first_calc_done;
 
    bool delete_counters  = false;
    bool delete_rules     = false;
    bool delete_rules_dyn = false;
 
    std::function<std::vector<double>(double *, size_t k)>
        transform_model_fun = nullptr;
 
    std::vector< std::string > transform_model_term_names;
    
public:
 
    void update_normalizing_constants(
        const std::vector< double > & params,
        BARRY_NCORES_ARG(=1),
        int i = -1
        );
 
    void update_likelihoods(
        const std::vector< double > & params,
        BARRY_NCORES_ARG(=1)
        );
 
    void update_pset_probs(
        const std::vector< double > & params,
        BARRY_NCORES_ARG(=1),
        int i = -1
        );
    
    void set_rengine(std::mt19937 * rengine_, bool delete_ = false) {
 
        if (delete_rengine)
            delete rengine;
 
        rengine        = rengine_;
        delete_rengine = delete_;
        
    };
 
    void set_seed(size_t s) {
 
        if (rengine == nullptr)
        {
            rengine = new std::mt19937;
            delete_rengine = true;
        }
 
        rengine->seed(s);
 
    };
        
    Model();
    Model(size_t size_);
    Model(const Model<Array_Type,Data_Counter_Type,Data_Rule_Type,Data_Rule_Dyn_Type> & Model_);
    Model<Array_Type,Data_Counter_Type,Data_Rule_Type,Data_Rule_Dyn_Type> & operator=(
        const Model<Array_Type,Data_Counter_Type,Data_Rule_Type,Data_Rule_Dyn_Type> & Model_
    );
 
    virtual ~Model() {
        if (delete_counters)
            delete counters;
 
        if (delete_rules)
            delete rules;
 
        if (delete_rules_dyn)
            delete rules_dyn;
 
        if (delete_rengine)
            delete rengine;
    };
    
    void store_psets() noexcept;
    std::vector< double > gen_key(const Array_Type & Array_);
    
    void add_counter(Counter<Array_Type, Data_Counter_Type> & counter);
    void add_counter(
        Counter_fun_type<Array_Type,Data_Counter_Type> count_fun_,
        Counter_fun_type<Array_Type,Data_Counter_Type> init_fun_    = nullptr,
        Data_Counter_Type                              data_        = nullptr
    );
    void set_counters(Counters<Array_Type,Data_Counter_Type> * counters_);
    void add_hasher(Hasher_fun_type<Array_Type,Data_Counter_Type> fun_);
    
    void add_rule(Rule<Array_Type, Data_Rule_Type> & rule);
    void add_rule(
        Rule_fun_type<Array_Type, Data_Rule_Type> count_fun_,
        Data_Rule_Type                            data_
    );
    
    void set_rules(Rules<Array_Type,Data_Rule_Type> * rules_);
 
    void add_rule_dyn(Rule<Array_Type, Data_Rule_Dyn_Type> & rule);
    void add_rule_dyn(
        Rule_fun_type<Array_Type, Data_Rule_Dyn_Type> count_fun_,
        Data_Rule_Dyn_Type                            data_
    );
    
    void set_rules_dyn(Rules<Array_Type,Data_Rule_Dyn_Type> * rules_);
    
 
    size_t add_array(const Array_Type & Array_, bool force_new = false);
    
    
    double likelihood(
        const std::vector<double> & params,
        const size_t & i,
        bool as_log = false,
        bool no_update_normconst = false
    );
    
    double likelihood(
        const std::vector<double> & params,
        const Array_Type & Array_,
        int i = -1,
        bool as_log = false,
        bool no_update_normconst = false
    );
    
    double likelihood(
        const std::vector<double> & params,
        const std::vector<double> & target_,
        const size_t & i,
        bool as_log = false,
        bool no_update_normconst = false
    );
 
    double likelihood(
        const std::vector<double> & params,
        const double * target_,
        const size_t & i,
        bool as_log = false,
        bool no_update_normconst = false
    );
    
    double likelihood_total(
        const std::vector<double> & params,
        bool as_log = false,
        BARRY_NCORES_ARG(=2),
        bool no_update_normconst = false
    );
 
    const std::vector< double > & get_normalizing_constants() const;
    const std::vector< double > & get_likelihoods() const;
 
    const std::vector< Array_Type > * get_pset(
        const size_t & i
    );
 
    const double * get_pset_stats(
        const size_t & i
    );
    
    void print_stats(size_t i) const;
 
    virtual void print() const;
    
    Array_Type sample(const Array_Type & Array_, const std::vector<double> & params = {});
    Array_Type sample(const size_t & i, const std::vector<double> & params);
    
    double conditional_prob(
        const Array_Type & Array_,
        const std::vector< double > & params,
        size_t i,
        size_t j
    );
    
    size_t size() const noexcept;
    size_t size_unique() const noexcept;
    size_t nterms() const noexcept;
    size_t nrules() const noexcept;
    size_t nrules_dyn() const noexcept;
    size_t support_size() const noexcept;
    std::vector< std::string > colnames() const;
 
    const std::mt19937 * get_rengine() const;
 
    Counters<Array_Type,Data_Counter_Type> * get_counters();
    Rules<Array_Type,Data_Rule_Type>       * get_rules();
    Rules<Array_Type,Data_Rule_Dyn_Type>   * get_rules_dyn();
    Support<Array_Type,Data_Counter_Type,Data_Rule_Type,Data_Rule_Dyn_Type> * get_support_fun();
 
    std::vector< std::vector< double > > * get_stats_target();
    std::vector< double > * get_stats_support(); 
    std::vector< size_t > * get_stats_support_sizes(); 
    std::vector< size_t > * get_stats_support_sizes_acc(); 
    std::vector< size_t > * get_arrays2support();
    std::vector< std::vector< Array_Type > > * get_pset_arrays();
    std::vector< double > * get_pset_stats();  
    std::vector< double > * get_pset_probs(); 
    std::vector< size_t > * get_pset_sizes();
    std::vector< size_t > * get_pset_locations();
 
    void set_transform_model(
        std::function<std::vector<double>(double*,size_t)> fun,
        std::vector< std::string > names
        );
    std::vector<double> transform_model(
        double * data,
        size_t k
    );
 
};
 
 
#endif