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 DistributionElementObject {
  std::string input_type; 
  std::shared_ptr<fims_data_object::DataObject<Type>>
      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> x; 
  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 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 x[i];
  }
 
  inline Type& get_observed(size_t i, size_t j) {
    if (this->input_type == "data") {
      return observed_values->at(i, j);
    }
    if (this->input_type == "random_effects") {
      return (*re)[i, j];
    }
    if (this->input_type == "prior") {
      return (*(priors[i, j]))[0];
    }
    return x[i];
  }
 
  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->observed_values->data.size();
    }
    if (this->input_type == "random_effects") {
      return (*re).size();
    }
    if (this->input_type == "prior") {
      return this->expected_values.size();
    }
    return x.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 x.size();
  }
};
 
template <typename Type>
struct DensityComponentBase : public fims_model_object::FIMSObject<Type>,
                              public DistributionElementObject<Type> {
  // 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; 
  int observed_data_id_m = -999; 
  fims::Vector<Type> lpdf_vec; 
  fims::Vector<Type> report_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 */