density_components_base.hpp

Go to the documentation of this file.

 
#ifndef DENSITY_COMPONENT_BASE_HPP
#define DENSITY_COMPONENT_BASE_HPP
 
#include "../../common/data_object.hpp"
#include "../../common/model_object.hpp"
#include "../../interface/interface.hpp"
#include "../../common/fims_vector.hpp"
#include "../../common/fims_math.hpp"
 
namespace fims_distributions {
 
template <typename Type>
struct DensityComponentBase : public fims_model_object::FIMSObject<Type> {
  std::string input_type;
 
  std::shared_ptr<fims_data_object::DataObject<Type>> data_observed_values;
 
  fims::Vector<Type> expected_values;
 
  fims::Vector<Type>* re = NULL;
 
  fims::Vector<Type>* re_expected_values = NULL;
 
  fims::Vector<Type>* data_expected_values = NULL;
 
  std::vector<fims::Vector<Type>*> priors;
 
  fims::Vector<Type> observed_values;
 
  fims::Vector<Type> expected_mean;
 
  std::string use_mean = fims::to_string("no");
 
  // std::shared_ptr<DistributionElementObject<Type>> expected;
  // // Expected value of distribution function.
 
  inline Type& get_observed(size_t i) {
    if (this->input_type == "data") {
      return data_observed_values->at(i);
    }
    if (this->input_type == "random_effects") {
      return (*re)[i];
    }
    if (this->input_type == "prior") {
      if (priors.size() == 0) {
        throw std::runtime_error("No priors defined for this distribution.");
      } else if (priors.size() == 1) {
        return (*(priors[0]))[i];
      } else if (priors.size() > 1) {
        return (*(priors[i]))[0];
      }
    }
    return observed_values[i];
  }
 
  inline Type& get_observed(size_t i, size_t j) {
    if (this->input_type == "data") {
      return data_observed_values->at(i, j);
    }
    return observed_values[i * (j - 1) + j];
  }
 
  inline Type& get_expected(size_t i) {
    if (this->input_type == "data") {
      return (*data_expected_values)[i];
    } else if (this->use_mean == "yes") {
      return this->expected_mean.get_force_scalar(i);
    } else if (this->input_type == "random_effects") {
      return (*re_expected_values)[i];
    } else {
      return this->expected_values.get_force_scalar(i);
    }
  }
 
  inline size_t get_n_x() {
    if (this->input_type == "data") {
      return this->data_observed_values->data.size();
    }
    if (this->input_type == "random_effects") {
      return (*re).size();
    }
    if (this->input_type == "prior") {
      return this->expected_values.size();
    }
    return observed_values.size();
  }
 
  inline size_t get_n_expected() {
    if (this->input_type == "data") {
      return (*data_expected_values).size();
    }
    if (this->input_type == "random_effects") {
      return (*re_expected_values).size();
    }
    if (this->input_type == "prior") {
      return this->expected_values.size();
    }
    return observed_values.size();
  }
  // id_g is the ID of the instance of the DensityComponentBase class.
  // this is like a memory tracker.
  // Assigning each one its own ID is a way to keep track of
  // all the instances of the DensityComponentBase class.
  static uint32_t id_g;
 
  Type lpdf;
 
  int observed_data_id_m = -999;
 
  fims::Vector<Type> lpdf_vec;
 
  bool osa_flag = false;
 
  bool simulate_flag = false;
 
  std::vector<uint32_t> key;
 
#ifdef TMB_MODEL
  ::objective_function<Type>* of;
#endif
 
  DensityComponentBase() {
    // initialize the priors vector with a size of 1 and set the first element
    // to NULL
    this->priors.resize(1);
    this->priors[0] = NULL;
    this->id = DensityComponentBase::id_g++;
  }
 
  virtual ~DensityComponentBase() {}
  virtual const Type evaluate() = 0;
};
 
template <typename Type>
uint32_t DensityComponentBase<Type>::id_g = 0;
 
}  // namespace fims_distributions
 
#endif /* DENSITY_COMPONENT_BASE_HPP */