rcpp_interface_base.hpp

Go to the documentation of this file.

 
#ifndef FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_INTERFACE_BASE_HPP
#define FIMS_INTERFACE_RCPP_RCPP_OBJECTS_RCPP_INTERFACE_BASE_HPP
 
#include <RcppCommon.h>
#include <map>
#include <vector>
 
#include "../../../common/def.hpp"
#include "../../../common/information.hpp"
#include "../../interface.hpp"
#include "rcpp_shared_primitive.hpp"
#include <limits>
 
#define RCPP_NO_SUGAR
#include <Rcpp.h>
 
class Parameter {
 public:
  static uint32_t id_g;
  uint32_t id_m;
  double initial_value_m = 0.0;
  double final_value_m = 0.0;
 
  double uncertainty_m = -999.0;
  double min_m = -std::numeric_limits<double>::infinity();
  double max_m = std::numeric_limits<double>::infinity();
  SharedString estimation_type_m = SharedString("constant");
 
  Parameter(double value, double min, double max, std::string estimation_type)
      : id_m(Parameter::id_g++),
        initial_value_m(value),
        min_m(min),
        max_m(max),
        estimation_type_m(estimation_type) {}
 
  Parameter(const Parameter& other)
      : id_m(other.id_m),
        initial_value_m(other.initial_value_m),
        final_value_m(other.final_value_m),
        min_m(other.min_m),
        max_m(other.max_m),
        estimation_type_m(other.estimation_type_m) {}
 
  Parameter& operator=(const Parameter& right) {
    // Check for self-assignment!
    if (this == &right)  // Same object?
      return *this;      // Yes, so skip assignment, and just return *this.
    this->id_m = right.id_m;
    this->initial_value_m = right.initial_value_m;
    this->estimation_type_m = right.estimation_type_m;
    this->min_m = right.min_m;
    this->max_m = right.max_m;
    return *this;
  }
 
  Parameter(double value) {
    initial_value_m = value;
    id_m = Parameter::id_g++;
  }
 
  Parameter() {
    initial_value_m = 0;
    id_m = Parameter::id_g++;
  }
};
uint32_t Parameter::id_g = 0;
 
inline double sanitize_val(double x) {
  if (std::isnan(x) || std::isinf(x)) {
    return -999.0;
  }
  return x;
}
 
std::ostream& operator<<(std::ostream& out, const Parameter& p) {
  out << "{\"id\": " << p.id_m
      << ",\n\"value\": " << sanitize_val(p.initial_value_m)
      << ",\n\"estimated_value\": " << sanitize_val(p.final_value_m)
      << ",\n\"uncertainty\": " << sanitize_val(p.uncertainty_m)
      << ",\n\"min\": ";
  if (p.min_m == -std::numeric_limits<double>::infinity()) {
    out << "\"-Infinity\"";
  } else {
    out << p.min_m;
  }
  out << ",\n\"max\": ";
  if (p.max_m == std::numeric_limits<double>::infinity()) {
    out << "\"Infinity\"";
  } else {
    out << p.max_m;
  }
 
  out << ",\n\"estimation_type\": \"" << p.estimation_type_m << "\"\n}";
 
  return out;
}
 
class ParameterVector {
 public:
  static uint32_t id_g;
  std::shared_ptr<std::vector<Parameter>> storage_m;
  uint32_t id_m;
 
  ParameterVector() {
    this->id_m = ParameterVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Parameter>>();
    this->storage_m->resize(1);  // push_back(Rcpp::wrap(p));
  }
 
  ParameterVector(const ParameterVector& other)
      : storage_m(other.storage_m), id_m(other.id_m) {}
 
  ParameterVector(size_t size) {
    this->id_m = ParameterVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Parameter>>();
    this->storage_m->resize(size);
    for (size_t i = 0; i < size; i++) {
      storage_m->at(i) = Parameter();
    }
  }
 
  ParameterVector(Rcpp::NumericVector x, size_t size) {
    if (static_cast<size_t>(x.size()) != size) {
      throw std::invalid_argument(
          "Error in call to ParameterVector(Rcpp::NumericVector x, size_t "
          "size): x.size() != size argument.");
    } else {
      this->id_m = ParameterVector::id_g++;
      this->storage_m = std::make_shared<std::vector<Parameter>>();
      // Use std::min to avoid comparing signed and unsigned types
      size_t n = std::min(static_cast<size_t>(x.size()), size);
      this->storage_m->resize(n);
      for (size_t i = 0; i < n; i++) {
        storage_m->at(i).initial_value_m = x[i];
      }
    }
  }
 
  ParameterVector(const fims::Vector<double>& v) {
    this->id_m = ParameterVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Parameter>>();
    this->storage_m->resize(v.size());
    for (size_t i = 0; i < v.size(); i++) {
      storage_m->at(i).initial_value_m = v[i];
    }
  }
 
  virtual ~ParameterVector() {}
 
  virtual uint32_t get_id() { return this->id_m; }
 
  inline Parameter& operator[](size_t pos) { return this->storage_m->at(pos); }
 
  SEXP at(R_xlen_t pos) {
    if (static_cast<size_t>(pos) == 0 ||
        static_cast<size_t>(pos) > this->storage_m->size()) {
      throw std::invalid_argument("ParameterVector: Index out of range");
      FIMS_ERROR_LOG(fims::to_string(pos) + "!<" +
                     fims::to_string(this->size()));
      return NULL;
    }
    return Rcpp::wrap(this->storage_m->at(pos - 1));
  }
 
  Parameter& get(size_t pos) {
    if (pos >= this->storage_m->size()) {
      throw std::invalid_argument("ParameterVector: Index out of range");
    }
    return (this->storage_m->at(pos));
  }
 
  void set(size_t pos, const Parameter& p) { this->storage_m->at(pos) = p; }
 
  size_t size() { return this->storage_m->size(); }
 
  void resize(size_t size) { this->storage_m->resize(size); }
 
  void set_all_estimable(bool estimable) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      if (estimable) {
        this->storage_m->at(i).estimation_type_m.set("fixed_effects");
      } else {
        this->storage_m->at(i).estimation_type_m.set("constant");
      }
    }
  }
 
  void set_all_random(bool random) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      if (random) {
        this->storage_m->at(i).estimation_type_m.set("random_effects");
      } else {
        this->storage_m->at(i).estimation_type_m.set("constant");
      }
    }
  }
 
  void fill(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i).initial_value_m = value;
    }
  }
 
  void fill_min(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i).min_m = value;
    }
  }
 
  void fill_max(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i).max_m = value;
    }
  }
 
  void show() {
    Rcpp::Rcout << this->storage_m->data() << "\n";
 
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      Rcpp::Rcout << storage_m->at(i) << "  ";
    }
  }
};
uint32_t ParameterVector::id_g = 0;
 
std::ostream& operator<<(std::ostream& out, ParameterVector& v) {
  out << "[";
  size_t size = v.size();
  for (size_t i = 0; i < size - 1; i++) {
    out << v[i] << ", ";
  }
  out << v[size - 1] << "]";
  return out;
}
 
class RealVector {
 public:
  static uint32_t id_g;
  std::shared_ptr<std::vector<double>> storage_m;
  uint32_t id_m;
 
  RealVector() {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->resize(1);
  }
 
  RealVector(const RealVector& other)
      : storage_m(other.storage_m), id_m(other.id_m) {}
 
  RealVector(size_t size) {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->resize(size);
  }
 
  RealVector(Rcpp::NumericVector x, size_t size) {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->assign(x.begin(), x.end());
  }
 
  RealVector(const fims::Vector<double>& v) {
    this->id_m = RealVector::id_g++;
    this->storage_m = std::make_shared<std::vector<double>>();
    this->storage_m->resize(v.size());
    for (size_t i = 0; i < v.size(); i++) {
      storage_m->at(i) = v[i];
    }
  }
 
  virtual ~RealVector() {}
 
  RealVector& operator=(const Rcpp::NumericVector& v) {
    this->storage_m->assign(v.begin(), v.end());
    return *this;
  }
 
  virtual uint32_t get_id() { return this->id_m; }
 
  void fromRVector(const Rcpp::NumericVector& orig) {
    this->storage_m->resize(orig.size());
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      this->storage_m->at(i) = orig[i];
    }
  }
 
  Rcpp::NumericVector toRVector() {
    Rcpp::NumericVector ret(this->storage_m->size());
    for (size_t i = 0; i < this->size(); i++) {
      ret[i] = this->storage_m->at(i);
    }
 
    return ret;
  }
 
  inline double& operator[](size_t pos) { return this->storage_m->at(pos); }
 
  SEXP at(R_xlen_t pos) {
    if (static_cast<size_t>(pos) == 0 ||
        static_cast<size_t>(pos) > this->storage_m->size()) {
      throw std::invalid_argument("RealVector: Index out of range");
      FIMS_ERROR_LOG(fims::to_string(pos) + "!<" +
                     fims::to_string(this->size()));
      return NULL;
    }
    return Rcpp::wrap(this->storage_m->at(pos - 1));
  }
 
  double& get(size_t pos) {
    if (pos >= this->storage_m->size()) {
      throw std::invalid_argument("RealVector: Index out of range");
    }
    return (this->storage_m->at(pos));
  }
 
  void set(size_t pos, const double& p) { this->storage_m->at(pos) = p; }
 
  size_t size() { return this->storage_m->size(); }
 
  void resize(size_t size) { this->storage_m->resize(size); }
 
  void fill(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i) = value;
    }
  }
 
  void show() {
    Rcpp::Rcout << this->storage_m->data() << "\n";
 
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      Rcpp::Rcout << storage_m->at(i) << "  ";
    }
  }
};
uint32_t RealVector::id_g = 0;
 
class FIMSRcppInterfaceBase {
 public:
  bool finalized = false;
  static std::vector<std::shared_ptr<FIMSRcppInterfaceBase>>
      fims_interface_objects;
 
  virtual bool add_to_fims_tmb() {
    Rcpp::Rcout << "fims_rcpp_interface_base::add_to_fims_tmb(): Not yet "
                   "implemented.\n";
    return false;
  }
 
  virtual void finalize() {}
 
  virtual std::string to_json() {
    FIMS_WARNING_LOG("Method not yet defined.");
    return "{\"name\": \"not yet implemented\"}";
  }
  void get_se_values(std::string name,
                     std::map<std::string, std::vector<double>>& se_values,
                     fims::Vector<double>& values) {
    auto se_vals = se_values.find(name);
    if (se_vals != se_values.end()) {
      std::vector<double>& se_vals_vector = (*se_vals).second;
      std::vector<double> uncertainty_std(
          se_vals_vector.begin(), se_vals_vector.begin() + values.size());
      std::vector<double> temp(se_vals_vector.begin() + values.size(),
                               se_vals_vector.end());
      se_vals_vector = temp;
      fims::Vector<double> uncertainty(uncertainty_std);
      values = uncertainty;
    } else {
      std::fill(values.begin(), values.end(), -999);
    }
  }
 
  virtual void set_uncertainty(
      std::map<std::string, std::vector<double>>& se_values) {
    FIMS_WARNING_LOG("Method not yet defined.");
  }
 
  std::string value_to_string(double value) {
    std::stringstream ss;
    if (value == std::numeric_limits<double>::infinity()) {
      ss << "\"Infinity\"";
    } else if (value == -std::numeric_limits<double>::infinity()) {
      ss << "\"-Infinity\"";
    } else if (value != value) {
      ss << "-999";
    } else {
      // Set precision (R default is 16)
      ss << std::fixed << std::setprecision(16) << value;
    }
    return ss.str();
  }
  std::string make_dimensions(uint32_t start, uint32_t end, uint32_t rep = 1) {
    std::stringstream ss;
 
    for (size_t i = 0; i < rep; i++) {
      for (size_t j = start; j < end; j++) {
        ss << j << ", ";
      }
      if (i < (rep - 1)) {
        ss << end << ", ";
      } else {
        ss << end;
      }
    }
    return ss.str();
  }
};
std::vector<std::shared_ptr<FIMSRcppInterfaceBase>>
    FIMSRcppInterfaceBase::fims_interface_objects;
 
#endif