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
 
#ifndef RCPP_NO_SUGAR
#define RCPP_NO_SUGAR
#endif
#include <RcppCommon.h>
#include <Rcpp.h>
#include <map>
#include <vector>
 
#include "common/information.hpp"
#include "../../interface.hpp"
#include "rcpp_shared_primitive.hpp"
#include <limits>
 
class Variable {
 public:
  static uint32_t id_g;
  uint32_t id_m;
  double initial_value_m = 0.0;
  double final_value_m = 0.0;
  SharedString estimation_type_m = SharedString("constant");
 
  Variable(double value, std::string estimation_type)
      : id_m(Variable::id_g++),
        initial_value_m(value),
        estimation_type_m(estimation_type) {}
 
  Variable(const Variable& other)
      : id_m(other.id_m),
        initial_value_m(other.initial_value_m),
        final_value_m(other.final_value_m),
        estimation_type_m(other.estimation_type_m) {}
 
  Variable& operator=(const Variable& 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;
    return *this;
  }
 
  Variable(double value) {
    initial_value_m = value;
    id_m = Variable::id_g++;
  }
 
  Variable() {
    initial_value_m = 0;
    id_m = Variable::id_g++;
  }
};
 
#ifdef FIMS_HEADER_ONLY
uint32_t Variable::id_g = 0;
#endif
 
inline double sanitize_val(double x) {
  if (std::isnan(x) || std::isinf(x)) {
    return -999.0;
  }
  return x;
}
 
inline std::ostream& operator<<(std::ostream& out, const Variable& p) {
  out << "{\"id\": " << p.id_m
      << ",\n\"value\": " << sanitize_val(p.initial_value_m)
      << ",\n\"estimated_value\": " << sanitize_val(p.final_value_m);
  out << ",\n\"estimation_type\": \"" << p.estimation_type_m << "\"\n}";
 
  return out;
}
 
RCPP_EXPOSED_CLASS(Variable)
 
 
class VariableVector {
 public:
  static uint32_t id_g;
  std::shared_ptr<std::vector<Variable>> storage_m;
  uint32_t id_m;
 
  VariableVector() {
    this->id_m = VariableVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Variable>>();
    this->storage_m->resize(1);  // push_back(Rcpp::wrap(p));
  }
 
  VariableVector(const VariableVector& other)
      : storage_m(other.storage_m), id_m(other.id_m) {}
 
  VariableVector(size_t size) {
    this->id_m = VariableVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Variable>>();
    this->storage_m->resize(size);
    for (size_t i = 0; i < size; i++) {
      storage_m->at(i) = Variable();
    }
  }
 
  VariableVector(Rcpp::NumericVector x, size_t size) {
    const size_t input_size = static_cast<size_t>(x.size());
    if (input_size != size) {
      throw std::invalid_argument(
          "VariableVector::VariableVector(Rcpp::NumericVector, size_t): `x` "
          "length (" +
          std::to_string(input_size) +
          ") must equal the "
          "requested size (" +
          std::to_string(size) +
          "). Received length: " + std::to_string(input_size) + ".");
    } else {
      this->id_m = VariableVector::id_g++;
      this->storage_m = std::make_shared<std::vector<Variable>>();
      // Use std::min to avoid comparing signed and unsigned types
      size_t n = std::min(input_size, size);
      this->storage_m->resize(n);
      for (size_t i = 0; i < n; i++) {
        storage_m->at(i).initial_value_m = x[i];
      }
    }
  }
 
  VariableVector(const fims::Vector<double>& v) {
    this->id_m = VariableVector::id_g++;
    this->storage_m = std::make_shared<std::vector<Variable>>();
    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 ~VariableVector() {}
 
  virtual uint32_t get_id() { return this->id_m; }
 
  inline Variable& 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("VariableVector: 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));
  }
 
  Variable& get(size_t pos) {
    if (pos >= this->storage_m->size()) {
      throw std::invalid_argument("VariableVector: Index out of range");
    }
    return (this->storage_m->at(pos));
  }
 
  void set(size_t pos, const Variable& 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_values(Rcpp::NumericVector values) {
    if (values.size() != this->storage_m->size()) {
      const size_t input_size = values.size();
      const size_t vector_size = this->storage_m->size();
      throw std::invalid_argument(
          "VariableVector::set_values(): `values` length (" +
          std::to_string(input_size) +
          ") must equal the VariableVector "
          "size (" +
          std::to_string(vector_size) + "). Received length: " +
          std::to_string(input_size) + ". Pass a numeric vector of length " +
          std::to_string(vector_size) + ".");
    }
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      this->storage_m->at(i).initial_value_m = values[i];
    }
  }
 
  void set_estimation_types(Rcpp::CharacterVector estimation_types) {
    const size_t vector_size = this->storage_m->size();
    const size_t input_size = estimation_types.size();
 
    if (input_size != 1 && input_size != vector_size) {
      throw std::invalid_argument(
          "VariableVector::set_estimation_types(): `estimation_types` length "
          "(" +
          std::to_string(input_size) +
          ") must be 1 (broadcast) or equal to the VariableVector size (" +
          std::to_string(vector_size) +
          ").\n"
          "Received length: " +
          std::to_string(input_size) +
          ". "
          "Pass a single estimation type to apply to all elements, or a "
          "vector of length " +
          std::to_string(vector_size) + ".");
    }
 
    auto validate_estimation_type = [&](const std::string& est_type) {
      if (est_type != "constant" && est_type != "fixed_effects" &&
          est_type != "random_effects") {
        throw std::invalid_argument(
            "Invalid estimation_type: " + est_type +
            ". Valid options are: constant, fixed_effects, or random_effects.");
      }
    };
 
    for (size_t i = 0; i < vector_size; i++) {
      std::string est_type =
          Rcpp::as<std::string>(estimation_types[input_size == 1 ? 0 : i]);
      validate_estimation_type(est_type);
      this->storage_m->at(i).estimation_type_m.set(est_type);
    }
  }
 
  void fill(double value) {
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      storage_m->at(i).initial_value_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) << "  ";
    }
  }
 
  VariableVector deep_copy() const {
    VariableVector copy;
    copy.storage_m = std::make_shared<std::vector<Variable>>();
    copy.storage_m->reserve(this->storage_m->size());
    for (size_t i = 0; i < this->storage_m->size(); i++) {
      Variable variable_copy;
      const Variable& variable = this->storage_m->at(i);
      variable_copy.initial_value_m = variable.initial_value_m;
      variable_copy.final_value_m = variable.final_value_m;
      variable_copy.estimation_type_m =
          SharedString(variable.estimation_type_m.get());
      copy.storage_m->push_back(variable_copy);
    }
    return copy;
  }
};
 
#ifdef FIMS_HEADER_ONLY
uint32_t VariableVector::id_g = 0;
#endif
 
inline std::ostream& operator<<(std::ostream& out, VariableVector& 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>>();
    const size_t input_size = static_cast<size_t>(x.size());
    if (input_size != size) {
      throw std::invalid_argument(
          "RealVector::RealVector(Rcpp::NumericVector, size_t): `x` length (" +
          std::to_string(input_size) +
          ") must equal the requested "
          "size (" +
          std::to_string(size) +
          "). Received length: " + std::to_string(input_size) + ".");
    }
    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 set_values(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 get_values() {
    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) << "  ";
    }
  }
 
  RealVector deep_copy() const {
    RealVector copy;
    copy.storage_m = std::make_shared<std::vector<double>>(*this->storage_m);
    return copy;
  }
};
#ifdef FIMS_HEADER_ONLY
uint32_t RealVector::id_g = 0;
#endif
 
RCPP_EXPOSED_CLASS(VariableVector)
RCPP_EXPOSED_CLASS(RealVector)
 
 
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\"}";
  }
 
  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();
  }
};
 
#endif