diff --git a/class_model_s_e_i_r.html b/class_model_s_e_i_r.html index fdbce3d0..3eaf7972 100644 --- a/class_model_s_e_i_r.html +++ b/class_model_s_e_i_r.html @@ -812,7 +812,7 @@

return;
}
ModelSEIR
Template for a Susceptible-Exposed-Infected-Removed (SEIR) model.
Definition: seir.hpp:16
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
diff --git a/class_model_s_e_i_r_d.html b/class_model_s_e_i_r_d.html index edca3373..ccae6966 100644 --- a/class_model_s_e_i_r_d.html +++ b/class_model_s_e_i_r_d.html @@ -916,7 +916,7 @@

return;
}
ModelSEIRD
Template for a Susceptible-Exposed-Infected-Removed-Deceased (SEIRD) model.
Definition: seird.hpp:9
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
diff --git a/classepiworld_1_1epimodels_1_1_model_s_e_i_r.html b/classepiworld_1_1epimodels_1_1_model_s_e_i_r.html index bac2abb3..7151f513 100644 --- a/classepiworld_1_1epimodels_1_1_model_s_e_i_r.html +++ b/classepiworld_1_1epimodels_1_1_model_s_e_i_r.html @@ -816,7 +816,7 @@

return;
}
ModelSEIR
Template for a Susceptible-Exposed-Infected-Removed (SEIR) model.
Definition: seir.hpp:16
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
diff --git a/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d.html b/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d.html index c561d0a9..f012675a 100644 --- a/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d.html +++ b/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d.html @@ -920,7 +920,7 @@

return;
}
ModelSEIRD
Template for a Susceptible-Exposed-Infected-Removed-Deceased (SEIRD) model.
Definition: seird.hpp:9
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
diff --git a/diffnet_8hpp_source.html b/diffnet_8hpp_source.html index 586ae40f..2de387fc 100644 --- a/diffnet_8hpp_source.html +++ b/diffnet_8hpp_source.html @@ -273,10 +273,10 @@
210 #endif
Agent
Agent (agents)
Definition: agent-bones.hpp:66
ModelDiffNet
Template for a Network Diffusion Model.
Definition: diffnet.hpp:15
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
epiworld::Model::get_n_viruses
size_t get_n_viruses() const
Number of viruses in the model.
Definition: epiworld.hpp:8553
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/epiworld_8hpp_source.html b/epiworld_8hpp_source.html index 52de1311..2b3cefe3 100644 --- a/epiworld_8hpp_source.html +++ b/epiworld_8hpp_source.html @@ -8183,7732 +8183,7732 @@
9004 
9005  }
9006 
-
9007  if (viruses.size() == 0u)
-
9008  {
-
9009  printf_epiworld(" (none)\n");
-
9010  }
-
9011 
-
9012  printf_epiworld("\nTool(s):\n");
-
9013  size_t n_tools_model = tools.size();
-
9014  for (size_t i = 0u; i < tools.size(); ++i)
-
9015  {
-
9016 
-
9017  if ((n_tools_model > 10) && (i >= 10))
-
9018  {
-
9019  printf_epiworld(" ...and %li more tools...\n", n_tools_model - i);
-
9020  break;
-
9021  }
-
9022 
-
9023  if (i < n_tools_model)
-
9024  {
-
9025  if (prevalence_tool_as_proportion[i])
-
9026  {
-
9027 
-
9028  printf_epiworld(
-
9029  " - %s (baseline prevalence: %.2f%%)\n",
-
9030  tools[i]->get_name().c_str(),
-
9031  prevalence_tool[i] * 100.0
-
9032  );
-
9033 
-
9034  }
-
9035  else
-
9036  {
-
9037 
-
9038  printf_epiworld(
-
9039  " - %s (baseline prevalence: %i seeds)\n",
-
9040  tools[i]->get_name().c_str(),
-
9041  static_cast<int>(prevalence_tool[i])
-
9042  );
-
9043 
-
9044  }
+
9007  auto nvariants = db.get_n_viruses() - n_viruses_model;
+
9008  if (nvariants > 0)
+
9009  {
+
9010 
+
9011  printf_epiworld(" ...and %li more variants...\n", nvariants);
+
9012 
+
9013  }
+
9014 
+
9015  if (viruses.size() == 0u)
+
9016  {
+
9017  printf_epiworld(" (none)\n");
+
9018  }
+
9019 
+
9020  printf_epiworld("\nTool(s):\n");
+
9021  size_t n_tools_model = tools.size();
+
9022  for (size_t i = 0u; i < tools.size(); ++i)
+
9023  {
+
9024 
+
9025  if ((n_tools_model > 10) && (i >= 10))
+
9026  {
+
9027  printf_epiworld(" ...and %li more tools...\n", n_tools_model - i);
+
9028  break;
+
9029  }
+
9030 
+
9031  if (i < n_tools_model)
+
9032  {
+
9033  if (prevalence_tool_as_proportion[i])
+
9034  {
+
9035 
+
9036  printf_epiworld(
+
9037  " - %s (baseline prevalence: %.2f%%)\n",
+
9038  tools[i]->get_name().c_str(),
+
9039  prevalence_tool[i] * 100.0
+
9040  );
+
9041 
+
9042  }
+
9043  else
+
9044  {
9045 
-
9046  } else {
-
9047 
-
9048  printf_epiworld(
-
9049  " - %s (originated in the model...)\n",
-
9050  tools[i]->get_name().c_str()
-
9051  );
-
9052 
-
9053  }
-
9054 
+
9046  printf_epiworld(
+
9047  " - %s (baseline prevalence: %i seeds)\n",
+
9048  tools[i]->get_name().c_str(),
+
9049  static_cast<int>(prevalence_tool[i])
+
9050  );
+
9051 
+
9052  }
+
9053 
+
9054  } else {
9055 
-
9056  }
-
9057 
-
9058  if (tools.size() == 0u)
-
9059  {
-
9060  printf_epiworld(" (none)\n");
-
9061  }
-
9062 
-
9063  // Information about the parameters included
-
9064  printf_epiworld("\nModel parameters:\n");
-
9065  epiworld_fast_uint nchar = 0u;
-
9066  for (auto & p : parameters)
-
9067  if (p.first.length() > nchar)
-
9068  nchar = p.first.length();
-
9069 
-
9070  std::string fmt = " - %-" + std::to_string(nchar + 1) + "s: ";
-
9071  for (auto & p : parameters)
-
9072  {
-
9073  std::string fmt_tmp = fmt;
-
9074  if (std::fabs(p.second) < 0.0001)
-
9075  fmt_tmp += "%.1e\n";
-
9076  else
-
9077  fmt_tmp += "%.4f\n";
-
9078 
-
9079  printf_epiworld(
-
9080  fmt_tmp.c_str(),
-
9081  p.first.c_str(),
-
9082  p.second
-
9083  );
-
9084 
-
9085  }
+
9056  printf_epiworld(
+
9057  " - %s (originated in the model...)\n",
+
9058  tools[i]->get_name().c_str()
+
9059  );
+
9060 
+
9061  }
+
9062 
+
9063 
+
9064  }
+
9065 
+
9066  if (tools.size() == 0u)
+
9067  {
+
9068  printf_epiworld(" (none)\n");
+
9069  }
+
9070 
+
9071  // Information about the parameters included
+
9072  printf_epiworld("\nModel parameters:\n");
+
9073  epiworld_fast_uint nchar = 0u;
+
9074  for (auto & p : parameters)
+
9075  if (p.first.length() > nchar)
+
9076  nchar = p.first.length();
+
9077 
+
9078  std::string fmt = " - %-" + std::to_string(nchar + 1) + "s: ";
+
9079  for (auto & p : parameters)
+
9080  {
+
9081  std::string fmt_tmp = fmt;
+
9082  if (std::fabs(p.second) < 0.0001)
+
9083  fmt_tmp += "%.1e\n";
+
9084  else
+
9085  fmt_tmp += "%.4f\n";
9086 
-
9087  if (parameters.size() == 0u)
-
9088  {
-
9089  printf_epiworld(" (none)\n");
-
9090  }
-
9091 
-
9092  nchar = 0u;
-
9093  for (auto & p : states_labels)
-
9094  if (p.length() > nchar)
-
9095  nchar = p.length();
-
9096 
-
9097 
-
9098 
-
9099  if (today() != 0)
-
9100  {
-
9101  fmt =
-
9102  std::string(" - (%") +
-
9103  std::to_string(std::to_string(nstates).length()) +
-
9104  std::string("d) %-") + std::to_string(nchar) +
-
9105  std::string("s : %") +
-
9106  std::to_string(std::to_string(size()).length()) +
-
9107  std::string("i -> %i\n");
-
9108  } else {
+
9087  printf_epiworld(
+
9088  fmt_tmp.c_str(),
+
9089  p.first.c_str(),
+
9090  p.second
+
9091  );
+
9092 
+
9093  }
+
9094 
+
9095  if (parameters.size() == 0u)
+
9096  {
+
9097  printf_epiworld(" (none)\n");
+
9098  }
+
9099 
+
9100  nchar = 0u;
+
9101  for (auto & p : states_labels)
+
9102  if (p.length() > nchar)
+
9103  nchar = p.length();
+
9104 
+
9105 
+
9106 
+
9107  if (today() != 0)
+
9108  {
9109  fmt =
9110  std::string(" - (%") +
9111  std::to_string(std::to_string(nstates).length()) +
9112  std::string("d) %-") + std::to_string(nchar) +
-
9113  std::string("s : %i\n");
-
9114  }
-
9115 
-
9116  if (today() != 0)
-
9117  {
-
9118  printf_epiworld("\nDistribution of the population at time %i:\n", today());
-
9119  for (size_t s = 0u; s < nstates; ++s)
-
9120  {
-
9121 
-
9122  printf_epiworld(
-
9123  fmt.c_str(),
-
9124  s,
-
9125  states_labels[s].c_str(),
-
9126  db.hist_total_counts[s],
-
9127  db.today_total[ s ]
-
9128  );
+
9113  std::string("s : %") +
+
9114  std::to_string(std::to_string(size()).length()) +
+
9115  std::string("i -> %i\n");
+
9116  } else {
+
9117  fmt =
+
9118  std::string(" - (%") +
+
9119  std::to_string(std::to_string(nstates).length()) +
+
9120  std::string("d) %-") + std::to_string(nchar) +
+
9121  std::string("s : %i\n");
+
9122  }
+
9123 
+
9124  if (today() != 0)
+
9125  {
+
9126  printf_epiworld("\nDistribution of the population at time %i:\n", today());
+
9127  for (size_t s = 0u; s < nstates; ++s)
+
9128  {
9129 
-
9130  }
-
9131  // else
-
9132  // {
-
9133 
-
9134  // printf_epiworld(
-
9135  // fmt.c_str(),
-
9136  // s,
-
9137  // states_labels[s].c_str(),
-
9138  // db.today_total[ s ]
-
9139  // );
-
9140 
-
9141  // }
-
9142  }
-
9143 
-
9144  if (today() != 0)
-
9145  (void) db.transition_probability(true);
-
9146 
-
9147  return *this;
+
9130  printf_epiworld(
+
9131  fmt.c_str(),
+
9132  s,
+
9133  states_labels[s].c_str(),
+
9134  db.hist_total_counts[s],
+
9135  db.today_total[ s ]
+
9136  );
+
9137 
+
9138  }
+
9139  // else
+
9140  // {
+
9141 
+
9142  // printf_epiworld(
+
9143  // fmt.c_str(),
+
9144  // s,
+
9145  // states_labels[s].c_str(),
+
9146  // db.today_total[ s ]
+
9147  // );
9148 
-
9149 }
-
9150 
-
9151 #endif
-
9152 /*//////////////////////////////////////////////////////////////////////////////
+
9149  // }
+
9150  }
+
9151 
+
9152  if (today() != 0)
+
9153  (void) db.transition_probability(true);
9154 
-
9155  End of -include/epiworld//model-meat-print.hpp-
+
9155  return *this;
9156 
-
9159 
-
9160 
-
9161 
-
9162 template<typename TSeq>
-
9163 inline Model<TSeq> && Model<TSeq>::clone() const {
+
9157 }
+
9158 
+
9159 #endif
+
9160 /*//////////////////////////////////////////////////////////////////////////////
+
9162 
+
9163  End of -include/epiworld//model-meat-print.hpp-
9164 
-
9165  // Step 1: Regen the individuals and make sure that:
-
9166  // - Neighbors point to the right place
-
9167  // - DB is pointing to the right place
-
9168  Model<TSeq> res(*this);
+
9167 
+
9168 
9169 
-
9170  // Removing old neighbors
-
9171  for (auto & p: res.population)
-
9172  p.neighbors.clear();
-
9173 
-
9174  // Rechecking individuals
-
9175  for (epiworld_fast_uint p = 0u; p < size(); ++p)
-
9176  {
-
9177  // Making room
-
9178  const Agent<TSeq> & agent_this = population[p];
-
9179  Agent<TSeq> & agent_res = res.population[p];
-
9180 
-
9181  // Agent pointing to the right model and agent
-
9182  agent_res.model = &res;
-
9183  agent_res.viruses.agent = &agent_res;
-
9184  agent_res.tools.agent = &agent_res;
-
9185 
-
9186  // Readding
-
9187  std::vector< Agent<TSeq> * > neigh = agent_this.neighbors;
-
9188  for (epiworld_fast_uint n = 0u; n < neigh.size(); ++n)
-
9189  {
-
9190  // Point to the right neighbors
-
9191  int loc = res.population_ids[neigh[n]->get_id()];
-
9192  agent_res.add_neighbor(res.population[loc], true, true);
+
9170 template<typename TSeq>
+
9171 inline Model<TSeq> && Model<TSeq>::clone() const {
+
9172 
+
9173  // Step 1: Regen the individuals and make sure that:
+
9174  // - Neighbors point to the right place
+
9175  // - DB is pointing to the right place
+
9176  Model<TSeq> res(*this);
+
9177 
+
9178  // Removing old neighbors
+
9179  for (auto & p: res.population)
+
9180  p.neighbors.clear();
+
9181 
+
9182  // Rechecking individuals
+
9183  for (epiworld_fast_uint p = 0u; p < size(); ++p)
+
9184  {
+
9185  // Making room
+
9186  const Agent<TSeq> & agent_this = population[p];
+
9187  Agent<TSeq> & agent_res = res.population[p];
+
9188 
+
9189  // Agent pointing to the right model and agent
+
9190  agent_res.model = &res;
+
9191  agent_res.viruses.agent = &agent_res;
+
9192  agent_res.tools.agent = &agent_res;
9193 
-
9194  }
-
9195 
-
9196  }
-
9197 
-
9198  return res;
-
9199 
-
9200 }
+
9194  // Readding
+
9195  std::vector< Agent<TSeq> * > neigh = agent_this.neighbors;
+
9196  for (epiworld_fast_uint n = 0u; n < neigh.size(); ++n)
+
9197  {
+
9198  // Point to the right neighbors
+
9199  int loc = res.population_ids[neigh[n]->get_id()];
+
9200  agent_res.add_neighbor(res.population[loc], true, true);
9201 
-
9202 
+
9202  }
9203 
-
9204 template<typename TSeq>
-
9205 inline void Model<TSeq>::add_state(
-
9206  std::string lab,
-
9207  UpdateFun<TSeq> fun
-
9208 )
-
9209 {
+
9204  }
+
9205 
+
9206  return res;
+
9207 
+
9208 }
+
9209 
9210 
-
9211  // Checking it doesn't match
-
9212  for (auto & s : states_labels)
-
9213  if (s == lab)
-
9214  throw std::logic_error("state \"" + s + "\" already registered.");
-
9215 
-
9216  states_labels.push_back(lab);
-
9217  state_fun.push_back(fun);
-
9218  nstates++;
-
9219 
-
9220 }
-
9221 
-
9222 
-
9223 template<typename TSeq>
-
9224 inline const std::vector< std::string > &
-
9225 Model<TSeq>::get_states() const
-
9226 {
-
9227  return states_labels;
+
9211 
+
9212 template<typename TSeq>
+
9213 inline void Model<TSeq>::add_state(
+
9214  std::string lab,
+
9215  UpdateFun<TSeq> fun
+
9216 )
+
9217 {
+
9218 
+
9219  // Checking it doesn't match
+
9220  for (auto & s : states_labels)
+
9221  if (s == lab)
+
9222  throw std::logic_error("state \"" + s + "\" already registered.");
+
9223 
+
9224  states_labels.push_back(lab);
+
9225  state_fun.push_back(fun);
+
9226  nstates++;
+
9227 
9228 }
9229 
-
9230 template<typename TSeq>
-
9231 inline const std::vector< UpdateFun<TSeq> > &
-
9232 Model<TSeq>::get_state_fun() const
-
9233 {
-
9234  return state_fun;
-
9235 }
-
9236 
-
9237 template<typename TSeq>
-
9238 inline void Model<TSeq>::print_state_codes() const
-
9239 {
-
9240 
-
9241  // Horizontal line
-
9242  std::string line = "";
-
9243  for (epiworld_fast_uint i = 0u; i < 80u; ++i)
-
9244  line += "_";
-
9245 
-
9246  printf_epiworld("\n%s\nstates CODES\n\n", line.c_str());
-
9247 
-
9248  epiworld_fast_uint nchar = 0u;
-
9249  for (auto & p : states_labels)
-
9250  if (p.length() > nchar)
-
9251  nchar = p.length();
-
9252 
-
9253  std::string fmt = " %2i = %-" + std::to_string(nchar + 1 + 4) + "s\n";
-
9254  for (epiworld_fast_uint i = 0u; i < nstates; ++i)
-
9255  {
-
9256 
-
9257  printf_epiworld(
-
9258  fmt.c_str(),
-
9259  i,
-
9260  (states_labels[i] + " (S)").c_str()
-
9261  );
-
9262 
-
9263  }
+
9230 
+
9231 template<typename TSeq>
+
9232 inline const std::vector< std::string > &
+
9233 Model<TSeq>::get_states() const
+
9234 {
+
9235  return states_labels;
+
9236 }
+
9237 
+
9238 template<typename TSeq>
+
9239 inline const std::vector< UpdateFun<TSeq> > &
+
9240 Model<TSeq>::get_state_fun() const
+
9241 {
+
9242  return state_fun;
+
9243 }
+
9244 
+
9245 template<typename TSeq>
+
9246 inline void Model<TSeq>::print_state_codes() const
+
9247 {
+
9248 
+
9249  // Horizontal line
+
9250  std::string line = "";
+
9251  for (epiworld_fast_uint i = 0u; i < 80u; ++i)
+
9252  line += "_";
+
9253 
+
9254  printf_epiworld("\n%s\nstates CODES\n\n", line.c_str());
+
9255 
+
9256  epiworld_fast_uint nchar = 0u;
+
9257  for (auto & p : states_labels)
+
9258  if (p.length() > nchar)
+
9259  nchar = p.length();
+
9260 
+
9261  std::string fmt = " %2i = %-" + std::to_string(nchar + 1 + 4) + "s\n";
+
9262  for (epiworld_fast_uint i = 0u; i < nstates; ++i)
+
9263  {
9264 
-
9265 }
-
9266 
-
9267 
-
9268 
-
9269 template<typename TSeq>
-
9270 inline epiworld_double Model<TSeq>::add_param(
-
9271  epiworld_double initial_value,
-
9272  std::string pname
-
9273  ) {
+
9265  printf_epiworld(
+
9266  fmt.c_str(),
+
9267  i,
+
9268  (states_labels[i] + " (S)").c_str()
+
9269  );
+
9270 
+
9271  }
+
9272 
+
9273 }
9274 
-
9275  if (parameters.find(pname) == parameters.end())
-
9276  parameters[pname] = initial_value;
-
9277 
-
9278  return initial_value;
-
9279 
-
9280 }
-
9281 
-
9282 template<typename TSeq>
-
9283 inline void Model<TSeq>::read_params(std::string fn)
-
9284 {
-
9285 
-
9286  std::ifstream paramsfile(fn);
+
9275 
+
9276 
+
9277 template<typename TSeq>
+
9278 inline epiworld_double Model<TSeq>::add_param(
+
9279  epiworld_double initial_value,
+
9280  std::string pname
+
9281  ) {
+
9282 
+
9283  if (parameters.find(pname) == parameters.end())
+
9284  parameters[pname] = initial_value;
+
9285 
+
9286  return initial_value;
9287 
-
9288  if (!paramsfile)
-
9289  throw std::logic_error("The file " + fn + " was not found.");
-
9290 
-
9291  std::regex pattern("^([^:]+)\\s*[:]\\s*([0-9]+|[0-9]*\\.[0-9]+)?\\s*$");
-
9292 
-
9293  std::string line;
-
9294  std::smatch match;
-
9295  auto empty = std::sregex_iterator();
-
9296 
-
9297  while (std::getline(paramsfile, line))
-
9298  {
-
9299 
-
9300  // Is it a comment or an empty line?
-
9301  if (std::regex_match(line, std::regex("^([*].+|//.+|#.+|\\s*)$")))
-
9302  continue;
-
9303 
-
9304  // Finding the patter, if it doesn't match, then error
-
9305  std::regex_match(line, match, pattern);
-
9306 
-
9307  if (match.empty())
-
9308  throw std::logic_error("The line does not match parameters:\n" + line);
-
9309 
-
9310  // Capturing the number
-
9311  std::string anumber = match[2u].str() + match[3u].str();
-
9312  epiworld_double tmp_num = static_cast<epiworld_double>(
-
9313  std::strtod(anumber.c_str(), nullptr)
-
9314  );
-
9315 
-
9316  add_param(
-
9317  tmp_num,
-
9318  std::regex_replace(
-
9319  match[1u].str(),
-
9320  std::regex("^\\s+|\\s+$"),
-
9321  "")
-
9322  );
+
9288 }
+
9289 
+
9290 template<typename TSeq>
+
9291 inline void Model<TSeq>::read_params(std::string fn)
+
9292 {
+
9293 
+
9294  std::ifstream paramsfile(fn);
+
9295 
+
9296  if (!paramsfile)
+
9297  throw std::logic_error("The file " + fn + " was not found.");
+
9298 
+
9299  std::regex pattern("^([^:]+)\\s*[:]\\s*([0-9]+|[0-9]*\\.[0-9]+)?\\s*$");
+
9300 
+
9301  std::string line;
+
9302  std::smatch match;
+
9303  auto empty = std::sregex_iterator();
+
9304 
+
9305  while (std::getline(paramsfile, line))
+
9306  {
+
9307 
+
9308  // Is it a comment or an empty line?
+
9309  if (std::regex_match(line, std::regex("^([*].+|//.+|#.+|\\s*)$")))
+
9310  continue;
+
9311 
+
9312  // Finding the patter, if it doesn't match, then error
+
9313  std::regex_match(line, match, pattern);
+
9314 
+
9315  if (match.empty())
+
9316  throw std::logic_error("The line does not match parameters:\n" + line);
+
9317 
+
9318  // Capturing the number
+
9319  std::string anumber = match[2u].str() + match[3u].str();
+
9320  epiworld_double tmp_num = static_cast<epiworld_double>(
+
9321  std::strtod(anumber.c_str(), nullptr)
+
9322  );
9323 
-
9324  }
-
9325 
-
9326 }
-
9327 
-
9328 template<typename TSeq>
-
9329 inline epiworld_double Model<TSeq>::get_param(std::string pname)
-
9330 {
-
9331  if (parameters.find(pname) == parameters.end())
-
9332  throw std::logic_error("The parameter " + pname + " does not exists.");
+
9324  add_param(
+
9325  tmp_num,
+
9326  std::regex_replace(
+
9327  match[1u].str(),
+
9328  std::regex("^\\s+|\\s+$"),
+
9329  "")
+
9330  );
+
9331 
+
9332  }
9333 
-
9334  return parameters[pname];
-
9335 }
-
9336 
-
9337 template<typename TSeq>
-
9338 inline void Model<TSeq>::set_param(std::string pname, epiworld_double value)
-
9339 {
-
9340  if (parameters.find(pname) == parameters.end())
-
9341  throw std::logic_error("The parameter " + pname + " does not exists.");
-
9342 
-
9343  parameters[pname] = value;
+
9334 }
+
9335 
+
9336 template<typename TSeq>
+
9337 inline epiworld_double Model<TSeq>::get_param(std::string pname)
+
9338 {
+
9339  if (parameters.find(pname) == parameters.end())
+
9340  throw std::logic_error("The parameter " + pname + " does not exists.");
+
9341 
+
9342  return parameters[pname];
+
9343 }
9344 
-
9345  return;
-
9346 
-
9347 }
-
9348 
-
9349 // // Same as before but using the size_t method
-
9350 // template<typename TSeq>
-
9351 // inline void Model<TSeq>::set_param(size_t k, epiworld_double value)
-
9352 // {
-
9353 // if (k >= parameters.size())
-
9354 // throw std::logic_error("The parameter index " + std::to_string(k) + " does not exists.");
-
9355 
-
9356 // // Access the k-th element of the std::unordered_map parameters
-
9357 
-
9358 
-
9359 // *(parameters.begin() + k) = value;
-
9360 
-
9361 // return;
-
9362 // }
+
9345 template<typename TSeq>
+
9346 inline void Model<TSeq>::set_param(std::string pname, epiworld_double value)
+
9347 {
+
9348  if (parameters.find(pname) == parameters.end())
+
9349  throw std::logic_error("The parameter " + pname + " does not exists.");
+
9350 
+
9351  parameters[pname] = value;
+
9352 
+
9353  return;
+
9354 
+
9355 }
+
9356 
+
9357 // // Same as before but using the size_t method
+
9358 // template<typename TSeq>
+
9359 // inline void Model<TSeq>::set_param(size_t k, epiworld_double value)
+
9360 // {
+
9361 // if (k >= parameters.size())
+
9362 // throw std::logic_error("The parameter index " + std::to_string(k) + " does not exists.");
9363 
-
9364 template<typename TSeq>
-
9365 inline epiworld_double Model<TSeq>::par(std::string pname)
-
9366 {
-
9367  return parameters[pname];
-
9368 }
-
9369 
-
9370 #define DURCAST(tunit,txtunit) {\
-
9371  elapsed = std::chrono::duration_cast<std::chrono:: tunit>(\
-
9372  time_end - time_start).count(); \
-
9373  elapsed_total = std::chrono::duration_cast<std::chrono:: tunit>(time_elapsed).count(); \
-
9374  abbr_unit = txtunit;}
-
9375 
-
9376 template<typename TSeq>
-
9377 inline void Model<TSeq>::get_elapsed(
-
9378  std::string unit,
-
9379  epiworld_double * last_elapsed,
-
9380  epiworld_double * total_elapsed,
-
9381  std::string * unit_abbr,
-
9382  bool print
-
9383 ) const {
-
9384 
-
9385  // Preparing the result
-
9386  epiworld_double elapsed, elapsed_total;
-
9387  std::string abbr_unit;
-
9388 
-
9389  // Figuring out the length
-
9390  if (unit == "auto")
-
9391  {
+
9364 // // Access the k-th element of the std::unordered_map parameters
+
9365 
+
9366 
+
9367 // *(parameters.begin() + k) = value;
+
9368 
+
9369 // return;
+
9370 // }
+
9371 
+
9372 template<typename TSeq>
+
9373 inline epiworld_double Model<TSeq>::par(std::string pname)
+
9374 {
+
9375  return parameters[pname];
+
9376 }
+
9377 
+
9378 #define DURCAST(tunit,txtunit) {\
+
9379  elapsed = std::chrono::duration_cast<std::chrono:: tunit>(\
+
9380  time_end - time_start).count(); \
+
9381  elapsed_total = std::chrono::duration_cast<std::chrono:: tunit>(time_elapsed).count(); \
+
9382  abbr_unit = txtunit;}
+
9383 
+
9384 template<typename TSeq>
+
9385 inline void Model<TSeq>::get_elapsed(
+
9386  std::string unit,
+
9387  epiworld_double * last_elapsed,
+
9388  epiworld_double * total_elapsed,
+
9389  std::string * unit_abbr,
+
9390  bool print
+
9391 ) const {
9392 
-
9393  size_t tlength = std::to_string(
-
9394  static_cast<int>(floor(time_elapsed.count()))
-
9395  ).length();
-
9396 
-
9397  if (tlength <= 1)
-
9398  unit = "nanoseconds";
-
9399  else if (tlength <= 3)
-
9400  unit = "microseconds";
-
9401  else if (tlength <= 6)
-
9402  unit = "milliseconds";
-
9403  else if (tlength <= 8)
-
9404  unit = "seconds";
-
9405  else if (tlength <= 9)
-
9406  unit = "minutes";
-
9407  else
-
9408  unit = "hours";
-
9409 
-
9410  }
-
9411 
-
9412  if (unit == "nanoseconds") DURCAST(nanoseconds,"ns")
-
9413  else if (unit == "microseconds") DURCAST(microseconds,"\xC2\xB5s")
-
9414  else if (unit == "milliseconds") DURCAST(milliseconds,"ms")
-
9415  else if (unit == "seconds") DURCAST(seconds,"s")
-
9416  else if (unit == "minutes") DURCAST(minutes,"m")
-
9417  else if (unit == "hours") DURCAST(hours,"h")
-
9418  else
-
9419  throw std::range_error("The time unit " + unit + " is not supported.");
-
9420 
-
9421 
-
9422  if (last_elapsed != nullptr)
-
9423  *last_elapsed = elapsed;
-
9424  if (total_elapsed != nullptr)
-
9425  *total_elapsed = elapsed_total;
-
9426  if (unit_abbr != nullptr)
-
9427  *unit_abbr = abbr_unit;
+
9393  // Preparing the result
+
9394  epiworld_double elapsed, elapsed_total;
+
9395  std::string abbr_unit;
+
9396 
+
9397  // Figuring out the length
+
9398  if (unit == "auto")
+
9399  {
+
9400 
+
9401  size_t tlength = std::to_string(
+
9402  static_cast<int>(floor(time_elapsed.count()))
+
9403  ).length();
+
9404 
+
9405  if (tlength <= 1)
+
9406  unit = "nanoseconds";
+
9407  else if (tlength <= 3)
+
9408  unit = "microseconds";
+
9409  else if (tlength <= 6)
+
9410  unit = "milliseconds";
+
9411  else if (tlength <= 8)
+
9412  unit = "seconds";
+
9413  else if (tlength <= 9)
+
9414  unit = "minutes";
+
9415  else
+
9416  unit = "hours";
+
9417 
+
9418  }
+
9419 
+
9420  if (unit == "nanoseconds") DURCAST(nanoseconds,"ns")
+
9421  else if (unit == "microseconds") DURCAST(microseconds,"\xC2\xB5s")
+
9422  else if (unit == "milliseconds") DURCAST(milliseconds,"ms")
+
9423  else if (unit == "seconds") DURCAST(seconds,"s")
+
9424  else if (unit == "minutes") DURCAST(minutes,"m")
+
9425  else if (unit == "hours") DURCAST(hours,"h")
+
9426  else
+
9427  throw std::range_error("The time unit " + unit + " is not supported.");
9428 
-
9429  if (!print)
-
9430  return;
-
9431 
-
9432  if (n_replicates > 1u)
-
9433  {
-
9434  printf_epiworld("last run elapsed time : %.2f%s\n",
-
9435  elapsed, abbr_unit.c_str());
-
9436  printf_epiworld("total elapsed time : %.2f%s\n",
-
9437  elapsed_total, abbr_unit.c_str());
-
9438  printf_epiworld("total runs : %i\n",
-
9439  static_cast<int>(n_replicates));
-
9440  printf_epiworld("mean run elapsed time : %.2f%s\n",
-
9441  elapsed_total/static_cast<epiworld_double>(n_replicates), abbr_unit.c_str());
-
9442 
-
9443  } else {
-
9444  printf_epiworld("last run elapsed time : %.2f%s.\n", elapsed, abbr_unit.c_str());
-
9445  }
-
9446 }
-
9447 
-
9448 template<typename TSeq>
-
9449 inline void Model<TSeq>::set_user_data(std::vector< std::string > names)
-
9450 {
-
9451  db.set_user_data(names);
-
9452 }
-
9453 
-
9454 template<typename TSeq>
-
9455 inline void Model<TSeq>::add_user_data(epiworld_fast_uint j, epiworld_double x)
-
9456 {
-
9457  db.add_user_data(j, x);
-
9458 }
-
9459 
-
9460 template<typename TSeq>
-
9461 inline void Model<TSeq>::add_user_data(std::vector<epiworld_double> x)
-
9462 {
-
9463  db.add_user_data(x);
-
9464 }
-
9465 
-
9466 template<typename TSeq>
-
9467 inline UserData<TSeq> & Model<TSeq>::get_user_data()
-
9468 {
-
9469  return db.get_user_data();
-
9470 }
-
9471 
-
9472 template<typename TSeq>
-
9473 inline void Model<TSeq>::add_global_action(
-
9474  std::function<void(Model<TSeq>*)> fun,
-
9475  std::string name,
-
9476  int date
-
9477 )
-
9478 {
+
9429 
+
9430  if (last_elapsed != nullptr)
+
9431  *last_elapsed = elapsed;
+
9432  if (total_elapsed != nullptr)
+
9433  *total_elapsed = elapsed_total;
+
9434  if (unit_abbr != nullptr)
+
9435  *unit_abbr = abbr_unit;
+
9436 
+
9437  if (!print)
+
9438  return;
+
9439 
+
9440  if (n_replicates > 1u)
+
9441  {
+
9442  printf_epiworld("last run elapsed time : %.2f%s\n",
+
9443  elapsed, abbr_unit.c_str());
+
9444  printf_epiworld("total elapsed time : %.2f%s\n",
+
9445  elapsed_total, abbr_unit.c_str());
+
9446  printf_epiworld("total runs : %i\n",
+
9447  static_cast<int>(n_replicates));
+
9448  printf_epiworld("mean run elapsed time : %.2f%s\n",
+
9449  elapsed_total/static_cast<epiworld_double>(n_replicates), abbr_unit.c_str());
+
9450 
+
9451  } else {
+
9452  printf_epiworld("last run elapsed time : %.2f%s.\n", elapsed, abbr_unit.c_str());
+
9453  }
+
9454 }
+
9455 
+
9456 template<typename TSeq>
+
9457 inline void Model<TSeq>::set_user_data(std::vector< std::string > names)
+
9458 {
+
9459  db.set_user_data(names);
+
9460 }
+
9461 
+
9462 template<typename TSeq>
+
9463 inline void Model<TSeq>::add_user_data(epiworld_fast_uint j, epiworld_double x)
+
9464 {
+
9465  db.add_user_data(j, x);
+
9466 }
+
9467 
+
9468 template<typename TSeq>
+
9469 inline void Model<TSeq>::add_user_data(std::vector<epiworld_double> x)
+
9470 {
+
9471  db.add_user_data(x);
+
9472 }
+
9473 
+
9474 template<typename TSeq>
+
9475 inline UserData<TSeq> & Model<TSeq>::get_user_data()
+
9476 {
+
9477  return db.get_user_data();
+
9478 }
9479 
-
9480  global_actions.push_back(
-
9481  GlobalAction<TSeq>(
-
9482  fun,
-
9483  name,
-
9484  date
-
9485  )
-
9486  );
+
9480 template<typename TSeq>
+
9481 inline void Model<TSeq>::add_global_action(
+
9482  std::function<void(Model<TSeq>*)> fun,
+
9483  std::string name,
+
9484  int date
+
9485 )
+
9486 {
9487 
-
9488 }
-
9489 
-
9490 template<typename TSeq>
-
9491 inline void Model<TSeq>::add_global_action(
-
9492  GlobalAction<TSeq> action
-
9493 )
-
9494 {
-
9495  global_actions.push_back(action);
+
9488  global_actions.push_back(
+
9489  GlobalAction<TSeq>(
+
9490  fun,
+
9491  name,
+
9492  date
+
9493  )
+
9494  );
+
9495 
9496 }
9497 
9498 template<typename TSeq>
-
9499 GlobalAction<TSeq> & Model<TSeq>::get_global_action(
-
9500  std::string name
+
9499 inline void Model<TSeq>::add_global_action(
+
9500  GlobalAction<TSeq> action
9501 )
9502 {
-
9503 
-
9504  for (auto & a : global_actions)
-
9505  if (a.name == name)
-
9506  return a;
-
9507 
-
9508  throw std::logic_error("The global action " + name + " was not found.");
-
9509 
-
9510 }
+
9503  global_actions.push_back(action);
+
9504 }
+
9505 
+
9506 template<typename TSeq>
+
9507 GlobalAction<TSeq> & Model<TSeq>::get_global_action(
+
9508  std::string name
+
9509 )
+
9510 {
9511 
-
9512 template<typename TSeq>
-
9513 GlobalAction<TSeq> & Model<TSeq>::get_global_action(
-
9514  size_t index
-
9515 )
-
9516 {
+
9512  for (auto & a : global_actions)
+
9513  if (a.name == name)
+
9514  return a;
+
9515 
+
9516  throw std::logic_error("The global action " + name + " was not found.");
9517 
-
9518  if (index >= global_actions.size())
-
9519  throw std::range_error("The index " + std::to_string(index) + " is out of range.");
-
9520 
-
9521  return global_actions[index];
-
9522 
-
9523 }
-
9524 
-
9525 // Remove implementation
-
9526 template<typename TSeq>
-
9527 inline void Model<TSeq>::rm_global_action(
-
9528  std::string name
-
9529 )
-
9530 {
-
9531 
-
9532  for (auto it = global_actions.begin(); it != global_actions.end(); ++it)
-
9533  {
-
9534  if (it->get_name() == name)
-
9535  {
-
9536  global_actions.erase(it);
-
9537  return;
-
9538  }
-
9539  }
-
9540 
-
9541  throw std::logic_error("The global action " + name + " was not found.");
-
9542 
-
9543 }
-
9544 
-
9545 // Same as above, but the index implementation
-
9546 template<typename TSeq>
-
9547 inline void Model<TSeq>::rm_global_action(
-
9548  size_t index
-
9549 )
-
9550 {
-
9551 
-
9552  if (index >= global_actions.size())
-
9553  throw std::range_error("The index " + std::to_string(index) + " is out of range.");
-
9554 
-
9555  global_actions.erase(global_actions.begin() + index);
-
9556 
-
9557 }
-
9558 
-
9559 template<typename TSeq>
-
9560 inline void Model<TSeq>::run_global_actions()
-
9561 {
+
9518 }
+
9519 
+
9520 template<typename TSeq>
+
9521 GlobalAction<TSeq> & Model<TSeq>::get_global_action(
+
9522  size_t index
+
9523 )
+
9524 {
+
9525 
+
9526  if (index >= global_actions.size())
+
9527  throw std::range_error("The index " + std::to_string(index) + " is out of range.");
+
9528 
+
9529  return global_actions[index];
+
9530 
+
9531 }
+
9532 
+
9533 // Remove implementation
+
9534 template<typename TSeq>
+
9535 inline void Model<TSeq>::rm_global_action(
+
9536  std::string name
+
9537 )
+
9538 {
+
9539 
+
9540  for (auto it = global_actions.begin(); it != global_actions.end(); ++it)
+
9541  {
+
9542  if (it->get_name() == name)
+
9543  {
+
9544  global_actions.erase(it);
+
9545  return;
+
9546  }
+
9547  }
+
9548 
+
9549  throw std::logic_error("The global action " + name + " was not found.");
+
9550 
+
9551 }
+
9552 
+
9553 // Same as above, but the index implementation
+
9554 template<typename TSeq>
+
9555 inline void Model<TSeq>::rm_global_action(
+
9556  size_t index
+
9557 )
+
9558 {
+
9559 
+
9560  if (index >= global_actions.size())
+
9561  throw std::range_error("The index " + std::to_string(index) + " is out of range.");
9562 
-
9563  for (auto & action: global_actions)
-
9564  {
-
9565  action(this, today());
-
9566  actions_run();
-
9567  }
-
9568 
-
9569 }
+
9563  global_actions.erase(global_actions.begin() + index);
+
9564 
+
9565 }
+
9566 
+
9567 template<typename TSeq>
+
9568 inline void Model<TSeq>::run_global_actions()
+
9569 {
9570 
-
9571 template<typename TSeq>
-
9572 inline void Model<TSeq>::queuing_on()
-
9573 {
-
9574  use_queuing = true;
-
9575 }
+
9571  for (auto & action: global_actions)
+
9572  {
+
9573  action(this, today());
+
9574  actions_run();
+
9575  }
9576 
-
9577 template<typename TSeq>
-
9578 inline Model<TSeq> & Model<TSeq>::queuing_off()
-
9579 {
-
9580  use_queuing = false;
-
9581  return *this;
-
9582 }
-
9583 
-
9584 template<typename TSeq>
-
9585 inline bool Model<TSeq>::is_queuing_on() const
-
9586 {
-
9587  return use_queuing;
-
9588 }
-
9589 
-
9590 template<typename TSeq>
-
9591 inline Queue<TSeq> & Model<TSeq>::get_queue()
-
9592 {
-
9593  return queue;
-
9594 }
-
9595 
-
9596 template<typename TSeq>
-
9597 inline const std::vector< VirusPtr<TSeq> > & Model<TSeq>::get_viruses() const
-
9598 {
-
9599  return viruses;
-
9600 }
-
9601 
-
9602 template<typename TSeq>
-
9603 inline const std::vector< epiworld_double > & Model<TSeq>::get_prevalence_virus() const
-
9604 {
-
9605  return prevalence_virus;
-
9606 }
-
9607 
-
9608 template<typename TSeq>
-
9609 inline const std::vector< bool > & Model<TSeq>::get_prevalence_virus_as_proportion() const
-
9610 {
-
9611  return prevalence_virus_as_proportion;
-
9612 }
-
9613 
-
9614 template<typename TSeq>
-
9615 const std::vector< ToolPtr<TSeq> > & Model<TSeq>::get_tools() const
-
9616 {
-
9617  return tools;
-
9618 }
-
9619 
-
9620 template<typename TSeq>
-
9621 inline Virus<TSeq> & Model<TSeq>::get_virus(size_t id)
-
9622 {
-
9623 
-
9624  if (viruses.size() <= id)
-
9625  throw std::length_error("The specified id for the virus is out of range");
-
9626 
-
9627  return *viruses[id];
-
9628 
-
9629 }
-
9630 
-
9631 template<typename TSeq>
-
9632 inline Tool<TSeq> & Model<TSeq>::get_tool(size_t id)
-
9633 {
+
9577 }
+
9578 
+
9579 template<typename TSeq>
+
9580 inline void Model<TSeq>::queuing_on()
+
9581 {
+
9582  use_queuing = true;
+
9583 }
+
9584 
+
9585 template<typename TSeq>
+
9586 inline Model<TSeq> & Model<TSeq>::queuing_off()
+
9587 {
+
9588  use_queuing = false;
+
9589  return *this;
+
9590 }
+
9591 
+
9592 template<typename TSeq>
+
9593 inline bool Model<TSeq>::is_queuing_on() const
+
9594 {
+
9595  return use_queuing;
+
9596 }
+
9597 
+
9598 template<typename TSeq>
+
9599 inline Queue<TSeq> & Model<TSeq>::get_queue()
+
9600 {
+
9601  return queue;
+
9602 }
+
9603 
+
9604 template<typename TSeq>
+
9605 inline const std::vector< VirusPtr<TSeq> > & Model<TSeq>::get_viruses() const
+
9606 {
+
9607  return viruses;
+
9608 }
+
9609 
+
9610 template<typename TSeq>
+
9611 inline const std::vector< epiworld_double > & Model<TSeq>::get_prevalence_virus() const
+
9612 {
+
9613  return prevalence_virus;
+
9614 }
+
9615 
+
9616 template<typename TSeq>
+
9617 inline const std::vector< bool > & Model<TSeq>::get_prevalence_virus_as_proportion() const
+
9618 {
+
9619  return prevalence_virus_as_proportion;
+
9620 }
+
9621 
+
9622 template<typename TSeq>
+
9623 const std::vector< ToolPtr<TSeq> > & Model<TSeq>::get_tools() const
+
9624 {
+
9625  return tools;
+
9626 }
+
9627 
+
9628 template<typename TSeq>
+
9629 inline Virus<TSeq> & Model<TSeq>::get_virus(size_t id)
+
9630 {
+
9631 
+
9632  if (viruses.size() <= id)
+
9633  throw std::length_error("The specified id for the virus is out of range");
9634 
-
9635  if (tools.size() <= id)
-
9636  throw std::length_error("The specified id for the tools is out of range");
-
9637 
-
9638  return *tools[id];
-
9639 
-
9640 }
-
9641 
+
9635  return *viruses[id];
+
9636 
+
9637 }
+
9638 
+
9639 template<typename TSeq>
+
9640 inline Tool<TSeq> & Model<TSeq>::get_tool(size_t id)
+
9641 {
9642 
-
9643 template<typename TSeq>
-
9644 inline void Model<TSeq>::set_agents_data(double * data_, size_t ncols_)
-
9645 {
-
9646  agents_data = data_;
-
9647  agents_data_ncols = ncols_;
+
9643  if (tools.size() <= id)
+
9644  throw std::length_error("The specified id for the tools is out of range");
+
9645 
+
9646  return *tools[id];
+
9647 
9648 }
9649 
-
9650 template<typename TSeq>
-
9651 inline double * Model<TSeq>::get_agents_data() {
-
9652  return this->agents_data;
-
9653 }
-
9654 
-
9655 template<typename TSeq>
-
9656 inline size_t Model<TSeq>::get_agents_data_ncols() const {
-
9657  return this->agents_data_ncols;
-
9658 }
-
9659 
-
9660 
-
9661 template<typename TSeq>
-
9662 inline void Model<TSeq>::set_name(std::string name)
-
9663 {
-
9664  this->name = name;
-
9665 }
-
9666 
-
9667 template<typename TSeq>
-
9668 inline std::string Model<TSeq>::get_name() const
-
9669 {
-
9670  return this->name;
-
9671 }
-
9672 
-
9673 #define VECT_MATCH(a, b, c) \
-
9674  EPI_DEBUG_FAIL_AT_TRUE(a.size() != b.size(), c) \
-
9675  for (size_t __i = 0u; __i < a.size(); ++__i) \
-
9676  {\
-
9677  EPI_DEBUG_FAIL_AT_TRUE(a[__i] != b[__i], c) \
-
9678  }
-
9679 
-
9680 template<typename TSeq>
-
9681 inline bool Model<TSeq>::operator==(const Model<TSeq> & other) const
-
9682 {
-
9683  EPI_DEBUG_FAIL_AT_TRUE(name != other.name, "names don't match")
-
9684  EPI_DEBUG_FAIL_AT_TRUE(db != other.db, "database don't match")
-
9685 
-
9686  VECT_MATCH(population, other.population, "population doesn't match")
+
9650 
+
9651 template<typename TSeq>
+
9652 inline void Model<TSeq>::set_agents_data(double * data_, size_t ncols_)
+
9653 {
+
9654  agents_data = data_;
+
9655  agents_data_ncols = ncols_;
+
9656 }
+
9657 
+
9658 template<typename TSeq>
+
9659 inline double * Model<TSeq>::get_agents_data() {
+
9660  return this->agents_data;
+
9661 }
+
9662 
+
9663 template<typename TSeq>
+
9664 inline size_t Model<TSeq>::get_agents_data_ncols() const {
+
9665  return this->agents_data_ncols;
+
9666 }
+
9667 
+
9668 
+
9669 template<typename TSeq>
+
9670 inline void Model<TSeq>::set_name(std::string name)
+
9671 {
+
9672  this->name = name;
+
9673 }
+
9674 
+
9675 template<typename TSeq>
+
9676 inline std::string Model<TSeq>::get_name() const
+
9677 {
+
9678  return this->name;
+
9679 }
+
9680 
+
9681 #define VECT_MATCH(a, b, c) \
+
9682  EPI_DEBUG_FAIL_AT_TRUE(a.size() != b.size(), c) \
+
9683  for (size_t __i = 0u; __i < a.size(); ++__i) \
+
9684  {\
+
9685  EPI_DEBUG_FAIL_AT_TRUE(a[__i] != b[__i], c) \
+
9686  }
9687 
-
9688  EPI_DEBUG_FAIL_AT_TRUE(
-
9689  using_backup != other.using_backup,
-
9690  "Model:: using_backup don't match"
-
9691  )
-
9692 
-
9693  if ((population_backup.size() != 0) & (other.population_backup.size() != 0))
-
9694  {
+
9688 template<typename TSeq>
+
9689 inline bool Model<TSeq>::operator==(const Model<TSeq> & other) const
+
9690 {
+
9691  EPI_DEBUG_FAIL_AT_TRUE(name != other.name, "names don't match")
+
9692  EPI_DEBUG_FAIL_AT_TRUE(db != other.db, "database don't match")
+
9693 
+
9694  VECT_MATCH(population, other.population, "population doesn't match")
9695 
-
9696  // False is population_backup.size() != other.population_backup.size()
-
9697  if (population_backup.size() != other.population_backup.size())
-
9698  return false;
-
9699 
-
9700  for (size_t i = 0u; i < population_backup.size(); ++i)
-
9701  {
-
9702  if (population_backup[i] != other.population_backup[i])
-
9703  return false;
-
9704  }
-
9705 
-
9706  } else if ((population_backup.size() == 0) & (other.population_backup.size() != 0)) {
-
9707  return false;
-
9708  } else if ((population_backup.size() != 0) & (other.population_backup.size() == 0))
-
9709  {
-
9710  return false;
-
9711  }
-
9712 
-
9713  EPI_DEBUG_FAIL_AT_TRUE(
-
9714  agents_data != other.agents_data,
-
9715  "Model:: agents_data don't match"
-
9716  )
-
9717 
-
9718  EPI_DEBUG_FAIL_AT_TRUE(
-
9719  agents_data_ncols != other.agents_data_ncols,
-
9720  "Model:: agents_data_ncols don't match"
-
9721  )
-
9722 
-
9723  EPI_DEBUG_FAIL_AT_TRUE(
-
9724  directed != other.directed,
-
9725  "Model:: directed don't match"
-
9726  )
-
9727 
-
9728  // Viruses -----------------------------------------------------------------
-
9729  EPI_DEBUG_FAIL_AT_TRUE(
-
9730  viruses.size() != other.viruses.size(),
-
9731  "Model:: viruses.size() don't match"
-
9732  )
-
9733 
-
9734  for (size_t i = 0u; i < viruses.size(); ++i)
-
9735  {
-
9736  EPI_DEBUG_FAIL_AT_TRUE(
-
9737  *viruses[i] != *other.viruses[i],
-
9738  "Model:: *viruses[i] don't match"
-
9739  )
-
9740 
-
9741  }
-
9742 
-
9743  VECT_MATCH(
-
9744  prevalence_virus,
-
9745  other.prevalence_virus,
-
9746  "virus prevalence don't match"
-
9747  )
-
9748 
-
9749  VECT_MATCH(
-
9750  prevalence_virus_as_proportion,
-
9751  other.prevalence_virus_as_proportion,
-
9752  "virus prevalence as prop don't match"
-
9753  )
-
9754 
-
9755  // Tools -------------------------------------------------------------------
-
9756  EPI_DEBUG_FAIL_AT_TRUE(
-
9757  tools.size() != other.tools.size(),
-
9758  "Model:: tools.size() don't match"
-
9759  )
-
9760 
-
9761  for (size_t i = 0u; i < tools.size(); ++i)
-
9762  {
-
9763  EPI_DEBUG_FAIL_AT_TRUE(
-
9764  *tools[i] != *other.tools[i],
-
9765  "Model:: *tools[i] don't match"
-
9766  )
-
9767 
-
9768  }
-
9769 
-
9770  VECT_MATCH(
-
9771  prevalence_tool,
-
9772  other.prevalence_tool,
-
9773  "tools prevalence don't match"
-
9774  )
-
9775 
-
9776  VECT_MATCH(
-
9777  prevalence_tool_as_proportion,
-
9778  other.prevalence_tool_as_proportion,
-
9779  "tools as prop don't match"
-
9780  )
-
9781 
-
9782  VECT_MATCH(
-
9783  entities,
-
9784  other.entities,
-
9785  "entities don't match"
-
9786  )
-
9787 
-
9788  if ((entities_backup.size() != 0) & (other.entities_backup.size() != 0))
-
9789  {
-
9790 
-
9791  for (size_t i = 0u; i < entities_backup.size(); ++i)
-
9792  {
-
9793 
-
9794  EPI_DEBUG_FAIL_AT_TRUE(
-
9795  entities_backup[i] != other.entities_backup[i],
-
9796  "Model:: entities_backup[i] don't match"
-
9797  )
-
9798 
-
9799  }
-
9800 
-
9801  } else if ((entities_backup.size() == 0) & (other.entities_backup.size() != 0)) {
-
9802  EPI_DEBUG_FAIL_AT_TRUE(true, "entities_backup don't match")
-
9803  } else if ((entities_backup.size() != 0) & (other.entities_backup.size() == 0))
-
9804  {
-
9805  EPI_DEBUG_FAIL_AT_TRUE(true, "entities_backup don't match")
-
9806  }
-
9807 
-
9808  EPI_DEBUG_FAIL_AT_TRUE(
-
9809  rewire_prop != other.rewire_prop,
-
9810  "Model:: rewire_prop don't match"
-
9811  )
-
9812 
-
9813  EPI_DEBUG_FAIL_AT_TRUE(
-
9814  parameters.size() != other.parameters.size(),
-
9815  "Model:: () don't match"
-
9816  )
-
9817 
-
9818  EPI_DEBUG_FAIL_AT_TRUE(
-
9819  parameters != other.parameters,
-
9820  "Model:: parameters don't match"
-
9821  )
-
9822 
-
9823  EPI_DEBUG_FAIL_AT_TRUE(
-
9824  ndays != other.ndays,
-
9825  "Model:: ndays don't match"
-
9826  )
-
9827 
-
9828  VECT_MATCH(
-
9829  states_labels,
-
9830  other.states_labels,
-
9831  "state labels don't match"
-
9832  )
-
9833 
-
9834  EPI_DEBUG_FAIL_AT_TRUE(
-
9835  nstates != other.nstates,
-
9836  "Model:: nstates don't match"
-
9837  )
-
9838 
-
9839  EPI_DEBUG_FAIL_AT_TRUE(
-
9840  verbose != other.verbose,
-
9841  "Model:: verbose don't match"
-
9842  )
-
9843 
-
9844  EPI_DEBUG_FAIL_AT_TRUE(
-
9845  current_date != other.current_date,
-
9846  "Model:: current_date don't match"
-
9847  )
-
9848 
-
9849  VECT_MATCH(global_actions, other.global_actions, "global action don't match");
-
9850 
-
9851  EPI_DEBUG_FAIL_AT_TRUE(
-
9852  queue != other.queue,
-
9853  "Model:: queue don't match"
-
9854  )
-
9855 
+
9696  EPI_DEBUG_FAIL_AT_TRUE(
+
9697  using_backup != other.using_backup,
+
9698  "Model:: using_backup don't match"
+
9699  )
+
9700 
+
9701  if ((population_backup.size() != 0) & (other.population_backup.size() != 0))
+
9702  {
+
9703 
+
9704  // False is population_backup.size() != other.population_backup.size()
+
9705  if (population_backup.size() != other.population_backup.size())
+
9706  return false;
+
9707 
+
9708  for (size_t i = 0u; i < population_backup.size(); ++i)
+
9709  {
+
9710  if (population_backup[i] != other.population_backup[i])
+
9711  return false;
+
9712  }
+
9713 
+
9714  } else if ((population_backup.size() == 0) & (other.population_backup.size() != 0)) {
+
9715  return false;
+
9716  } else if ((population_backup.size() != 0) & (other.population_backup.size() == 0))
+
9717  {
+
9718  return false;
+
9719  }
+
9720 
+
9721  EPI_DEBUG_FAIL_AT_TRUE(
+
9722  agents_data != other.agents_data,
+
9723  "Model:: agents_data don't match"
+
9724  )
+
9725 
+
9726  EPI_DEBUG_FAIL_AT_TRUE(
+
9727  agents_data_ncols != other.agents_data_ncols,
+
9728  "Model:: agents_data_ncols don't match"
+
9729  )
+
9730 
+
9731  EPI_DEBUG_FAIL_AT_TRUE(
+
9732  directed != other.directed,
+
9733  "Model:: directed don't match"
+
9734  )
+
9735 
+
9736  // Viruses -----------------------------------------------------------------
+
9737  EPI_DEBUG_FAIL_AT_TRUE(
+
9738  viruses.size() != other.viruses.size(),
+
9739  "Model:: viruses.size() don't match"
+
9740  )
+
9741 
+
9742  for (size_t i = 0u; i < viruses.size(); ++i)
+
9743  {
+
9744  EPI_DEBUG_FAIL_AT_TRUE(
+
9745  *viruses[i] != *other.viruses[i],
+
9746  "Model:: *viruses[i] don't match"
+
9747  )
+
9748 
+
9749  }
+
9750 
+
9751  VECT_MATCH(
+
9752  prevalence_virus,
+
9753  other.prevalence_virus,
+
9754  "virus prevalence don't match"
+
9755  )
+
9756 
+
9757  VECT_MATCH(
+
9758  prevalence_virus_as_proportion,
+
9759  other.prevalence_virus_as_proportion,
+
9760  "virus prevalence as prop don't match"
+
9761  )
+
9762 
+
9763  // Tools -------------------------------------------------------------------
+
9764  EPI_DEBUG_FAIL_AT_TRUE(
+
9765  tools.size() != other.tools.size(),
+
9766  "Model:: tools.size() don't match"
+
9767  )
+
9768 
+
9769  for (size_t i = 0u; i < tools.size(); ++i)
+
9770  {
+
9771  EPI_DEBUG_FAIL_AT_TRUE(
+
9772  *tools[i] != *other.tools[i],
+
9773  "Model:: *tools[i] don't match"
+
9774  )
+
9775 
+
9776  }
+
9777 
+
9778  VECT_MATCH(
+
9779  prevalence_tool,
+
9780  other.prevalence_tool,
+
9781  "tools prevalence don't match"
+
9782  )
+
9783 
+
9784  VECT_MATCH(
+
9785  prevalence_tool_as_proportion,
+
9786  other.prevalence_tool_as_proportion,
+
9787  "tools as prop don't match"
+
9788  )
+
9789 
+
9790  VECT_MATCH(
+
9791  entities,
+
9792  other.entities,
+
9793  "entities don't match"
+
9794  )
+
9795 
+
9796  if ((entities_backup.size() != 0) & (other.entities_backup.size() != 0))
+
9797  {
+
9798 
+
9799  for (size_t i = 0u; i < entities_backup.size(); ++i)
+
9800  {
+
9801 
+
9802  EPI_DEBUG_FAIL_AT_TRUE(
+
9803  entities_backup[i] != other.entities_backup[i],
+
9804  "Model:: entities_backup[i] don't match"
+
9805  )
+
9806 
+
9807  }
+
9808 
+
9809  } else if ((entities_backup.size() == 0) & (other.entities_backup.size() != 0)) {
+
9810  EPI_DEBUG_FAIL_AT_TRUE(true, "entities_backup don't match")
+
9811  } else if ((entities_backup.size() != 0) & (other.entities_backup.size() == 0))
+
9812  {
+
9813  EPI_DEBUG_FAIL_AT_TRUE(true, "entities_backup don't match")
+
9814  }
+
9815 
+
9816  EPI_DEBUG_FAIL_AT_TRUE(
+
9817  rewire_prop != other.rewire_prop,
+
9818  "Model:: rewire_prop don't match"
+
9819  )
+
9820 
+
9821  EPI_DEBUG_FAIL_AT_TRUE(
+
9822  parameters.size() != other.parameters.size(),
+
9823  "Model:: () don't match"
+
9824  )
+
9825 
+
9826  EPI_DEBUG_FAIL_AT_TRUE(
+
9827  parameters != other.parameters,
+
9828  "Model:: parameters don't match"
+
9829  )
+
9830 
+
9831  EPI_DEBUG_FAIL_AT_TRUE(
+
9832  ndays != other.ndays,
+
9833  "Model:: ndays don't match"
+
9834  )
+
9835 
+
9836  VECT_MATCH(
+
9837  states_labels,
+
9838  other.states_labels,
+
9839  "state labels don't match"
+
9840  )
+
9841 
+
9842  EPI_DEBUG_FAIL_AT_TRUE(
+
9843  nstates != other.nstates,
+
9844  "Model:: nstates don't match"
+
9845  )
+
9846 
+
9847  EPI_DEBUG_FAIL_AT_TRUE(
+
9848  verbose != other.verbose,
+
9849  "Model:: verbose don't match"
+
9850  )
+
9851 
+
9852  EPI_DEBUG_FAIL_AT_TRUE(
+
9853  current_date != other.current_date,
+
9854  "Model:: current_date don't match"
+
9855  )
9856 
-
9857  EPI_DEBUG_FAIL_AT_TRUE(
-
9858  use_queuing != other.use_queuing,
-
9859  "Model:: use_queuing don't match"
-
9860  )
-
9861 
-
9862  return true;
-
9863 
-
9864 }
-
9865 
-
9866 #undef VECT_MATCH
-
9867 #undef DURCAST
-
9868 #undef CASES_PAR
-
9869 #undef CASE_PAR
-
9870 #undef CHECK_INIT
-
9871 #endif
-
9872 /*//////////////////////////////////////////////////////////////////////////////
-
9874 
-
9875  End of -include/epiworld/model-meat.hpp-
-
9876 
-
9879 
-
9880 
-
9881 
-
9882 /*//////////////////////////////////////////////////////////////////////////////
+
9857  VECT_MATCH(global_actions, other.global_actions, "global action don't match");
+
9858 
+
9859  EPI_DEBUG_FAIL_AT_TRUE(
+
9860  queue != other.queue,
+
9861  "Model:: queue don't match"
+
9862  )
+
9863 
+
9864 
+
9865  EPI_DEBUG_FAIL_AT_TRUE(
+
9866  use_queuing != other.use_queuing,
+
9867  "Model:: use_queuing don't match"
+
9868  )
+
9869 
+
9870  return true;
+
9871 
+
9872 }
+
9873 
+
9874 #undef VECT_MATCH
+
9875 #undef DURCAST
+
9876 #undef CASES_PAR
+
9877 #undef CASE_PAR
+
9878 #undef CHECK_INIT
+
9879 #endif
+
9880 /*//////////////////////////////////////////////////////////////////////////////
+
9882 
+
9883  End of -include/epiworld/model-meat.hpp-
9884 
-
9885  Start of -include/epiworld/viruses-bones.hpp-
-
9886 
+
9887 
+
9888 
9889 
-
9890 
-
9891 #ifndef EPIWORLD_VIRUSES_BONES_HPP
-
9892 #define EPIWORLD_VIRUSES_BONES_HPP
-
9893 
-
9894 template<typename TSeq>
-
9895 class Virus;
-
9896 
-
9897 template<typename TSeq>
-
9898 class Agent;
-
9899 
+
9890 /*//////////////////////////////////////////////////////////////////////////////
+
9892 
+
9893  Start of -include/epiworld/viruses-bones.hpp-
+
9894 
+
9897 
+
9898 
+
9899 #ifndef EPIWORLD_VIRUSES_BONES_HPP
+
9900 #define EPIWORLD_VIRUSES_BONES_HPP
+
9901 
+
9902 template<typename TSeq>
+
9903 class Virus;
+
9904 
9905 template<typename TSeq>
-
9906 class Viruses {
-
9907  friend class Virus<TSeq>;
-
9908  friend class Agent<TSeq>;
-
9909 private:
-
9910  std::vector< VirusPtr<TSeq> > * dat;
-
9911  const epiworld_fast_uint * n_viruses;
-
9912 
-
9913 public:
-
9914 
-
9915  Viruses() = delete;
-
9916  Viruses(Agent<TSeq> & p) : dat(&p.viruses), n_viruses(&p.n_viruses) {};
-
9917 
-
9918  typename std::vector< VirusPtr<TSeq> >::iterator begin();
-
9919  typename std::vector< VirusPtr<TSeq> >::iterator end();
+
9906 class Agent;
+
9907 
+
9913 template<typename TSeq>
+
9914 class Viruses {
+
9915  friend class Virus<TSeq>;
+
9916  friend class Agent<TSeq>;
+
9917 private:
+
9918  std::vector< VirusPtr<TSeq> > * dat;
+
9919  const epiworld_fast_uint * n_viruses;
9920 
-
9921  VirusPtr<TSeq> & operator()(size_t i);
-
9922  VirusPtr<TSeq> & operator[](size_t i);
-
9923 
-
9924  size_t size() const noexcept;
+
9921 public:
+
9922 
+
9923  Viruses() = delete;
+
9924  Viruses(Agent<TSeq> & p) : dat(&p.viruses), n_viruses(&p.n_viruses) {};
9925 
-
9926  void print() const noexcept;
-
9927 
-
9928 };
-
9929 
-
9930 template<typename TSeq>
-
9931 inline typename std::vector< VirusPtr<TSeq> >::iterator Viruses<TSeq>::begin()
-
9932 {
+
9926  typename std::vector< VirusPtr<TSeq> >::iterator begin();
+
9927  typename std::vector< VirusPtr<TSeq> >::iterator end();
+
9928 
+
9929  VirusPtr<TSeq> & operator()(size_t i);
+
9930  VirusPtr<TSeq> & operator[](size_t i);
+
9931 
+
9932  size_t size() const noexcept;
9933 
-
9934  if (*n_viruses == 0u)
-
9935  return dat->end();
-
9936 
-
9937  return dat->begin();
-
9938 }
-
9939 
-
9940 template<typename TSeq>
-
9941 inline typename std::vector< VirusPtr<TSeq> >::iterator Viruses<TSeq>::end()
-
9942 {
-
9943 
-
9944  #ifdef EPI_DEBUG
-
9945  if (dat->size() < *n_viruses)
-
9946  throw EPI_DEBUG_ERROR(std::logic_error, "Viruses:: The end of the virus is out of range");
-
9947  #endif
-
9948 
-
9949  return begin() + *n_viruses;
-
9950 }
-
9951 
-
9952 template<typename TSeq>
-
9953 inline VirusPtr<TSeq> & Viruses<TSeq>::operator()(size_t i)
-
9954 {
-
9955 
-
9956  if (i >= *n_viruses)
-
9957  throw std::range_error("Virus index out of range.");
-
9958 
-
9959  return dat->operator[](i);
-
9960 
-
9961 }
-
9962 
-
9963 template<typename TSeq>
-
9964 inline VirusPtr<TSeq> & Viruses<TSeq>::operator[](size_t i)
-
9965 {
+
9934  void print() const noexcept;
+
9935 
+
9936 };
+
9937 
+
9938 template<typename TSeq>
+
9939 inline typename std::vector< VirusPtr<TSeq> >::iterator Viruses<TSeq>::begin()
+
9940 {
+
9941 
+
9942  if (*n_viruses == 0u)
+
9943  return dat->end();
+
9944 
+
9945  return dat->begin();
+
9946 }
+
9947 
+
9948 template<typename TSeq>
+
9949 inline typename std::vector< VirusPtr<TSeq> >::iterator Viruses<TSeq>::end()
+
9950 {
+
9951 
+
9952  #ifdef EPI_DEBUG
+
9953  if (dat->size() < *n_viruses)
+
9954  throw EPI_DEBUG_ERROR(std::logic_error, "Viruses:: The end of the virus is out of range");
+
9955  #endif
+
9956 
+
9957  return begin() + *n_viruses;
+
9958 }
+
9959 
+
9960 template<typename TSeq>
+
9961 inline VirusPtr<TSeq> & Viruses<TSeq>::operator()(size_t i)
+
9962 {
+
9963 
+
9964  if (i >= *n_viruses)
+
9965  throw std::range_error("Virus index out of range.");
9966 
9967  return dat->operator[](i);
9968 
9969 }
9970 
9971 template<typename TSeq>
-
9972 inline size_t Viruses<TSeq>::size() const noexcept
+
9972 inline VirusPtr<TSeq> & Viruses<TSeq>::operator[](size_t i)
9973 {
-
9974  return *n_viruses;
-
9975 }
+
9974 
+
9975  return dat->operator[](i);
9976 
-
9977 template<typename TSeq>
-
9978 inline void Viruses<TSeq>::print() const noexcept
-
9979 {
-
9980 
-
9981  if (*n_viruses == 0u)
-
9982  {
-
9983  printf_epiworld("List of viruses (none)\n");
-
9984  return;
-
9985  }
-
9986 
-
9987  printf_epiworld("List of viruses (%i): ", *n_viruses);
+
9977 }
+
9978 
+
9979 template<typename TSeq>
+
9980 inline size_t Viruses<TSeq>::size() const noexcept
+
9981 {
+
9982  return *n_viruses;
+
9983 }
+
9984 
+
9985 template<typename TSeq>
+
9986 inline void Viruses<TSeq>::print() const noexcept
+
9987 {
9988 
-
9989  // Printing the name of each virus separated by a comma
-
9990  for (size_t i = 0u; i < *n_viruses; ++i)
-
9991  {
-
9992  if (i == *n_viruses - 1u)
-
9993  {
-
9994  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
-
9995  } else
-
9996  {
-
9997  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
-
9998  }
-
9999  }
-
10000 
-
10001  printf_epiworld("\n");
-
10002 
-
10003 }
-
10004 
-
10010 template<typename TSeq>
-
10011 class Viruses_const {
-
10012  friend class Virus<TSeq>;
-
10013  friend class Agent<TSeq>;
-
10014 private:
-
10015  const std::vector< VirusPtr<TSeq> > * dat;
-
10016  const epiworld_fast_uint * n_viruses;
-
10017 
-
10018 public:
-
10019 
-
10020  Viruses_const() = delete;
-
10021  Viruses_const(const Agent<TSeq> & p) : dat(&p.viruses), n_viruses(&p.n_viruses) {};
-
10022 
-
10023  typename std::vector< VirusPtr<TSeq> >::const_iterator begin() const;
-
10024  typename std::vector< VirusPtr<TSeq> >::const_iterator end() const;
+
9989  if (*n_viruses == 0u)
+
9990  {
+
9991  printf_epiworld("List of viruses (none)\n");
+
9992  return;
+
9993  }
+
9994 
+
9995  printf_epiworld("List of viruses (%i): ", *n_viruses);
+
9996 
+
9997  // Printing the name of each virus separated by a comma
+
9998  for (size_t i = 0u; i < *n_viruses; ++i)
+
9999  {
+
10000  if (i == *n_viruses - 1u)
+
10001  {
+
10002  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
+
10003  } else
+
10004  {
+
10005  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
+
10006  }
+
10007  }
+
10008 
+
10009  printf_epiworld("\n");
+
10010 
+
10011 }
+
10012 
+
10018 template<typename TSeq>
+
10019 class Viruses_const {
+
10020  friend class Virus<TSeq>;
+
10021  friend class Agent<TSeq>;
+
10022 private:
+
10023  const std::vector< VirusPtr<TSeq> > * dat;
+
10024  const epiworld_fast_uint * n_viruses;
10025 
-
10026  const VirusPtr<TSeq> & operator()(size_t i);
-
10027  const VirusPtr<TSeq> & operator[](size_t i);
-
10028 
-
10029  size_t size() const noexcept;
+
10026 public:
+
10027 
+
10028  Viruses_const() = delete;
+
10029  Viruses_const(const Agent<TSeq> & p) : dat(&p.viruses), n_viruses(&p.n_viruses) {};
10030 
-
10031  void print() const noexcept;
-
10032 
-
10033 };
-
10034 
-
10035 template<typename TSeq>
-
10036 inline typename std::vector< VirusPtr<TSeq> >::const_iterator Viruses_const<TSeq>::begin() const {
-
10037 
-
10038  if (*n_viruses == 0u)
-
10039  return dat->end();
-
10040 
-
10041  return dat->begin();
-
10042 }
-
10043 
-
10044 template<typename TSeq>
-
10045 inline typename std::vector< VirusPtr<TSeq> >::const_iterator Viruses_const<TSeq>::end() const {
-
10046 
-
10047  #ifdef EPI_DEBUG
-
10048  if (dat->size() < *n_viruses)
-
10049  throw EPI_DEBUG_ERROR(std::logic_error, "Viruses_const:: The end of the virus is out of range");
-
10050  #endif
-
10051  return begin() + *n_viruses;
-
10052 }
-
10053 
-
10054 template<typename TSeq>
-
10055 inline const VirusPtr<TSeq> & Viruses_const<TSeq>::operator()(size_t i)
-
10056 {
-
10057 
-
10058  if (i >= *n_viruses)
-
10059  throw std::range_error("Virus index out of range.");
-
10060 
-
10061  return dat->operator[](i);
-
10062 
-
10063 }
-
10064 
-
10065 template<typename TSeq>
-
10066 inline const VirusPtr<TSeq> & Viruses_const<TSeq>::operator[](size_t i)
-
10067 {
+
10031  typename std::vector< VirusPtr<TSeq> >::const_iterator begin() const;
+
10032  typename std::vector< VirusPtr<TSeq> >::const_iterator end() const;
+
10033 
+
10034  const VirusPtr<TSeq> & operator()(size_t i);
+
10035  const VirusPtr<TSeq> & operator[](size_t i);
+
10036 
+
10037  size_t size() const noexcept;
+
10038 
+
10039  void print() const noexcept;
+
10040 
+
10041 };
+
10042 
+
10043 template<typename TSeq>
+
10044 inline typename std::vector< VirusPtr<TSeq> >::const_iterator Viruses_const<TSeq>::begin() const {
+
10045 
+
10046  if (*n_viruses == 0u)
+
10047  return dat->end();
+
10048 
+
10049  return dat->begin();
+
10050 }
+
10051 
+
10052 template<typename TSeq>
+
10053 inline typename std::vector< VirusPtr<TSeq> >::const_iterator Viruses_const<TSeq>::end() const {
+
10054 
+
10055  #ifdef EPI_DEBUG
+
10056  if (dat->size() < *n_viruses)
+
10057  throw EPI_DEBUG_ERROR(std::logic_error, "Viruses_const:: The end of the virus is out of range");
+
10058  #endif
+
10059  return begin() + *n_viruses;
+
10060 }
+
10061 
+
10062 template<typename TSeq>
+
10063 inline const VirusPtr<TSeq> & Viruses_const<TSeq>::operator()(size_t i)
+
10064 {
+
10065 
+
10066  if (i >= *n_viruses)
+
10067  throw std::range_error("Virus index out of range.");
10068 
10069  return dat->operator[](i);
10070 
10071 }
10072 
10073 template<typename TSeq>
-
10074 inline size_t Viruses_const<TSeq>::size() const noexcept
+
10074 inline const VirusPtr<TSeq> & Viruses_const<TSeq>::operator[](size_t i)
10075 {
-
10076  return *n_viruses;
-
10077 }
+
10076 
+
10077  return dat->operator[](i);
10078 
-
10079 template<typename TSeq>
-
10080 inline void Viruses_const<TSeq>::print() const noexcept
-
10081 {
-
10082 
-
10083  if (*n_viruses == 0u)
-
10084  {
-
10085  printf_epiworld("List of viruses (none)\n");
-
10086  return;
-
10087  }
-
10088 
-
10089  printf_epiworld("List of viruses (%i): ", *n_viruses);
+
10079 }
+
10080 
+
10081 template<typename TSeq>
+
10082 inline size_t Viruses_const<TSeq>::size() const noexcept
+
10083 {
+
10084  return *n_viruses;
+
10085 }
+
10086 
+
10087 template<typename TSeq>
+
10088 inline void Viruses_const<TSeq>::print() const noexcept
+
10089 {
10090 
-
10091  // Printing the name of each virus separated by a comma
-
10092  for (size_t i = 0u; i < *n_viruses; ++i)
-
10093  {
-
10094  if (i == *n_viruses - 1u)
-
10095  {
-
10096  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
-
10097  } else
-
10098  {
-
10099  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
-
10100  }
-
10101  }
-
10102 
-
10103  printf_epiworld("\n");
-
10104 
-
10105 }
-
10106 
-
10107 
-
10108 #endif
-
10109 /*//////////////////////////////////////////////////////////////////////////////
-
10111 
-
10112  End of -include/epiworld/viruses-bones.hpp-
-
10113 
-
10116 
-
10117 
-
10118 
-
10119 /*//////////////////////////////////////////////////////////////////////////////
+
10091  if (*n_viruses == 0u)
+
10092  {
+
10093  printf_epiworld("List of viruses (none)\n");
+
10094  return;
+
10095  }
+
10096 
+
10097  printf_epiworld("List of viruses (%i): ", *n_viruses);
+
10098 
+
10099  // Printing the name of each virus separated by a comma
+
10100  for (size_t i = 0u; i < *n_viruses; ++i)
+
10101  {
+
10102  if (i == *n_viruses - 1u)
+
10103  {
+
10104  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
+
10105  } else
+
10106  {
+
10107  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
+
10108  }
+
10109  }
+
10110 
+
10111  printf_epiworld("\n");
+
10112 
+
10113 }
+
10114 
+
10115 
+
10116 #endif
+
10117 /*//////////////////////////////////////////////////////////////////////////////
+
10119 
+
10120  End of -include/epiworld/viruses-bones.hpp-
10121 
-
10122  Start of -include/epiworld/virus-bones.hpp-
-
10123 
+
10124 
+
10125 
10126 
-
10127 
-
10128 #ifndef EPIWORLD_VIRUS_HPP
-
10129 #define EPIWORLD_VIRUS_HPP
-
10130 
-
10131 template<typename TSeq>
-
10132 class Agent;
-
10133 
-
10134 template<typename TSeq>
-
10135 class Virus;
-
10136 
-
10137 template<typename TSeq>
-
10138 class Model;
-
10139 
-
10150 template<typename TSeq>
-
10151 class Virus {
-
10152  friend class Agent<TSeq>;
-
10153  friend class Model<TSeq>;
-
10154  friend class DataBase<TSeq>;
-
10155  friend void default_add_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
10156  friend void default_rm_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
10157 private:
-
10158 
-
10159  Agent<TSeq> * agent = nullptr;
-
10160 
-
10161  std::shared_ptr<TSeq> baseline_sequence = nullptr;
-
10162  std::shared_ptr<std::string> virus_name = nullptr;
-
10163  int date = -99;
-
10164  int id = -99;
-
10165  bool active = true;
-
10166  MutFun<TSeq> mutation_fun = nullptr;
-
10167  PostRecoveryFun<TSeq> post_recovery_fun = nullptr;
-
10168  VirusFun<TSeq> probability_of_infecting_fun = nullptr;
-
10169  VirusFun<TSeq> probability_of_recovery_fun = nullptr;
-
10170  VirusFun<TSeq> probability_of_death_fun = nullptr;
-
10171  VirusFun<TSeq> incubation_fun = nullptr;
-
10172 
-
10173  // Setup parameters
-
10174  std::vector< epiworld_double > data = {};
-
10175 
-
10176  epiworld_fast_int state_init = -99; ///< Change of state when added to agent.
-
10177  epiworld_fast_int state_post = -99; ///< Change of state when removed from agent.
-
10178  epiworld_fast_int state_removed = -99; ///< Change of state when agent is removed
-
10179 
-
10180  epiworld_fast_int queue_init = Queue<TSeq>::Everyone; ///< Change of state when added to agent.
-
10181  epiworld_fast_int queue_post = -Queue<TSeq>::Everyone; ///< Change of state when removed from agent.
-
10182  epiworld_fast_int queue_removed = -99; ///< Change of state when agent is removed
+
10127 /*//////////////////////////////////////////////////////////////////////////////
+
10129 
+
10130  Start of -include/epiworld/virus-bones.hpp-
+
10131 
+
10134 
+
10135 
+
10136 #ifndef EPIWORLD_VIRUS_HPP
+
10137 #define EPIWORLD_VIRUS_HPP
+
10138 
+
10139 template<typename TSeq>
+
10140 class Agent;
+
10141 
+
10142 template<typename TSeq>
+
10143 class Virus;
+
10144 
+
10145 template<typename TSeq>
+
10146 class Model;
+
10147 
+
10158 template<typename TSeq>
+
10159 class Virus {
+
10160  friend class Agent<TSeq>;
+
10161  friend class Model<TSeq>;
+
10162  friend class DataBase<TSeq>;
+
10163  friend void default_add_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
10164  friend void default_rm_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
10165 private:
+
10166 
+
10167  Agent<TSeq> * agent = nullptr;
+
10168 
+
10169  std::shared_ptr<TSeq> baseline_sequence = nullptr;
+
10170  std::shared_ptr<std::string> virus_name = nullptr;
+
10171  int date = -99;
+
10172  int id = -99;
+
10173  bool active = true;
+
10174  MutFun<TSeq> mutation_fun = nullptr;
+
10175  PostRecoveryFun<TSeq> post_recovery_fun = nullptr;
+
10176  VirusFun<TSeq> probability_of_infecting_fun = nullptr;
+
10177  VirusFun<TSeq> probability_of_recovery_fun = nullptr;
+
10178  VirusFun<TSeq> probability_of_death_fun = nullptr;
+
10179  VirusFun<TSeq> incubation_fun = nullptr;
+
10180 
+
10181  // Setup parameters
+
10182  std::vector< epiworld_double > data = {};
10183 
-
10184 public:
-
10185  Virus(std::string name = "unknown virus");
-
10186 
-
10187  void mutate(Model<TSeq> * model);
-
10188  void set_mutation(MutFun<TSeq> fun);
-
10189 
-
10190  std::shared_ptr<TSeq> get_sequence();
-
10191  void set_sequence(TSeq sequence);
-
10192 
-
10193  Agent<TSeq> * get_agent();
-
10194  void set_agent(Agent<TSeq> * p);
-
10195 
-
10196  void set_date(int d);
-
10197  int get_date() const;
-
10198 
-
10199  void set_id(int idx);
-
10200  int get_id() const;
-
10201 
-
10211  epiworld_double get_prob_infecting(Model<TSeq> * model);
-
10212  epiworld_double get_prob_recovery(Model<TSeq> * model);
-
10213  epiworld_double get_prob_death(Model<TSeq> * model);
-
10214  epiworld_double get_incubation(Model<TSeq> * model);
-
10215 
-
10216  void post_recovery(Model<TSeq> * model);
-
10217  void set_post_recovery(PostRecoveryFun<TSeq> fun);
-
10218  void set_post_immunity(epiworld_double prob);
-
10219  void set_post_immunity(epiworld_double * prob);
-
10220 
-
10221  void set_prob_infecting_fun(VirusFun<TSeq> fun);
-
10222  void set_prob_recovery_fun(VirusFun<TSeq> fun);
-
10223  void set_prob_death_fun(VirusFun<TSeq> fun);
-
10224  void set_incubation_fun(VirusFun<TSeq> fun);
-
10225 
-
10226  void set_prob_infecting(const epiworld_double * prob);
-
10227  void set_prob_recovery(const epiworld_double * prob);
-
10228  void set_prob_death(const epiworld_double * prob);
-
10229  void set_incubation(const epiworld_double * prob);
-
10230 
-
10231  void set_prob_infecting(epiworld_double prob);
-
10232  void set_prob_recovery(epiworld_double prob);
-
10233  void set_prob_death(epiworld_double prob);
-
10234  void set_incubation(epiworld_double prob);
-
10236 
-
10237 
-
10238  void set_name(std::string name);
-
10239  std::string get_name() const;
-
10240 
-
10241  std::vector< epiworld_double > & get_data();
-
10242 
-
10256  void set_state(
-
10257  epiworld_fast_int init,
-
10258  epiworld_fast_int end,
-
10259  epiworld_fast_int removed = -99
-
10260  );
-
10261 
-
10262  void set_queue(
-
10263  epiworld_fast_int init,
-
10264  epiworld_fast_int end,
-
10265  epiworld_fast_int removed = -99
-
10266  );
-
10267 
-
10268  void get_state(
-
10269  epiworld_fast_int * init,
-
10270  epiworld_fast_int * end,
-
10271  epiworld_fast_int * removed = nullptr
-
10272  );
-
10273 
-
10274  void get_queue(
-
10275  epiworld_fast_int * init,
-
10276  epiworld_fast_int * end,
-
10277  epiworld_fast_int * removed = nullptr
-
10278  );
-
10280 
-
10281  bool operator==(const Virus<TSeq> & other) const;
-
10282  bool operator!=(const Virus<TSeq> & other) const {return !operator==(other);};
-
10283 
-
10284  void print() const;
-
10285 
-
10286 };
-
10287 
-
10288 #endif
-
10289 /*//////////////////////////////////////////////////////////////////////////////
+
10184  epiworld_fast_int state_init = -99; ///< Change of state when added to agent.
+
10185  epiworld_fast_int state_post = -99; ///< Change of state when removed from agent.
+
10186  epiworld_fast_int state_removed = -99; ///< Change of state when agent is removed
+
10187 
+
10188  epiworld_fast_int queue_init = Queue<TSeq>::Everyone; ///< Change of state when added to agent.
+
10189  epiworld_fast_int queue_post = -Queue<TSeq>::Everyone; ///< Change of state when removed from agent.
+
10190  epiworld_fast_int queue_removed = -99; ///< Change of state when agent is removed
+
10191 
+
10192 public:
+
10193  Virus(std::string name = "unknown virus");
+
10194 
+
10195  void mutate(Model<TSeq> * model);
+
10196  void set_mutation(MutFun<TSeq> fun);
+
10197 
+
10198  std::shared_ptr<TSeq> get_sequence();
+
10199  void set_sequence(TSeq sequence);
+
10200 
+
10201  Agent<TSeq> * get_agent();
+
10202  void set_agent(Agent<TSeq> * p);
+
10203 
+
10204  void set_date(int d);
+
10205  int get_date() const;
+
10206 
+
10207  void set_id(int idx);
+
10208  int get_id() const;
+
10209 
+
10219  epiworld_double get_prob_infecting(Model<TSeq> * model);
+
10220  epiworld_double get_prob_recovery(Model<TSeq> * model);
+
10221  epiworld_double get_prob_death(Model<TSeq> * model);
+
10222  epiworld_double get_incubation(Model<TSeq> * model);
+
10223 
+
10224  void post_recovery(Model<TSeq> * model);
+
10225  void set_post_recovery(PostRecoveryFun<TSeq> fun);
+
10226  void set_post_immunity(epiworld_double prob);
+
10227  void set_post_immunity(epiworld_double * prob);
+
10228 
+
10229  void set_prob_infecting_fun(VirusFun<TSeq> fun);
+
10230  void set_prob_recovery_fun(VirusFun<TSeq> fun);
+
10231  void set_prob_death_fun(VirusFun<TSeq> fun);
+
10232  void set_incubation_fun(VirusFun<TSeq> fun);
+
10233 
+
10234  void set_prob_infecting(const epiworld_double * prob);
+
10235  void set_prob_recovery(const epiworld_double * prob);
+
10236  void set_prob_death(const epiworld_double * prob);
+
10237  void set_incubation(const epiworld_double * prob);
+
10238 
+
10239  void set_prob_infecting(epiworld_double prob);
+
10240  void set_prob_recovery(epiworld_double prob);
+
10241  void set_prob_death(epiworld_double prob);
+
10242  void set_incubation(epiworld_double prob);
+
10244 
+
10245 
+
10246  void set_name(std::string name);
+
10247  std::string get_name() const;
+
10248 
+
10249  std::vector< epiworld_double > & get_data();
+
10250 
+
10264  void set_state(
+
10265  epiworld_fast_int init,
+
10266  epiworld_fast_int end,
+
10267  epiworld_fast_int removed = -99
+
10268  );
+
10269 
+
10270  void set_queue(
+
10271  epiworld_fast_int init,
+
10272  epiworld_fast_int end,
+
10273  epiworld_fast_int removed = -99
+
10274  );
+
10275 
+
10276  void get_state(
+
10277  epiworld_fast_int * init,
+
10278  epiworld_fast_int * end,
+
10279  epiworld_fast_int * removed = nullptr
+
10280  );
+
10281 
+
10282  void get_queue(
+
10283  epiworld_fast_int * init,
+
10284  epiworld_fast_int * end,
+
10285  epiworld_fast_int * removed = nullptr
+
10286  );
+
10288 
+
10289  bool operator==(const Virus<TSeq> & other) const;
+
10290  bool operator!=(const Virus<TSeq> & other) const {return !operator==(other);};
10291 
-
10292  End of -include/epiworld/virus-bones.hpp-
+
10292  void print() const;
10293 
-
10296 
-
10297 
-
10298 /*//////////////////////////////////////////////////////////////////////////////
-
10300 
-
10301  Start of -include/epiworld/virus-meat.hpp-
-
10302 
+
10294 };
+
10295 
+
10296 #endif
+
10297 /*//////////////////////////////////////////////////////////////////////////////
+
10299 
+
10300  End of -include/epiworld/virus-bones.hpp-
+
10301 
+
10304 
10305 
-
10306 
-
10307 #ifndef EPIWORLD_VIRUS_MEAT_HPP
-
10308 #define EPIWORLD_VIRUS_MEAT_HPP
-
10309 
-
10318 template<typename TSeq>
-
10319 inline VirusFun<TSeq> virus_fun_logit(
-
10320  std::vector< int > vars,
-
10321  std::vector< double > coefs,
-
10322  Model<TSeq> * model,
-
10323  bool logit = true
-
10324 ) {
-
10325 
-
10326  // Checking that there are features
-
10327  if (coefs.size() == 0u)
-
10328  throw std::logic_error(
-
10329  "The -coefs- argument should feature at least one element."
-
10330  );
-
10331 
-
10332  if (coefs.size() != vars.size())
-
10333  throw std::length_error(
-
10334  std::string("The length of -coef- (") +
-
10335  std::to_string(coefs.size()) +
-
10336  std::string(") and -vars- (") +
-
10337  std::to_string(vars.size()) +
-
10338  std::string(") should match. ")
-
10339  );
-
10340 
-
10341  // Checking that there are variables in the model
-
10342  if (model != nullptr)
-
10343  {
-
10344 
-
10345  size_t K = model->get_agents_data_ncols();
-
10346  for (const auto & var: vars)
-
10347  {
-
10348  if ((var >= static_cast<int>(K)) | (var < 0))
-
10349  throw std::range_error(
-
10350  std::string("The variable ") +
-
10351  std::to_string(var) +
-
10352  std::string(" is out of range.") +
-
10353  std::string(" The agents only feature ") +
-
10354  std::to_string(K) +
-
10355  std::string("variables (features).")
-
10356  );
-
10357  }
-
10358 
-
10359  }
-
10360 
-
10361  std::vector< epiworld_double > coefs_f;
-
10362  for (auto c: coefs)
-
10363  coefs_f.push_back(static_cast<epiworld_double>(c));
-
10364 
-
10365  VirusFun<TSeq> fun_infect = [coefs_f,vars,logit](
-
10366  Agent<TSeq> * agent,
-
10367  Virus<TSeq> & virus,
-
10368  Model<TSeq> * model
-
10369  ) -> epiworld_double {
-
10370 
-
10371  size_t K = coefs_f.size();
-
10372  epiworld_double res = 0.0;
-
10373 
-
10374  #if defined(__OPENMP) || defined(_OPENMP)
-
10375  #pragma omp simd reduction(+:res)
-
10376  #endif
-
10377  for (size_t i = 0u; i < K; ++i)
-
10378  res += agent->operator[](vars.at(i)) * coefs_f.at(i);
-
10379 
-
10380  return 1.0/(1.0 + std::exp(-res));
+
10306 /*//////////////////////////////////////////////////////////////////////////////
+
10308 
+
10309  Start of -include/epiworld/virus-meat.hpp-
+
10310 
+
10313 
+
10314 
+
10315 #ifndef EPIWORLD_VIRUS_MEAT_HPP
+
10316 #define EPIWORLD_VIRUS_MEAT_HPP
+
10317 
+
10326 template<typename TSeq>
+
10327 inline VirusFun<TSeq> virus_fun_logit(
+
10328  std::vector< int > vars,
+
10329  std::vector< double > coefs,
+
10330  Model<TSeq> * model,
+
10331  bool logit = true
+
10332 ) {
+
10333 
+
10334  // Checking that there are features
+
10335  if (coefs.size() == 0u)
+
10336  throw std::logic_error(
+
10337  "The -coefs- argument should feature at least one element."
+
10338  );
+
10339 
+
10340  if (coefs.size() != vars.size())
+
10341  throw std::length_error(
+
10342  std::string("The length of -coef- (") +
+
10343  std::to_string(coefs.size()) +
+
10344  std::string(") and -vars- (") +
+
10345  std::to_string(vars.size()) +
+
10346  std::string(") should match. ")
+
10347  );
+
10348 
+
10349  // Checking that there are variables in the model
+
10350  if (model != nullptr)
+
10351  {
+
10352 
+
10353  size_t K = model->get_agents_data_ncols();
+
10354  for (const auto & var: vars)
+
10355  {
+
10356  if ((var >= static_cast<int>(K)) | (var < 0))
+
10357  throw std::range_error(
+
10358  std::string("The variable ") +
+
10359  std::to_string(var) +
+
10360  std::string(" is out of range.") +
+
10361  std::string(" The agents only feature ") +
+
10362  std::to_string(K) +
+
10363  std::string("variables (features).")
+
10364  );
+
10365  }
+
10366 
+
10367  }
+
10368 
+
10369  std::vector< epiworld_double > coefs_f;
+
10370  for (auto c: coefs)
+
10371  coefs_f.push_back(static_cast<epiworld_double>(c));
+
10372 
+
10373  VirusFun<TSeq> fun_infect = [coefs_f,vars,logit](
+
10374  Agent<TSeq> * agent,
+
10375  Virus<TSeq> & virus,
+
10376  Model<TSeq> * model
+
10377  ) -> epiworld_double {
+
10378 
+
10379  size_t K = coefs_f.size();
+
10380  epiworld_double res = 0.0;
10381 
-
10382  };
-
10383 
-
10384  return fun_infect;
-
10385 
-
10386 }
+
10382  #if defined(__OPENMP) || defined(_OPENMP)
+
10383  #pragma omp simd reduction(+:res)
+
10384  #endif
+
10385  for (size_t i = 0u; i < K; ++i)
+
10386  res += agent->operator[](vars.at(i)) * coefs_f.at(i);
10387 
-
10388 template<typename TSeq>
-
10389 inline Virus<TSeq>::Virus(std::string name) {
-
10390  set_name(name);
-
10391 }
-
10392 
-
10393 template<typename TSeq>
-
10394 inline void Virus<TSeq>::mutate(
-
10395  Model<TSeq> * model
-
10396 ) {
-
10397 
-
10398  if (mutation_fun)
-
10399  if (mutation_fun(agent, *this, model))
-
10400  model->get_db().record_virus(*this);
-
10401 
-
10402  return;
-
10403 
-
10404 }
+
10388  return 1.0/(1.0 + std::exp(-res));
+
10389 
+
10390  };
+
10391 
+
10392  return fun_infect;
+
10393 
+
10394 }
+
10395 
+
10396 template<typename TSeq>
+
10397 inline Virus<TSeq>::Virus(std::string name) {
+
10398  set_name(name);
+
10399 }
+
10400 
+
10401 template<typename TSeq>
+
10402 inline void Virus<TSeq>::mutate(
+
10403  Model<TSeq> * model
+
10404 ) {
10405 
-
10406 template<typename TSeq>
-
10407 inline void Virus<TSeq>::set_mutation(
-
10408  MutFun<TSeq> fun
-
10409 ) {
-
10410  mutation_fun = MutFun<TSeq>(fun);
-
10411 }
-
10412 
-
10413 template<typename TSeq>
-
10414 inline std::shared_ptr<TSeq> Virus<TSeq>::get_sequence()
-
10415 {
-
10416 
-
10417  return baseline_sequence;
-
10418 
+
10406  if (mutation_fun)
+
10407  if (mutation_fun(agent, *this, model))
+
10408  model->get_db().record_virus(*this);
+
10409 
+
10410  return;
+
10411 
+
10412 }
+
10413 
+
10414 template<typename TSeq>
+
10415 inline void Virus<TSeq>::set_mutation(
+
10416  MutFun<TSeq> fun
+
10417 ) {
+
10418  mutation_fun = MutFun<TSeq>(fun);
10419 }
10420 
10421 template<typename TSeq>
-
10422 inline void Virus<TSeq>::set_sequence(TSeq sequence)
+
10422 inline std::shared_ptr<TSeq> Virus<TSeq>::get_sequence()
10423 {
10424 
-
10425  baseline_sequence = std::make_shared<TSeq>(sequence);
-
10426  return;
-
10427 
-
10428 }
-
10429 
-
10430 template<typename TSeq>
-
10431 inline Agent<TSeq> * Virus<TSeq>::get_agent()
-
10432 {
-
10433 
-
10434  return agent;
+
10425  return baseline_sequence;
+
10426 
+
10427 }
+
10428 
+
10429 template<typename TSeq>
+
10430 inline void Virus<TSeq>::set_sequence(TSeq sequence)
+
10431 {
+
10432 
+
10433  baseline_sequence = std::make_shared<TSeq>(sequence);
+
10434  return;
10435 
10436 }
10437 
10438 template<typename TSeq>
-
10439 inline void Virus<TSeq>::set_agent(Agent<TSeq> * p)
+
10439 inline Agent<TSeq> * Virus<TSeq>::get_agent()
10440 {
-
10441  agent = p;
-
10442 }
+
10441 
+
10442  return agent;
10443 
-
10444 template<typename TSeq>
-
10445 inline void Virus<TSeq>::set_id(int idx)
-
10446 {
-
10447 
-
10448  id = idx;
-
10449  return;
-
10450 
-
10451 }
-
10452 
-
10453 template<typename TSeq>
-
10454 inline int Virus<TSeq>::get_id() const
-
10455 {
-
10456 
-
10457  return id;
+
10444 }
+
10445 
+
10446 template<typename TSeq>
+
10447 inline void Virus<TSeq>::set_agent(Agent<TSeq> * p)
+
10448 {
+
10449  agent = p;
+
10450 }
+
10451 
+
10452 template<typename TSeq>
+
10453 inline void Virus<TSeq>::set_id(int idx)
+
10454 {
+
10455 
+
10456  id = idx;
+
10457  return;
10458 
10459 }
10460 
10461 template<typename TSeq>
-
10462 inline void Virus<TSeq>::set_date(int d)
+
10462 inline int Virus<TSeq>::get_id() const
10463 {
-
10464 
-
10465  date = d;
-
10466  return;
-
10467 
-
10468 }
-
10469 
-
10470 template<typename TSeq>
-
10471 inline int Virus<TSeq>::get_date() const
-
10472 {
-
10473 
-
10474  return date;
-
10475 
+
10464 
+
10465  return id;
+
10466 
+
10467 }
+
10468 
+
10469 template<typename TSeq>
+
10470 inline void Virus<TSeq>::set_date(int d)
+
10471 {
+
10472 
+
10473  date = d;
+
10474  return;
+
10475 
10476 }
10477 
10478 template<typename TSeq>
-
10479 inline epiworld_double Virus<TSeq>::get_prob_infecting(
-
10480  Model<TSeq> * model
-
10481 )
-
10482 {
-
10483 
-
10484  if (probability_of_infecting_fun)
-
10485  return probability_of_infecting_fun(agent, *this, model);
-
10486 
-
10487  return EPI_DEFAULT_VIRUS_PROB_INFECTION;
-
10488 
-
10489 }
-
10490 
+
10479 inline int Virus<TSeq>::get_date() const
+
10480 {
+
10481 
+
10482  return date;
+
10483 
+
10484 }
+
10485 
+
10486 template<typename TSeq>
+
10487 inline epiworld_double Virus<TSeq>::get_prob_infecting(
+
10488  Model<TSeq> * model
+
10489 )
+
10490 {
10491 
-
10492 
-
10493 template<typename TSeq>
-
10494 inline epiworld_double Virus<TSeq>::get_prob_recovery(
-
10495  Model<TSeq> * model
-
10496 )
-
10497 {
+
10492  if (probability_of_infecting_fun)
+
10493  return probability_of_infecting_fun(agent, *this, model);
+
10494 
+
10495  return EPI_DEFAULT_VIRUS_PROB_INFECTION;
+
10496 
+
10497 }
10498 
-
10499  if (probability_of_recovery_fun)
-
10500  return probability_of_recovery_fun(agent, *this, model);
-
10501 
-
10502  return EPI_DEFAULT_VIRUS_PROB_RECOVERY;
-
10503 
-
10504 }
-
10505 
+
10499 
+
10500 
+
10501 template<typename TSeq>
+
10502 inline epiworld_double Virus<TSeq>::get_prob_recovery(
+
10503  Model<TSeq> * model
+
10504 )
+
10505 {
10506 
-
10507 
-
10508 template<typename TSeq>
-
10509 inline epiworld_double Virus<TSeq>::get_prob_death(
-
10510  Model<TSeq> * model
-
10511 )
-
10512 {
+
10507  if (probability_of_recovery_fun)
+
10508  return probability_of_recovery_fun(agent, *this, model);
+
10509 
+
10510  return EPI_DEFAULT_VIRUS_PROB_RECOVERY;
+
10511 
+
10512 }
10513 
-
10514  if (probability_of_death_fun)
-
10515  return probability_of_death_fun(agent, *this, model);
-
10516 
-
10517  return EPI_DEFAULT_VIRUS_PROB_DEATH;
-
10518 
-
10519 }
-
10520 
-
10521 template<typename TSeq>
-
10522 inline epiworld_double Virus<TSeq>::get_incubation(
-
10523  Model<TSeq> * model
-
10524 )
-
10525 {
+
10514 
+
10515 
+
10516 template<typename TSeq>
+
10517 inline epiworld_double Virus<TSeq>::get_prob_death(
+
10518  Model<TSeq> * model
+
10519 )
+
10520 {
+
10521 
+
10522  if (probability_of_death_fun)
+
10523  return probability_of_death_fun(agent, *this, model);
+
10524 
+
10525  return EPI_DEFAULT_VIRUS_PROB_DEATH;
10526 
-
10527  if (incubation_fun)
-
10528  return incubation_fun(agent, *this, model);
-
10529 
-
10530  return EPI_DEFAULT_INCUBATION_DAYS;
-
10531 
-
10532 }
-
10533 
-
10534 template<typename TSeq>
-
10535 inline void Virus<TSeq>::set_prob_infecting_fun(VirusFun<TSeq> fun)
-
10536 {
-
10537  probability_of_infecting_fun = fun;
-
10538 }
+
10527 }
+
10528 
+
10529 template<typename TSeq>
+
10530 inline epiworld_double Virus<TSeq>::get_incubation(
+
10531  Model<TSeq> * model
+
10532 )
+
10533 {
+
10534 
+
10535  if (incubation_fun)
+
10536  return incubation_fun(agent, *this, model);
+
10537 
+
10538  return EPI_DEFAULT_INCUBATION_DAYS;
10539 
-
10540 template<typename TSeq>
-
10541 inline void Virus<TSeq>::set_prob_recovery_fun(VirusFun<TSeq> fun)
-
10542 {
-
10543  probability_of_recovery_fun = fun;
-
10544 }
-
10545 
-
10546 template<typename TSeq>
-
10547 inline void Virus<TSeq>::set_prob_death_fun(VirusFun<TSeq> fun)
-
10548 {
-
10549  probability_of_death_fun = fun;
-
10550 }
-
10551 
-
10552 template<typename TSeq>
-
10553 inline void Virus<TSeq>::set_incubation_fun(VirusFun<TSeq> fun)
-
10554 {
-
10555  incubation_fun = fun;
-
10556 }
-
10557 
-
10558 template<typename TSeq>
-
10559 inline void Virus<TSeq>::set_prob_infecting(const epiworld_double * prob)
-
10560 {
-
10561  VirusFun<TSeq> tmpfun =
-
10562  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10563  {
-
10564  return *prob;
-
10565  };
-
10566 
-
10567  probability_of_infecting_fun = tmpfun;
-
10568 }
-
10569 
-
10570 template<typename TSeq>
-
10571 inline void Virus<TSeq>::set_prob_recovery(const epiworld_double * prob)
-
10572 {
-
10573  VirusFun<TSeq> tmpfun =
-
10574  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10575  {
-
10576  return *prob;
-
10577  };
-
10578 
-
10579  probability_of_recovery_fun = tmpfun;
-
10580 }
-
10581 
-
10582 template<typename TSeq>
-
10583 inline void Virus<TSeq>::set_prob_death(const epiworld_double * prob)
-
10584 {
-
10585  VirusFun<TSeq> tmpfun =
-
10586  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10587  {
-
10588  return *prob;
-
10589  };
-
10590 
-
10591  probability_of_death_fun = tmpfun;
-
10592 }
-
10593 
-
10594 template<typename TSeq>
-
10595 inline void Virus<TSeq>::set_incubation(const epiworld_double * prob)
-
10596 {
-
10597  VirusFun<TSeq> tmpfun =
-
10598  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10599  {
-
10600  return *prob;
-
10601  };
-
10602 
-
10603  incubation_fun = tmpfun;
-
10604 }
-
10605 
-
10606 template<typename TSeq>
-
10607 inline void Virus<TSeq>::set_prob_infecting(epiworld_double prob)
-
10608 {
-
10609  VirusFun<TSeq> tmpfun =
-
10610  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10611  {
-
10612  return prob;
-
10613  };
-
10614 
-
10615  probability_of_infecting_fun = tmpfun;
-
10616 }
-
10617 
-
10618 template<typename TSeq>
-
10619 inline void Virus<TSeq>::set_prob_recovery(epiworld_double prob)
-
10620 {
-
10621  VirusFun<TSeq> tmpfun =
-
10622  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10623  {
-
10624  return prob;
-
10625  };
-
10626 
-
10627  probability_of_recovery_fun = tmpfun;
-
10628 }
-
10629 
-
10630 template<typename TSeq>
-
10631 inline void Virus<TSeq>::set_prob_death(epiworld_double prob)
-
10632 {
-
10633  VirusFun<TSeq> tmpfun =
-
10634  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10635  {
-
10636  return prob;
-
10637  };
-
10638 
-
10639  probability_of_death_fun = tmpfun;
-
10640 }
-
10641 
-
10642 template<typename TSeq>
-
10643 inline void Virus<TSeq>::set_incubation(epiworld_double prob)
-
10644 {
-
10645  VirusFun<TSeq> tmpfun =
-
10646  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
-
10647  {
-
10648  return prob;
-
10649  };
-
10650 
-
10651  incubation_fun = tmpfun;
-
10652 }
-
10653 
-
10654 template<typename TSeq>
-
10655 inline void Virus<TSeq>::set_post_recovery(PostRecoveryFun<TSeq> fun)
-
10656 {
-
10657  if (post_recovery_fun)
-
10658  {
-
10659  printf_epiworld(
-
10660  "Warning: a PostRecoveryFun is alreay in place (overwriting)."
-
10661  );
-
10662  }
-
10663 
-
10664  post_recovery_fun = fun;
-
10665 }
-
10666 
-
10667 template<typename TSeq>
-
10668 inline void Virus<TSeq>::post_recovery(
-
10669  Model<TSeq> * model
-
10670 )
-
10671 {
-
10672 
-
10673  if (post_recovery_fun)
-
10674  post_recovery_fun(agent, *this, model);
-
10675 
-
10676  return;
-
10677 
-
10678 }
-
10679 
-
10680 template<typename TSeq>
-
10681 inline void Virus<TSeq>::set_post_immunity(
-
10682  epiworld_double prob
-
10683 )
-
10684 {
-
10685 
-
10686  if (post_recovery_fun)
-
10687  {
-
10688 
-
10689  std::string msg =
-
10690  std::string(
-
10691  "You cannot set post immunity when a post_recovery "
-
10692  ) +
-
10693  std::string(
-
10694  "function is already in place. Redesign the post_recovery function."
-
10695  );
+
10540 }
+
10541 
+
10542 template<typename TSeq>
+
10543 inline void Virus<TSeq>::set_prob_infecting_fun(VirusFun<TSeq> fun)
+
10544 {
+
10545  probability_of_infecting_fun = fun;
+
10546 }
+
10547 
+
10548 template<typename TSeq>
+
10549 inline void Virus<TSeq>::set_prob_recovery_fun(VirusFun<TSeq> fun)
+
10550 {
+
10551  probability_of_recovery_fun = fun;
+
10552 }
+
10553 
+
10554 template<typename TSeq>
+
10555 inline void Virus<TSeq>::set_prob_death_fun(VirusFun<TSeq> fun)
+
10556 {
+
10557  probability_of_death_fun = fun;
+
10558 }
+
10559 
+
10560 template<typename TSeq>
+
10561 inline void Virus<TSeq>::set_incubation_fun(VirusFun<TSeq> fun)
+
10562 {
+
10563  incubation_fun = fun;
+
10564 }
+
10565 
+
10566 template<typename TSeq>
+
10567 inline void Virus<TSeq>::set_prob_infecting(const epiworld_double * prob)
+
10568 {
+
10569  VirusFun<TSeq> tmpfun =
+
10570  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10571  {
+
10572  return *prob;
+
10573  };
+
10574 
+
10575  probability_of_infecting_fun = tmpfun;
+
10576 }
+
10577 
+
10578 template<typename TSeq>
+
10579 inline void Virus<TSeq>::set_prob_recovery(const epiworld_double * prob)
+
10580 {
+
10581  VirusFun<TSeq> tmpfun =
+
10582  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10583  {
+
10584  return *prob;
+
10585  };
+
10586 
+
10587  probability_of_recovery_fun = tmpfun;
+
10588 }
+
10589 
+
10590 template<typename TSeq>
+
10591 inline void Virus<TSeq>::set_prob_death(const epiworld_double * prob)
+
10592 {
+
10593  VirusFun<TSeq> tmpfun =
+
10594  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10595  {
+
10596  return *prob;
+
10597  };
+
10598 
+
10599  probability_of_death_fun = tmpfun;
+
10600 }
+
10601 
+
10602 template<typename TSeq>
+
10603 inline void Virus<TSeq>::set_incubation(const epiworld_double * prob)
+
10604 {
+
10605  VirusFun<TSeq> tmpfun =
+
10606  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10607  {
+
10608  return *prob;
+
10609  };
+
10610 
+
10611  incubation_fun = tmpfun;
+
10612 }
+
10613 
+
10614 template<typename TSeq>
+
10615 inline void Virus<TSeq>::set_prob_infecting(epiworld_double prob)
+
10616 {
+
10617  VirusFun<TSeq> tmpfun =
+
10618  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10619  {
+
10620  return prob;
+
10621  };
+
10622 
+
10623  probability_of_infecting_fun = tmpfun;
+
10624 }
+
10625 
+
10626 template<typename TSeq>
+
10627 inline void Virus<TSeq>::set_prob_recovery(epiworld_double prob)
+
10628 {
+
10629  VirusFun<TSeq> tmpfun =
+
10630  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10631  {
+
10632  return prob;
+
10633  };
+
10634 
+
10635  probability_of_recovery_fun = tmpfun;
+
10636 }
+
10637 
+
10638 template<typename TSeq>
+
10639 inline void Virus<TSeq>::set_prob_death(epiworld_double prob)
+
10640 {
+
10641  VirusFun<TSeq> tmpfun =
+
10642  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10643  {
+
10644  return prob;
+
10645  };
+
10646 
+
10647  probability_of_death_fun = tmpfun;
+
10648 }
+
10649 
+
10650 template<typename TSeq>
+
10651 inline void Virus<TSeq>::set_incubation(epiworld_double prob)
+
10652 {
+
10653  VirusFun<TSeq> tmpfun =
+
10654  [prob](Agent<TSeq> *, Virus<TSeq> &, Model<TSeq> *)
+
10655  {
+
10656  return prob;
+
10657  };
+
10658 
+
10659  incubation_fun = tmpfun;
+
10660 }
+
10661 
+
10662 template<typename TSeq>
+
10663 inline void Virus<TSeq>::set_post_recovery(PostRecoveryFun<TSeq> fun)
+
10664 {
+
10665  if (post_recovery_fun)
+
10666  {
+
10667  printf_epiworld(
+
10668  "Warning: a PostRecoveryFun is alreay in place (overwriting)."
+
10669  );
+
10670  }
+
10671 
+
10672  post_recovery_fun = fun;
+
10673 }
+
10674 
+
10675 template<typename TSeq>
+
10676 inline void Virus<TSeq>::post_recovery(
+
10677  Model<TSeq> * model
+
10678 )
+
10679 {
+
10680 
+
10681  if (post_recovery_fun)
+
10682  post_recovery_fun(agent, *this, model);
+
10683 
+
10684  return;
+
10685 
+
10686 }
+
10687 
+
10688 template<typename TSeq>
+
10689 inline void Virus<TSeq>::set_post_immunity(
+
10690  epiworld_double prob
+
10691 )
+
10692 {
+
10693 
+
10694  if (post_recovery_fun)
+
10695  {
10696 
-
10697  throw std::logic_error(msg);
-
10698 
-
10699  }
-
10700 
-
10701  // To make sure that we keep registering the virus
-
10702  ToolPtr<TSeq> __no_reinfect = std::make_shared<Tool<TSeq>>(
-
10703  "Immunity (" + *virus_name + ")"
-
10704  );
-
10705 
-
10706  __no_reinfect->set_susceptibility_reduction(prob);
-
10707  __no_reinfect->set_death_reduction(0.0);
-
10708  __no_reinfect->set_transmission_reduction(0.0);
-
10709  __no_reinfect->set_recovery_enhancer(0.0);
-
10710 
-
10711  PostRecoveryFun<TSeq> tmpfun =
-
10712  [__no_reinfect](
-
10713  Agent<TSeq> * p, Virus<TSeq> &, Model<TSeq> * m
-
10714  )
-
10715  {
-
10716 
-
10717  // Have we registered the tool?
-
10718  if (__no_reinfect->get_id() == -99)
-
10719  m->get_db().record_tool(*__no_reinfect);
-
10720 
-
10721  p->add_tool(__no_reinfect, m);
-
10722 
-
10723  return;
-
10724 
-
10725  };
-
10726 
-
10727  post_recovery_fun = tmpfun;
+
10697  std::string msg =
+
10698  std::string(
+
10699  "You cannot set post immunity when a post_recovery "
+
10700  ) +
+
10701  std::string(
+
10702  "function is already in place. Redesign the post_recovery function."
+
10703  );
+
10704 
+
10705  throw std::logic_error(msg);
+
10706 
+
10707  }
+
10708 
+
10709  // To make sure that we keep registering the virus
+
10710  ToolPtr<TSeq> __no_reinfect = std::make_shared<Tool<TSeq>>(
+
10711  "Immunity (" + *virus_name + ")"
+
10712  );
+
10713 
+
10714  __no_reinfect->set_susceptibility_reduction(prob);
+
10715  __no_reinfect->set_death_reduction(0.0);
+
10716  __no_reinfect->set_transmission_reduction(0.0);
+
10717  __no_reinfect->set_recovery_enhancer(0.0);
+
10718 
+
10719  PostRecoveryFun<TSeq> tmpfun =
+
10720  [__no_reinfect](
+
10721  Agent<TSeq> * p, Virus<TSeq> &, Model<TSeq> * m
+
10722  )
+
10723  {
+
10724 
+
10725  // Have we registered the tool?
+
10726  if (__no_reinfect->get_id() == -99)
+
10727  m->get_db().record_tool(*__no_reinfect);
10728 
-
10729 }
+
10729  p->add_tool(__no_reinfect, m);
10730 
-
10731 template<typename TSeq>
-
10732 inline void Virus<TSeq>::set_post_immunity(
-
10733  epiworld_double * prob
-
10734 )
-
10735 {
+
10731  return;
+
10732 
+
10733  };
+
10734 
+
10735  post_recovery_fun = tmpfun;
10736 
-
10737  if (post_recovery_fun)
-
10738  {
-
10739 
-
10740  std::string msg =
-
10741  std::string(
-
10742  "You cannot set post immunity when a post_recovery "
-
10743  ) +
-
10744  std::string(
-
10745  "function is already in place. Redesign the post_recovery function."
-
10746  );
+
10737 }
+
10738 
+
10739 template<typename TSeq>
+
10740 inline void Virus<TSeq>::set_post_immunity(
+
10741  epiworld_double * prob
+
10742 )
+
10743 {
+
10744 
+
10745  if (post_recovery_fun)
+
10746  {
10747 
-
10748  throw std::logic_error(msg);
-
10749 
-
10750  }
-
10751 
-
10752  // To make sure that we keep registering the virus
-
10753  ToolPtr<TSeq> __no_reinfect = std::make_shared<Tool<TSeq>>(
-
10754  "Immunity (" + *virus_name + ")"
-
10755  );
-
10756 
-
10757  __no_reinfect->set_susceptibility_reduction(prob);
-
10758  __no_reinfect->set_death_reduction(0.0);
-
10759  __no_reinfect->set_transmission_reduction(0.0);
-
10760  __no_reinfect->set_recovery_enhancer(0.0);
-
10761 
-
10762  PostRecoveryFun<TSeq> tmpfun =
-
10763  [__no_reinfect](Agent<TSeq> * p, Virus<TSeq> &, Model<TSeq> * m)
-
10764  {
-
10765 
-
10766  // Have we registered the tool?
-
10767  if (__no_reinfect->get_id() == -99)
-
10768  m->get_db().record_tool(*__no_reinfect);
+
10748  std::string msg =
+
10749  std::string(
+
10750  "You cannot set post immunity when a post_recovery "
+
10751  ) +
+
10752  std::string(
+
10753  "function is already in place. Redesign the post_recovery function."
+
10754  );
+
10755 
+
10756  throw std::logic_error(msg);
+
10757 
+
10758  }
+
10759 
+
10760  // To make sure that we keep registering the virus
+
10761  ToolPtr<TSeq> __no_reinfect = std::make_shared<Tool<TSeq>>(
+
10762  "Immunity (" + *virus_name + ")"
+
10763  );
+
10764 
+
10765  __no_reinfect->set_susceptibility_reduction(prob);
+
10766  __no_reinfect->set_death_reduction(0.0);
+
10767  __no_reinfect->set_transmission_reduction(0.0);
+
10768  __no_reinfect->set_recovery_enhancer(0.0);
10769 
-
10770  p->add_tool(__no_reinfect, m);
-
10771 
-
10772  return;
+
10770  PostRecoveryFun<TSeq> tmpfun =
+
10771  [__no_reinfect](Agent<TSeq> * p, Virus<TSeq> &, Model<TSeq> * m)
+
10772  {
10773 
-
10774  };
-
10775 
-
10776  post_recovery_fun = tmpfun;
+
10774  // Have we registered the tool?
+
10775  if (__no_reinfect->get_id() == -99)
+
10776  m->get_db().record_tool(*__no_reinfect);
10777 
-
10778 }
+
10778  p->add_tool(__no_reinfect, m);
10779 
-
10780 template<typename TSeq>
-
10781 inline void Virus<TSeq>::set_name(std::string name)
-
10782 {
+
10780  return;
+
10781 
+
10782  };
10783 
-
10784  if (name == "")
-
10785  virus_name = nullptr;
-
10786  else
-
10787  virus_name = std::make_shared<std::string>(name);
-
10788 
-
10789 }
-
10790 
-
10791 template<typename TSeq>
-
10792 inline std::string Virus<TSeq>::get_name() const
-
10793 {
-
10794 
-
10795  if (virus_name)
-
10796  return *virus_name;
-
10797 
-
10798  return "unknown virus";
-
10799 
-
10800 }
-
10801 
-
10802 template<typename TSeq>
-
10803 inline std::vector< epiworld_double > & Virus<TSeq>::get_data() {
-
10804  return data;
-
10805 }
-
10806 
-
10807 template<typename TSeq>
-
10808 inline void Virus<TSeq>::set_state(
-
10809  epiworld_fast_int init,
-
10810  epiworld_fast_int end,
-
10811  epiworld_fast_int removed
-
10812 )
-
10813 {
-
10814  state_init = init;
-
10815  state_post = end;
-
10816  state_removed = removed;
-
10817 }
-
10818 
-
10819 template<typename TSeq>
-
10820 inline void Virus<TSeq>::set_queue(
-
10821  epiworld_fast_int init,
-
10822  epiworld_fast_int end,
-
10823  epiworld_fast_int removed
-
10824 )
-
10825 {
+
10784  post_recovery_fun = tmpfun;
+
10785 
+
10786 }
+
10787 
+
10788 template<typename TSeq>
+
10789 inline void Virus<TSeq>::set_name(std::string name)
+
10790 {
+
10791 
+
10792  if (name == "")
+
10793  virus_name = nullptr;
+
10794  else
+
10795  virus_name = std::make_shared<std::string>(name);
+
10796 
+
10797 }
+
10798 
+
10799 template<typename TSeq>
+
10800 inline std::string Virus<TSeq>::get_name() const
+
10801 {
+
10802 
+
10803  if (virus_name)
+
10804  return *virus_name;
+
10805 
+
10806  return "unknown virus";
+
10807 
+
10808 }
+
10809 
+
10810 template<typename TSeq>
+
10811 inline std::vector< epiworld_double > & Virus<TSeq>::get_data() {
+
10812  return data;
+
10813 }
+
10814 
+
10815 template<typename TSeq>
+
10816 inline void Virus<TSeq>::set_state(
+
10817  epiworld_fast_int init,
+
10818  epiworld_fast_int end,
+
10819  epiworld_fast_int removed
+
10820 )
+
10821 {
+
10822  state_init = init;
+
10823  state_post = end;
+
10824  state_removed = removed;
+
10825 }
10826 
-
10827  queue_init = init;
-
10828  queue_post = end;
-
10829  queue_removed = removed;
-
10830 
-
10831 }
-
10832 
-
10833 template<typename TSeq>
-
10834 inline void Virus<TSeq>::get_state(
-
10835  epiworld_fast_int * init,
-
10836  epiworld_fast_int * end,
-
10837  epiworld_fast_int * removed
-
10838 )
-
10839 {
+
10827 template<typename TSeq>
+
10828 inline void Virus<TSeq>::set_queue(
+
10829  epiworld_fast_int init,
+
10830  epiworld_fast_int end,
+
10831  epiworld_fast_int removed
+
10832 )
+
10833 {
+
10834 
+
10835  queue_init = init;
+
10836  queue_post = end;
+
10837  queue_removed = removed;
+
10838 
+
10839 }
10840 
-
10841  if (init != nullptr)
-
10842  *init = state_init;
-
10843 
-
10844  if (end != nullptr)
-
10845  *end = state_post;
-
10846 
-
10847  if (removed != nullptr)
-
10848  *removed = state_removed;
-
10849 
-
10850 }
+
10841 template<typename TSeq>
+
10842 inline void Virus<TSeq>::get_state(
+
10843  epiworld_fast_int * init,
+
10844  epiworld_fast_int * end,
+
10845  epiworld_fast_int * removed
+
10846 )
+
10847 {
+
10848 
+
10849  if (init != nullptr)
+
10850  *init = state_init;
10851 
-
10852 template<typename TSeq>
-
10853 inline void Virus<TSeq>::get_queue(
-
10854  epiworld_fast_int * init,
-
10855  epiworld_fast_int * end,
-
10856  epiworld_fast_int * removed
-
10857 )
-
10858 {
+
10852  if (end != nullptr)
+
10853  *end = state_post;
+
10854 
+
10855  if (removed != nullptr)
+
10856  *removed = state_removed;
+
10857 
+
10858 }
10859 
-
10860  if (init != nullptr)
-
10861  *init = queue_init;
-
10862 
-
10863  if (end != nullptr)
-
10864  *end = queue_post;
-
10865 
-
10866  if (removed != nullptr)
-
10867  *removed = queue_removed;
-
10868 
-
10869 }
+
10860 template<typename TSeq>
+
10861 inline void Virus<TSeq>::get_queue(
+
10862  epiworld_fast_int * init,
+
10863  epiworld_fast_int * end,
+
10864  epiworld_fast_int * removed
+
10865 )
+
10866 {
+
10867 
+
10868  if (init != nullptr)
+
10869  *init = queue_init;
10870 
-
10871 template<>
-
10872 inline bool Virus<std::vector<int>>::operator==(
-
10873  const Virus<std::vector<int>> & other
-
10874  ) const
-
10875 {
-
10876 
-
10877 
-
10878  EPI_DEBUG_FAIL_AT_TRUE(
-
10879  baseline_sequence->size() != other.baseline_sequence->size(),
-
10880  "Virus:: baseline_sequence don't match"
-
10881  )
-
10882 
-
10883  for (size_t i = 0u; i < baseline_sequence->size(); ++i)
-
10884  {
+
10871  if (end != nullptr)
+
10872  *end = queue_post;
+
10873 
+
10874  if (removed != nullptr)
+
10875  *removed = queue_removed;
+
10876 
+
10877 }
+
10878 
+
10879 template<>
+
10880 inline bool Virus<std::vector<int>>::operator==(
+
10881  const Virus<std::vector<int>> & other
+
10882  ) const
+
10883 {
+
10884 
10885 
-
10886  EPI_DEBUG_FAIL_AT_TRUE(
-
10887  baseline_sequence->operator[](i) != other.baseline_sequence->operator[](i),
-
10888  "Virus:: baseline_sequence[i] don't match"
-
10889  )
+
10886  EPI_DEBUG_FAIL_AT_TRUE(
+
10887  baseline_sequence->size() != other.baseline_sequence->size(),
+
10888  "Virus:: baseline_sequence don't match"
+
10889  )
10890 
-
10891  }
-
10892 
-
10893  EPI_DEBUG_FAIL_AT_TRUE(
-
10894  virus_name != other.virus_name,
-
10895  "Virus:: virus_name don't match"
-
10896  )
-
10897 
-
10898  EPI_DEBUG_FAIL_AT_TRUE(
-
10899  state_init != other.state_init,
-
10900  "Virus:: state_init don't match"
-
10901  )
-
10902 
-
10903  EPI_DEBUG_FAIL_AT_TRUE(
-
10904  state_post != other.state_post,
-
10905  "Virus:: state_post don't match"
-
10906  )
-
10907 
-
10908  EPI_DEBUG_FAIL_AT_TRUE(
-
10909  state_removed != other.state_removed,
-
10910  "Virus:: state_removed don't match"
-
10911  )
-
10912 
-
10913  EPI_DEBUG_FAIL_AT_TRUE(
-
10914  queue_init != other.queue_init,
-
10915  "Virus:: queue_init don't match"
-
10916  )
-
10917 
-
10918  EPI_DEBUG_FAIL_AT_TRUE(
-
10919  queue_post != other.queue_post,
-
10920  "Virus:: queue_post don't match"
-
10921  )
-
10922 
-
10923  EPI_DEBUG_FAIL_AT_TRUE(
-
10924  queue_removed != other.queue_removed,
-
10925  "Virus:: queue_removed don't match"
-
10926  )
-
10927 
-
10928  return true;
-
10929 
-
10930 }
-
10931 
-
10932 template<typename TSeq>
-
10933 inline bool Virus<TSeq>::operator==(const Virus<TSeq> & other) const
-
10934 {
-
10935 
-
10936  EPI_DEBUG_FAIL_AT_TRUE(
-
10937  *baseline_sequence != *other.baseline_sequence,
-
10938  "Virus:: baseline_sequence don't match"
-
10939  )
-
10940 
-
10941  EPI_DEBUG_FAIL_AT_TRUE(
-
10942  virus_name != other.virus_name,
-
10943  "Virus:: virus_name don't match"
-
10944  )
-
10945 
-
10946  EPI_DEBUG_FAIL_AT_TRUE(
-
10947  state_init != other.state_init,
-
10948  "Virus:: state_init don't match"
-
10949  )
-
10950 
-
10951  EPI_DEBUG_FAIL_AT_TRUE(
-
10952  state_post != other.state_post,
-
10953  "Virus:: state_post don't match"
-
10954  )
-
10955 
-
10956  EPI_DEBUG_FAIL_AT_TRUE(
-
10957  state_removed != other.state_removed,
-
10958  "Virus:: state_removed don't match"
-
10959  )
-
10960 
-
10961  EPI_DEBUG_FAIL_AT_TRUE(
-
10962  queue_init != other.queue_init,
-
10963  "Virus:: queue_init don't match"
-
10964  )
-
10965 
-
10966  EPI_DEBUG_FAIL_AT_TRUE(
-
10967  queue_post != other.queue_post,
-
10968  "Virus:: queue_post don't match"
-
10969  )
-
10970 
-
10971  EPI_DEBUG_FAIL_AT_TRUE(
-
10972  queue_removed != other.queue_removed,
-
10973  "Virus:: queue_removed don't match"
-
10974  )
-
10975 
-
10976  return true;
-
10977 
-
10978 }
-
10979 
-
10980 template<typename TSeq>
-
10981 inline void Virus<TSeq>::print() const
-
10982 {
+
10891  for (size_t i = 0u; i < baseline_sequence->size(); ++i)
+
10892  {
+
10893 
+
10894  EPI_DEBUG_FAIL_AT_TRUE(
+
10895  baseline_sequence->operator[](i) != other.baseline_sequence->operator[](i),
+
10896  "Virus:: baseline_sequence[i] don't match"
+
10897  )
+
10898 
+
10899  }
+
10900 
+
10901  EPI_DEBUG_FAIL_AT_TRUE(
+
10902  virus_name != other.virus_name,
+
10903  "Virus:: virus_name don't match"
+
10904  )
+
10905 
+
10906  EPI_DEBUG_FAIL_AT_TRUE(
+
10907  state_init != other.state_init,
+
10908  "Virus:: state_init don't match"
+
10909  )
+
10910 
+
10911  EPI_DEBUG_FAIL_AT_TRUE(
+
10912  state_post != other.state_post,
+
10913  "Virus:: state_post don't match"
+
10914  )
+
10915 
+
10916  EPI_DEBUG_FAIL_AT_TRUE(
+
10917  state_removed != other.state_removed,
+
10918  "Virus:: state_removed don't match"
+
10919  )
+
10920 
+
10921  EPI_DEBUG_FAIL_AT_TRUE(
+
10922  queue_init != other.queue_init,
+
10923  "Virus:: queue_init don't match"
+
10924  )
+
10925 
+
10926  EPI_DEBUG_FAIL_AT_TRUE(
+
10927  queue_post != other.queue_post,
+
10928  "Virus:: queue_post don't match"
+
10929  )
+
10930 
+
10931  EPI_DEBUG_FAIL_AT_TRUE(
+
10932  queue_removed != other.queue_removed,
+
10933  "Virus:: queue_removed don't match"
+
10934  )
+
10935 
+
10936  return true;
+
10937 
+
10938 }
+
10939 
+
10940 template<typename TSeq>
+
10941 inline bool Virus<TSeq>::operator==(const Virus<TSeq> & other) const
+
10942 {
+
10943 
+
10944  EPI_DEBUG_FAIL_AT_TRUE(
+
10945  *baseline_sequence != *other.baseline_sequence,
+
10946  "Virus:: baseline_sequence don't match"
+
10947  )
+
10948 
+
10949  EPI_DEBUG_FAIL_AT_TRUE(
+
10950  virus_name != other.virus_name,
+
10951  "Virus:: virus_name don't match"
+
10952  )
+
10953 
+
10954  EPI_DEBUG_FAIL_AT_TRUE(
+
10955  state_init != other.state_init,
+
10956  "Virus:: state_init don't match"
+
10957  )
+
10958 
+
10959  EPI_DEBUG_FAIL_AT_TRUE(
+
10960  state_post != other.state_post,
+
10961  "Virus:: state_post don't match"
+
10962  )
+
10963 
+
10964  EPI_DEBUG_FAIL_AT_TRUE(
+
10965  state_removed != other.state_removed,
+
10966  "Virus:: state_removed don't match"
+
10967  )
+
10968 
+
10969  EPI_DEBUG_FAIL_AT_TRUE(
+
10970  queue_init != other.queue_init,
+
10971  "Virus:: queue_init don't match"
+
10972  )
+
10973 
+
10974  EPI_DEBUG_FAIL_AT_TRUE(
+
10975  queue_post != other.queue_post,
+
10976  "Virus:: queue_post don't match"
+
10977  )
+
10978 
+
10979  EPI_DEBUG_FAIL_AT_TRUE(
+
10980  queue_removed != other.queue_removed,
+
10981  "Virus:: queue_removed don't match"
+
10982  )
10983 
-
10984  printf_epiworld("Virus : %s\n", virus_name->c_str());
-
10985  printf_epiworld("Id : %s\n", (id < 0)? std::string("(empty)").c_str() : std::to_string(id).c_str());
-
10986  printf_epiworld("state_init : %i\n", state_init);
-
10987  printf_epiworld("state_post : %i\n", state_post);
-
10988  printf_epiworld("state_removed : %i\n", state_removed);
-
10989  printf_epiworld("queue_init : %i\n", queue_init);
-
10990  printf_epiworld("queue_post : %i\n", queue_post);
-
10991  printf_epiworld("queue_removed : %i\n", queue_removed);
-
10992 
-
10993 }
-
10994 
-
10995 #endif
-
10996 /*//////////////////////////////////////////////////////////////////////////////
-
10998 
-
10999  End of -include/epiworld/virus-meat.hpp-
+
10984  return true;
+
10985 
+
10986 }
+
10987 
+
10988 template<typename TSeq>
+
10989 inline void Virus<TSeq>::print() const
+
10990 {
+
10991 
+
10992  printf_epiworld("Virus : %s\n", virus_name->c_str());
+
10993  printf_epiworld("Id : %s\n", (id < 0)? std::string("(empty)").c_str() : std::to_string(id).c_str());
+
10994  printf_epiworld("state_init : %i\n", state_init);
+
10995  printf_epiworld("state_post : %i\n", state_post);
+
10996  printf_epiworld("state_removed : %i\n", state_removed);
+
10997  printf_epiworld("queue_init : %i\n", queue_init);
+
10998  printf_epiworld("queue_post : %i\n", queue_post);
+
10999  printf_epiworld("queue_removed : %i\n", queue_removed);
11000 
-
11003 
-
11004 
-
11005 
-
11006 /*//////////////////////////////////////////////////////////////////////////////
+
11001 }
+
11002 
+
11003 #endif
+
11004 /*//////////////////////////////////////////////////////////////////////////////
+
11006 
+
11007  End of -include/epiworld/virus-meat.hpp-
11008 
-
11009  Start of -include/epiworld/tools-bones.hpp-
-
11010 
-
11013 
-
11014 
-
11015 #ifndef EPIWORLD_TOOLS_BONES_HPP
-
11016 #define EPIWORLD_TOOLS_BONES_HPP
-
11017 
-
11018 template<typename TSeq>
-
11019 class Tool;
-
11020 
-
11021 template<typename TSeq>
-
11022 class Agent;
-
11023 
-
11024 // #define ToolPtr<TSeq> std::shared_ptr< Tool<TSeq> >
+
11011 
+
11012 
+
11013 
+
11014 /*//////////////////////////////////////////////////////////////////////////////
+
11016 
+
11017  Start of -include/epiworld/tools-bones.hpp-
+
11018 
+
11021 
+
11022 
+
11023 #ifndef EPIWORLD_TOOLS_BONES_HPP
+
11024 #define EPIWORLD_TOOLS_BONES_HPP
11025 
-
11031 template<typename TSeq>
-
11032 class Tools {
-
11033  friend class Tool<TSeq>;
-
11034  friend class Agent<TSeq>;
-
11035 private:
-
11036  std::vector< ToolPtr<TSeq> > * dat;
-
11037  const epiworld_fast_uint * n_tools;
-
11038 
-
11039 public:
-
11040 
-
11041  Tools() = delete;
-
11042  Tools(Agent<TSeq> & p) : dat(&p.tools), n_tools(&p.n_tools) {};
-
11043 
-
11044  typename std::vector< ToolPtr<TSeq> >::iterator begin();
-
11045  typename std::vector< ToolPtr<TSeq> >::iterator end();
+
11026 template<typename TSeq>
+
11027 class Tool;
+
11028 
+
11029 template<typename TSeq>
+
11030 class Agent;
+
11031 
+
11032 // #define ToolPtr<TSeq> std::shared_ptr< Tool<TSeq> >
+
11033 
+
11039 template<typename TSeq>
+
11040 class Tools {
+
11041  friend class Tool<TSeq>;
+
11042  friend class Agent<TSeq>;
+
11043 private:
+
11044  std::vector< ToolPtr<TSeq> > * dat;
+
11045  const epiworld_fast_uint * n_tools;
11046 
-
11047  ToolPtr<TSeq> & operator()(size_t i);
-
11048  ToolPtr<TSeq> & operator[](size_t i);
-
11049 
-
11050  size_t size() const noexcept;
+
11047 public:
+
11048 
+
11049  Tools() = delete;
+
11050  Tools(Agent<TSeq> & p) : dat(&p.tools), n_tools(&p.n_tools) {};
11051 
-
11052  void print() const noexcept;
-
11053 
-
11054 };
-
11055 
-
11056 template<typename TSeq>
-
11057 inline typename std::vector< ToolPtr<TSeq> >::iterator Tools<TSeq>::begin()
-
11058 {
+
11052  typename std::vector< ToolPtr<TSeq> >::iterator begin();
+
11053  typename std::vector< ToolPtr<TSeq> >::iterator end();
+
11054 
+
11055  ToolPtr<TSeq> & operator()(size_t i);
+
11056  ToolPtr<TSeq> & operator[](size_t i);
+
11057 
+
11058  size_t size() const noexcept;
11059 
-
11060  if (*n_tools == 0u)
-
11061  return dat->end();
-
11062 
-
11063  return dat->begin();
-
11064 }
-
11065 
-
11066 template<typename TSeq>
-
11067 inline typename std::vector< ToolPtr<TSeq> >::iterator Tools<TSeq>::end()
-
11068 {
-
11069 
-
11070  return begin() + *n_tools;
-
11071 }
-
11072 
-
11073 template<typename TSeq>
-
11074 inline ToolPtr<TSeq> & Tools<TSeq>::operator()(size_t i)
-
11075 {
-
11076 
-
11077  if (i >= *n_tools)
-
11078  throw std::range_error("Tool index out of range.");
-
11079 
-
11080  return dat->operator[](i);
-
11081 
-
11082 }
-
11083 
-
11084 template<typename TSeq>
-
11085 inline ToolPtr<TSeq> & Tools<TSeq>::operator[](size_t i)
-
11086 {
+
11060  void print() const noexcept;
+
11061 
+
11062 };
+
11063 
+
11064 template<typename TSeq>
+
11065 inline typename std::vector< ToolPtr<TSeq> >::iterator Tools<TSeq>::begin()
+
11066 {
+
11067 
+
11068  if (*n_tools == 0u)
+
11069  return dat->end();
+
11070 
+
11071  return dat->begin();
+
11072 }
+
11073 
+
11074 template<typename TSeq>
+
11075 inline typename std::vector< ToolPtr<TSeq> >::iterator Tools<TSeq>::end()
+
11076 {
+
11077 
+
11078  return begin() + *n_tools;
+
11079 }
+
11080 
+
11081 template<typename TSeq>
+
11082 inline ToolPtr<TSeq> & Tools<TSeq>::operator()(size_t i)
+
11083 {
+
11084 
+
11085  if (i >= *n_tools)
+
11086  throw std::range_error("Tool index out of range.");
11087 
11088  return dat->operator[](i);
11089 
11090 }
11091 
11092 template<typename TSeq>
-
11093 inline size_t Tools<TSeq>::size() const noexcept
+
11093 inline ToolPtr<TSeq> & Tools<TSeq>::operator[](size_t i)
11094 {
-
11095  return *n_tools;
-
11096 }
+
11095 
+
11096  return dat->operator[](i);
11097 
-
11098 template<typename TSeq>
-
11099 inline void Tools<TSeq>::print() const noexcept
-
11100 {
-
11101  if (*n_tools == 0u)
-
11102  {
-
11103  printf_epiworld("List of tools (none)\n");
-
11104  return;
-
11105  }
-
11106 
-
11107  printf_epiworld("List of tools (%i): ", *n_tools);
-
11108 
-
11109  // Printing the name of each virus separated by a comma
-
11110  for (size_t i = 0u; i < *n_tools; ++i)
-
11111  {
-
11112  if (i == *n_tools - 1u)
-
11113  {
-
11114  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
-
11115  } else
-
11116  {
-
11117  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
-
11118  }
-
11119  }
-
11120 
-
11121  printf_epiworld("\n");
-
11122 
-
11123 }
-
11124 
-
11130 template<typename TSeq>
-
11131 class Tools_const {
-
11132  friend class Tool<TSeq>;
-
11133  friend class Agent<TSeq>;
-
11134 private:
-
11135  const std::vector< ToolPtr<TSeq> > * dat;
-
11136  const epiworld_fast_uint * n_tools;
-
11137 
-
11138 public:
-
11139 
-
11140  Tools_const() = delete;
-
11141  Tools_const(const Agent<TSeq> & p) : dat(&p.tools), n_tools(&p.n_tools) {};
-
11142 
-
11143  typename std::vector< ToolPtr<TSeq> >::const_iterator begin() const;
-
11144  typename std::vector< ToolPtr<TSeq> >::const_iterator end() const;
+
11098 }
+
11099 
+
11100 template<typename TSeq>
+
11101 inline size_t Tools<TSeq>::size() const noexcept
+
11102 {
+
11103  return *n_tools;
+
11104 }
+
11105 
+
11106 template<typename TSeq>
+
11107 inline void Tools<TSeq>::print() const noexcept
+
11108 {
+
11109  if (*n_tools == 0u)
+
11110  {
+
11111  printf_epiworld("List of tools (none)\n");
+
11112  return;
+
11113  }
+
11114 
+
11115  printf_epiworld("List of tools (%i): ", *n_tools);
+
11116 
+
11117  // Printing the name of each virus separated by a comma
+
11118  for (size_t i = 0u; i < *n_tools; ++i)
+
11119  {
+
11120  if (i == *n_tools - 1u)
+
11121  {
+
11122  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
+
11123  } else
+
11124  {
+
11125  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
+
11126  }
+
11127  }
+
11128 
+
11129  printf_epiworld("\n");
+
11130 
+
11131 }
+
11132 
+
11138 template<typename TSeq>
+
11139 class Tools_const {
+
11140  friend class Tool<TSeq>;
+
11141  friend class Agent<TSeq>;
+
11142 private:
+
11143  const std::vector< ToolPtr<TSeq> > * dat;
+
11144  const epiworld_fast_uint * n_tools;
11145 
-
11146  const ToolPtr<TSeq> & operator()(size_t i);
-
11147  const ToolPtr<TSeq> & operator[](size_t i);
-
11148 
-
11149  size_t size() const noexcept;
+
11146 public:
+
11147 
+
11148  Tools_const() = delete;
+
11149  Tools_const(const Agent<TSeq> & p) : dat(&p.tools), n_tools(&p.n_tools) {};
11150 
-
11151  void print() const noexcept;
-
11152 
-
11153 };
-
11154 
-
11155 template<typename TSeq>
-
11156 inline typename std::vector< ToolPtr<TSeq> >::const_iterator Tools_const<TSeq>::begin() const {
-
11157 
-
11158  if (*n_tools == 0u)
-
11159  return dat->end();
-
11160 
-
11161  return dat->begin();
-
11162 }
-
11163 
-
11164 template<typename TSeq>
-
11165 inline typename std::vector< ToolPtr<TSeq> >::const_iterator Tools_const<TSeq>::end() const {
-
11166 
-
11167  return begin() + *n_tools;
-
11168 }
-
11169 
-
11170 template<typename TSeq>
-
11171 inline const ToolPtr<TSeq> & Tools_const<TSeq>::operator()(size_t i)
-
11172 {
-
11173 
-
11174  if (i >= *n_tools)
-
11175  throw std::range_error("Tool index out of range.");
-
11176 
-
11177  return dat->operator[](i);
-
11178 
-
11179 }
-
11180 
-
11181 template<typename TSeq>
-
11182 inline const ToolPtr<TSeq> & Tools_const<TSeq>::operator[](size_t i)
-
11183 {
+
11151  typename std::vector< ToolPtr<TSeq> >::const_iterator begin() const;
+
11152  typename std::vector< ToolPtr<TSeq> >::const_iterator end() const;
+
11153 
+
11154  const ToolPtr<TSeq> & operator()(size_t i);
+
11155  const ToolPtr<TSeq> & operator[](size_t i);
+
11156 
+
11157  size_t size() const noexcept;
+
11158 
+
11159  void print() const noexcept;
+
11160 
+
11161 };
+
11162 
+
11163 template<typename TSeq>
+
11164 inline typename std::vector< ToolPtr<TSeq> >::const_iterator Tools_const<TSeq>::begin() const {
+
11165 
+
11166  if (*n_tools == 0u)
+
11167  return dat->end();
+
11168 
+
11169  return dat->begin();
+
11170 }
+
11171 
+
11172 template<typename TSeq>
+
11173 inline typename std::vector< ToolPtr<TSeq> >::const_iterator Tools_const<TSeq>::end() const {
+
11174 
+
11175  return begin() + *n_tools;
+
11176 }
+
11177 
+
11178 template<typename TSeq>
+
11179 inline const ToolPtr<TSeq> & Tools_const<TSeq>::operator()(size_t i)
+
11180 {
+
11181 
+
11182  if (i >= *n_tools)
+
11183  throw std::range_error("Tool index out of range.");
11184 
11185  return dat->operator[](i);
11186 
11187 }
11188 
11189 template<typename TSeq>
-
11190 inline size_t Tools_const<TSeq>::size() const noexcept
+
11190 inline const ToolPtr<TSeq> & Tools_const<TSeq>::operator[](size_t i)
11191 {
-
11192  return *n_tools;
-
11193 }
+
11192 
+
11193  return dat->operator[](i);
11194 
-
11195 template<typename TSeq>
-
11196 inline void Tools_const<TSeq>::print() const noexcept
-
11197 {
-
11198  if (*n_tools == 0u)
-
11199  {
-
11200  printf_epiworld("List of tools (none)\n");
-
11201  return;
-
11202  }
-
11203 
-
11204  printf_epiworld("List of tools (%i): ", *n_tools);
-
11205 
-
11206  // Printing the name of each virus separated by a comma
-
11207  for (size_t i = 0u; i < *n_tools; ++i)
-
11208  {
-
11209  if (i == *n_tools - 1u)
-
11210  {
-
11211  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
-
11212  } else
-
11213  {
-
11214  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
-
11215  }
-
11216  }
-
11217 
-
11218  printf_epiworld("\n");
-
11219 
-
11220 }
-
11221 
-
11222 
-
11223 
-
11224 #endif
-
11225 /*//////////////////////////////////////////////////////////////////////////////
+
11195 }
+
11196 
+
11197 template<typename TSeq>
+
11198 inline size_t Tools_const<TSeq>::size() const noexcept
+
11199 {
+
11200  return *n_tools;
+
11201 }
+
11202 
+
11203 template<typename TSeq>
+
11204 inline void Tools_const<TSeq>::print() const noexcept
+
11205 {
+
11206  if (*n_tools == 0u)
+
11207  {
+
11208  printf_epiworld("List of tools (none)\n");
+
11209  return;
+
11210  }
+
11211 
+
11212  printf_epiworld("List of tools (%i): ", *n_tools);
+
11213 
+
11214  // Printing the name of each virus separated by a comma
+
11215  for (size_t i = 0u; i < *n_tools; ++i)
+
11216  {
+
11217  if (i == *n_tools - 1u)
+
11218  {
+
11219  printf_epiworld("%s", dat->operator[](i)->get_name().c_str());
+
11220  } else
+
11221  {
+
11222  printf_epiworld("%s, ", dat->operator[](i)->get_name().c_str());
+
11223  }
+
11224  }
+
11225 
+
11226  printf_epiworld("\n");
11227 
-
11228  End of -include/epiworld/tools-bones.hpp-
+
11228 }
11229 
-
11232 
-
11233 
-
11234 
-
11235 /*//////////////////////////////////////////////////////////////////////////////
+
11230 
+
11231 
+
11232 #endif
+
11233 /*//////////////////////////////////////////////////////////////////////////////
+
11235 
+
11236  End of -include/epiworld/tools-bones.hpp-
11237 
-
11238  Start of -include/epiworld/tool-bones.hpp-
-
11239 
+
11240 
+
11241 
11242 
-
11243 
-
11244 
-
11245 #ifndef EPIWORLD_TOOL_BONES_HPP
-
11246 #define EPIWORLD_TOOL_BONES_HPP
+
11243 /*//////////////////////////////////////////////////////////////////////////////
+
11245 
+
11246  Start of -include/epiworld/tool-bones.hpp-
11247 
-
11248 template<typename TSeq>
-
11249 class Virus;
11250 
-
11251 template<typename TSeq>
-
11252 class Agent;
-
11253 
-
11254 template<typename TSeq>
-
11255 class Model;
-
11256 
-
11257 template<typename TSeq>
-
11258 class Tool;
-
11259 
-
11265 template<typename TSeq>
-
11266 class Tool {
-
11267  friend class Agent<TSeq>;
-
11268  friend class Model<TSeq>;
-
11269  friend void default_add_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
11270  friend void default_rm_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
11271 private:
-
11272 
-
11273  Agent<TSeq> * agent = nullptr;
-
11274  int pos_in_agent = -99; ///< Location in the agent
-
11275 
-
11276  int date = -99;
-
11277  int id = -99;
-
11278  std::shared_ptr<std::string> tool_name = nullptr;
-
11279  std::shared_ptr<TSeq> sequence = nullptr;
-
11280  ToolFun<TSeq> susceptibility_reduction_fun = nullptr;
-
11281  ToolFun<TSeq> transmission_reduction_fun = nullptr;
-
11282  ToolFun<TSeq> recovery_enhancer_fun = nullptr;
-
11283  ToolFun<TSeq> death_reduction_fun = nullptr;
-
11284 
-
11285  // Setup parameters
-
11286  std::vector< epiworld_double * > params;
-
11287 
-
11288  epiworld_fast_int state_init = -99;
-
11289  epiworld_fast_int state_post = -99;
-
11290 
-
11291  epiworld_fast_int queue_init = Queue<TSeq>::NoOne; ///< Change of state when added to agent.
-
11292  epiworld_fast_int queue_post = Queue<TSeq>::NoOne; ///< Change of state when removed from agent.
-
11293 
-
11294  void set_agent(Agent<TSeq> * p, size_t idx);
+
11251 
+
11252 
+
11253 #ifndef EPIWORLD_TOOL_BONES_HPP
+
11254 #define EPIWORLD_TOOL_BONES_HPP
+
11255 
+
11256 template<typename TSeq>
+
11257 class Virus;
+
11258 
+
11259 template<typename TSeq>
+
11260 class Agent;
+
11261 
+
11262 template<typename TSeq>
+
11263 class Model;
+
11264 
+
11265 template<typename TSeq>
+
11266 class Tool;
+
11267 
+
11273 template<typename TSeq>
+
11274 class Tool {
+
11275  friend class Agent<TSeq>;
+
11276  friend class Model<TSeq>;
+
11277  friend void default_add_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
11278  friend void default_rm_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
11279 private:
+
11280 
+
11281  Agent<TSeq> * agent = nullptr;
+
11282  int pos_in_agent = -99; ///< Location in the agent
+
11283 
+
11284  int date = -99;
+
11285  int id = -99;
+
11286  std::shared_ptr<std::string> tool_name = nullptr;
+
11287  std::shared_ptr<TSeq> sequence = nullptr;
+
11288  ToolFun<TSeq> susceptibility_reduction_fun = nullptr;
+
11289  ToolFun<TSeq> transmission_reduction_fun = nullptr;
+
11290  ToolFun<TSeq> recovery_enhancer_fun = nullptr;
+
11291  ToolFun<TSeq> death_reduction_fun = nullptr;
+
11292 
+
11293  // Setup parameters
+
11294  std::vector< epiworld_double * > params;
11295 
-
11296 public:
-
11297  Tool(std::string name = "unknown tool");
-
11298  // Tool(TSeq d, std::string name = "unknown tool");
-
11299 
-
11300  void set_sequence(TSeq d);
-
11301  void set_sequence(std::shared_ptr<TSeq> d);
-
11302  std::shared_ptr<TSeq> get_sequence();
+
11296  epiworld_fast_int state_init = -99;
+
11297  epiworld_fast_int state_post = -99;
+
11298 
+
11299  epiworld_fast_int queue_init = Queue<TSeq>::NoOne; ///< Change of state when added to agent.
+
11300  epiworld_fast_int queue_post = Queue<TSeq>::NoOne; ///< Change of state when removed from agent.
+
11301 
+
11302  void set_agent(Agent<TSeq> * p, size_t idx);
11303 
-
11313  epiworld_double get_susceptibility_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
-
11314  epiworld_double get_transmission_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
-
11315  epiworld_double get_recovery_enhancer(VirusPtr<TSeq> v, Model<TSeq> * model);
-
11316  epiworld_double get_death_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
-
11317 
-
11318  void set_susceptibility_reduction_fun(ToolFun<TSeq> fun);
-
11319  void set_transmission_reduction_fun(ToolFun<TSeq> fun);
-
11320  void set_recovery_enhancer_fun(ToolFun<TSeq> fun);
-
11321  void set_death_reduction_fun(ToolFun<TSeq> fun);
-
11322 
-
11323  void set_susceptibility_reduction(epiworld_double * prob);
-
11324  void set_transmission_reduction(epiworld_double * prob);
-
11325  void set_recovery_enhancer(epiworld_double * prob);
-
11326  void set_death_reduction(epiworld_double * prob);
-
11327 
-
11328  void set_susceptibility_reduction(epiworld_double prob);
-
11329  void set_transmission_reduction(epiworld_double prob);
-
11330  void set_recovery_enhancer(epiworld_double prob);
-
11331  void set_death_reduction(epiworld_double prob);
-
11333 
-
11334  void set_name(std::string name);
-
11335  std::string get_name() const;
-
11336 
-
11337  Agent<TSeq> * get_agent();
-
11338  int get_id() const;
-
11339  void set_id(int id);
-
11340  void set_date(int d);
-
11341  int get_date() const;
-
11342 
-
11343  void set_state(epiworld_fast_int init, epiworld_fast_int post);
-
11344  void set_queue(epiworld_fast_int init, epiworld_fast_int post);
-
11345  void get_state(epiworld_fast_int * init, epiworld_fast_int * post);
-
11346  void get_queue(epiworld_fast_int * init, epiworld_fast_int * post);
-
11347 
-
11348  bool operator==(const Tool<TSeq> & other) const;
-
11349  bool operator!=(const Tool<TSeq> & other) const {return !operator==(other);};
+
11304 public:
+
11305  Tool(std::string name = "unknown tool");
+
11306  // Tool(TSeq d, std::string name = "unknown tool");
+
11307 
+
11308  void set_sequence(TSeq d);
+
11309  void set_sequence(std::shared_ptr<TSeq> d);
+
11310  std::shared_ptr<TSeq> get_sequence();
+
11311 
+
11321  epiworld_double get_susceptibility_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
+
11322  epiworld_double get_transmission_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
+
11323  epiworld_double get_recovery_enhancer(VirusPtr<TSeq> v, Model<TSeq> * model);
+
11324  epiworld_double get_death_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
+
11325 
+
11326  void set_susceptibility_reduction_fun(ToolFun<TSeq> fun);
+
11327  void set_transmission_reduction_fun(ToolFun<TSeq> fun);
+
11328  void set_recovery_enhancer_fun(ToolFun<TSeq> fun);
+
11329  void set_death_reduction_fun(ToolFun<TSeq> fun);
+
11330 
+
11331  void set_susceptibility_reduction(epiworld_double * prob);
+
11332  void set_transmission_reduction(epiworld_double * prob);
+
11333  void set_recovery_enhancer(epiworld_double * prob);
+
11334  void set_death_reduction(epiworld_double * prob);
+
11335 
+
11336  void set_susceptibility_reduction(epiworld_double prob);
+
11337  void set_transmission_reduction(epiworld_double prob);
+
11338  void set_recovery_enhancer(epiworld_double prob);
+
11339  void set_death_reduction(epiworld_double prob);
+
11341 
+
11342  void set_name(std::string name);
+
11343  std::string get_name() const;
+
11344 
+
11345  Agent<TSeq> * get_agent();
+
11346  int get_id() const;
+
11347  void set_id(int id);
+
11348  void set_date(int d);
+
11349  int get_date() const;
11350 
-
11351  void print() const;
-
11352 
-
11353 };
-
11354 
-
11355 #endif
-
11356 /*//////////////////////////////////////////////////////////////////////////////
+
11351  void set_state(epiworld_fast_int init, epiworld_fast_int post);
+
11352  void set_queue(epiworld_fast_int init, epiworld_fast_int post);
+
11353  void get_state(epiworld_fast_int * init, epiworld_fast_int * post);
+
11354  void get_queue(epiworld_fast_int * init, epiworld_fast_int * post);
+
11355 
+
11356  bool operator==(const Tool<TSeq> & other) const;
+
11357  bool operator!=(const Tool<TSeq> & other) const {return !operator==(other);};
11358 
-
11359  End of -include/epiworld/tool-bones.hpp-
+
11359  void print() const;
11360 
-
11363 
-
11364 
-
11365 /*//////////////////////////////////////////////////////////////////////////////
-
11367 
-
11368  Start of -include/epiworld/tool-meat.hpp-
-
11369 
+
11361 };
+
11362 
+
11363 #endif
+
11364 /*//////////////////////////////////////////////////////////////////////////////
+
11366 
+
11367  End of -include/epiworld/tool-bones.hpp-
+
11368 
+
11371 
11372 
-
11373 
-
11374 
-
11375 #ifndef EPIWORLD_TOOLS_MEAT_HPP
-
11376 #define EPIWORLD_TOOLS_MEAT_HPP
+
11373 /*//////////////////////////////////////////////////////////////////////////////
+
11375 
+
11376  Start of -include/epiworld/tool-meat.hpp-
11377 
-
11386 template<typename TSeq>
-
11387 inline ToolFun<TSeq> tool_fun_logit(
-
11388  std::vector< int > vars,
-
11389  std::vector< double > coefs,
-
11390  Model<TSeq> * model
-
11391 ) {
-
11392 
-
11393  // Checking that there are features
-
11394  if (coefs.size() == 0u)
-
11395  throw std::logic_error(
-
11396  "The -coefs- argument should feature at least one element."
-
11397  );
-
11398 
-
11399  if (coefs.size() != vars.size())
-
11400  throw std::length_error(
-
11401  std::string("The length of -coef- (") +
-
11402  std::to_string(coefs.size()) +
-
11403  std::string(") and -vars- (") +
-
11404  std::to_string(vars.size()) +
-
11405  std::string(") should match. ")
-
11406  );
-
11407 
-
11408  // Checking that there are variables in the model
-
11409  if (model != nullptr)
-
11410  {
-
11411 
-
11412  size_t K = model->get_agents_data_ncols();
-
11413  for (const auto & var: vars)
-
11414  {
-
11415  if ((var >= static_cast<int>(K)) | (var < 0))
-
11416  throw std::range_error(
-
11417  std::string("The variable ") +
-
11418  std::to_string(var) +
-
11419  std::string(" is out of range.") +
-
11420  std::string(" The agents only feature ") +
-
11421  std::to_string(K) +
-
11422  std::string("variables (features).")
-
11423  );
-
11424  }
-
11425 
-
11426  }
-
11427 
-
11428  std::vector< epiworld_double > coefs_f;
-
11429  for (auto c: coefs)
-
11430  coefs_f.push_back(static_cast<epiworld_double>(c));
-
11431 
-
11432  ToolFun<TSeq> fun_ = [coefs_f,vars](
-
11433  Tool<TSeq>& tool,
-
11434  Agent<TSeq> * agent,
-
11435  VirusPtr<TSeq> virus,
-
11436  Model<TSeq> * model
-
11437  ) -> epiworld_double {
-
11438 
-
11439  size_t K = coefs_f.size();
-
11440  epiworld_double res = 0.0;
-
11441 
-
11442  #if defined(__OPENMP) || defined(_OPENMP)
-
11443  #pragma omp simd reduction(+:res)
-
11444  #endif
-
11445  for (size_t i = 0u; i < K; ++i)
-
11446  res += agent->operator[](vars.at(i)) * coefs_f.at(i);
-
11447 
-
11448  return 1.0/(1.0 + std::exp(-res));
+
11380 
+
11381 
+
11382 
+
11383 #ifndef EPIWORLD_TOOLS_MEAT_HPP
+
11384 #define EPIWORLD_TOOLS_MEAT_HPP
+
11385 
+
11394 template<typename TSeq>
+
11395 inline ToolFun<TSeq> tool_fun_logit(
+
11396  std::vector< int > vars,
+
11397  std::vector< double > coefs,
+
11398  Model<TSeq> * model
+
11399 ) {
+
11400 
+
11401  // Checking that there are features
+
11402  if (coefs.size() == 0u)
+
11403  throw std::logic_error(
+
11404  "The -coefs- argument should feature at least one element."
+
11405  );
+
11406 
+
11407  if (coefs.size() != vars.size())
+
11408  throw std::length_error(
+
11409  std::string("The length of -coef- (") +
+
11410  std::to_string(coefs.size()) +
+
11411  std::string(") and -vars- (") +
+
11412  std::to_string(vars.size()) +
+
11413  std::string(") should match. ")
+
11414  );
+
11415 
+
11416  // Checking that there are variables in the model
+
11417  if (model != nullptr)
+
11418  {
+
11419 
+
11420  size_t K = model->get_agents_data_ncols();
+
11421  for (const auto & var: vars)
+
11422  {
+
11423  if ((var >= static_cast<int>(K)) | (var < 0))
+
11424  throw std::range_error(
+
11425  std::string("The variable ") +
+
11426  std::to_string(var) +
+
11427  std::string(" is out of range.") +
+
11428  std::string(" The agents only feature ") +
+
11429  std::to_string(K) +
+
11430  std::string("variables (features).")
+
11431  );
+
11432  }
+
11433 
+
11434  }
+
11435 
+
11436  std::vector< epiworld_double > coefs_f;
+
11437  for (auto c: coefs)
+
11438  coefs_f.push_back(static_cast<epiworld_double>(c));
+
11439 
+
11440  ToolFun<TSeq> fun_ = [coefs_f,vars](
+
11441  Tool<TSeq>& tool,
+
11442  Agent<TSeq> * agent,
+
11443  VirusPtr<TSeq> virus,
+
11444  Model<TSeq> * model
+
11445  ) -> epiworld_double {
+
11446 
+
11447  size_t K = coefs_f.size();
+
11448  epiworld_double res = 0.0;
11449 
-
11450  };
-
11451 
-
11452  return fun_;
-
11453 
-
11454 }
+
11450  #if defined(__OPENMP) || defined(_OPENMP)
+
11451  #pragma omp simd reduction(+:res)
+
11452  #endif
+
11453  for (size_t i = 0u; i < K; ++i)
+
11454  res += agent->operator[](vars.at(i)) * coefs_f.at(i);
11455 
-
11456 template<typename TSeq>
-
11457 inline Tool<TSeq>::Tool(std::string name)
-
11458 {
-
11459  set_name(name);
-
11460 }
+
11456  return 1.0/(1.0 + std::exp(-res));
+
11457 
+
11458  };
+
11459 
+
11460  return fun_;
11461 
-
11462 // template<typename TSeq>
-
11463 // inline Tool<TSeq>::Tool(TSeq d, std::string name) {
-
11464 // sequence = std::make_shared<TSeq>(d);
-
11465 // tool_name = std::make_shared<std::string>(name);
-
11466 // }
-
11467 
-
11468 template<typename TSeq>
-
11469 inline void Tool<TSeq>::set_sequence(TSeq d) {
-
11470  sequence = std::make_shared<TSeq>(d);
-
11471 }
-
11472 
-
11473 template<typename TSeq>
-
11474 inline void Tool<TSeq>::set_sequence(std::shared_ptr<TSeq> d) {
-
11475  sequence = d;
-
11476 }
-
11477 
-
11478 template<typename TSeq>
-
11479 inline std::shared_ptr<TSeq> Tool<TSeq>::get_sequence() {
-
11480  return sequence;
-
11481 }
-
11482 
-
11483 template<typename TSeq>
-
11484 inline epiworld_double Tool<TSeq>::get_susceptibility_reduction(
-
11485  VirusPtr<TSeq> v,
-
11486  Model<TSeq> * model
-
11487 )
-
11488 {
-
11489 
-
11490  if (susceptibility_reduction_fun)
-
11491  return susceptibility_reduction_fun(*this, this->agent, v, model);
-
11492 
-
11493  return DEFAULT_TOOL_CONTAGION_REDUCTION;
-
11494 
-
11495 }
-
11496 
-
11497 template<typename TSeq>
-
11498 inline epiworld_double Tool<TSeq>::get_transmission_reduction(
-
11499  VirusPtr<TSeq> v,
-
11500  Model<TSeq> * model
-
11501 )
-
11502 {
-
11503 
-
11504  if (transmission_reduction_fun)
-
11505  return transmission_reduction_fun(*this, this->agent, v, model);
-
11506 
-
11507  return DEFAULT_TOOL_TRANSMISSION_REDUCTION;
-
11508 
-
11509 }
-
11510 
-
11511 template<typename TSeq>
-
11512 inline epiworld_double Tool<TSeq>::get_recovery_enhancer(
-
11513  VirusPtr<TSeq> v,
-
11514  Model<TSeq> * model
-
11515 )
-
11516 {
-
11517 
-
11518  if (recovery_enhancer_fun)
-
11519  return recovery_enhancer_fun(*this, this->agent, v, model);
-
11520 
-
11521  return DEFAULT_TOOL_RECOVERY_ENHANCER;
-
11522 
-
11523 }
-
11524 
-
11525 template<typename TSeq>
-
11526 inline epiworld_double Tool<TSeq>::get_death_reduction(
-
11527  VirusPtr<TSeq> v,
-
11528  Model<TSeq> * model
-
11529 )
-
11530 {
-
11531 
-
11532  if (death_reduction_fun)
-
11533  return death_reduction_fun(*this, this->agent, v, model);
-
11534 
-
11535  return DEFAULT_TOOL_DEATH_REDUCTION;
-
11536 
-
11537 }
-
11538 
-
11539 template<typename TSeq>
-
11540 inline void Tool<TSeq>::set_susceptibility_reduction_fun(
-
11541  ToolFun<TSeq> fun
-
11542 )
-
11543 {
-
11544  susceptibility_reduction_fun = fun;
+
11462 }
+
11463 
+
11464 template<typename TSeq>
+
11465 inline Tool<TSeq>::Tool(std::string name)
+
11466 {
+
11467  set_name(name);
+
11468 }
+
11469 
+
11470 // template<typename TSeq>
+
11471 // inline Tool<TSeq>::Tool(TSeq d, std::string name) {
+
11472 // sequence = std::make_shared<TSeq>(d);
+
11473 // tool_name = std::make_shared<std::string>(name);
+
11474 // }
+
11475 
+
11476 template<typename TSeq>
+
11477 inline void Tool<TSeq>::set_sequence(TSeq d) {
+
11478  sequence = std::make_shared<TSeq>(d);
+
11479 }
+
11480 
+
11481 template<typename TSeq>
+
11482 inline void Tool<TSeq>::set_sequence(std::shared_ptr<TSeq> d) {
+
11483  sequence = d;
+
11484 }
+
11485 
+
11486 template<typename TSeq>
+
11487 inline std::shared_ptr<TSeq> Tool<TSeq>::get_sequence() {
+
11488  return sequence;
+
11489 }
+
11490 
+
11491 template<typename TSeq>
+
11492 inline epiworld_double Tool<TSeq>::get_susceptibility_reduction(
+
11493  VirusPtr<TSeq> v,
+
11494  Model<TSeq> * model
+
11495 )
+
11496 {
+
11497 
+
11498  if (susceptibility_reduction_fun)
+
11499  return susceptibility_reduction_fun(*this, this->agent, v, model);
+
11500 
+
11501  return DEFAULT_TOOL_CONTAGION_REDUCTION;
+
11502 
+
11503 }
+
11504 
+
11505 template<typename TSeq>
+
11506 inline epiworld_double Tool<TSeq>::get_transmission_reduction(
+
11507  VirusPtr<TSeq> v,
+
11508  Model<TSeq> * model
+
11509 )
+
11510 {
+
11511 
+
11512  if (transmission_reduction_fun)
+
11513  return transmission_reduction_fun(*this, this->agent, v, model);
+
11514 
+
11515  return DEFAULT_TOOL_TRANSMISSION_REDUCTION;
+
11516 
+
11517 }
+
11518 
+
11519 template<typename TSeq>
+
11520 inline epiworld_double Tool<TSeq>::get_recovery_enhancer(
+
11521  VirusPtr<TSeq> v,
+
11522  Model<TSeq> * model
+
11523 )
+
11524 {
+
11525 
+
11526  if (recovery_enhancer_fun)
+
11527  return recovery_enhancer_fun(*this, this->agent, v, model);
+
11528 
+
11529  return DEFAULT_TOOL_RECOVERY_ENHANCER;
+
11530 
+
11531 }
+
11532 
+
11533 template<typename TSeq>
+
11534 inline epiworld_double Tool<TSeq>::get_death_reduction(
+
11535  VirusPtr<TSeq> v,
+
11536  Model<TSeq> * model
+
11537 )
+
11538 {
+
11539 
+
11540  if (death_reduction_fun)
+
11541  return death_reduction_fun(*this, this->agent, v, model);
+
11542 
+
11543  return DEFAULT_TOOL_DEATH_REDUCTION;
+
11544 
11545 }
11546 
11547 template<typename TSeq>
-
11548 inline void Tool<TSeq>::set_transmission_reduction_fun(
+
11548 inline void Tool<TSeq>::set_susceptibility_reduction_fun(
11549  ToolFun<TSeq> fun
11550 )
11551 {
-
11552  transmission_reduction_fun = fun;
+
11552  susceptibility_reduction_fun = fun;
11553 }
11554 
11555 template<typename TSeq>
-
11556 inline void Tool<TSeq>::set_recovery_enhancer_fun(
+
11556 inline void Tool<TSeq>::set_transmission_reduction_fun(
11557  ToolFun<TSeq> fun
11558 )
11559 {
-
11560  recovery_enhancer_fun = fun;
+
11560  transmission_reduction_fun = fun;
11561 }
11562 
11563 template<typename TSeq>
-
11564 inline void Tool<TSeq>::set_death_reduction_fun(
+
11564 inline void Tool<TSeq>::set_recovery_enhancer_fun(
11565  ToolFun<TSeq> fun
11566 )
11567 {
-
11568  death_reduction_fun = fun;
+
11568  recovery_enhancer_fun = fun;
11569 }
11570 
11571 template<typename TSeq>
-
11572 inline void Tool<TSeq>::set_susceptibility_reduction(epiworld_double * prob)
-
11573 {
-
11574 
-
11575  ToolFun<TSeq> tmpfun =
-
11576  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11577  {
-
11578  return *prob;
-
11579  };
-
11580 
-
11581  susceptibility_reduction_fun = tmpfun;
+
11572 inline void Tool<TSeq>::set_death_reduction_fun(
+
11573  ToolFun<TSeq> fun
+
11574 )
+
11575 {
+
11576  death_reduction_fun = fun;
+
11577 }
+
11578 
+
11579 template<typename TSeq>
+
11580 inline void Tool<TSeq>::set_susceptibility_reduction(epiworld_double * prob)
+
11581 {
11582 
-
11583 }
-
11584 
-
11585 // EPIWORLD_SET_LAMBDA(susceptibility_reduction)
-
11586 template<typename TSeq>
-
11587 inline void Tool<TSeq>::set_transmission_reduction(epiworld_double * prob)
-
11588 {
-
11589 
-
11590  ToolFun<TSeq> tmpfun =
-
11591  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11592  {
-
11593  return *prob;
-
11594  };
-
11595 
-
11596  transmission_reduction_fun = tmpfun;
-
11597 
-
11598 }
-
11599 
-
11600 // EPIWORLD_SET_LAMBDA(transmission_reduction)
-
11601 template<typename TSeq>
-
11602 inline void Tool<TSeq>::set_recovery_enhancer(epiworld_double * prob)
-
11603 {
-
11604 
-
11605  ToolFun<TSeq> tmpfun =
-
11606  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11607  {
-
11608  return *prob;
-
11609  };
-
11610 
-
11611  recovery_enhancer_fun = tmpfun;
+
11583  ToolFun<TSeq> tmpfun =
+
11584  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11585  {
+
11586  return *prob;
+
11587  };
+
11588 
+
11589  susceptibility_reduction_fun = tmpfun;
+
11590 
+
11591 }
+
11592 
+
11593 // EPIWORLD_SET_LAMBDA(susceptibility_reduction)
+
11594 template<typename TSeq>
+
11595 inline void Tool<TSeq>::set_transmission_reduction(epiworld_double * prob)
+
11596 {
+
11597 
+
11598  ToolFun<TSeq> tmpfun =
+
11599  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11600  {
+
11601  return *prob;
+
11602  };
+
11603 
+
11604  transmission_reduction_fun = tmpfun;
+
11605 
+
11606 }
+
11607 
+
11608 // EPIWORLD_SET_LAMBDA(transmission_reduction)
+
11609 template<typename TSeq>
+
11610 inline void Tool<TSeq>::set_recovery_enhancer(epiworld_double * prob)
+
11611 {
11612 
-
11613 }
-
11614 
-
11615 // EPIWORLD_SET_LAMBDA(recovery_enhancer)
-
11616 template<typename TSeq>
-
11617 inline void Tool<TSeq>::set_death_reduction(epiworld_double * prob)
-
11618 {
-
11619 
-
11620  ToolFun<TSeq> tmpfun =
-
11621  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11622  {
-
11623  return *prob;
-
11624  };
-
11625 
-
11626  death_reduction_fun = tmpfun;
+
11613  ToolFun<TSeq> tmpfun =
+
11614  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11615  {
+
11616  return *prob;
+
11617  };
+
11618 
+
11619  recovery_enhancer_fun = tmpfun;
+
11620 
+
11621 }
+
11622 
+
11623 // EPIWORLD_SET_LAMBDA(recovery_enhancer)
+
11624 template<typename TSeq>
+
11625 inline void Tool<TSeq>::set_death_reduction(epiworld_double * prob)
+
11626 {
11627 
-
11628 }
-
11629 
-
11630 // EPIWORLD_SET_LAMBDA(death_reduction)
-
11631 
-
11632 // #undef EPIWORLD_SET_LAMBDA
-
11633 template<typename TSeq>
-
11634 inline void Tool<TSeq>::set_susceptibility_reduction(
-
11635  epiworld_double prob
-
11636 )
-
11637 {
-
11638 
-
11639  ToolFun<TSeq> tmpfun =
-
11640  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11641  {
-
11642  return prob;
-
11643  };
-
11644 
-
11645  susceptibility_reduction_fun = tmpfun;
+
11628  ToolFun<TSeq> tmpfun =
+
11629  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11630  {
+
11631  return *prob;
+
11632  };
+
11633 
+
11634  death_reduction_fun = tmpfun;
+
11635 
+
11636 }
+
11637 
+
11638 // EPIWORLD_SET_LAMBDA(death_reduction)
+
11639 
+
11640 // #undef EPIWORLD_SET_LAMBDA
+
11641 template<typename TSeq>
+
11642 inline void Tool<TSeq>::set_susceptibility_reduction(
+
11643  epiworld_double prob
+
11644 )
+
11645 {
11646 
-
11647 }
-
11648 
-
11649 template<typename TSeq>
-
11650 inline void Tool<TSeq>::set_transmission_reduction(
-
11651  epiworld_double prob
-
11652 )
-
11653 {
+
11647  ToolFun<TSeq> tmpfun =
+
11648  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11649  {
+
11650  return prob;
+
11651  };
+
11652 
+
11653  susceptibility_reduction_fun = tmpfun;
11654 
-
11655  ToolFun<TSeq> tmpfun =
-
11656  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11657  {
-
11658  return prob;
-
11659  };
-
11660 
-
11661  transmission_reduction_fun = tmpfun;
+
11655 }
+
11656 
+
11657 template<typename TSeq>
+
11658 inline void Tool<TSeq>::set_transmission_reduction(
+
11659  epiworld_double prob
+
11660 )
+
11661 {
11662 
-
11663 }
-
11664 
-
11665 template<typename TSeq>
-
11666 inline void Tool<TSeq>::set_recovery_enhancer(
-
11667  epiworld_double prob
-
11668 )
-
11669 {
+
11663  ToolFun<TSeq> tmpfun =
+
11664  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11665  {
+
11666  return prob;
+
11667  };
+
11668 
+
11669  transmission_reduction_fun = tmpfun;
11670 
-
11671  ToolFun<TSeq> tmpfun =
-
11672  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11673  {
-
11674  return prob;
-
11675  };
-
11676 
-
11677  recovery_enhancer_fun = tmpfun;
+
11671 }
+
11672 
+
11673 template<typename TSeq>
+
11674 inline void Tool<TSeq>::set_recovery_enhancer(
+
11675  epiworld_double prob
+
11676 )
+
11677 {
11678 
-
11679 }
-
11680 
-
11681 template<typename TSeq>
-
11682 inline void Tool<TSeq>::set_death_reduction(
-
11683  epiworld_double prob
-
11684 )
-
11685 {
+
11679  ToolFun<TSeq> tmpfun =
+
11680  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11681  {
+
11682  return prob;
+
11683  };
+
11684 
+
11685  recovery_enhancer_fun = tmpfun;
11686 
-
11687  ToolFun<TSeq> tmpfun =
-
11688  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
-
11689  {
-
11690  return prob;
-
11691  };
-
11692 
-
11693  death_reduction_fun = tmpfun;
+
11687 }
+
11688 
+
11689 template<typename TSeq>
+
11690 inline void Tool<TSeq>::set_death_reduction(
+
11691  epiworld_double prob
+
11692 )
+
11693 {
11694 
-
11695 }
-
11696 
-
11697 template<typename TSeq>
-
11698 inline void Tool<TSeq>::set_name(std::string name)
-
11699 {
-
11700  if (name != "")
-
11701  tool_name = std::make_shared<std::string>(name);
-
11702 }
-
11703 
-
11704 template<typename TSeq>
-
11705 inline std::string Tool<TSeq>::get_name() const {
-
11706 
-
11707  if (tool_name)
-
11708  return *tool_name;
-
11709 
-
11710  return "unknown tool";
+
11695  ToolFun<TSeq> tmpfun =
+
11696  [prob](Tool<TSeq> &, Agent<TSeq> *, VirusPtr<TSeq>, Model<TSeq> *)
+
11697  {
+
11698  return prob;
+
11699  };
+
11700 
+
11701  death_reduction_fun = tmpfun;
+
11702 
+
11703 }
+
11704 
+
11705 template<typename TSeq>
+
11706 inline void Tool<TSeq>::set_name(std::string name)
+
11707 {
+
11708  if (name != "")
+
11709  tool_name = std::make_shared<std::string>(name);
+
11710 }
11711 
-
11712 }
-
11713 
-
11714 template<typename TSeq>
-
11715 inline Agent<TSeq> * Tool<TSeq>::get_agent()
-
11716 {
-
11717  return this->agent;
-
11718 }
+
11712 template<typename TSeq>
+
11713 inline std::string Tool<TSeq>::get_name() const {
+
11714 
+
11715  if (tool_name)
+
11716  return *tool_name;
+
11717 
+
11718  return "unknown tool";
11719 
-
11720 template<typename TSeq>
-
11721 inline void Tool<TSeq>::set_agent(Agent<TSeq> * p, size_t idx)
-
11722 {
-
11723  agent = p;
-
11724  pos_in_agent = static_cast<int>(idx);
-
11725 }
-
11726 
-
11727 template<typename TSeq>
-
11728 inline int Tool<TSeq>::get_id() const {
-
11729  return id;
-
11730 }
-
11731 
-
11732 
-
11733 template<typename TSeq>
-
11734 inline void Tool<TSeq>::set_id(int id)
-
11735 {
-
11736  this->id = id;
-
11737 }
-
11738 
-
11739 template<typename TSeq>
-
11740 inline void Tool<TSeq>::set_date(int d)
-
11741 {
-
11742  this->date = d;
-
11743 }
-
11744 
-
11745 template<typename TSeq>
-
11746 inline int Tool<TSeq>::get_date() const
-
11747 {
-
11748  return date;
-
11749 }
-
11750 
-
11751 template<typename TSeq>
-
11752 inline void Tool<TSeq>::set_state(
-
11753  epiworld_fast_int init,
-
11754  epiworld_fast_int end
-
11755 )
-
11756 {
-
11757  state_init = init;
-
11758  state_post = end;
-
11759 }
-
11760 
-
11761 template<typename TSeq>
-
11762 inline void Tool<TSeq>::set_queue(
-
11763  epiworld_fast_int init,
-
11764  epiworld_fast_int end
-
11765 )
-
11766 {
-
11767  queue_init = init;
-
11768  queue_post = end;
-
11769 }
-
11770 
-
11771 template<typename TSeq>
-
11772 inline void Tool<TSeq>::get_state(
-
11773  epiworld_fast_int * init,
-
11774  epiworld_fast_int * post
-
11775 )
-
11776 {
-
11777  if (init != nullptr)
-
11778  *init = state_init;
-
11779 
-
11780  if (post != nullptr)
-
11781  *post = state_post;
-
11782 
-
11783 }
-
11784 
-
11785 template<typename TSeq>
-
11786 inline void Tool<TSeq>::get_queue(
-
11787  epiworld_fast_int * init,
-
11788  epiworld_fast_int * post
-
11789 )
-
11790 {
-
11791  if (init != nullptr)
-
11792  *init = queue_init;
-
11793 
-
11794  if (post != nullptr)
-
11795  *post = queue_post;
-
11796 
-
11797 }
-
11798 
-
11799 template<>
-
11800 inline bool Tool<std::vector<int>>::operator==(
-
11801  const Tool<std::vector<int>> & other
-
11802  ) const
-
11803 {
-
11804 
-
11805  if (sequence->size() != other.sequence->size())
-
11806  return false;
-
11807 
-
11808  for (size_t i = 0u; i < sequence->size(); ++i)
-
11809  {
-
11810  if (sequence->operator[](i) != other.sequence->operator[](i))
-
11811  return false;
-
11812  }
-
11813 
-
11814  if (tool_name != other.tool_name)
-
11815  return false;
-
11816 
-
11817  if (state_init != other.state_init)
-
11818  return false;
-
11819 
-
11820  if (state_post != other.state_post)
-
11821  return false;
-
11822 
-
11823  if (queue_init != other.queue_init)
-
11824  return false;
-
11825 
-
11826  if (queue_post != other.queue_post)
-
11827  return false;
-
11828 
-
11829 
-
11830  return true;
-
11831 
-
11832 }
+
11720 }
+
11721 
+
11722 template<typename TSeq>
+
11723 inline Agent<TSeq> * Tool<TSeq>::get_agent()
+
11724 {
+
11725  return this->agent;
+
11726 }
+
11727 
+
11728 template<typename TSeq>
+
11729 inline void Tool<TSeq>::set_agent(Agent<TSeq> * p, size_t idx)
+
11730 {
+
11731  agent = p;
+
11732  pos_in_agent = static_cast<int>(idx);
+
11733 }
+
11734 
+
11735 template<typename TSeq>
+
11736 inline int Tool<TSeq>::get_id() const {
+
11737  return id;
+
11738 }
+
11739 
+
11740 
+
11741 template<typename TSeq>
+
11742 inline void Tool<TSeq>::set_id(int id)
+
11743 {
+
11744  this->id = id;
+
11745 }
+
11746 
+
11747 template<typename TSeq>
+
11748 inline void Tool<TSeq>::set_date(int d)
+
11749 {
+
11750  this->date = d;
+
11751 }
+
11752 
+
11753 template<typename TSeq>
+
11754 inline int Tool<TSeq>::get_date() const
+
11755 {
+
11756  return date;
+
11757 }
+
11758 
+
11759 template<typename TSeq>
+
11760 inline void Tool<TSeq>::set_state(
+
11761  epiworld_fast_int init,
+
11762  epiworld_fast_int end
+
11763 )
+
11764 {
+
11765  state_init = init;
+
11766  state_post = end;
+
11767 }
+
11768 
+
11769 template<typename TSeq>
+
11770 inline void Tool<TSeq>::set_queue(
+
11771  epiworld_fast_int init,
+
11772  epiworld_fast_int end
+
11773 )
+
11774 {
+
11775  queue_init = init;
+
11776  queue_post = end;
+
11777 }
+
11778 
+
11779 template<typename TSeq>
+
11780 inline void Tool<TSeq>::get_state(
+
11781  epiworld_fast_int * init,
+
11782  epiworld_fast_int * post
+
11783 )
+
11784 {
+
11785  if (init != nullptr)
+
11786  *init = state_init;
+
11787 
+
11788  if (post != nullptr)
+
11789  *post = state_post;
+
11790 
+
11791 }
+
11792 
+
11793 template<typename TSeq>
+
11794 inline void Tool<TSeq>::get_queue(
+
11795  epiworld_fast_int * init,
+
11796  epiworld_fast_int * post
+
11797 )
+
11798 {
+
11799  if (init != nullptr)
+
11800  *init = queue_init;
+
11801 
+
11802  if (post != nullptr)
+
11803  *post = queue_post;
+
11804 
+
11805 }
+
11806 
+
11807 template<>
+
11808 inline bool Tool<std::vector<int>>::operator==(
+
11809  const Tool<std::vector<int>> & other
+
11810  ) const
+
11811 {
+
11812 
+
11813  if (sequence->size() != other.sequence->size())
+
11814  return false;
+
11815 
+
11816  for (size_t i = 0u; i < sequence->size(); ++i)
+
11817  {
+
11818  if (sequence->operator[](i) != other.sequence->operator[](i))
+
11819  return false;
+
11820  }
+
11821 
+
11822  if (tool_name != other.tool_name)
+
11823  return false;
+
11824 
+
11825  if (state_init != other.state_init)
+
11826  return false;
+
11827 
+
11828  if (state_post != other.state_post)
+
11829  return false;
+
11830 
+
11831  if (queue_init != other.queue_init)
+
11832  return false;
11833 
-
11834 template<typename TSeq>
-
11835 inline bool Tool<TSeq>::operator==(const Tool<TSeq> & other) const
-
11836 {
-
11837  if (*sequence != *other.sequence)
-
11838  return false;
+
11834  if (queue_post != other.queue_post)
+
11835  return false;
+
11836 
+
11837 
+
11838  return true;
11839 
-
11840  if (tool_name != other.tool_name)
-
11841  return false;
-
11842 
-
11843  if (state_init != other.state_init)
-
11844  return false;
-
11845 
-
11846  if (state_post != other.state_post)
-
11847  return false;
-
11848 
-
11849  if (queue_init != other.queue_init)
-
11850  return false;
-
11851 
-
11852  if (queue_post != other.queue_post)
-
11853  return false;
-
11854 
-
11855  return true;
+
11840 }
+
11841 
+
11842 template<typename TSeq>
+
11843 inline bool Tool<TSeq>::operator==(const Tool<TSeq> & other) const
+
11844 {
+
11845  if (*sequence != *other.sequence)
+
11846  return false;
+
11847 
+
11848  if (tool_name != other.tool_name)
+
11849  return false;
+
11850 
+
11851  if (state_init != other.state_init)
+
11852  return false;
+
11853 
+
11854  if (state_post != other.state_post)
+
11855  return false;
11856 
-
11857 }
-
11858 
+
11857  if (queue_init != other.queue_init)
+
11858  return false;
11859 
-
11860 template<typename TSeq>
-
11861 inline void Tool<TSeq>::print() const
-
11862 {
-
11863 
-
11864  printf_epiworld("Tool : %s\n", tool_name->c_str());
-
11865  printf_epiworld("Id : %s\n", (id < 0)? std::string("(empty)").c_str() : std::to_string(id).c_str());
-
11866  printf_epiworld("state_init : %i\n", state_init);
-
11867  printf_epiworld("state_post : %i\n", state_post);
-
11868  printf_epiworld("queue_init : %i\n", queue_init);
-
11869  printf_epiworld("queue_post : %i\n", queue_post);
-
11870 
-
11871 }
-
11872 
-
11873 #endif
-
11874 /*//////////////////////////////////////////////////////////////////////////////
-
11876 
-
11877  End of -include/epiworld/tool-meat.hpp-
+
11860  if (queue_post != other.queue_post)
+
11861  return false;
+
11862 
+
11863  return true;
+
11864 
+
11865 }
+
11866 
+
11867 
+
11868 template<typename TSeq>
+
11869 inline void Tool<TSeq>::print() const
+
11870 {
+
11871 
+
11872  printf_epiworld("Tool : %s\n", tool_name->c_str());
+
11873  printf_epiworld("Id : %s\n", (id < 0)? std::string("(empty)").c_str() : std::to_string(id).c_str());
+
11874  printf_epiworld("state_init : %i\n", state_init);
+
11875  printf_epiworld("state_post : %i\n", state_post);
+
11876  printf_epiworld("queue_init : %i\n", queue_init);
+
11877  printf_epiworld("queue_post : %i\n", queue_post);
11878 
-
11881 
-
11882 
-
11883 
-
11884 /*//////////////////////////////////////////////////////////////////////////////
+
11879 }
+
11880 
+
11881 #endif
+
11882 /*//////////////////////////////////////////////////////////////////////////////
+
11884 
+
11885  End of -include/epiworld/tool-meat.hpp-
11886 
-
11887  Start of -include/epiworld/entity-bones.hpp-
-
11888 
+
11889 
+
11890 
11891 
-
11892 
-
11893 #ifndef EPIWORLD_ENTITY_BONES_HPP
-
11894 #define EPIWORLD_ENTITY_BONES_HPP
-
11895 
-
11896 template<typename TSeq>
-
11897 class Model;
-
11898 
-
11899 template<typename TSeq>
-
11900 class Agent;
-
11901 
-
11902 template<typename TSeq>
-
11903 class AgentsSample;
-
11904 
-
11905 template<typename TSeq>
-
11906 inline void default_add_entity(Action<TSeq> & a, Model<TSeq> * m);
-
11907 
-
11908 template<typename TSeq>
-
11909 inline void default_rm_entity(Action<TSeq> & a, Model<TSeq> * m);
-
11910 
-
11911 template<typename TSeq>
-
11912 class Entity {
-
11913  friend class Agent<TSeq>;
-
11914  friend class AgentsSample<TSeq>;
-
11915  friend class Model<TSeq>;
-
11916  friend void default_add_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
11917  friend void default_rm_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
11918 private:
-
11919 
-
11920  Model<TSeq> * model;
-
11921 
-
11922  int id = -1;
-
11923  std::vector< size_t > agents; ///< Vector of agents
-
11924  std::vector< size_t > agents_location; ///< Location where the entity is stored in the agent
-
11925  size_t n_agents = 0u;
-
11926 
-
11936  std::vector< Agent<TSeq> * > sampled_agents;
-
11937  size_t sampled_agents_n = 0u;
-
11938  std::vector< size_t > sampled_agents_left;
-
11939  size_t sampled_agents_left_n = 0u;
-
11940  // int date_last_add_or_remove = -99; ///< Last time the entity added or removed an agent
-
11942 
-
11943  int max_capacity = -1;
-
11944  std::string entity_name = "Unknown entity";
-
11945 
-
11946  std::vector< epiworld_double > location = {0.0}; ///< An arbitrary vector for location
-
11947 
-
11948  epiworld_fast_int state_init = -99;
-
11949  epiworld_fast_int state_post = -99;
+
11892 /*//////////////////////////////////////////////////////////////////////////////
+
11894 
+
11895  Start of -include/epiworld/entity-bones.hpp-
+
11896 
+
11899 
+
11900 
+
11901 #ifndef EPIWORLD_ENTITY_BONES_HPP
+
11902 #define EPIWORLD_ENTITY_BONES_HPP
+
11903 
+
11904 template<typename TSeq>
+
11905 class Model;
+
11906 
+
11907 template<typename TSeq>
+
11908 class Agent;
+
11909 
+
11910 template<typename TSeq>
+
11911 class AgentsSample;
+
11912 
+
11913 template<typename TSeq>
+
11914 inline void default_add_entity(Action<TSeq> & a, Model<TSeq> * m);
+
11915 
+
11916 template<typename TSeq>
+
11917 inline void default_rm_entity(Action<TSeq> & a, Model<TSeq> * m);
+
11918 
+
11919 template<typename TSeq>
+
11920 class Entity {
+
11921  friend class Agent<TSeq>;
+
11922  friend class AgentsSample<TSeq>;
+
11923  friend class Model<TSeq>;
+
11924  friend void default_add_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
11925  friend void default_rm_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
11926 private:
+
11927 
+
11928  Model<TSeq> * model;
+
11929 
+
11930  int id = -1;
+
11931  std::vector< size_t > agents; ///< Vector of agents
+
11932  std::vector< size_t > agents_location; ///< Location where the entity is stored in the agent
+
11933  size_t n_agents = 0u;
+
11934 
+
11944  std::vector< Agent<TSeq> * > sampled_agents;
+
11945  size_t sampled_agents_n = 0u;
+
11946  std::vector< size_t > sampled_agents_left;
+
11947  size_t sampled_agents_left_n = 0u;
+
11948  // int date_last_add_or_remove = -99; ///< Last time the entity added or removed an agent
11950 
-
11951  epiworld_fast_int queue_init = 0; ///< Change of state when added to agent.
-
11952  epiworld_fast_int queue_post = 0; ///< Change of state when removed from agent.
+
11951  int max_capacity = -1;
+
11952  std::string entity_name = "Unknown entity";
11953 
-
11954 public:
+
11954  std::vector< epiworld_double > location = {0.0}; ///< An arbitrary vector for location
11955 
-
11956  // Entity() = delete;
-
11957  // Entity(Entity<TSeq> & e) = delete;
-
11958  // Entity(const Entity<TSeq> & e);
-
11959  // Entity(Entity && e);
-
11960  Entity(std::string name) : entity_name(name) {};
-
11961  // Entity<TSeq> & operator=(const Entity<TSeq> & e);
-
11962 
-
11963  void add_agent(Agent<TSeq> & p, Model<TSeq> * model);
-
11964  void add_agent(Agent<TSeq> * p, Model<TSeq> * model);
-
11965  void rm_agent(size_t idx);
-
11966  size_t size() const noexcept;
-
11967  void set_location(std::vector< epiworld_double > loc);
-
11968  std::vector< epiworld_double > & get_location();
-
11969 
-
11970  typename std::vector< Agent<TSeq> * >::iterator begin();
-
11971  typename std::vector< Agent<TSeq> * >::iterator end();
-
11972 
-
11973  typename std::vector< Agent<TSeq> * >::const_iterator begin() const;
-
11974  typename std::vector< Agent<TSeq> * >::const_iterator end() const;
-
11975 
-
11976  Agent<TSeq> * operator[](size_t i);
+
11956  epiworld_fast_int state_init = -99;
+
11957  epiworld_fast_int state_post = -99;
+
11958 
+
11959  epiworld_fast_int queue_init = 0; ///< Change of state when added to agent.
+
11960  epiworld_fast_int queue_post = 0; ///< Change of state when removed from agent.
+
11961 
+
11962 public:
+
11963 
+
11964  // Entity() = delete;
+
11965  // Entity(Entity<TSeq> & e) = delete;
+
11966  // Entity(const Entity<TSeq> & e);
+
11967  // Entity(Entity && e);
+
11968  Entity(std::string name) : entity_name(name) {};
+
11969  // Entity<TSeq> & operator=(const Entity<TSeq> & e);
+
11970 
+
11971  void add_agent(Agent<TSeq> & p, Model<TSeq> * model);
+
11972  void add_agent(Agent<TSeq> * p, Model<TSeq> * model);
+
11973  void rm_agent(size_t idx);
+
11974  size_t size() const noexcept;
+
11975  void set_location(std::vector< epiworld_double > loc);
+
11976  std::vector< epiworld_double > & get_location();
11977 
-
11978  int get_id() const noexcept;
-
11979  const std::string & get_name() const noexcept;
+
11978  typename std::vector< Agent<TSeq> * >::iterator begin();
+
11979  typename std::vector< Agent<TSeq> * >::iterator end();
11980 
-
11981  void set_state(epiworld_fast_int init, epiworld_fast_int post);
-
11982  void set_queue(epiworld_fast_int init, epiworld_fast_int post);
-
11983  void get_state(epiworld_fast_int * init, epiworld_fast_int * post);
-
11984  void get_queue(epiworld_fast_int * init, epiworld_fast_int * post);
+
11981  typename std::vector< Agent<TSeq> * >::const_iterator begin() const;
+
11982  typename std::vector< Agent<TSeq> * >::const_iterator end() const;
+
11983 
+
11984  Agent<TSeq> * operator[](size_t i);
11985 
-
11986  void reset();
-
11987 
-
11988  bool operator==(const Entity<TSeq> & other) const;
-
11989  bool operator!=(const Entity<TSeq> & other) const {return !operator==(other);};
-
11990 
-
11991 };
-
11992 
+
11986  int get_id() const noexcept;
+
11987  const std::string & get_name() const noexcept;
+
11988 
+
11989  void set_state(epiworld_fast_int init, epiworld_fast_int post);
+
11990  void set_queue(epiworld_fast_int init, epiworld_fast_int post);
+
11991  void get_state(epiworld_fast_int * init, epiworld_fast_int * post);
+
11992  void get_queue(epiworld_fast_int * init, epiworld_fast_int * post);
11993 
-
11994 #endif
-
11995 /*//////////////////////////////////////////////////////////////////////////////
-
11997 
-
11998  End of -include/epiworld/entity-bones.hpp-
-
11999 
-
12002 
-
12003 
-
12004 /*//////////////////////////////////////////////////////////////////////////////
-
12006 
-
12007  Start of -include/epiworld/entity-meat.hpp-
-
12008 
+
11994  void reset();
+
11995 
+
11996  bool operator==(const Entity<TSeq> & other) const;
+
11997  bool operator!=(const Entity<TSeq> & other) const {return !operator==(other);};
+
11998 
+
11999 };
+
12000 
+
12001 
+
12002 #endif
+
12003 /*//////////////////////////////////////////////////////////////////////////////
+
12005 
+
12006  End of -include/epiworld/entity-bones.hpp-
+
12007 
+
12010 
12011 
-
12012 
-
12013 #ifndef EPIWORLD_ENTITY_MEAT_HPP
-
12014 #define EPIWORLD_ENTITY_MEAT_HPP
-
12015 
-
12016 template<typename TSeq>
-
12017 inline void Entity<TSeq>::add_agent(
-
12018  Agent<TSeq> & p,
-
12019  Model<TSeq> * model
-
12020  )
-
12021 {
-
12022 
-
12023  // Need to add it to the actions, through the individual
-
12024  p.add_entity(*this, model);
-
12025 
-
12026 }
-
12027 
-
12028 template<typename TSeq>
-
12029 inline void Entity<TSeq>::add_agent(
-
12030  Agent<TSeq> * p,
-
12031  Model<TSeq> * model
-
12032  )
-
12033 {
-
12034  p->add_entity(*this, model);
-
12035 }
-
12036 
-
12037 template<typename TSeq>
-
12038 inline void Entity<TSeq>::rm_agent(size_t idx)
-
12039 {
-
12040  if (idx >= n_agents)
-
12041  throw std::out_of_range(
-
12042  "Trying to remove agent "+ std::to_string(idx) +
-
12043  " out of " + std::to_string(n_agents)
-
12044  );
-
12045 
-
12046  model->population[idx].rm_entity(*this);
-
12047 
-
12048  return;
-
12049 }
-
12050 
-
12051 template<typename TSeq>
-
12052 inline size_t Entity<TSeq>::size() const noexcept
-
12053 {
-
12054  return n_agents;
-
12055 }
-
12056 
-
12057 template<typename TSeq>
-
12058 inline void Entity<TSeq>::set_location(std::vector< epiworld_double > loc)
-
12059 {
-
12060  location = loc;
-
12061 }
-
12062 
-
12063 template<typename TSeq>
-
12064 inline std::vector< epiworld_double > & Entity<TSeq>::get_location()
-
12065 {
-
12066  return location;
-
12067 }
-
12068 
-
12069 template<typename TSeq>
-
12070 inline typename std::vector< Agent<TSeq> * >::iterator Entity<TSeq>::begin()
-
12071 {
-
12072 
-
12073  if (n_agents == 0)
-
12074  return agents.end();
-
12075 
-
12076  return agents.begin();
-
12077 
-
12078 }
-
12079 
-
12080 template<typename TSeq>
-
12081 inline typename std::vector< Agent<TSeq> * >::iterator Entity<TSeq>::end()
-
12082 {
-
12083  return agents.begin() + n_agents;
-
12084 }
+
12012 /*//////////////////////////////////////////////////////////////////////////////
+
12014 
+
12015  Start of -include/epiworld/entity-meat.hpp-
+
12016 
+
12019 
+
12020 
+
12021 #ifndef EPIWORLD_ENTITY_MEAT_HPP
+
12022 #define EPIWORLD_ENTITY_MEAT_HPP
+
12023 
+
12024 template<typename TSeq>
+
12025 inline void Entity<TSeq>::add_agent(
+
12026  Agent<TSeq> & p,
+
12027  Model<TSeq> * model
+
12028  )
+
12029 {
+
12030 
+
12031  // Need to add it to the actions, through the individual
+
12032  p.add_entity(*this, model);
+
12033 
+
12034 }
+
12035 
+
12036 template<typename TSeq>
+
12037 inline void Entity<TSeq>::add_agent(
+
12038  Agent<TSeq> * p,
+
12039  Model<TSeq> * model
+
12040  )
+
12041 {
+
12042  p->add_entity(*this, model);
+
12043 }
+
12044 
+
12045 template<typename TSeq>
+
12046 inline void Entity<TSeq>::rm_agent(size_t idx)
+
12047 {
+
12048  if (idx >= n_agents)
+
12049  throw std::out_of_range(
+
12050  "Trying to remove agent "+ std::to_string(idx) +
+
12051  " out of " + std::to_string(n_agents)
+
12052  );
+
12053 
+
12054  model->population[idx].rm_entity(*this);
+
12055 
+
12056  return;
+
12057 }
+
12058 
+
12059 template<typename TSeq>
+
12060 inline size_t Entity<TSeq>::size() const noexcept
+
12061 {
+
12062  return n_agents;
+
12063 }
+
12064 
+
12065 template<typename TSeq>
+
12066 inline void Entity<TSeq>::set_location(std::vector< epiworld_double > loc)
+
12067 {
+
12068  location = loc;
+
12069 }
+
12070 
+
12071 template<typename TSeq>
+
12072 inline std::vector< epiworld_double > & Entity<TSeq>::get_location()
+
12073 {
+
12074  return location;
+
12075 }
+
12076 
+
12077 template<typename TSeq>
+
12078 inline typename std::vector< Agent<TSeq> * >::iterator Entity<TSeq>::begin()
+
12079 {
+
12080 
+
12081  if (n_agents == 0)
+
12082  return agents.end();
+
12083 
+
12084  return agents.begin();
12085 
-
12086 template<typename TSeq>
-
12087 inline typename std::vector< Agent<TSeq> * >::const_iterator Entity<TSeq>::begin() const
-
12088 {
-
12089 
-
12090  if (n_agents == 0)
-
12091  return agents.end();
-
12092 
-
12093  return agents.begin();
-
12094 
-
12095 }
-
12096 
-
12097 template<typename TSeq>
-
12098 inline typename std::vector< Agent<TSeq> * >::const_iterator Entity<TSeq>::end() const
-
12099 {
-
12100  return agents.begin() + n_agents;
-
12101 }
+
12086 }
+
12087 
+
12088 template<typename TSeq>
+
12089 inline typename std::vector< Agent<TSeq> * >::iterator Entity<TSeq>::end()
+
12090 {
+
12091  return agents.begin() + n_agents;
+
12092 }
+
12093 
+
12094 template<typename TSeq>
+
12095 inline typename std::vector< Agent<TSeq> * >::const_iterator Entity<TSeq>::begin() const
+
12096 {
+
12097 
+
12098  if (n_agents == 0)
+
12099  return agents.end();
+
12100 
+
12101  return agents.begin();
12102 
-
12103 template<typename TSeq>
-
12104 inline Agent<TSeq> * Entity<TSeq>::operator[](size_t i)
-
12105 {
-
12106  if (n_agents <= i)
-
12107  throw std::logic_error("There are not that many agents in this entity.");
-
12108 
-
12109  return &model->get_agents()[i];
-
12110 }
-
12111 
-
12112 template<typename TSeq>
-
12113 inline int Entity<TSeq>::get_id() const noexcept
-
12114 {
-
12115  return id;
-
12116 }
-
12117 
-
12118 template<typename TSeq>
-
12119 inline const std::string & Entity<TSeq>::get_name() const noexcept
-
12120 {
-
12121  return entity_name;
-
12122 }
-
12123 
-
12124 template<typename TSeq>
-
12125 inline void Entity<TSeq>::set_state(
-
12126  epiworld_fast_int init,
-
12127  epiworld_fast_int end
-
12128 )
-
12129 {
-
12130  state_init = init;
-
12131  state_post = end;
-
12132 }
-
12133 
-
12134 template<typename TSeq>
-
12135 inline void Entity<TSeq>::set_queue(
-
12136  epiworld_fast_int init,
-
12137  epiworld_fast_int end
-
12138 )
-
12139 {
-
12140  queue_init = init;
-
12141  queue_post = end;
-
12142 }
-
12143 
-
12144 template<typename TSeq>
-
12145 inline void Entity<TSeq>::get_state(
-
12146  epiworld_fast_int * init,
-
12147  epiworld_fast_int * post
-
12148 )
-
12149 {
-
12150  if (init != nullptr)
-
12151  *init = state_init;
-
12152 
-
12153  if (post != nullptr)
-
12154  *post = state_post;
-
12155 
-
12156 }
-
12157 
-
12158 template<typename TSeq>
-
12159 inline void Entity<TSeq>::get_queue(
-
12160  epiworld_fast_int * init,
-
12161  epiworld_fast_int * post
-
12162 )
-
12163 {
-
12164  if (init != nullptr)
-
12165  *init = queue_init;
-
12166 
-
12167  if (post != nullptr)
-
12168  *post = queue_post;
-
12169 
-
12170 }
-
12171 
-
12172 template<typename TSeq>
-
12173 inline void Entity<TSeq>::reset()
-
12174 {
-
12175  sampled_agents.clear();
-
12176  sampled_agents_n = 0u;
-
12177  sampled_agents_left.clear();
-
12178  sampled_agents_left_n = 0u;
-
12179 }
-
12180 
-
12181 template<typename TSeq>
-
12182 inline bool Entity<TSeq>::operator==(const Entity<TSeq> & other) const
-
12183 {
-
12184 
-
12185  if (id != other.id)
-
12186  return false;
-
12187 
-
12188  if (n_agents != other.n_agents)
-
12189  return false;
-
12190 
-
12191  for (size_t i = 0u; i < n_agents; ++i)
-
12192  {
-
12193  if (agents[i] != other.agents[i])
-
12194  return false;
-
12195  }
-
12196 
-
12197 
-
12198  if (max_capacity != other.max_capacity)
-
12199  return false;
-
12200 
-
12201  if (entity_name != other.entity_name)
-
12202  return false;
-
12203 
-
12204  if (location.size() != other.location.size())
-
12205  return false;
-
12206 
-
12207  for (size_t i = 0u; i < location.size(); ++i)
-
12208  {
-
12209 
-
12210  if (location[i] != other.location[i])
-
12211  return false;
-
12212 
-
12213  }
+
12103 }
+
12104 
+
12105 template<typename TSeq>
+
12106 inline typename std::vector< Agent<TSeq> * >::const_iterator Entity<TSeq>::end() const
+
12107 {
+
12108  return agents.begin() + n_agents;
+
12109 }
+
12110 
+
12111 template<typename TSeq>
+
12112 inline Agent<TSeq> * Entity<TSeq>::operator[](size_t i)
+
12113 {
+
12114  if (n_agents <= i)
+
12115  throw std::logic_error("There are not that many agents in this entity.");
+
12116 
+
12117  return &model->get_agents()[i];
+
12118 }
+
12119 
+
12120 template<typename TSeq>
+
12121 inline int Entity<TSeq>::get_id() const noexcept
+
12122 {
+
12123  return id;
+
12124 }
+
12125 
+
12126 template<typename TSeq>
+
12127 inline const std::string & Entity<TSeq>::get_name() const noexcept
+
12128 {
+
12129  return entity_name;
+
12130 }
+
12131 
+
12132 template<typename TSeq>
+
12133 inline void Entity<TSeq>::set_state(
+
12134  epiworld_fast_int init,
+
12135  epiworld_fast_int end
+
12136 )
+
12137 {
+
12138  state_init = init;
+
12139  state_post = end;
+
12140 }
+
12141 
+
12142 template<typename TSeq>
+
12143 inline void Entity<TSeq>::set_queue(
+
12144  epiworld_fast_int init,
+
12145  epiworld_fast_int end
+
12146 )
+
12147 {
+
12148  queue_init = init;
+
12149  queue_post = end;
+
12150 }
+
12151 
+
12152 template<typename TSeq>
+
12153 inline void Entity<TSeq>::get_state(
+
12154  epiworld_fast_int * init,
+
12155  epiworld_fast_int * post
+
12156 )
+
12157 {
+
12158  if (init != nullptr)
+
12159  *init = state_init;
+
12160 
+
12161  if (post != nullptr)
+
12162  *post = state_post;
+
12163 
+
12164 }
+
12165 
+
12166 template<typename TSeq>
+
12167 inline void Entity<TSeq>::get_queue(
+
12168  epiworld_fast_int * init,
+
12169  epiworld_fast_int * post
+
12170 )
+
12171 {
+
12172  if (init != nullptr)
+
12173  *init = queue_init;
+
12174 
+
12175  if (post != nullptr)
+
12176  *post = queue_post;
+
12177 
+
12178 }
+
12179 
+
12180 template<typename TSeq>
+
12181 inline void Entity<TSeq>::reset()
+
12182 {
+
12183  sampled_agents.clear();
+
12184  sampled_agents_n = 0u;
+
12185  sampled_agents_left.clear();
+
12186  sampled_agents_left_n = 0u;
+
12187 }
+
12188 
+
12189 template<typename TSeq>
+
12190 inline bool Entity<TSeq>::operator==(const Entity<TSeq> & other) const
+
12191 {
+
12192 
+
12193  if (id != other.id)
+
12194  return false;
+
12195 
+
12196  if (n_agents != other.n_agents)
+
12197  return false;
+
12198 
+
12199  for (size_t i = 0u; i < n_agents; ++i)
+
12200  {
+
12201  if (agents[i] != other.agents[i])
+
12202  return false;
+
12203  }
+
12204 
+
12205 
+
12206  if (max_capacity != other.max_capacity)
+
12207  return false;
+
12208 
+
12209  if (entity_name != other.entity_name)
+
12210  return false;
+
12211 
+
12212  if (location.size() != other.location.size())
+
12213  return false;
12214 
-
12215  if (state_init != other.state_init)
-
12216  return false;
+
12215  for (size_t i = 0u; i < location.size(); ++i)
+
12216  {
12217 
-
12218  if (state_post != other.state_post)
-
12219  return false;
+
12218  if (location[i] != other.location[i])
+
12219  return false;
12220 
-
12221  if (queue_init != other.queue_init)
-
12222  return false;
-
12223 
-
12224  if (queue_post != other.queue_post)
-
12225  return false;
-
12226 
-
12227  return true;
+
12221  }
+
12222 
+
12223  if (state_init != other.state_init)
+
12224  return false;
+
12225 
+
12226  if (state_post != other.state_post)
+
12227  return false;
12228 
-
12229 }
-
12230 
-
12231 #endif
-
12232 /*//////////////////////////////////////////////////////////////////////////////
+
12229  if (queue_init != other.queue_init)
+
12230  return false;
+
12231 
+
12232  if (queue_post != other.queue_post)
+
12233  return false;
12234 
-
12235  End of -include/epiworld/entity-meat.hpp-
+
12235  return true;
12236 
-
12239 
-
12240 
-
12241 
-
12242 /*//////////////////////////////////////////////////////////////////////////////
+
12237 }
+
12238 
+
12239 #endif
+
12240 /*//////////////////////////////////////////////////////////////////////////////
+
12242 
+
12243  End of -include/epiworld/entity-meat.hpp-
12244 
-
12245  Start of -include/epiworld/entities-bones.hpp-
-
12246 
+
12247 
+
12248 
12249 
-
12250 
-
12251 #ifndef EPIWORLD_ENTITIES_BONES_HPP
-
12252 #define EPIWORLD_ENTITIES_BONES_HPP
-
12253 
-
12254 template<typename TSeq>
-
12255 class Virus;
-
12256 
-
12257 template<typename TSeq>
-
12258 class Agent;
-
12259 
-
12260 
-
12266 template<typename TSeq>
-
12267 class Entities {
-
12268  friend class Entity<TSeq>;
-
12269  friend class Agent<TSeq>;
-
12270 private:
-
12271  std::vector< Entity<TSeq> * > dat;
-
12272  const size_t n_entities;
-
12273 
-
12274 public:
-
12275 
-
12276  Entities() = delete;
-
12277  Entities(Agent<TSeq> & p);
-
12278 
-
12279  typename std::vector< Entity<TSeq> * >::iterator begin();
-
12280  typename std::vector< Entity<TSeq> * >::iterator end();
+
12250 /*//////////////////////////////////////////////////////////////////////////////
+
12252 
+
12253  Start of -include/epiworld/entities-bones.hpp-
+
12254 
+
12257 
+
12258 
+
12259 #ifndef EPIWORLD_ENTITIES_BONES_HPP
+
12260 #define EPIWORLD_ENTITIES_BONES_HPP
+
12261 
+
12262 template<typename TSeq>
+
12263 class Virus;
+
12264 
+
12265 template<typename TSeq>
+
12266 class Agent;
+
12267 
+
12268 
+
12274 template<typename TSeq>
+
12275 class Entities {
+
12276  friend class Entity<TSeq>;
+
12277  friend class Agent<TSeq>;
+
12278 private:
+
12279  std::vector< Entity<TSeq> * > dat;
+
12280  const size_t n_entities;
12281 
-
12282  Entity<TSeq> & operator()(size_t i);
-
12283  Entity<TSeq> & operator[](size_t i);
-
12284 
-
12285  size_t size() const noexcept;
+
12282 public:
+
12283 
+
12284  Entities() = delete;
+
12285  Entities(Agent<TSeq> & p);
12286 
-
12287  bool operator==(const Entities<TSeq> & other) const;
-
12288 
-
12289 };
-
12290 
-
12291 template<typename TSeq>
-
12292 inline Entities<TSeq>::Entities(Agent<TSeq> & p) :
-
12293  n_entities(p.get_n_entities())
-
12294 {
-
12295 
-
12296  dat.reserve(n_entities);
-
12297  for (size_t i = 0u; i < n_entities; ++i)
-
12298  dat.push_back(&p.get_entity(i));
-
12299 
-
12300 }
-
12301 
-
12302 template<typename TSeq>
-
12303 inline typename std::vector< Entity<TSeq>* >::iterator Entities<TSeq>::begin()
-
12304 {
-
12305 
-
12306  if (n_entities == 0u)
-
12307  return dat.end();
-
12308 
-
12309  return dat.begin();
-
12310 }
-
12311 
-
12312 template<typename TSeq>
-
12313 inline typename std::vector< Entity<TSeq>* >::iterator Entities<TSeq>::end()
-
12314 {
-
12315 
-
12316  return begin() + n_entities;
-
12317 }
-
12318 
-
12319 template<typename TSeq>
-
12320 inline Entity<TSeq> & Entities<TSeq>::operator()(size_t i)
-
12321 {
-
12322 
-
12323  if (i >= n_entities)
-
12324  throw std::range_error("Entity index out of range.");
-
12325 
-
12326  return *dat[i];
-
12327 
-
12328 }
-
12329 
-
12330 template<typename TSeq>
-
12331 inline Entity<TSeq> & Entities<TSeq>::operator[](size_t i)
-
12332 {
+
12287  typename std::vector< Entity<TSeq> * >::iterator begin();
+
12288  typename std::vector< Entity<TSeq> * >::iterator end();
+
12289 
+
12290  Entity<TSeq> & operator()(size_t i);
+
12291  Entity<TSeq> & operator[](size_t i);
+
12292 
+
12293  size_t size() const noexcept;
+
12294 
+
12295  bool operator==(const Entities<TSeq> & other) const;
+
12296 
+
12297 };
+
12298 
+
12299 template<typename TSeq>
+
12300 inline Entities<TSeq>::Entities(Agent<TSeq> & p) :
+
12301  n_entities(p.get_n_entities())
+
12302 {
+
12303 
+
12304  dat.reserve(n_entities);
+
12305  for (size_t i = 0u; i < n_entities; ++i)
+
12306  dat.push_back(&p.get_entity(i));
+
12307 
+
12308 }
+
12309 
+
12310 template<typename TSeq>
+
12311 inline typename std::vector< Entity<TSeq>* >::iterator Entities<TSeq>::begin()
+
12312 {
+
12313 
+
12314  if (n_entities == 0u)
+
12315  return dat.end();
+
12316 
+
12317  return dat.begin();
+
12318 }
+
12319 
+
12320 template<typename TSeq>
+
12321 inline typename std::vector< Entity<TSeq>* >::iterator Entities<TSeq>::end()
+
12322 {
+
12323 
+
12324  return begin() + n_entities;
+
12325 }
+
12326 
+
12327 template<typename TSeq>
+
12328 inline Entity<TSeq> & Entities<TSeq>::operator()(size_t i)
+
12329 {
+
12330 
+
12331  if (i >= n_entities)
+
12332  throw std::range_error("Entity index out of range.");
12333 
12334  return *dat[i];
12335 
12336 }
12337 
12338 template<typename TSeq>
-
12339 inline size_t Entities<TSeq>::size() const noexcept
+
12339 inline Entity<TSeq> & Entities<TSeq>::operator[](size_t i)
12340 {
-
12341  return n_entities;
-
12342 }
+
12341 
+
12342  return *dat[i];
12343 
-
12344 template<typename TSeq>
-
12345 inline bool Entities<TSeq>::operator==(const Entities<TSeq> & other) const
-
12346 {
-
12347 
-
12348  if (n_entities != other.n_entities)
-
12349  return false;
-
12350 
-
12351  for (size_t i = 0u; i < dat.size(); ++i)
-
12352  {
-
12353  if (dat[i] != other.dat[i])
-
12354  return false;
-
12355  }
-
12356 
-
12357  return true;
-
12358 }
-
12359 
-
12365 template<typename TSeq>
-
12366 class Entities_const {
-
12367  friend class Virus<TSeq>;
-
12368  friend class Agent<TSeq>;
-
12369 private:
-
12370  const std::vector< Entity<TSeq>* > dat;
-
12371  const size_t n_entities;
-
12372 
-
12373 public:
-
12374 
-
12375  Entities_const() = delete;
-
12376  Entities_const(const Agent<TSeq> & p);
-
12377 
-
12378  typename std::vector< Entity<TSeq>* >::const_iterator begin();
-
12379  typename std::vector< Entity<TSeq>* >::const_iterator end();
+
12344 }
+
12345 
+
12346 template<typename TSeq>
+
12347 inline size_t Entities<TSeq>::size() const noexcept
+
12348 {
+
12349  return n_entities;
+
12350 }
+
12351 
+
12352 template<typename TSeq>
+
12353 inline bool Entities<TSeq>::operator==(const Entities<TSeq> & other) const
+
12354 {
+
12355 
+
12356  if (n_entities != other.n_entities)
+
12357  return false;
+
12358 
+
12359  for (size_t i = 0u; i < dat.size(); ++i)
+
12360  {
+
12361  if (dat[i] != other.dat[i])
+
12362  return false;
+
12363  }
+
12364 
+
12365  return true;
+
12366 }
+
12367 
+
12373 template<typename TSeq>
+
12374 class Entities_const {
+
12375  friend class Virus<TSeq>;
+
12376  friend class Agent<TSeq>;
+
12377 private:
+
12378  const std::vector< Entity<TSeq>* > dat;
+
12379  const size_t n_entities;
12380 
-
12381  const Entity<TSeq> & operator()(size_t i);
-
12382  const Entity<TSeq> & operator[](size_t i);
-
12383 
-
12384  size_t size() const noexcept;
+
12381 public:
+
12382 
+
12383  Entities_const() = delete;
+
12384  Entities_const(const Agent<TSeq> & p);
12385 
-
12386  bool operator==(const Entities_const<TSeq> & other) const;
-
12387 
-
12388 };
-
12389 
-
12390 template<typename TSeq>
-
12391 inline Entities_const<TSeq>::Entities_const(const Agent<TSeq> & p) :
-
12392  n_entities(p.get_n_entities())
-
12393 {
-
12394 
-
12395  dat.reserve(n_entities);
-
12396  for (size_t i = 0u; i < n_entities; ++i)
-
12397  dat.push_back(&p.get_entity(i));
-
12398 
-
12399 }
-
12400 
-
12401 template<typename TSeq>
-
12402 inline typename std::vector< Entity<TSeq>* >::const_iterator Entities_const<TSeq>::begin() {
-
12403 
-
12404  if (n_entities == 0u)
-
12405  return dat.end();
-
12406 
-
12407  return dat.begin();
-
12408 }
-
12409 
-
12410 template<typename TSeq>
-
12411 inline typename std::vector< Entity<TSeq>* >::const_iterator Entities_const<TSeq>::end() {
-
12412 
-
12413  return begin() + n_entities;
-
12414 }
-
12415 
-
12416 template<typename TSeq>
-
12417 inline const Entity<TSeq> & Entities_const<TSeq>::operator()(size_t i)
-
12418 {
-
12419 
-
12420  if (i >= n_entities)
-
12421  throw std::range_error("Entity index out of range.");
-
12422 
-
12423  return *dat[i];
-
12424 
-
12425 }
-
12426 
-
12427 template<typename TSeq>
-
12428 inline const Entity<TSeq> & Entities_const<TSeq>::operator[](size_t i)
-
12429 {
+
12386  typename std::vector< Entity<TSeq>* >::const_iterator begin();
+
12387  typename std::vector< Entity<TSeq>* >::const_iterator end();
+
12388 
+
12389  const Entity<TSeq> & operator()(size_t i);
+
12390  const Entity<TSeq> & operator[](size_t i);
+
12391 
+
12392  size_t size() const noexcept;
+
12393 
+
12394  bool operator==(const Entities_const<TSeq> & other) const;
+
12395 
+
12396 };
+
12397 
+
12398 template<typename TSeq>
+
12399 inline Entities_const<TSeq>::Entities_const(const Agent<TSeq> & p) :
+
12400  n_entities(p.get_n_entities())
+
12401 {
+
12402 
+
12403  dat.reserve(n_entities);
+
12404  for (size_t i = 0u; i < n_entities; ++i)
+
12405  dat.push_back(&p.get_entity(i));
+
12406 
+
12407 }
+
12408 
+
12409 template<typename TSeq>
+
12410 inline typename std::vector< Entity<TSeq>* >::const_iterator Entities_const<TSeq>::begin() {
+
12411 
+
12412  if (n_entities == 0u)
+
12413  return dat.end();
+
12414 
+
12415  return dat.begin();
+
12416 }
+
12417 
+
12418 template<typename TSeq>
+
12419 inline typename std::vector< Entity<TSeq>* >::const_iterator Entities_const<TSeq>::end() {
+
12420 
+
12421  return begin() + n_entities;
+
12422 }
+
12423 
+
12424 template<typename TSeq>
+
12425 inline const Entity<TSeq> & Entities_const<TSeq>::operator()(size_t i)
+
12426 {
+
12427 
+
12428  if (i >= n_entities)
+
12429  throw std::range_error("Entity index out of range.");
12430 
12431  return *dat[i];
12432 
12433 }
12434 
12435 template<typename TSeq>
-
12436 inline size_t Entities_const<TSeq>::size() const noexcept
+
12436 inline const Entity<TSeq> & Entities_const<TSeq>::operator[](size_t i)
12437 {
-
12438  return n_entities;
-
12439 }
+
12438 
+
12439  return *dat[i];
12440 
-
12441 template<typename TSeq>
-
12442 inline bool Entities_const<TSeq>::operator==(const Entities_const<TSeq> & other) const
-
12443 {
-
12444 
-
12445  if (n_entities != other.n_entities)
-
12446  return false;
-
12447 
-
12448  for (size_t i = 0u; i < dat.size(); ++i)
-
12449  {
-
12450  if (dat[i] != other.dat[i])
-
12451  return false;
-
12452  }
-
12453 
-
12454  return true;
-
12455 }
-
12456 
-
12457 
-
12458 #endif
-
12459 /*//////////////////////////////////////////////////////////////////////////////
+
12441 }
+
12442 
+
12443 template<typename TSeq>
+
12444 inline size_t Entities_const<TSeq>::size() const noexcept
+
12445 {
+
12446  return n_entities;
+
12447 }
+
12448 
+
12449 template<typename TSeq>
+
12450 inline bool Entities_const<TSeq>::operator==(const Entities_const<TSeq> & other) const
+
12451 {
+
12452 
+
12453  if (n_entities != other.n_entities)
+
12454  return false;
+
12455 
+
12456  for (size_t i = 0u; i < dat.size(); ++i)
+
12457  {
+
12458  if (dat[i] != other.dat[i])
+
12459  return false;
+
12460  }
12461 
-
12462  End of -include/epiworld/entities-bones.hpp-
-
12463 
-
12466 
-
12467 
-
12468 
-
12469 /*//////////////////////////////////////////////////////////////////////////////
+
12462  return true;
+
12463 }
+
12464 
+
12465 
+
12466 #endif
+
12467 /*//////////////////////////////////////////////////////////////////////////////
+
12469 
+
12470  End of -include/epiworld/entities-bones.hpp-
12471 
-
12472  Start of -include/epiworld/agent-meat-state.hpp-
-
12473 
-
12476 
-
12477 
-
12478 #ifndef EPIWORLD_PERSON_MEAT_STATE_HPP
-
12479 #define EPIWORLD_PERSON_MEAT_STATE_HPP
-
12480 
-
12481 // template<typename TSeq>
-
12482 // class Model;
-
12483 
-
12484 // template<typename TSeq>
-
12485 // class Agent;
-
12486 
-
12487 
-
12498 /*//////////////////////////////////////////////////////////////////////////////
-
12500 
-
12501  Start of -include/epiworld//agent-meat-virus-sampling.hpp-
-
12502 
-
12505 
-
12506 
-
12507 #ifndef EPIWORLD_AGENT_MEAT_VIRUS_SAMPLING
-
12508 #define EPIWORLD_AGENT_MEAT_VIRUS_SAMPLING
-
12509 
-
12514 namespace sampler {
-
12515 
-
12529 template<typename TSeq>
-
12530 inline std::function<void(Agent<TSeq>*,Model<TSeq>*)> make_update_susceptible(
-
12531  std::vector< epiworld_fast_uint > exclude = {}
-
12532  )
-
12533 {
-
12534 
-
12535 
-
12536  if (exclude.size() == 0u)
-
12537  {
-
12538 
-
12539  std::function<void(Agent<TSeq>*,Model<TSeq>*)> sampler =
-
12540  [](Agent<TSeq> * p, Model<TSeq> * m) -> void
-
12541  {
-
12542 
-
12543  if (p->get_virus() != nullptr)
-
12544  throw std::logic_error(
-
12545  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
-
12546  std::string("Agent id ") + std::to_string(p->get_id()) +
-
12547  std::string(" has a virus.")
-
12548  );
-
12549 
-
12550  // This computes the prob of getting any neighbor variant
-
12551  size_t nviruses_tmp = 0u;
-
12552  for (auto & neighbor: p->get_neighbors())
-
12553  {
-
12554 
-
12555  auto & v = neighbor->get_virus();
-
12556  if (v == nullptr)
-
12557  continue;
-
12558 
-
12559  /* And it is a function of susceptibility_reduction as well */
-
12560  m->array_double_tmp[nviruses_tmp] =
-
12561  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
12562  v->get_prob_infecting(m) *
-
12563  (1.0 - neighbor->get_transmission_reduction(v, m))
-
12564  ;
-
12565 
-
12566  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
12567 
-
12568  }
-
12569 
-
12570  // No virus to compute
-
12571  if (nviruses_tmp == 0u)
-
12572  return;
-
12573 
-
12574  // Running the roulette
-
12575  int which = roulette(nviruses_tmp, m);
-
12576 
-
12577  if (which < 0)
-
12578  return;
-
12579 
-
12580  p->set_virus(*m->array_virus_tmp[which], m);
+
12474 
+
12475 
+
12476 
+
12477 /*//////////////////////////////////////////////////////////////////////////////
+
12479 
+
12480  Start of -include/epiworld/agent-meat-state.hpp-
+
12481 
+
12484 
+
12485 
+
12486 #ifndef EPIWORLD_PERSON_MEAT_STATE_HPP
+
12487 #define EPIWORLD_PERSON_MEAT_STATE_HPP
+
12488 
+
12489 // template<typename TSeq>
+
12490 // class Model;
+
12491 
+
12492 // template<typename TSeq>
+
12493 // class Agent;
+
12494 
+
12495 
+
12506 /*//////////////////////////////////////////////////////////////////////////////
+
12508 
+
12509  Start of -include/epiworld//agent-meat-virus-sampling.hpp-
+
12510 
+
12513 
+
12514 
+
12515 #ifndef EPIWORLD_AGENT_MEAT_VIRUS_SAMPLING
+
12516 #define EPIWORLD_AGENT_MEAT_VIRUS_SAMPLING
+
12517 
+
12522 namespace sampler {
+
12523 
+
12537 template<typename TSeq>
+
12538 inline std::function<void(Agent<TSeq>*,Model<TSeq>*)> make_update_susceptible(
+
12539  std::vector< epiworld_fast_uint > exclude = {}
+
12540  )
+
12541 {
+
12542 
+
12543 
+
12544  if (exclude.size() == 0u)
+
12545  {
+
12546 
+
12547  std::function<void(Agent<TSeq>*,Model<TSeq>*)> sampler =
+
12548  [](Agent<TSeq> * p, Model<TSeq> * m) -> void
+
12549  {
+
12550 
+
12551  if (p->get_virus() != nullptr)
+
12552  throw std::logic_error(
+
12553  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
+
12554  std::string("Agent id ") + std::to_string(p->get_id()) +
+
12555  std::string(" has a virus.")
+
12556  );
+
12557 
+
12558  // This computes the prob of getting any neighbor variant
+
12559  size_t nviruses_tmp = 0u;
+
12560  for (auto & neighbor: p->get_neighbors())
+
12561  {
+
12562 
+
12563  auto & v = neighbor->get_virus();
+
12564  if (v == nullptr)
+
12565  continue;
+
12566 
+
12567  /* And it is a function of susceptibility_reduction as well */
+
12568  m->array_double_tmp[nviruses_tmp] =
+
12569  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
12570  v->get_prob_infecting(m) *
+
12571  (1.0 - neighbor->get_transmission_reduction(v, m))
+
12572  ;
+
12573 
+
12574  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
12575 
+
12576  }
+
12577 
+
12578  // No virus to compute
+
12579  if (nviruses_tmp == 0u)
+
12580  return;
12581 
-
12582  return;
-
12583  };
+
12582  // Running the roulette
+
12583  int which = roulette(nviruses_tmp, m);
12584 
-
12585  return sampler;
-
12586 
-
12587  } else {
-
12588 
-
12589  // Making room for the query
-
12590  std::shared_ptr<std::vector<bool>> exclude_agent_bool =
-
12591  std::make_shared<std::vector<bool>>(0);
+
12585  if (which < 0)
+
12586  return;
+
12587 
+
12588  p->set_virus(*m->array_virus_tmp[which], m);
+
12589 
+
12590  return;
+
12591  };
12592 
-
12593  std::shared_ptr<std::vector<epiworld_fast_uint>> exclude_agent_bool_idx =
-
12594  std::make_shared<std::vector<epiworld_fast_uint>>(exclude);
-
12595 
-
12596  std::function<void(Agent<TSeq>*,Model<TSeq>*)> sampler =
-
12597  [exclude_agent_bool,exclude_agent_bool_idx](Agent<TSeq> * p, Model<TSeq> * m) -> void
-
12598  {
-
12599 
-
12600  // The first time we call it, we need to initialize the vector
-
12601  if (exclude_agent_bool->size() == 0u)
-
12602  {
+
12593  return sampler;
+
12594 
+
12595  } else {
+
12596 
+
12597  // Making room for the query
+
12598  std::shared_ptr<std::vector<bool>> exclude_agent_bool =
+
12599  std::make_shared<std::vector<bool>>(0);
+
12600 
+
12601  std::shared_ptr<std::vector<epiworld_fast_uint>> exclude_agent_bool_idx =
+
12602  std::make_shared<std::vector<epiworld_fast_uint>>(exclude);
12603 
-
12604  exclude_agent_bool->resize(m->get_states().size(), false);
-
12605  for (auto s : *exclude_agent_bool_idx)
-
12606  {
-
12607  if (s >= exclude_agent_bool->size())
-
12608  throw std::logic_error(
-
12609  std::string("You are trying to exclude a state that is out of range: ") +
-
12610  std::to_string(s) + std::string(". There are only ") +
-
12611  std::to_string(exclude_agent_bool->size()) +
-
12612  std::string(" states in the model.")
-
12613  );
-
12614 
-
12615  exclude_agent_bool->operator[](s) = true;
-
12616 
-
12617  }
-
12618 
-
12619  }
-
12620 
-
12621  if (p->get_virus() != nullptr)
-
12622  throw std::logic_error(
-
12623  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
-
12624  std::string("Agent id ") + std::to_string(p->get_id()) +
-
12625  std::string(" has a virus.")
-
12626  );
-
12627 
-
12628  // This computes the prob of getting any neighbor variant
-
12629  size_t nviruses_tmp = 0u;
-
12630  for (auto & neighbor: p->get_neighbors())
-
12631  {
-
12632 
-
12633  // If the state is in the list, exclude it
-
12634  if (exclude_agent_bool->operator[](neighbor->get_state()))
-
12635  continue;
-
12636 
-
12637  auto & v = neighbor->get_virus();
-
12638  if (v == nullptr)
-
12639  continue;
-
12640 
-
12641 
-
12642  /* And it is a function of susceptibility_reduction as well */
-
12643  m->array_double_tmp[nviruses_tmp] =
-
12644  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
12645  v->get_prob_infecting(m) *
-
12646  (1.0 - neighbor->get_transmission_reduction(v, m))
-
12647  ;
-
12648 
-
12649  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
12650 
-
12651  }
-
12652 
-
12653  // No virus to compute
-
12654  if (nviruses_tmp == 0u)
-
12655  return;
-
12656 
-
12657  // Running the roulette
-
12658  int which = roulette(nviruses_tmp, m);
-
12659 
-
12660  if (which < 0)
-
12661  return;
-
12662 
-
12663  p->set_virus(*m->array_virus_tmp[which], m);
+
12604  std::function<void(Agent<TSeq>*,Model<TSeq>*)> sampler =
+
12605  [exclude_agent_bool,exclude_agent_bool_idx](Agent<TSeq> * p, Model<TSeq> * m) -> void
+
12606  {
+
12607 
+
12608  // The first time we call it, we need to initialize the vector
+
12609  if (exclude_agent_bool->size() == 0u)
+
12610  {
+
12611 
+
12612  exclude_agent_bool->resize(m->get_states().size(), false);
+
12613  for (auto s : *exclude_agent_bool_idx)
+
12614  {
+
12615  if (s >= exclude_agent_bool->size())
+
12616  throw std::logic_error(
+
12617  std::string("You are trying to exclude a state that is out of range: ") +
+
12618  std::to_string(s) + std::string(". There are only ") +
+
12619  std::to_string(exclude_agent_bool->size()) +
+
12620  std::string(" states in the model.")
+
12621  );
+
12622 
+
12623  exclude_agent_bool->operator[](s) = true;
+
12624 
+
12625  }
+
12626 
+
12627  }
+
12628 
+
12629  if (p->get_virus() != nullptr)
+
12630  throw std::logic_error(
+
12631  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
+
12632  std::string("Agent id ") + std::to_string(p->get_id()) +
+
12633  std::string(" has a virus.")
+
12634  );
+
12635 
+
12636  // This computes the prob of getting any neighbor variant
+
12637  size_t nviruses_tmp = 0u;
+
12638  for (auto & neighbor: p->get_neighbors())
+
12639  {
+
12640 
+
12641  // If the state is in the list, exclude it
+
12642  if (exclude_agent_bool->operator[](neighbor->get_state()))
+
12643  continue;
+
12644 
+
12645  auto & v = neighbor->get_virus();
+
12646  if (v == nullptr)
+
12647  continue;
+
12648 
+
12649 
+
12650  /* And it is a function of susceptibility_reduction as well */
+
12651  m->array_double_tmp[nviruses_tmp] =
+
12652  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
12653  v->get_prob_infecting(m) *
+
12654  (1.0 - neighbor->get_transmission_reduction(v, m))
+
12655  ;
+
12656 
+
12657  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
12658 
+
12659  }
+
12660 
+
12661  // No virus to compute
+
12662  if (nviruses_tmp == 0u)
+
12663  return;
12664 
-
12665  return;
-
12666 
-
12667  };
-
12668 
-
12669  return sampler;
+
12665  // Running the roulette
+
12666  int which = roulette(nviruses_tmp, m);
+
12667 
+
12668  if (which < 0)
+
12669  return;
12670 
-
12671  }
-
12672 
-
12673 }
+
12671  p->set_virus(*m->array_virus_tmp[which], m);
+
12672 
+
12673  return;
12674 
-
12688 template<typename TSeq = int>
-
12689 inline std::function<Virus<TSeq>*(Agent<TSeq>*,Model<TSeq>*)> make_sample_virus_neighbors(
-
12690  std::vector< epiworld_fast_uint > exclude = {}
-
12691 )
-
12692 {
-
12693  if (exclude.size() == 0u)
-
12694  {
-
12695 
-
12696  std::function<Virus<TSeq>*(Agent<TSeq>*,Model<TSeq>*)> res =
-
12697  [](Agent<TSeq> * p, Model<TSeq> * m) -> Virus<TSeq>* {
-
12698 
-
12699  if (p->get_virus() != nullptr)
-
12700  throw std::logic_error(
-
12701  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
-
12702  std::string("Agent id ") + std::to_string(p->get_id()) +
-
12703  std::string(" has a virus.")
-
12704  );
-
12705 
-
12706  // This computes the prob of getting any neighbor variant
-
12707  size_t nviruses_tmp = 0u;
-
12708  for (auto & neighbor: p->get_neighbors())
-
12709  {
-
12710 
-
12711  if (neighbor->get_virus() == nullptr)
-
12712  continue;
+
12675  };
+
12676 
+
12677  return sampler;
+
12678 
+
12679  }
+
12680 
+
12681 }
+
12682 
+
12696 template<typename TSeq = int>
+
12697 inline std::function<Virus<TSeq>*(Agent<TSeq>*,Model<TSeq>*)> make_sample_virus_neighbors(
+
12698  std::vector< epiworld_fast_uint > exclude = {}
+
12699 )
+
12700 {
+
12701  if (exclude.size() == 0u)
+
12702  {
+
12703 
+
12704  std::function<Virus<TSeq>*(Agent<TSeq>*,Model<TSeq>*)> res =
+
12705  [](Agent<TSeq> * p, Model<TSeq> * m) -> Virus<TSeq>* {
+
12706 
+
12707  if (p->get_virus() != nullptr)
+
12708  throw std::logic_error(
+
12709  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
+
12710  std::string("Agent id ") + std::to_string(p->get_id()) +
+
12711  std::string(" has a virus.")
+
12712  );
12713 
-
12714  auto & v = neighbor->get_virus();
-
12715 
-
12716  #ifdef EPI_DEBUG
-
12717  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
-
12718  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
12719  #endif
-
12720 
-
12721  /* And it is a function of susceptibility_reduction as well */
-
12722  m->array_double_tmp[nviruses_tmp] =
-
12723  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
12724  v->get_prob_infecting(m) *
-
12725  (1.0 - neighbor->get_transmission_reduction(v, m))
-
12726  ;
-
12727 
-
12728  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
12729 
-
12730  }
-
12731 
-
12732  // No virus to compute
-
12733  if (nviruses_tmp == 0u)
-
12734  return nullptr;
-
12735 
-
12736  // Running the roulette
-
12737  int which = roulette(nviruses_tmp, m);
-
12738 
-
12739  if (which < 0)
-
12740  return nullptr;
-
12741 
-
12742  return m->array_virus_tmp[which];
+
12714  // This computes the prob of getting any neighbor variant
+
12715  size_t nviruses_tmp = 0u;
+
12716  for (auto & neighbor: p->get_neighbors())
+
12717  {
+
12718 
+
12719  if (neighbor->get_virus() == nullptr)
+
12720  continue;
+
12721 
+
12722  auto & v = neighbor->get_virus();
+
12723 
+
12724  #ifdef EPI_DEBUG
+
12725  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
+
12726  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
12727  #endif
+
12728 
+
12729  /* And it is a function of susceptibility_reduction as well */
+
12730  m->array_double_tmp[nviruses_tmp] =
+
12731  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
12732  v->get_prob_infecting(m) *
+
12733  (1.0 - neighbor->get_transmission_reduction(v, m))
+
12734  ;
+
12735 
+
12736  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
12737 
+
12738  }
+
12739 
+
12740  // No virus to compute
+
12741  if (nviruses_tmp == 0u)
+
12742  return nullptr;
12743 
-
12744  };
-
12745 
-
12746  return res;
-
12747 
-
12748 
-
12749  } else {
-
12750 
-
12751  // Making room for the query
-
12752  std::shared_ptr<std::vector<bool>> exclude_agent_bool =
-
12753  std::make_shared<std::vector<bool>>(0);
-
12754 
-
12755  std::shared_ptr<std::vector<epiworld_fast_uint>> exclude_agent_bool_idx =
-
12756  std::make_shared<std::vector<epiworld_fast_uint>>(exclude);
-
12757 
+
12744  // Running the roulette
+
12745  int which = roulette(nviruses_tmp, m);
+
12746 
+
12747  if (which < 0)
+
12748  return nullptr;
+
12749 
+
12750  return m->array_virus_tmp[which];
+
12751 
+
12752  };
+
12753 
+
12754  return res;
+
12755 
+
12756 
+
12757  } else {
12758 
-
12759  std::function<Virus<TSeq>*(Agent<TSeq>*,Model<TSeq>*)> res =
-
12760  [exclude_agent_bool,exclude_agent_bool_idx](Agent<TSeq> * p, Model<TSeq> * m) -> Virus<TSeq>* {
-
12761 
-
12762  // The first time we call it, we need to initialize the vector
-
12763  if (exclude_agent_bool->size() == 0u)
-
12764  {
+
12759  // Making room for the query
+
12760  std::shared_ptr<std::vector<bool>> exclude_agent_bool =
+
12761  std::make_shared<std::vector<bool>>(0);
+
12762 
+
12763  std::shared_ptr<std::vector<epiworld_fast_uint>> exclude_agent_bool_idx =
+
12764  std::make_shared<std::vector<epiworld_fast_uint>>(exclude);
12765 
-
12766  exclude_agent_bool->resize(m->get_states().size(), false);
-
12767  for (auto s : *exclude_agent_bool_idx)
-
12768  {
-
12769  if (s >= exclude_agent_bool->size())
-
12770  throw std::logic_error(
-
12771  std::string("You are trying to exclude a state that is out of range: ") +
-
12772  std::to_string(s) + std::string(". There are only ") +
-
12773  std::to_string(exclude_agent_bool->size()) +
-
12774  std::string(" states in the model.")
-
12775  );
-
12776 
-
12777  exclude_agent_bool->operator[](s) = true;
-
12778 
-
12779  }
-
12780 
-
12781  }
-
12782 
-
12783  if (p->get_virus() != nullptr)
-
12784  throw std::logic_error(
-
12785  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
-
12786  std::string("Agent id ") + std::to_string(p->get_id()) +
-
12787  std::string(" has a virus.")
-
12788  );
-
12789 
-
12790  // This computes the prob of getting any neighbor variant
-
12791  size_t nviruses_tmp = 0u;
-
12792  for (auto & neighbor: p->get_neighbors())
-
12793  {
-
12794 
-
12795  // If the state is in the list, exclude it
-
12796  if (exclude_agent_bool->operator[](neighbor->get_state()))
-
12797  continue;
-
12798 
-
12799  if (neighbor->get_virus() == nullptr)
-
12800  continue;
-
12801 
-
12802  auto & v = neighbor->get_virus();
-
12803 
-
12804  #ifdef EPI_DEBUG
-
12805  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
-
12806  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
12807  #endif
-
12808 
-
12809  /* And it is a function of susceptibility_reduction as well */
-
12810  m->array_double_tmp[nviruses_tmp] =
-
12811  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
12812  v->get_prob_infecting(m) *
-
12813  (1.0 - neighbor->get_transmission_reduction(v, m))
-
12814  ;
-
12815 
-
12816  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
12817 
-
12818  }
-
12819 
-
12820  // No virus to compute
-
12821  if (nviruses_tmp == 0u)
-
12822  return nullptr;
-
12823 
-
12824  // Running the roulette
-
12825  int which = roulette(nviruses_tmp, m);
-
12826 
-
12827  if (which < 0)
-
12828  return nullptr;
-
12829 
-
12830  return m->array_virus_tmp[which];
+
12766 
+
12767  std::function<Virus<TSeq>*(Agent<TSeq>*,Model<TSeq>*)> res =
+
12768  [exclude_agent_bool,exclude_agent_bool_idx](Agent<TSeq> * p, Model<TSeq> * m) -> Virus<TSeq>* {
+
12769 
+
12770  // The first time we call it, we need to initialize the vector
+
12771  if (exclude_agent_bool->size() == 0u)
+
12772  {
+
12773 
+
12774  exclude_agent_bool->resize(m->get_states().size(), false);
+
12775  for (auto s : *exclude_agent_bool_idx)
+
12776  {
+
12777  if (s >= exclude_agent_bool->size())
+
12778  throw std::logic_error(
+
12779  std::string("You are trying to exclude a state that is out of range: ") +
+
12780  std::to_string(s) + std::string(". There are only ") +
+
12781  std::to_string(exclude_agent_bool->size()) +
+
12782  std::string(" states in the model.")
+
12783  );
+
12784 
+
12785  exclude_agent_bool->operator[](s) = true;
+
12786 
+
12787  }
+
12788 
+
12789  }
+
12790 
+
12791  if (p->get_virus() != nullptr)
+
12792  throw std::logic_error(
+
12793  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense! ") +
+
12794  std::string("Agent id ") + std::to_string(p->get_id()) +
+
12795  std::string(" has a virus.")
+
12796  );
+
12797 
+
12798  // This computes the prob of getting any neighbor variant
+
12799  size_t nviruses_tmp = 0u;
+
12800  for (auto & neighbor: p->get_neighbors())
+
12801  {
+
12802 
+
12803  // If the state is in the list, exclude it
+
12804  if (exclude_agent_bool->operator[](neighbor->get_state()))
+
12805  continue;
+
12806 
+
12807  if (neighbor->get_virus() == nullptr)
+
12808  continue;
+
12809 
+
12810  auto & v = neighbor->get_virus();
+
12811 
+
12812  #ifdef EPI_DEBUG
+
12813  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
+
12814  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
12815  #endif
+
12816 
+
12817  /* And it is a function of susceptibility_reduction as well */
+
12818  m->array_double_tmp[nviruses_tmp] =
+
12819  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
12820  v->get_prob_infecting(m) *
+
12821  (1.0 - neighbor->get_transmission_reduction(v, m))
+
12822  ;
+
12823 
+
12824  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
12825 
+
12826  }
+
12827 
+
12828  // No virus to compute
+
12829  if (nviruses_tmp == 0u)
+
12830  return nullptr;
12831 
-
12832  };
-
12833 
-
12834  return res;
-
12835 
-
12836  }
+
12832  // Running the roulette
+
12833  int which = roulette(nviruses_tmp, m);
+
12834 
+
12835  if (which < 0)
+
12836  return nullptr;
12837 
-
12838 }
+
12838  return m->array_virus_tmp[which];
12839 
-
12856 template<typename TSeq = int>
-
12857 inline Virus<TSeq> * sample_virus_single(Agent<TSeq> * p, Model<TSeq> * m)
-
12858 {
-
12859 
-
12860  if (p->get_virus() != nullptr)
-
12861  throw std::logic_error(
-
12862  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense!") +
-
12863  std::string("Agent id ") + std::to_string(p->get_id()) +
-
12864  std::string(" has a virus.")
-
12865  );
-
12866 
-
12867  // This computes the prob of getting any neighbor variant
-
12868  size_t nviruses_tmp = 0u;
-
12869  for (auto & neighbor: p->get_neighbors())
-
12870  {
-
12871  #ifdef EPI_DEBUG
-
12872  int _vcount_neigh = 0;
-
12873  #endif
+
12840  };
+
12841 
+
12842  return res;
+
12843 
+
12844  }
+
12845 
+
12846 }
+
12847 
+
12864 template<typename TSeq = int>
+
12865 inline Virus<TSeq> * sample_virus_single(Agent<TSeq> * p, Model<TSeq> * m)
+
12866 {
+
12867 
+
12868  if (p->get_virus() != nullptr)
+
12869  throw std::logic_error(
+
12870  std::string("Using the -default_update_susceptible- on agents WITH viruses makes no sense!") +
+
12871  std::string("Agent id ") + std::to_string(p->get_id()) +
+
12872  std::string(" has a virus.")
+
12873  );
12874 
-
12875  if (neighbor->get_virus() == nullptr)
-
12876  continue;
-
12877 
-
12878  auto & v = neighbor->get_virus();
-
12879 
-
12880  #ifdef EPI_DEBUG
-
12881  if (nviruses_tmp >= m->array_virus_tmp.size())
-
12882  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
12883  #endif
-
12884 
-
12885  /* And it is a function of susceptibility_reduction as well */
-
12886  m->array_double_tmp[nviruses_tmp] =
-
12887  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
12888  v->get_prob_infecting(m) *
-
12889  (1.0 - neighbor->get_transmission_reduction(v, m))
-
12890  ;
-
12891 
-
12892  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
12893 
-
12894  #ifdef EPI_DEBUG
-
12895  if (
-
12896  (m->array_double_tmp[nviruses_tmp - 1] < 0.0) |
-
12897  (m->array_double_tmp[nviruses_tmp - 1] > 1.0)
-
12898  )
-
12899  {
-
12900  printf_epiworld(
-
12901  "[epi-debug] Agent %i's virus %i has transmission prob outside of [0, 1]: %.4f!\n",
-
12902  static_cast<int>(neighbor->get_id()),
-
12903  static_cast<int>(_vcount_neigh++),
-
12904  m->array_double_tmp[nviruses_tmp - 1]
-
12905  );
-
12906  }
-
12907  #endif
-
12908 
-
12909  }
-
12910 
-
12911 
-
12912  // No virus to compute
-
12913  if (nviruses_tmp == 0u)
-
12914  return nullptr;
-
12915 
-
12916  #ifdef EPI_DEBUG
-
12917  m->get_db().n_transmissions_potential++;
-
12918  #endif
+
12875  // This computes the prob of getting any neighbor variant
+
12876  size_t nviruses_tmp = 0u;
+
12877  for (auto & neighbor: p->get_neighbors())
+
12878  {
+
12879  #ifdef EPI_DEBUG
+
12880  int _vcount_neigh = 0;
+
12881  #endif
+
12882 
+
12883  if (neighbor->get_virus() == nullptr)
+
12884  continue;
+
12885 
+
12886  auto & v = neighbor->get_virus();
+
12887 
+
12888  #ifdef EPI_DEBUG
+
12889  if (nviruses_tmp >= m->array_virus_tmp.size())
+
12890  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
12891  #endif
+
12892 
+
12893  /* And it is a function of susceptibility_reduction as well */
+
12894  m->array_double_tmp[nviruses_tmp] =
+
12895  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
12896  v->get_prob_infecting(m) *
+
12897  (1.0 - neighbor->get_transmission_reduction(v, m))
+
12898  ;
+
12899 
+
12900  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
12901 
+
12902  #ifdef EPI_DEBUG
+
12903  if (
+
12904  (m->array_double_tmp[nviruses_tmp - 1] < 0.0) |
+
12905  (m->array_double_tmp[nviruses_tmp - 1] > 1.0)
+
12906  )
+
12907  {
+
12908  printf_epiworld(
+
12909  "[epi-debug] Agent %i's virus %i has transmission prob outside of [0, 1]: %.4f!\n",
+
12910  static_cast<int>(neighbor->get_id()),
+
12911  static_cast<int>(_vcount_neigh++),
+
12912  m->array_double_tmp[nviruses_tmp - 1]
+
12913  );
+
12914  }
+
12915  #endif
+
12916 
+
12917  }
+
12918 
12919 
-
12920  // Running the roulette
-
12921  int which = roulette(nviruses_tmp, m);
-
12922 
-
12923  if (which < 0)
-
12924  return nullptr;
-
12925 
-
12926  #ifdef EPI_DEBUG
-
12927  m->get_db().n_transmissions_today++;
-
12928  #endif
-
12929 
-
12930  return m->array_virus_tmp[which];
-
12931 
-
12932 }
+
12920  // No virus to compute
+
12921  if (nviruses_tmp == 0u)
+
12922  return nullptr;
+
12923 
+
12924  #ifdef EPI_DEBUG
+
12925  m->get_db().n_transmissions_potential++;
+
12926  #endif
+
12927 
+
12928  // Running the roulette
+
12929  int which = roulette(nviruses_tmp, m);
+
12930 
+
12931  if (which < 0)
+
12932  return nullptr;
12933 
-
12934 }
-
12935 
-
12936 #endif
-
12937 /*//////////////////////////////////////////////////////////////////////////////
-
12939 
-
12940  End of -include/epiworld//agent-meat-virus-sampling.hpp-
-
12941 
-
12944 
-
12945 
-
12946 
+
12934  #ifdef EPI_DEBUG
+
12935  m->get_db().n_transmissions_today++;
+
12936  #endif
+
12937 
+
12938  return m->array_virus_tmp[which];
+
12939 
+
12940 }
+
12941 
+
12942 }
+
12943 
+
12944 #endif
+
12945 /*//////////////////////////////////////////////////////////////////////////////
12947 
-
12948 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
12949 inline void default_update_susceptible(
-
12950  Agent<TSeq> * p,
-
12951  Model<TSeq> * m
-
12952  )
-
12953 {
+
12948  End of -include/epiworld//agent-meat-virus-sampling.hpp-
+
12949 
+
12952 
+
12953 
12954 
-
12955  Virus<TSeq> * virus = sampler::sample_virus_single<TSeq>(p, m);
-
12956 
-
12957  if (virus == nullptr)
-
12958  return;
-
12959 
-
12960  p->set_virus(*virus, m);
-
12961 
-
12962  return;
-
12963 
-
12964 }
-
12965 
-
12966 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
12967 inline void default_update_exposed(Agent<TSeq> * p, Model<TSeq> * m) {
-
12968 
-
12969  if (p->get_virus() == nullptr)
-
12970  throw std::logic_error(
-
12971  std::string("Using the -default_update_exposed- on agents WITHOUT viruses makes no sense! ") +
-
12972  std::string("Agent id ") + std::to_string(p->get_id()) + std::string(" has no virus registered.")
-
12973  );
-
12974 
-
12975  // Die
-
12976  auto & virus = p->get_virus();
-
12977  m->array_double_tmp[0u] =
-
12978  virus->get_prob_death(m) * (1.0 - p->get_death_reduction(virus, m));
-
12979 
-
12980  // Recover
-
12981  m->array_double_tmp[1u] =
-
12982  1.0 - (1.0 - virus->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(virus, m));
-
12983 
-
12984 
-
12985  // Running the roulette
-
12986  int which = roulette(2u, m);
+
12955 
+
12956 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
12957 inline void default_update_susceptible(
+
12958  Agent<TSeq> * p,
+
12959  Model<TSeq> * m
+
12960  )
+
12961 {
+
12962 
+
12963  Virus<TSeq> * virus = sampler::sample_virus_single<TSeq>(p, m);
+
12964 
+
12965  if (virus == nullptr)
+
12966  return;
+
12967 
+
12968  p->set_virus(*virus, m);
+
12969 
+
12970  return;
+
12971 
+
12972 }
+
12973 
+
12974 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
12975 inline void default_update_exposed(Agent<TSeq> * p, Model<TSeq> * m) {
+
12976 
+
12977  if (p->get_virus() == nullptr)
+
12978  throw std::logic_error(
+
12979  std::string("Using the -default_update_exposed- on agents WITHOUT viruses makes no sense! ") +
+
12980  std::string("Agent id ") + std::to_string(p->get_id()) + std::string(" has no virus registered.")
+
12981  );
+
12982 
+
12983  // Die
+
12984  auto & virus = p->get_virus();
+
12985  m->array_double_tmp[0u] =
+
12986  virus->get_prob_death(m) * (1.0 - p->get_death_reduction(virus, m));
12987 
-
12988  if (which < 0)
-
12989  return;
-
12990 
-
12991  // Which roulette happen?
-
12992  if (which == 0u) // If odd
-
12993  {
-
12994 
-
12995  p->rm_agent_by_virus(m);
-
12996 
-
12997  } else {
+
12988  // Recover
+
12989  m->array_double_tmp[1u] =
+
12990  1.0 - (1.0 - virus->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(virus, m));
+
12991 
+
12992 
+
12993  // Running the roulette
+
12994  int which = roulette(2u, m);
+
12995 
+
12996  if (which < 0)
+
12997  return;
12998 
-
12999  p->rm_virus(m);
-
13000 
-
13001  }
+
12999  // Which roulette happen?
+
13000  if (which == 0u) // If odd
+
13001  {
13002 
-
13003  return ;
-
13004 
-
13005 }
+
13003  p->rm_agent_by_virus(m);
+
13004 
+
13005  } else {
13006 
-
13007 #endif
-
13008 /*//////////////////////////////////////////////////////////////////////////////
+
13007  p->rm_virus(m);
+
13008 
+
13009  }
13010 
-
13011  End of -include/epiworld/agent-meat-state.hpp-
+
13011  return ;
13012 
-
13015 
-
13016 
-
13017 /*//////////////////////////////////////////////////////////////////////////////
-
13019 
-
13020  Start of -include/epiworld/agent-bones.hpp-
-
13021 
+
13013 }
+
13014 
+
13015 #endif
+
13016 /*//////////////////////////////////////////////////////////////////////////////
+
13018 
+
13019  End of -include/epiworld/agent-meat-state.hpp-
+
13020 
+
13023 
13024 
-
13025 
-
13026 #ifndef EPIWORLD_PERSON_BONES_HPP
-
13027 #define EPIWORLD_PERSON_BONES_HPP
-
13028 
-
13029 template<typename TSeq>
-
13030 class Model;
-
13031 
-
13032 template<typename TSeq>
-
13033 class Virus;
-
13034 
-
13035 template<typename TSeq>
-
13036 class Viruses;
-
13037 
-
13038 template<typename TSeq>
-
13039 class Viruses_const;
-
13040 
-
13041 template<typename TSeq>
-
13042 class Tool;
-
13043 
-
13044 template<typename TSeq>
-
13045 class Tools;
-
13046 
-
13047 template<typename TSeq>
-
13048 class Tools_const;
-
13049 
-
13050 template<typename TSeq>
-
13051 class Queue;
-
13052 
-
13053 template<typename TSeq>
-
13054 struct Action;
-
13055 
-
13056 template<typename TSeq>
-
13057 class Entity;
-
13058 
-
13059 template<typename TSeq>
-
13060 class Entities;
-
13061 
-
13062 template<typename TSeq>
-
13063 inline void default_add_virus(Action<TSeq> & a, Model<TSeq> * m);
-
13064 
-
13065 template<typename TSeq>
-
13066 inline void default_add_tool(Action<TSeq> & a, Model<TSeq> * m);
-
13067 
-
13068 template<typename TSeq>
-
13069 inline void default_add_entity(Action<TSeq> & a, Model<TSeq> * m);
-
13070 
-
13071 template<typename TSeq>
-
13072 inline void default_rm_virus(Action<TSeq> & a, Model<TSeq> * m);
-
13073 
-
13074 template<typename TSeq>
-
13075 inline void default_rm_tool(Action<TSeq> & a, Model<TSeq> * m);
-
13076 
-
13077 template<typename TSeq>
-
13078 inline void default_rm_entity(Action<TSeq> & a, Model<TSeq> * m);
-
13079 
-
13080 template<typename TSeq>
-
13081 inline void default_change_state(Action<TSeq> & a, Model<TSeq> * m);
-
13082 
-
13083 
+
13025 /*//////////////////////////////////////////////////////////////////////////////
+
13027 
+
13028  Start of -include/epiworld/agent-bones.hpp-
+
13029 
+
13032 
+
13033 
+
13034 #ifndef EPIWORLD_PERSON_BONES_HPP
+
13035 #define EPIWORLD_PERSON_BONES_HPP
+
13036 
+
13037 template<typename TSeq>
+
13038 class Model;
+
13039 
+
13040 template<typename TSeq>
+
13041 class Virus;
+
13042 
+
13043 template<typename TSeq>
+
13044 class Viruses;
+
13045 
+
13046 template<typename TSeq>
+
13047 class Viruses_const;
+
13048 
+
13049 template<typename TSeq>
+
13050 class Tool;
+
13051 
+
13052 template<typename TSeq>
+
13053 class Tools;
+
13054 
+
13055 template<typename TSeq>
+
13056 class Tools_const;
+
13057 
+
13058 template<typename TSeq>
+
13059 class Queue;
+
13060 
+
13061 template<typename TSeq>
+
13062 struct Action;
+
13063 
+
13064 template<typename TSeq>
+
13065 class Entity;
+
13066 
+
13067 template<typename TSeq>
+
13068 class Entities;
+
13069 
+
13070 template<typename TSeq>
+
13071 inline void default_add_virus(Action<TSeq> & a, Model<TSeq> * m);
+
13072 
+
13073 template<typename TSeq>
+
13074 inline void default_add_tool(Action<TSeq> & a, Model<TSeq> * m);
+
13075 
+
13076 template<typename TSeq>
+
13077 inline void default_add_entity(Action<TSeq> & a, Model<TSeq> * m);
+
13078 
+
13079 template<typename TSeq>
+
13080 inline void default_rm_virus(Action<TSeq> & a, Model<TSeq> * m);
+
13081 
+
13082 template<typename TSeq>
+
13083 inline void default_rm_tool(Action<TSeq> & a, Model<TSeq> * m);
13084 
-
13090 template<typename TSeq>
-
13091 class Agent {
-
13092  friend class Model<TSeq>;
-
13093  friend class Virus<TSeq>;
-
13094  friend class Tool<TSeq>;
-
13095  friend class Tools<TSeq>;
-
13096  friend class Tools_const<TSeq>;
-
13097  friend class Queue<TSeq>;
-
13098  friend class Entities<TSeq>;
-
13099  friend class AgentsSample<TSeq>;
-
13100  friend void default_add_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13101  friend void default_add_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13102  friend void default_add_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13103  friend void default_rm_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13104  friend void default_rm_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13105  friend void default_rm_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13106  friend void default_change_state<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
-
13107 private:
-
13108 
-
13109  Model<TSeq> * model;
-
13110 
-
13111  std::vector< size_t > neighbors;
-
13112  std::vector< size_t > neighbors_locations;
-
13113  size_t n_neighbors = 0u;
-
13114 
-
13115  std::vector< size_t > entities;
-
13116  std::vector< size_t > entities_locations;
-
13117  size_t n_entities = 0u;
+
13085 template<typename TSeq>
+
13086 inline void default_rm_entity(Action<TSeq> & a, Model<TSeq> * m);
+
13087 
+
13088 template<typename TSeq>
+
13089 inline void default_change_state(Action<TSeq> & a, Model<TSeq> * m);
+
13090 
+
13091 
+
13092 
+
13098 template<typename TSeq>
+
13099 class Agent {
+
13100  friend class Model<TSeq>;
+
13101  friend class Virus<TSeq>;
+
13102  friend class Tool<TSeq>;
+
13103  friend class Tools<TSeq>;
+
13104  friend class Tools_const<TSeq>;
+
13105  friend class Queue<TSeq>;
+
13106  friend class Entities<TSeq>;
+
13107  friend class AgentsSample<TSeq>;
+
13108  friend void default_add_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13109  friend void default_add_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13110  friend void default_add_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13111  friend void default_rm_virus<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13112  friend void default_rm_tool<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13113  friend void default_rm_entity<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13114  friend void default_change_state<TSeq>(Action<TSeq> & a, Model<TSeq> * m);
+
13115 private:
+
13116 
+
13117  Model<TSeq> * model;
13118 
-
13119  epiworld_fast_uint state = 0u;
-
13120  epiworld_fast_uint state_prev = 0u; ///< For accounting, if need to undo a change.
-
13121 
-
13122  int state_last_changed = -1; ///< Last time the agent was updated.
-
13123  int id = -1;
-
13124 
-
13125  VirusPtr<TSeq> virus = nullptr;
+
13119  std::vector< size_t > neighbors;
+
13120  std::vector< size_t > neighbors_locations;
+
13121  size_t n_neighbors = 0u;
+
13122 
+
13123  std::vector< size_t > entities;
+
13124  std::vector< size_t > entities_locations;
+
13125  size_t n_entities = 0u;
13126 
-
13127  std::vector< ToolPtr<TSeq> > tools;
-
13128  epiworld_fast_uint n_tools = 0u;
-
13129 
-
13130  std::vector< Agent<TSeq> * > sampled_agents;
-
13131  size_t sampled_agents_n = 0u;
-
13132  std::vector< size_t > sampled_agents_left;
-
13133  size_t sampled_agents_left_n = 0u;
-
13134  int date_last_build_sample = -99;
-
13135 
-
13136 public:
+
13127  epiworld_fast_uint state = 0u;
+
13128  epiworld_fast_uint state_prev = 0u; ///< For accounting, if need to undo a change.
+
13129 
+
13130  int state_last_changed = -1; ///< Last time the agent was updated.
+
13131  int id = -1;
+
13132 
+
13133  VirusPtr<TSeq> virus = nullptr;
+
13134 
+
13135  std::vector< ToolPtr<TSeq> > tools;
+
13136  epiworld_fast_uint n_tools = 0u;
13137 
-
13138  Agent();
-
13139  Agent(Agent<TSeq> && p);
-
13140  Agent(const Agent<TSeq> & p);
-
13141  Agent<TSeq> & operator=(const Agent<TSeq> & other_agent);
-
13142 
-
13154  void add_tool(
-
13155  ToolPtr<TSeq> tool,
-
13156  Model<TSeq> * model,
-
13157  epiworld_fast_int state_new = -99,
-
13158  epiworld_fast_int queue = -99
-
13159  );
-
13160 
-
13161  void add_tool(
-
13162  Tool<TSeq> tool,
-
13163  Model<TSeq> * model,
-
13164  epiworld_fast_int state_new = -99,
-
13165  epiworld_fast_int queue = -99
-
13166  );
-
13167 
-
13168  void set_virus(
-
13169  VirusPtr<TSeq> virus,
-
13170  Model<TSeq> * model,
-
13171  epiworld_fast_int state_new = -99,
-
13172  epiworld_fast_int queue = -99
-
13173  );
-
13174 
-
13175  void set_virus(
-
13176  Virus<TSeq> virus,
-
13177  Model<TSeq> * model,
-
13178  epiworld_fast_int state_new = -99,
-
13179  epiworld_fast_int queue = -99
-
13180  );
-
13181 
-
13182  void add_entity(
-
13183  Entity<TSeq> & entity,
-
13184  Model<TSeq> * model,
-
13185  epiworld_fast_int state_new = -99,
-
13186  epiworld_fast_int queue = -99
-
13187  );
-
13188 
-
13189  void rm_tool(
-
13190  epiworld_fast_uint tool_idx,
-
13191  Model<TSeq> * model,
-
13192  epiworld_fast_int state_new = -99,
-
13193  epiworld_fast_int queue = -99
-
13194  );
-
13195 
-
13196  void rm_tool(
-
13197  ToolPtr<TSeq> & tool,
-
13198  Model<TSeq> * model,
-
13199  epiworld_fast_int state_new = -99,
-
13200  epiworld_fast_int queue = -99
-
13201  );
-
13202 
-
13203  void rm_virus(
-
13204  Model<TSeq> * model,
-
13205  epiworld_fast_int state_new = -99,
-
13206  epiworld_fast_int queue = -99
-
13207  );
-
13208 
-
13209  void rm_entity(
-
13210  epiworld_fast_uint entity_idx,
-
13211  Model<TSeq> * model,
-
13212  epiworld_fast_int state_new = -99,
-
13213  epiworld_fast_int queue = -99
-
13214  );
-
13215 
-
13216  void rm_entity(
-
13217  Entity<TSeq> & entity,
-
13218  Model<TSeq> * model,
-
13219  epiworld_fast_int state_new = -99,
-
13220  epiworld_fast_int queue = -99
-
13221  );
-
13222 
-
13223  void rm_agent_by_virus(
-
13224  Model<TSeq> * model,
-
13225  epiworld_fast_int state_new = -99,
-
13226  epiworld_fast_int queue = -99
-
13227  ); ///< Agent removed by virus
-
13229 
-
13237  epiworld_double get_susceptibility_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
-
13238  epiworld_double get_transmission_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
-
13239  epiworld_double get_recovery_enhancer(VirusPtr<TSeq> v, Model<TSeq> * model);
-
13240  epiworld_double get_death_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
-
13242 
-
13243  int get_id() const; ///< Id of the individual
-
13244 
-
13245  VirusPtr<TSeq> & get_virus();
-
13246 
-
13247  ToolPtr<TSeq> & get_tool(int i);
-
13248  Tools<TSeq> get_tools();
-
13249  const Tools_const<TSeq> get_tools() const;
-
13250  size_t get_n_tools() const noexcept;
-
13251 
-
13252  void mutate_virus();
-
13253  void add_neighbor(
-
13254  Agent<TSeq> & p,
-
13255  bool check_source = true,
-
13256  bool check_target = true
-
13257  );
-
13258 
-
13266  void swap_neighbors(
-
13267  Agent<TSeq> & other,
-
13268  size_t n_this,
-
13269  size_t n_other
-
13270  );
-
13271 
-
13272  std::vector< Agent<TSeq> * > get_neighbors();
-
13273  size_t get_n_neighbors() const;
-
13274 
-
13275  void change_state(
-
13276  Model<TSeq> * model,
-
13277  epiworld_fast_uint new_state,
-
13278  epiworld_fast_int queue = 0
-
13279  );
-
13280 
-
13281  const epiworld_fast_uint & get_state() const;
+
13138  std::vector< Agent<TSeq> * > sampled_agents;
+
13139  size_t sampled_agents_n = 0u;
+
13140  std::vector< size_t > sampled_agents_left;
+
13141  size_t sampled_agents_left_n = 0u;
+
13142  int date_last_build_sample = -99;
+
13143 
+
13144 public:
+
13145 
+
13146  Agent();
+
13147  Agent(Agent<TSeq> && p);
+
13148  Agent(const Agent<TSeq> & p);
+
13149  Agent<TSeq> & operator=(const Agent<TSeq> & other_agent);
+
13150 
+
13162  void add_tool(
+
13163  ToolPtr<TSeq> tool,
+
13164  Model<TSeq> * model,
+
13165  epiworld_fast_int state_new = -99,
+
13166  epiworld_fast_int queue = -99
+
13167  );
+
13168 
+
13169  void add_tool(
+
13170  Tool<TSeq> tool,
+
13171  Model<TSeq> * model,
+
13172  epiworld_fast_int state_new = -99,
+
13173  epiworld_fast_int queue = -99
+
13174  );
+
13175 
+
13176  void set_virus(
+
13177  VirusPtr<TSeq> virus,
+
13178  Model<TSeq> * model,
+
13179  epiworld_fast_int state_new = -99,
+
13180  epiworld_fast_int queue = -99
+
13181  );
+
13182 
+
13183  void set_virus(
+
13184  Virus<TSeq> virus,
+
13185  Model<TSeq> * model,
+
13186  epiworld_fast_int state_new = -99,
+
13187  epiworld_fast_int queue = -99
+
13188  );
+
13189 
+
13190  void add_entity(
+
13191  Entity<TSeq> & entity,
+
13192  Model<TSeq> * model,
+
13193  epiworld_fast_int state_new = -99,
+
13194  epiworld_fast_int queue = -99
+
13195  );
+
13196 
+
13197  void rm_tool(
+
13198  epiworld_fast_uint tool_idx,
+
13199  Model<TSeq> * model,
+
13200  epiworld_fast_int state_new = -99,
+
13201  epiworld_fast_int queue = -99
+
13202  );
+
13203 
+
13204  void rm_tool(
+
13205  ToolPtr<TSeq> & tool,
+
13206  Model<TSeq> * model,
+
13207  epiworld_fast_int state_new = -99,
+
13208  epiworld_fast_int queue = -99
+
13209  );
+
13210 
+
13211  void rm_virus(
+
13212  Model<TSeq> * model,
+
13213  epiworld_fast_int state_new = -99,
+
13214  epiworld_fast_int queue = -99
+
13215  );
+
13216 
+
13217  void rm_entity(
+
13218  epiworld_fast_uint entity_idx,
+
13219  Model<TSeq> * model,
+
13220  epiworld_fast_int state_new = -99,
+
13221  epiworld_fast_int queue = -99
+
13222  );
+
13223 
+
13224  void rm_entity(
+
13225  Entity<TSeq> & entity,
+
13226  Model<TSeq> * model,
+
13227  epiworld_fast_int state_new = -99,
+
13228  epiworld_fast_int queue = -99
+
13229  );
+
13230 
+
13231  void rm_agent_by_virus(
+
13232  Model<TSeq> * model,
+
13233  epiworld_fast_int state_new = -99,
+
13234  epiworld_fast_int queue = -99
+
13235  ); ///< Agent removed by virus
+
13237 
+
13245  epiworld_double get_susceptibility_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
+
13246  epiworld_double get_transmission_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
+
13247  epiworld_double get_recovery_enhancer(VirusPtr<TSeq> v, Model<TSeq> * model);
+
13248  epiworld_double get_death_reduction(VirusPtr<TSeq> v, Model<TSeq> * model);
+
13250 
+
13251  int get_id() const; ///< Id of the individual
+
13252 
+
13253  VirusPtr<TSeq> & get_virus();
+
13254 
+
13255  ToolPtr<TSeq> & get_tool(int i);
+
13256  Tools<TSeq> get_tools();
+
13257  const Tools_const<TSeq> get_tools() const;
+
13258  size_t get_n_tools() const noexcept;
+
13259 
+
13260  void mutate_virus();
+
13261  void add_neighbor(
+
13262  Agent<TSeq> & p,
+
13263  bool check_source = true,
+
13264  bool check_target = true
+
13265  );
+
13266 
+
13274  void swap_neighbors(
+
13275  Agent<TSeq> & other,
+
13276  size_t n_this,
+
13277  size_t n_other
+
13278  );
+
13279 
+
13280  std::vector< Agent<TSeq> * > get_neighbors();
+
13281  size_t get_n_neighbors() const;
13282 
-
13283  void reset();
-
13284 
-
13285  bool has_tool(epiworld_fast_uint t) const;
-
13286  bool has_tool(std::string name) const;
-
13287  bool has_tool(const Tool<TSeq> & t) const;
-
13288  bool has_virus(epiworld_fast_uint t) const;
-
13289  bool has_virus(std::string name) const;
-
13290  bool has_virus(const Virus<TSeq> & v) const;
-
13291 
-
13292  void print(Model<TSeq> * model, bool compressed = false) const;
-
13293 
-
13310  double & operator()(size_t j);
-
13311  double & operator[](size_t j);
-
13312  double operator()(size_t j) const;
-
13313  double operator[](size_t j) const;
-
13315 
-
13316  Entities<TSeq> get_entities();
-
13317  const Entities_const<TSeq> get_entities() const;
-
13318  const Entity<TSeq> & get_entity(size_t i) const;
-
13319  Entity<TSeq> & get_entity(size_t i);
-
13320  size_t get_n_entities() const;
-
13321 
-
13322  bool operator==(const Agent<TSeq> & other) const;
-
13323  bool operator!=(const Agent<TSeq> & other) const {return !operator==(other);};
-
13324 
-
13325 };
-
13326 
-
13327 
-
13328 
-
13329 #endif
-
13330 /*//////////////////////////////////////////////////////////////////////////////
+
13283  void change_state(
+
13284  Model<TSeq> * model,
+
13285  epiworld_fast_uint new_state,
+
13286  epiworld_fast_int queue = 0
+
13287  );
+
13288 
+
13289  const epiworld_fast_uint & get_state() const;
+
13290 
+
13291  void reset();
+
13292 
+
13293  bool has_tool(epiworld_fast_uint t) const;
+
13294  bool has_tool(std::string name) const;
+
13295  bool has_tool(const Tool<TSeq> & t) const;
+
13296  bool has_virus(epiworld_fast_uint t) const;
+
13297  bool has_virus(std::string name) const;
+
13298  bool has_virus(const Virus<TSeq> & v) const;
+
13299 
+
13300  void print(Model<TSeq> * model, bool compressed = false) const;
+
13301 
+
13318  double & operator()(size_t j);
+
13319  double & operator[](size_t j);
+
13320  double operator()(size_t j) const;
+
13321  double operator[](size_t j) const;
+
13323 
+
13324  Entities<TSeq> get_entities();
+
13325  const Entities_const<TSeq> get_entities() const;
+
13326  const Entity<TSeq> & get_entity(size_t i) const;
+
13327  Entity<TSeq> & get_entity(size_t i);
+
13328  size_t get_n_entities() const;
+
13329 
+
13330  bool operator==(const Agent<TSeq> & other) const;
+
13331  bool operator!=(const Agent<TSeq> & other) const {return !operator==(other);};
13332 
-
13333  End of -include/epiworld/agent-bones.hpp-
+
13333 };
13334 
-
13337 
-
13338 
-
13339 /*//////////////////////////////////////////////////////////////////////////////
-
13341 
-
13342  Start of -include/epiworld/agent-meat.hpp-
-
13343 
+
13335 
+
13336 
+
13337 #endif
+
13338 /*//////////////////////////////////////////////////////////////////////////////
+
13340 
+
13341  End of -include/epiworld/agent-bones.hpp-
+
13342 
+
13345 
13346 
-
13347 
-
13348 #ifndef EPIWORLD_PERSON_MEAT_HPP
-
13349 #define EPIWORLD_PERSON_MEAT_HPP
-
13350 
-
13351 #define CHECK_COALESCE_(proposed_, virus_tool_, alt_) \
-
13352  if (static_cast<int>(proposed_) == -99) {\
-
13353  if (static_cast<int>(virus_tool_) == -99) \
-
13354  (proposed_) = (alt_);\
-
13355  else (proposed_) = (virus_tool_);}
-
13356 
-
13357 // To large to add directly here
-
13358 /*//////////////////////////////////////////////////////////////////////////////
-
13360 
-
13361  Start of -include/epiworld//agent-actions-meat.hpp-
-
13362 
-
13365 
-
13366 
-
13367 #ifndef EPIWORLD_AGENT_ACTIONS_MEAT_HPP
-
13368 #define EPIWORLD_AGENT_ACTIONS_MEAT_HPP
-
13369 
-
13370 template<typename TSeq>
-
13371 inline void default_add_virus(Action<TSeq> & a, Model<TSeq> * m)
-
13372 {
+
13347 /*//////////////////////////////////////////////////////////////////////////////
+
13349 
+
13350  Start of -include/epiworld/agent-meat.hpp-
+
13351 
+
13354 
+
13355 
+
13356 #ifndef EPIWORLD_PERSON_MEAT_HPP
+
13357 #define EPIWORLD_PERSON_MEAT_HPP
+
13358 
+
13359 #define CHECK_COALESCE_(proposed_, virus_tool_, alt_) \
+
13360  if (static_cast<int>(proposed_) == -99) {\
+
13361  if (static_cast<int>(virus_tool_) == -99) \
+
13362  (proposed_) = (alt_);\
+
13363  else (proposed_) = (virus_tool_);}
+
13364 
+
13365 // To large to add directly here
+
13366 /*//////////////////////////////////////////////////////////////////////////////
+
13368 
+
13369  Start of -include/epiworld//agent-actions-meat.hpp-
+
13370 
13373 
-
13374  Agent<TSeq> * p = a.agent;
-
13375  VirusPtr<TSeq> v = a.virus;
-
13376 
-
13377  // Has a agent? If so, we need to register the transmission
-
13378  if (v->get_agent())
-
13379  {
-
13380 
-
13381  // ... only if not the same agent
-
13382  if (v->get_agent()->get_id() != p->get_id())
-
13383  m->get_db().record_transmission(
-
13384  v->get_agent()->get_id(),
-
13385  p->get_id(),
-
13386  v->get_id(),
-
13387  v->get_date()
-
13388  );
-
13389 
-
13390  }
-
13391 
-
13392  p->virus = std::make_shared< Virus<TSeq> >(*v);
-
13393  p->virus->set_date(m->today());
-
13394  p->virus->set_agent(p);
-
13395 
-
13396  // Change of state needs to be recorded and updated on the
-
13397  // tools.
-
13398  if (p->state_prev != p->state)
-
13399  {
-
13400  auto & db = m->get_db();
-
13401  db.update_state(p->state_prev, p->state);
-
13402 
-
13403  for (size_t i = 0u; i < p->n_tools; ++i)
-
13404  db.update_tool(p->tools[i]->get_id(), p->state_prev, p->state);
-
13405  }
-
13406 
-
13407  // Lastly, we increase the daily count of the virus
-
13408  #ifdef EPI_DEBUG
-
13409  m->get_db().today_virus.at(v->get_id()).at(p->state)++;
-
13410  #else
-
13411  m->get_db().today_virus[v->get_id()][p->state]++;
-
13412  #endif
-
13413 
-
13414 }
-
13415 
-
13416 template<typename TSeq>
-
13417 inline void default_add_tool(Action<TSeq> & a, Model<TSeq> * m)
-
13418 {
-
13419 
-
13420  Agent<TSeq> * p = a.agent;
-
13421  ToolPtr<TSeq> t = a.tool;
-
13422 
-
13423  // Update tool accounting
-
13424  p->n_tools++;
-
13425  size_t n_tools = p->n_tools;
-
13426 
-
13427  if (n_tools <= p->tools.size())
-
13428  p->tools[n_tools - 1] = std::make_shared< Tool<TSeq> >(*t);
-
13429  else
-
13430  p->tools.push_back(std::make_shared< Tool<TSeq> >(*t));
-
13431 
-
13432  n_tools--;
-
13433 
-
13434  p->tools[n_tools]->set_date(m->today());
-
13435  p->tools[n_tools]->set_agent(p, n_tools);
-
13436 
-
13437  // Change of state needs to be recorded and updated on the
-
13438  // tools.
-
13439  if (p->state_prev != p->state)
-
13440  {
-
13441  auto & db = m->get_db();
-
13442  db.update_state(p->state_prev, p->state);
-
13443 
-
13444  if (p->virus)
-
13445  db.update_virus(p->virus->get_id(), p->state_prev, p->state);
-
13446  }
-
13447 
-
13448  m->get_db().today_tool[t->get_id()][p->state]++;
-
13449 
-
13450 
-
13451 }
-
13452 
-
13453 template<typename TSeq>
-
13454 inline void default_rm_virus(Action<TSeq> & a, Model<TSeq> * model)
-
13455 {
-
13456 
-
13457  Agent<TSeq> * p = a.agent;
-
13458  VirusPtr<TSeq> & v = a.virus;
-
13459 
-
13460  // Calling the virus action over the removed virus
-
13461  v->post_recovery(model);
-
13462 
-
13463  p->virus = nullptr;
+
13374 
+
13375 #ifndef EPIWORLD_AGENT_ACTIONS_MEAT_HPP
+
13376 #define EPIWORLD_AGENT_ACTIONS_MEAT_HPP
+
13377 
+
13378 template<typename TSeq>
+
13379 inline void default_add_virus(Action<TSeq> & a, Model<TSeq> * m)
+
13380 {
+
13381 
+
13382  Agent<TSeq> * p = a.agent;
+
13383  VirusPtr<TSeq> v = a.virus;
+
13384 
+
13385  // Has a agent? If so, we need to register the transmission
+
13386  if (v->get_agent())
+
13387  {
+
13388 
+
13389  // ... only if not the same agent
+
13390  if (v->get_agent()->get_id() != p->get_id())
+
13391  m->get_db().record_transmission(
+
13392  v->get_agent()->get_id(),
+
13393  p->get_id(),
+
13394  v->get_id(),
+
13395  v->get_date()
+
13396  );
+
13397 
+
13398  }
+
13399 
+
13400  p->virus = std::make_shared< Virus<TSeq> >(*v);
+
13401  p->virus->set_date(m->today());
+
13402  p->virus->set_agent(p);
+
13403 
+
13404  // Change of state needs to be recorded and updated on the
+
13405  // tools.
+
13406  if (p->state_prev != p->state)
+
13407  {
+
13408  auto & db = m->get_db();
+
13409  db.update_state(p->state_prev, p->state);
+
13410 
+
13411  for (size_t i = 0u; i < p->n_tools; ++i)
+
13412  db.update_tool(p->tools[i]->get_id(), p->state_prev, p->state);
+
13413  }
+
13414 
+
13415  // Lastly, we increase the daily count of the virus
+
13416  #ifdef EPI_DEBUG
+
13417  m->get_db().today_virus.at(v->get_id()).at(p->state)++;
+
13418  #else
+
13419  m->get_db().today_virus[v->get_id()][p->state]++;
+
13420  #endif
+
13421 
+
13422 }
+
13423 
+
13424 template<typename TSeq>
+
13425 inline void default_add_tool(Action<TSeq> & a, Model<TSeq> * m)
+
13426 {
+
13427 
+
13428  Agent<TSeq> * p = a.agent;
+
13429  ToolPtr<TSeq> t = a.tool;
+
13430 
+
13431  // Update tool accounting
+
13432  p->n_tools++;
+
13433  size_t n_tools = p->n_tools;
+
13434 
+
13435  if (n_tools <= p->tools.size())
+
13436  p->tools[n_tools - 1] = std::make_shared< Tool<TSeq> >(*t);
+
13437  else
+
13438  p->tools.push_back(std::make_shared< Tool<TSeq> >(*t));
+
13439 
+
13440  n_tools--;
+
13441 
+
13442  p->tools[n_tools]->set_date(m->today());
+
13443  p->tools[n_tools]->set_agent(p, n_tools);
+
13444 
+
13445  // Change of state needs to be recorded and updated on the
+
13446  // tools.
+
13447  if (p->state_prev != p->state)
+
13448  {
+
13449  auto & db = m->get_db();
+
13450  db.update_state(p->state_prev, p->state);
+
13451 
+
13452  if (p->virus)
+
13453  db.update_virus(p->virus->get_id(), p->state_prev, p->state);
+
13454  }
+
13455 
+
13456  m->get_db().today_tool[t->get_id()][p->state]++;
+
13457 
+
13458 
+
13459 }
+
13460 
+
13461 template<typename TSeq>
+
13462 inline void default_rm_virus(Action<TSeq> & a, Model<TSeq> * model)
+
13463 {
13464 
-
13465  // Change of state needs to be recorded and updated on the
-
13466  // tools.
-
13467  if (p->state_prev != p->state)
-
13468  {
-
13469  auto & db = model->get_db();
-
13470  db.update_state(p->state_prev, p->state);
-
13471 
-
13472  for (size_t i = 0u; i < p->n_tools; ++i)
-
13473  db.update_tool(p->tools[i]->get_id(), p->state_prev, p->state);
-
13474  }
-
13475 
-
13476  // The counters of the virus only needs to decrease
-
13477  #ifdef EPI_DEBUG
-
13478  model->get_db().today_virus.at(v->get_id()).at(p->state_prev)--;
-
13479  #else
-
13480  model->get_db().today_virus[v->get_id()][p->state_prev]--;
-
13481  #endif
-
13482 
-
13483 
-
13484  return;
-
13485 
-
13486 }
-
13487 
-
13488 template<typename TSeq>
-
13489 inline void default_rm_tool(Action<TSeq> & a, Model<TSeq> * m)
-
13490 {
-
13491 
-
13492  Agent<TSeq> * p = a.agent;
-
13493  ToolPtr<TSeq> & t = a.agent->tools[a.tool->pos_in_agent];
-
13494 
-
13495  if (--p->n_tools > 0)
-
13496  {
-
13497  p->tools[p->n_tools]->pos_in_agent = t->pos_in_agent;
-
13498  std::swap(
-
13499  p->tools[t->pos_in_agent],
-
13500  p->tools[p->n_tools]
-
13501  );
-
13502  }
-
13503 
-
13504  // Change of state needs to be recorded and updated on the
-
13505  // tools.
-
13506  if (p->state_prev != p->state)
-
13507  {
-
13508  auto & db = m->get_db();
-
13509  db.update_state(p->state_prev, p->state);
-
13510 
-
13511  if (p->virus)
-
13512  db.update_virus(p->virus->get_id(), p->state_prev, p->state);
-
13513  }
-
13514 
-
13515  // Lastly, we increase the daily count of the tool
-
13516  #ifdef EPI_DEBUG
-
13517  m->get_db().today_tool.at(t->get_id()).at(p->state_prev)--;
-
13518  #else
-
13519  m->get_db().today_tool[t->get_id()][p->state_prev]--;
-
13520  #endif
-
13521 
-
13522  return;
-
13523 
-
13524 }
-
13525 
-
13526 template<typename TSeq>
-
13527 inline void default_change_state(Action<TSeq> & a, Model<TSeq> * m)
-
13528 {
+
13465  Agent<TSeq> * p = a.agent;
+
13466  VirusPtr<TSeq> & v = a.virus;
+
13467 
+
13468  // Calling the virus action over the removed virus
+
13469  v->post_recovery(model);
+
13470 
+
13471  p->virus = nullptr;
+
13472 
+
13473  // Change of state needs to be recorded and updated on the
+
13474  // tools.
+
13475  if (p->state_prev != p->state)
+
13476  {
+
13477  auto & db = model->get_db();
+
13478  db.update_state(p->state_prev, p->state);
+
13479 
+
13480  for (size_t i = 0u; i < p->n_tools; ++i)
+
13481  db.update_tool(p->tools[i]->get_id(), p->state_prev, p->state);
+
13482  }
+
13483 
+
13484  // The counters of the virus only needs to decrease
+
13485  #ifdef EPI_DEBUG
+
13486  model->get_db().today_virus.at(v->get_id()).at(p->state_prev)--;
+
13487  #else
+
13488  model->get_db().today_virus[v->get_id()][p->state_prev]--;
+
13489  #endif
+
13490 
+
13491 
+
13492  return;
+
13493 
+
13494 }
+
13495 
+
13496 template<typename TSeq>
+
13497 inline void default_rm_tool(Action<TSeq> & a, Model<TSeq> * m)
+
13498 {
+
13499 
+
13500  Agent<TSeq> * p = a.agent;
+
13501  ToolPtr<TSeq> & t = a.agent->tools[a.tool->pos_in_agent];
+
13502 
+
13503  if (--p->n_tools > 0)
+
13504  {
+
13505  p->tools[p->n_tools]->pos_in_agent = t->pos_in_agent;
+
13506  std::swap(
+
13507  p->tools[t->pos_in_agent],
+
13508  p->tools[p->n_tools]
+
13509  );
+
13510  }
+
13511 
+
13512  // Change of state needs to be recorded and updated on the
+
13513  // tools.
+
13514  if (p->state_prev != p->state)
+
13515  {
+
13516  auto & db = m->get_db();
+
13517  db.update_state(p->state_prev, p->state);
+
13518 
+
13519  if (p->virus)
+
13520  db.update_virus(p->virus->get_id(), p->state_prev, p->state);
+
13521  }
+
13522 
+
13523  // Lastly, we increase the daily count of the tool
+
13524  #ifdef EPI_DEBUG
+
13525  m->get_db().today_tool.at(t->get_id()).at(p->state_prev)--;
+
13526  #else
+
13527  m->get_db().today_tool[t->get_id()][p->state_prev]--;
+
13528  #endif
13529 
-
13530  Agent<TSeq> * p = a.agent;
+
13530  return;
13531 
-
13532  if (p->state_prev != p->state)
-
13533  {
-
13534  auto & db = m->get_db();
-
13535  db.update_state(p->state_prev, p->state);
-
13536 
-
13537  if (p->virus)
-
13538  db.update_virus(p->virus->get_id(), p->state_prev, p->state);
+
13532 }
+
13533 
+
13534 template<typename TSeq>
+
13535 inline void default_change_state(Action<TSeq> & a, Model<TSeq> * m)
+
13536 {
+
13537 
+
13538  Agent<TSeq> * p = a.agent;
13539 
-
13540  for (size_t i = 0u; i < p->n_tools; ++i)
-
13541  db.update_tool(p->tools[i]->get_id(), p->state_prev, p->state);
-
13542 
-
13543  }
+
13540  if (p->state_prev != p->state)
+
13541  {
+
13542  auto & db = m->get_db();
+
13543  db.update_state(p->state_prev, p->state);
13544 
-
13545 }
-
13546 
-
13547 template<typename TSeq>
-
13548 inline void default_add_entity(Action<TSeq> & a, Model<TSeq> *)
-
13549 {
+
13545  if (p->virus)
+
13546  db.update_virus(p->virus->get_id(), p->state_prev, p->state);
+
13547 
+
13548  for (size_t i = 0u; i < p->n_tools; ++i)
+
13549  db.update_tool(p->tools[i]->get_id(), p->state_prev, p->state);
13550 
-
13551  Agent<TSeq> * p = a.agent;
-
13552  Entity<TSeq> * e = a.entity;
-
13553 
-
13554  // Checking the agent and the entity are not linked
-
13555  if ((p->get_n_entities() > 0) && (e->size() > 0))
-
13556  {
-
13557 
-
13558  if (p->get_n_entities() > e->size()) // Slower search through the agent
-
13559  {
-
13560  for (size_t i = 0u; i < e->size(); ++i)
-
13561  if(e->operator[](i)->get_id() == p->get_id())
-
13562  throw std::logic_error("An entity cannot be reassigned to an agent.");
-
13563  }
-
13564  else // Slower search through the entity
-
13565  {
-
13566  for (size_t i = 0u; i < p->get_n_entities(); ++i)
-
13567  if(p->get_entity(i).get_id() == e->get_id())
-
13568  throw std::logic_error("An entity cannot be reassigned to an agent.");
-
13569  }
-
13570 
-
13571  // It means that agent and entity were not associated.
-
13572  }
-
13573 
-
13574  // Adding the entity to the agent
-
13575  if (++p->n_entities <= p->entities.size())
-
13576  {
-
13577 
-
13578  p->entities[p->n_entities - 1] = e->get_id();
-
13579  p->entities_locations[p->n_entities - 1] = e->n_agents;
-
13580 
-
13581  } else
-
13582  {
-
13583  p->entities.push_back(e->get_id());
-
13584  p->entities_locations.push_back(e->n_agents);
-
13585  }
-
13586 
-
13587  // Adding the agent to the entity
-
13588  // Adding the entity to the agent
-
13589  if (++e->n_agents <= e->agents.size())
+
13551  }
+
13552 
+
13553 }
+
13554 
+
13555 template<typename TSeq>
+
13556 inline void default_add_entity(Action<TSeq> & a, Model<TSeq> *)
+
13557 {
+
13558 
+
13559  Agent<TSeq> * p = a.agent;
+
13560  Entity<TSeq> * e = a.entity;
+
13561 
+
13562  // Checking the agent and the entity are not linked
+
13563  if ((p->get_n_entities() > 0) && (e->size() > 0))
+
13564  {
+
13565 
+
13566  if (p->get_n_entities() > e->size()) // Slower search through the agent
+
13567  {
+
13568  for (size_t i = 0u; i < e->size(); ++i)
+
13569  if(e->operator[](i)->get_id() == p->get_id())
+
13570  throw std::logic_error("An entity cannot be reassigned to an agent.");
+
13571  }
+
13572  else // Slower search through the entity
+
13573  {
+
13574  for (size_t i = 0u; i < p->get_n_entities(); ++i)
+
13575  if(p->get_entity(i).get_id() == e->get_id())
+
13576  throw std::logic_error("An entity cannot be reassigned to an agent.");
+
13577  }
+
13578 
+
13579  // It means that agent and entity were not associated.
+
13580  }
+
13581 
+
13582  // Adding the entity to the agent
+
13583  if (++p->n_entities <= p->entities.size())
+
13584  {
+
13585 
+
13586  p->entities[p->n_entities - 1] = e->get_id();
+
13587  p->entities_locations[p->n_entities - 1] = e->n_agents;
+
13588 
+
13589  } else
13590  {
-
13591 
-
13592  e->agents[e->n_agents - 1] = p->get_id();
-
13593  // Adjusted by '-1' since the list of entities in the agent just grew.
-
13594  e->agents_location[e->n_agents - 1] = p->n_entities - 1;
-
13595 
-
13596  } else
-
13597  {
-
13598  e->agents.push_back(p->get_id());
-
13599  e->agents_location.push_back(p->n_entities - 1);
-
13600  }
-
13601 
-
13602  // Today was the last modification
-
13603  // e->date_last_add_or_remove = m->today();
-
13604 
-
13605 }
-
13606 
-
13607 template<typename TSeq>
-
13608 inline void default_rm_entity(Action<TSeq> & a, Model<TSeq> * m)
-
13609 {
-
13610 
-
13611  Agent<TSeq> * p = a.agent;
-
13612  Entity<TSeq> * e = a.entity;
-
13613  size_t idx_agent_in_entity = a.idx_agent;
-
13614  size_t idx_entity_in_agent = a.idx_object;
-
13615 
-
13616  if (--p->n_entities > 0)
-
13617  {
-
13618 
-
13619  // When we move the end entity to the new location, the
-
13620  // moved entity needs to reflect the change, i.e., where the
-
13621  // entity will now be located in the agent
-
13622  size_t agent_location_in_last_entity = p->entities_locations[p->n_entities];
-
13623  Entity<TSeq> * last_entity = &m->get_entities()[p->entities[p->n_entities]]; ///< Last entity of the agent
-
13624 
-
13625  // The end entity will be located where the removed was
-
13626  last_entity->agents_location[agent_location_in_last_entity] = idx_entity_in_agent;
-
13627 
-
13628  // We now make the swap
-
13629  std::swap(
-
13630  p->entities[p->n_entities],
-
13631  p->entities[idx_entity_in_agent]
-
13632  );
-
13633 
-
13634  }
+
13591  p->entities.push_back(e->get_id());
+
13592  p->entities_locations.push_back(e->n_agents);
+
13593  }
+
13594 
+
13595  // Adding the agent to the entity
+
13596  // Adding the entity to the agent
+
13597  if (++e->n_agents <= e->agents.size())
+
13598  {
+
13599 
+
13600  e->agents[e->n_agents - 1] = p->get_id();
+
13601  // Adjusted by '-1' since the list of entities in the agent just grew.
+
13602  e->agents_location[e->n_agents - 1] = p->n_entities - 1;
+
13603 
+
13604  } else
+
13605  {
+
13606  e->agents.push_back(p->get_id());
+
13607  e->agents_location.push_back(p->n_entities - 1);
+
13608  }
+
13609 
+
13610  // Today was the last modification
+
13611  // e->date_last_add_or_remove = m->today();
+
13612 
+
13613 }
+
13614 
+
13615 template<typename TSeq>
+
13616 inline void default_rm_entity(Action<TSeq> & a, Model<TSeq> * m)
+
13617 {
+
13618 
+
13619  Agent<TSeq> * p = a.agent;
+
13620  Entity<TSeq> * e = a.entity;
+
13621  size_t idx_agent_in_entity = a.idx_agent;
+
13622  size_t idx_entity_in_agent = a.idx_object;
+
13623 
+
13624  if (--p->n_entities > 0)
+
13625  {
+
13626 
+
13627  // When we move the end entity to the new location, the
+
13628  // moved entity needs to reflect the change, i.e., where the
+
13629  // entity will now be located in the agent
+
13630  size_t agent_location_in_last_entity = p->entities_locations[p->n_entities];
+
13631  Entity<TSeq> * last_entity = &m->get_entities()[p->entities[p->n_entities]]; ///< Last entity of the agent
+
13632 
+
13633  // The end entity will be located where the removed was
+
13634  last_entity->agents_location[agent_location_in_last_entity] = idx_entity_in_agent;
13635 
-
13636  if (--e->n_agents > 0)
-
13637  {
-
13638 
-
13639  // When we move the end agent to the new location, the
-
13640  // moved agent needs to reflect the change, i.e., where the
-
13641  // agent will now be located in the entity
-
13642  size_t entity_location_in_last_agent = e->agents_location[e->n_agents];
-
13643  Agent<TSeq> * last_agent = &m->get_agents()[e->agents[e->n_agents]]; ///< Last agent of the entity
-
13644 
-
13645  // The end entity will be located where the removed was
-
13646  last_agent->entities_locations[entity_location_in_last_agent] = idx_agent_in_entity;
-
13647 
-
13648  // We now make the swap
-
13649  std::swap(
-
13650  e->agents[e->n_agents],
-
13651  e->agents[idx_agent_in_entity]
-
13652  );
-
13653 
-
13654  }
+
13636  // We now make the swap
+
13637  std::swap(
+
13638  p->entities[p->n_entities],
+
13639  p->entities[idx_entity_in_agent]
+
13640  );
+
13641 
+
13642  }
+
13643 
+
13644  if (--e->n_agents > 0)
+
13645  {
+
13646 
+
13647  // When we move the end agent to the new location, the
+
13648  // moved agent needs to reflect the change, i.e., where the
+
13649  // agent will now be located in the entity
+
13650  size_t entity_location_in_last_agent = e->agents_location[e->n_agents];
+
13651  Agent<TSeq> * last_agent = &m->get_agents()[e->agents[e->n_agents]]; ///< Last agent of the entity
+
13652 
+
13653  // The end entity will be located where the removed was
+
13654  last_agent->entities_locations[entity_location_in_last_agent] = idx_agent_in_entity;
13655 
-
13656  // Setting the date of the last removal
-
13657  // e->date_last_add_or_remove = m->today();
-
13658 
-
13659  return;
-
13660 
-
13661 }
-
13662 #endif
-
13663 /*//////////////////////////////////////////////////////////////////////////////
-
13665 
-
13666  End of -include/epiworld//agent-actions-meat.hpp-
-
13667 
-
13670 
-
13671 
-
13672 
-
13673 template<typename TSeq>
-
13674 inline Agent<TSeq>::Agent() {}
+
13656  // We now make the swap
+
13657  std::swap(
+
13658  e->agents[e->n_agents],
+
13659  e->agents[idx_agent_in_entity]
+
13660  );
+
13661 
+
13662  }
+
13663 
+
13664  // Setting the date of the last removal
+
13665  // e->date_last_add_or_remove = m->today();
+
13666 
+
13667  return;
+
13668 
+
13669 }
+
13670 #endif
+
13671 /*//////////////////////////////////////////////////////////////////////////////
+
13673 
+
13674  End of -include/epiworld//agent-actions-meat.hpp-
13675 
-
13676 template<typename TSeq>
-
13677 inline Agent<TSeq>::Agent(Agent<TSeq> && p) :
-
13678  model(p.model),
-
13679  neighbors(std::move(p.neighbors)),
-
13680  neighbors_locations(std::move(p.neighbors_locations)),
-
13681  n_neighbors(p.n_neighbors),
-
13682  entities(std::move(p.entities)),
-
13683  entities_locations(std::move(p.entities_locations)),
-
13684  n_entities(p.n_entities),
-
13685  state(p.state),
-
13686  state_prev(p.state_prev),
-
13687  state_last_changed(p.state_last_changed),
-
13688  id(p.id),
-
13689  tools(std::move(p.tools)), /// Needs to be adjusted
-
13690  n_tools(p.n_tools)
-
13691 {
-
13692 
-
13693  state = p.state;
-
13694  id = p.id;
-
13695 
-
13696  // Dealing with the virus
-
13697  if (p.virus != nullptr)
-
13698  {
-
13699  virus = std::move(p.virus);
-
13700  virus->set_agent(this);
-
13701  }
-
13702 
-
13703  int loc = 0;
-
13704  for (auto & t : tools)
-
13705  {
-
13706 
-
13707  // Will create a copy of the virus, with the exeption of
-
13708  // the virus code
-
13709  t->agent = this;
-
13710  t->pos_in_agent = loc++;
-
13711 
-
13712  }
-
13713 
-
13714 }
-
13715 
-
13716 template<typename TSeq>
-
13717 inline Agent<TSeq>::Agent(const Agent<TSeq> & p) :
-
13718  model(p.model),
-
13719  neighbors(p.neighbors),
-
13720  neighbors_locations(p.neighbors_locations),
-
13721  n_neighbors(p.n_neighbors),
-
13722  entities(p.entities),
-
13723  entities_locations(p.entities_locations),
-
13724  n_entities(p.n_entities),
-
13725  sampled_agents(0u),
-
13726  sampled_agents_n(0u),
-
13727  sampled_agents_left_n(0u),
-
13728  date_last_build_sample(-99)
-
13729 {
-
13730 
-
13731  state = p.state;
-
13732  id = p.id;
-
13733 
-
13734  // Dealing with the virus
-
13735  if (p.virus != nullptr)
-
13736  {
-
13737  virus = std::make_shared<Virus<TSeq>>(*p.virus);
-
13738  virus->set_agent(this);
-
13739  }
-
13740 
-
13741 
-
13742  tools.reserve(p.get_n_tools());
-
13743  n_tools = tools.size();
-
13744  for (size_t i = 0u; i < n_tools; ++i)
-
13745  {
-
13746 
-
13747  // Will create a copy of the virus, with the exeption of
-
13748  // the virus code
-
13749  tools.emplace_back(std::make_shared<Tool<TSeq>>(*p.tools[i]));
-
13750  tools.back()->set_agent(this, i);
-
13751 
-
13752  }
-
13753 
-
13754 }
-
13755 
-
13756 template<typename TSeq>
-
13757 inline Agent<TSeq> & Agent<TSeq>::operator=(
-
13758  const Agent<TSeq> & other_agent
-
13759 )
-
13760 {
-
13761 
-
13762  model = other_agent.model;
+
13678 
+
13679 
+
13680 
+
13681 template<typename TSeq>
+
13682 inline Agent<TSeq>::Agent() {}
+
13683 
+
13684 template<typename TSeq>
+
13685 inline Agent<TSeq>::Agent(Agent<TSeq> && p) :
+
13686  model(p.model),
+
13687  neighbors(std::move(p.neighbors)),
+
13688  neighbors_locations(std::move(p.neighbors_locations)),
+
13689  n_neighbors(p.n_neighbors),
+
13690  entities(std::move(p.entities)),
+
13691  entities_locations(std::move(p.entities_locations)),
+
13692  n_entities(p.n_entities),
+
13693  state(p.state),
+
13694  state_prev(p.state_prev),
+
13695  state_last_changed(p.state_last_changed),
+
13696  id(p.id),
+
13697  tools(std::move(p.tools)), /// Needs to be adjusted
+
13698  n_tools(p.n_tools)
+
13699 {
+
13700 
+
13701  state = p.state;
+
13702  id = p.id;
+
13703 
+
13704  // Dealing with the virus
+
13705  if (p.virus != nullptr)
+
13706  {
+
13707  virus = std::move(p.virus);
+
13708  virus->set_agent(this);
+
13709  }
+
13710 
+
13711  int loc = 0;
+
13712  for (auto & t : tools)
+
13713  {
+
13714 
+
13715  // Will create a copy of the virus, with the exeption of
+
13716  // the virus code
+
13717  t->agent = this;
+
13718  t->pos_in_agent = loc++;
+
13719 
+
13720  }
+
13721 
+
13722 }
+
13723 
+
13724 template<typename TSeq>
+
13725 inline Agent<TSeq>::Agent(const Agent<TSeq> & p) :
+
13726  model(p.model),
+
13727  neighbors(p.neighbors),
+
13728  neighbors_locations(p.neighbors_locations),
+
13729  n_neighbors(p.n_neighbors),
+
13730  entities(p.entities),
+
13731  entities_locations(p.entities_locations),
+
13732  n_entities(p.n_entities),
+
13733  sampled_agents(0u),
+
13734  sampled_agents_n(0u),
+
13735  sampled_agents_left_n(0u),
+
13736  date_last_build_sample(-99)
+
13737 {
+
13738 
+
13739  state = p.state;
+
13740  id = p.id;
+
13741 
+
13742  // Dealing with the virus
+
13743  if (p.virus != nullptr)
+
13744  {
+
13745  virus = std::make_shared<Virus<TSeq>>(*p.virus);
+
13746  virus->set_agent(this);
+
13747  }
+
13748 
+
13749 
+
13750  tools.reserve(p.get_n_tools());
+
13751  n_tools = tools.size();
+
13752  for (size_t i = 0u; i < n_tools; ++i)
+
13753  {
+
13754 
+
13755  // Will create a copy of the virus, with the exeption of
+
13756  // the virus code
+
13757  tools.emplace_back(std::make_shared<Tool<TSeq>>(*p.tools[i]));
+
13758  tools.back()->set_agent(this, i);
+
13759 
+
13760  }
+
13761 
+
13762 }
13763 
-
13764  neighbors = other_agent.neighbors;
-
13765  neighbors_locations = other_agent.neighbors_locations;
-
13766  n_neighbors = other_agent.n_neighbors;
-
13767 
-
13768  entities = other_agent.entities;
-
13769  entities_locations = other_agent.entities_locations;
-
13770  n_entities = other_agent.n_entities;
+
13764 template<typename TSeq>
+
13765 inline Agent<TSeq> & Agent<TSeq>::operator=(
+
13766  const Agent<TSeq> & other_agent
+
13767 )
+
13768 {
+
13769 
+
13770  model = other_agent.model;
13771 
-
13772  sampled_agents.clear();
-
13773  sampled_agents_n = 0;
-
13774  sampled_agents_left_n = 0;
-
13775  date_last_build_sample = -99;
-
13776 
-
13777  // neighbors = other_agent.neighbors;
-
13778  // entities = other_agent.entities;
-
13779  // entities_locations = other_agent.entities_locations;
-
13780  // n_entities = other_agent.n_entities;
-
13781  state = other_agent.state;
-
13782  state_prev = other_agent.state_prev;
-
13783  state_last_changed = other_agent.state_last_changed;
-
13784  id = other_agent.id;
-
13785 
-
13786  if (other_agent.virus != nullptr)
-
13787  {
-
13788  virus = std::make_shared<Virus<TSeq>>(*other_agent.virus);
-
13789  virus->set_agent(this);
-
13790  } else
-
13791  virus = nullptr;
-
13792 
-
13793  // tools = other_agent.tools;
-
13794  n_tools = other_agent.n_tools;
-
13795  for (size_t i = 0u; i < n_tools; ++i)
-
13796  {
-
13797  tools[i] = std::make_shared<Tool<TSeq>>(*other_agent.tools[i]);
-
13798  tools[i]->set_agent(this, i);
-
13799  }
+
13772  neighbors = other_agent.neighbors;
+
13773  neighbors_locations = other_agent.neighbors_locations;
+
13774  n_neighbors = other_agent.n_neighbors;
+
13775 
+
13776  entities = other_agent.entities;
+
13777  entities_locations = other_agent.entities_locations;
+
13778  n_entities = other_agent.n_entities;
+
13779 
+
13780  sampled_agents.clear();
+
13781  sampled_agents_n = 0;
+
13782  sampled_agents_left_n = 0;
+
13783  date_last_build_sample = -99;
+
13784 
+
13785  // neighbors = other_agent.neighbors;
+
13786  // entities = other_agent.entities;
+
13787  // entities_locations = other_agent.entities_locations;
+
13788  // n_entities = other_agent.n_entities;
+
13789  state = other_agent.state;
+
13790  state_prev = other_agent.state_prev;
+
13791  state_last_changed = other_agent.state_last_changed;
+
13792  id = other_agent.id;
+
13793 
+
13794  if (other_agent.virus != nullptr)
+
13795  {
+
13796  virus = std::make_shared<Virus<TSeq>>(*other_agent.virus);
+
13797  virus->set_agent(this);
+
13798  } else
+
13799  virus = nullptr;
13800 
-
13801  return *this;
-
13802 
-
13803 }
-
13804 
-
13805 template<typename TSeq>
-
13806 inline void Agent<TSeq>::add_tool(
-
13807  ToolPtr<TSeq> tool,
-
13808  Model<TSeq> * model,
-
13809  epiworld_fast_int state_new,
-
13810  epiworld_fast_int queue
-
13811 ) {
+
13801  // tools = other_agent.tools;
+
13802  n_tools = other_agent.n_tools;
+
13803  for (size_t i = 0u; i < n_tools; ++i)
+
13804  {
+
13805  tools[i] = std::make_shared<Tool<TSeq>>(*other_agent.tools[i]);
+
13806  tools[i]->set_agent(this, i);
+
13807  }
+
13808 
+
13809  return *this;
+
13810 
+
13811 }
13812 
-
13813  // Checking the virus exists
-
13814  if (tool->get_id() >= static_cast<int>(model->get_db().get_n_tools()))
-
13815  throw std::range_error("The tool with id: " + std::to_string(tool->get_id()) +
-
13816  " has not been registered. There are only " + std::to_string(model->get_n_tools()) +
-
13817  " included in the model.");
-
13818 
-
13819  CHECK_COALESCE_(state_new, tool->state_init, state);
-
13820  CHECK_COALESCE_(queue, tool->queue_init, Queue<TSeq>::NoOne);
-
13821 
-
13822  model->actions_add(
-
13823  this, nullptr, tool, nullptr, state_new, queue, default_add_tool<TSeq>, -1, -1
-
13824  );
-
13825 
-
13826 }
-
13827 
-
13828 template<typename TSeq>
-
13829 inline void Agent<TSeq>::add_tool(
-
13830  Tool<TSeq> tool,
-
13831  Model<TSeq> * model,
-
13832  epiworld_fast_int state_new,
-
13833  epiworld_fast_int queue
-
13834 )
-
13835 {
-
13836  ToolPtr<TSeq> tool_ptr = std::make_shared< Tool<TSeq> >(tool);
-
13837  add_tool(tool_ptr, model, state_new, queue);
-
13838 }
-
13839 
-
13840 template<typename TSeq>
-
13841 inline void Agent<TSeq>::set_virus(
-
13842  VirusPtr<TSeq> virus,
-
13843  Model<TSeq> * model,
-
13844  epiworld_fast_int state_new,
-
13845  epiworld_fast_int queue
-
13846 )
-
13847 {
-
13848 
-
13849  // Checking the virus exists
-
13850  if (virus->get_id() >= static_cast<int>(model->get_db().get_n_viruses()))
-
13851  throw std::range_error("The virus with id: " + std::to_string(virus->get_id()) +
-
13852  " has not been registered. There are only " + std::to_string(model->get_n_viruses()) +
-
13853  " included in the model.");
-
13854 
-
13855  CHECK_COALESCE_(state_new, virus->state_init, state);
-
13856  CHECK_COALESCE_(queue, virus->queue_init, Queue<TSeq>::NoOne);
-
13857 
-
13858  model->actions_add(
-
13859  this, virus, nullptr, nullptr, state_new, queue, default_add_virus<TSeq>, -1, -1
-
13860  );
-
13861 
-
13862 }
-
13863 
-
13864 template<typename TSeq>
-
13865 inline void Agent<TSeq>::set_virus(
-
13866  Virus<TSeq> virus,
-
13867  Model<TSeq> * model,
-
13868  epiworld_fast_int state_new,
-
13869  epiworld_fast_int queue
-
13870 )
-
13871 {
-
13872  VirusPtr<TSeq> virus_ptr = std::make_shared< Virus<TSeq> >(virus);
-
13873  set_virus(virus_ptr, model, state_new, queue);
-
13874 }
-
13875 
-
13876 template<typename TSeq>
-
13877 inline void Agent<TSeq>::add_entity(
-
13878  Entity<TSeq> & entity,
-
13879  Model<TSeq> * model,
-
13880  epiworld_fast_int state_new,
-
13881  epiworld_fast_int queue
-
13882 )
-
13883 {
-
13884 
-
13885  CHECK_COALESCE_(state_new, entity.state_init, state);
-
13886  CHECK_COALESCE_(queue, entity.queue_init, Queue<TSeq>::NoOne);
-
13887 
-
13888  if (model != nullptr)
-
13889  {
-
13890 
-
13891  model->actions_add(
-
13892  this, nullptr, nullptr, &entity, state_new, queue, default_add_entity<TSeq>, -1, -1
-
13893  );
-
13894 
-
13895  }
-
13896  else // If no model is passed, then we assume that we only need to add the
-
13897  // model entity
-
13898  {
-
13899 
-
13900  Action<TSeq> a(
-
13901  this, nullptr, nullptr, &entity, state_new, queue, default_add_entity<TSeq>,
-
13902  -1, -1
-
13903  );
-
13904 
-
13905  // default_add_entity(a, model); /* passing model makes nothing */
-
13906 
-
13907  }
-
13908 
-
13909 }
-
13910 
-
13911 template<typename TSeq>
-
13912 inline void Agent<TSeq>::rm_tool(
-
13913  epiworld_fast_uint tool_idx,
-
13914  Model<TSeq> * model,
-
13915  epiworld_fast_int state_new,
-
13916  epiworld_fast_int queue
-
13917 )
-
13918 {
-
13919 
-
13920  CHECK_COALESCE_(state_new, tools[tool_idx]->state_post, state);
-
13921  CHECK_COALESCE_(queue, tools[tool_idx]->queue_post, Queue<TSeq>::NoOne);
-
13922 
-
13923  if (tool_idx >= n_tools)
-
13924  throw std::range_error(
-
13925  "The Tool you want to remove is out of range. This Agent only has " +
-
13926  std::to_string(n_tools) + " tools."
-
13927  );
-
13928 
-
13929  model->actions_add(
-
13930  this, nullptr, tools[tool_idx], nullptr, state_new, queue, default_rm_tool<TSeq>, -1, -1
-
13931  );
-
13932 
-
13933 }
-
13934 
-
13935 template<typename TSeq>
-
13936 inline void Agent<TSeq>::rm_tool(
-
13937  ToolPtr<TSeq> & tool,
-
13938  Model<TSeq> * model,
-
13939  epiworld_fast_int state_new,
-
13940  epiworld_fast_int queue
-
13941 )
-
13942 {
-
13943 
-
13944  if (tool->agent != this)
-
13945  throw std::logic_error("Cannot remove a virus from another agent!");
-
13946 
-
13947  model->actions_add(
-
13948  this, nullptr, tool, nullptr, state_new, queue, default_rm_tool<TSeq>, -1, -1
-
13949  );
-
13950 
-
13951 }
-
13952 
-
13953 template<typename TSeq>
-
13954 inline void Agent<TSeq>::rm_virus(
-
13955  Model<TSeq> * model,
-
13956  epiworld_fast_int state_new,
-
13957  epiworld_fast_int queue
-
13958 )
-
13959 {
+
13813 template<typename TSeq>
+
13814 inline void Agent<TSeq>::add_tool(
+
13815  ToolPtr<TSeq> tool,
+
13816  Model<TSeq> * model,
+
13817  epiworld_fast_int state_new,
+
13818  epiworld_fast_int queue
+
13819 ) {
+
13820 
+
13821  // Checking the virus exists
+
13822  if (tool->get_id() >= static_cast<int>(model->get_db().get_n_tools()))
+
13823  throw std::range_error("The tool with id: " + std::to_string(tool->get_id()) +
+
13824  " has not been registered. There are only " + std::to_string(model->get_n_tools()) +
+
13825  " included in the model.");
+
13826 
+
13827  CHECK_COALESCE_(state_new, tool->state_init, state);
+
13828  CHECK_COALESCE_(queue, tool->queue_init, Queue<TSeq>::NoOne);
+
13829 
+
13830  model->actions_add(
+
13831  this, nullptr, tool, nullptr, state_new, queue, default_add_tool<TSeq>, -1, -1
+
13832  );
+
13833 
+
13834 }
+
13835 
+
13836 template<typename TSeq>
+
13837 inline void Agent<TSeq>::add_tool(
+
13838  Tool<TSeq> tool,
+
13839  Model<TSeq> * model,
+
13840  epiworld_fast_int state_new,
+
13841  epiworld_fast_int queue
+
13842 )
+
13843 {
+
13844  ToolPtr<TSeq> tool_ptr = std::make_shared< Tool<TSeq> >(tool);
+
13845  add_tool(tool_ptr, model, state_new, queue);
+
13846 }
+
13847 
+
13848 template<typename TSeq>
+
13849 inline void Agent<TSeq>::set_virus(
+
13850  VirusPtr<TSeq> virus,
+
13851  Model<TSeq> * model,
+
13852  epiworld_fast_int state_new,
+
13853  epiworld_fast_int queue
+
13854 )
+
13855 {
+
13856 
+
13857  // Checking the virus exists
+
13858  if (virus->get_id() >= static_cast<int>(model->get_db().get_n_viruses()))
+
13859  throw std::range_error("The virus with id: " + std::to_string(virus->get_id()) +
+
13860  " has not been registered. There are only " + std::to_string(model->get_n_viruses()) +
+
13861  " included in the model.");
+
13862 
+
13863  CHECK_COALESCE_(state_new, virus->state_init, state);
+
13864  CHECK_COALESCE_(queue, virus->queue_init, Queue<TSeq>::NoOne);
+
13865 
+
13866  model->actions_add(
+
13867  this, virus, nullptr, nullptr, state_new, queue, default_add_virus<TSeq>, -1, -1
+
13868  );
+
13869 
+
13870 }
+
13871 
+
13872 template<typename TSeq>
+
13873 inline void Agent<TSeq>::set_virus(
+
13874  Virus<TSeq> virus,
+
13875  Model<TSeq> * model,
+
13876  epiworld_fast_int state_new,
+
13877  epiworld_fast_int queue
+
13878 )
+
13879 {
+
13880  VirusPtr<TSeq> virus_ptr = std::make_shared< Virus<TSeq> >(virus);
+
13881  set_virus(virus_ptr, model, state_new, queue);
+
13882 }
+
13883 
+
13884 template<typename TSeq>
+
13885 inline void Agent<TSeq>::add_entity(
+
13886  Entity<TSeq> & entity,
+
13887  Model<TSeq> * model,
+
13888  epiworld_fast_int state_new,
+
13889  epiworld_fast_int queue
+
13890 )
+
13891 {
+
13892 
+
13893  CHECK_COALESCE_(state_new, entity.state_init, state);
+
13894  CHECK_COALESCE_(queue, entity.queue_init, Queue<TSeq>::NoOne);
+
13895 
+
13896  if (model != nullptr)
+
13897  {
+
13898 
+
13899  model->actions_add(
+
13900  this, nullptr, nullptr, &entity, state_new, queue, default_add_entity<TSeq>, -1, -1
+
13901  );
+
13902 
+
13903  }
+
13904  else // If no model is passed, then we assume that we only need to add the
+
13905  // model entity
+
13906  {
+
13907 
+
13908  Action<TSeq> a(
+
13909  this, nullptr, nullptr, &entity, state_new, queue, default_add_entity<TSeq>,
+
13910  -1, -1
+
13911  );
+
13912 
+
13913  // default_add_entity(a, model); /* passing model makes nothing */
+
13914 
+
13915  }
+
13916 
+
13917 }
+
13918 
+
13919 template<typename TSeq>
+
13920 inline void Agent<TSeq>::rm_tool(
+
13921  epiworld_fast_uint tool_idx,
+
13922  Model<TSeq> * model,
+
13923  epiworld_fast_int state_new,
+
13924  epiworld_fast_int queue
+
13925 )
+
13926 {
+
13927 
+
13928  CHECK_COALESCE_(state_new, tools[tool_idx]->state_post, state);
+
13929  CHECK_COALESCE_(queue, tools[tool_idx]->queue_post, Queue<TSeq>::NoOne);
+
13930 
+
13931  if (tool_idx >= n_tools)
+
13932  throw std::range_error(
+
13933  "The Tool you want to remove is out of range. This Agent only has " +
+
13934  std::to_string(n_tools) + " tools."
+
13935  );
+
13936 
+
13937  model->actions_add(
+
13938  this, nullptr, tools[tool_idx], nullptr, state_new, queue, default_rm_tool<TSeq>, -1, -1
+
13939  );
+
13940 
+
13941 }
+
13942 
+
13943 template<typename TSeq>
+
13944 inline void Agent<TSeq>::rm_tool(
+
13945  ToolPtr<TSeq> & tool,
+
13946  Model<TSeq> * model,
+
13947  epiworld_fast_int state_new,
+
13948  epiworld_fast_int queue
+
13949 )
+
13950 {
+
13951 
+
13952  if (tool->agent != this)
+
13953  throw std::logic_error("Cannot remove a virus from another agent!");
+
13954 
+
13955  model->actions_add(
+
13956  this, nullptr, tool, nullptr, state_new, queue, default_rm_tool<TSeq>, -1, -1
+
13957  );
+
13958 
+
13959 }
13960 
-
13961  if (virus == nullptr)
-
13962  throw std::logic_error(
-
13963  "There is no virus to remove here!"
-
13964  );
-
13965 
-
13966  CHECK_COALESCE_(state_new, virus->state_post, state);
-
13967  CHECK_COALESCE_(queue, virus->queue_post, Queue<TSeq>::Everyone);
+
13961 template<typename TSeq>
+
13962 inline void Agent<TSeq>::rm_virus(
+
13963  Model<TSeq> * model,
+
13964  epiworld_fast_int state_new,
+
13965  epiworld_fast_int queue
+
13966 )
+
13967 {
13968 
-
13969  model->actions_add(
-
13970  this, virus, nullptr, nullptr, state_new, queue,
-
13971  default_rm_virus<TSeq>, -1, -1
+
13969  if (virus == nullptr)
+
13970  throw std::logic_error(
+
13971  "There is no virus to remove here!"
13972  );
-
13973 
-
13974 }
-
13975 
-
13976 template<typename TSeq>
-
13977 inline void Agent<TSeq>::rm_entity(
-
13978  epiworld_fast_uint entity_idx,
-
13979  Model<TSeq> * model,
-
13980  epiworld_fast_int state_new,
-
13981  epiworld_fast_int queue
-
13982 )
-
13983 {
-
13984 
-
13985  if (entity_idx >= n_entities)
-
13986  throw std::range_error(
-
13987  "The Entity you want to remove is out of range. This Agent only has " +
-
13988  std::to_string(n_entities) + " entitites."
-
13989  );
-
13990  else if (n_entities == 0u)
-
13991  throw std::logic_error(
-
13992  "There is entity to remove here!"
-
13993  );
-
13994 
-
13995  CHECK_COALESCE_(state_new, model->entities[entity_idx].state_post, state);
-
13996  CHECK_COALESCE_(queue, model->entities[entity_idx].queue_post, Queue<TSeq>::NoOne);
-
13997 
-
13998  model->actions_add(
-
13999  this, nullptr, nullptr, model->entities[entity_idx], state_new, queue,
-
14000  default_rm_entity<TSeq>, entities_locations[entity_idx], entity_idx
-
14001  );
-
14002 }
-
14003 
-
14004 template<typename TSeq>
-
14005 inline void Agent<TSeq>::rm_entity(
-
14006  Entity<TSeq> & entity,
-
14007  Model<TSeq> * model,
-
14008  epiworld_fast_int state_new,
-
14009  epiworld_fast_int queue
-
14010 )
-
14011 {
-
14012 
-
14013  // Looking for entity location in the agent
-
14014  int entity_idx = -1;
-
14015  for (size_t i = 0u; i < n_entities; ++i)
-
14016  {
-
14017  if (entities[i] == entity->get_id())
-
14018  entity_idx = i;
-
14019  }
+
13973 
+
13974  CHECK_COALESCE_(state_new, virus->state_post, state);
+
13975  CHECK_COALESCE_(queue, virus->queue_post, Queue<TSeq>::Everyone);
+
13976 
+
13977  model->actions_add(
+
13978  this, virus, nullptr, nullptr, state_new, queue,
+
13979  default_rm_virus<TSeq>, -1, -1
+
13980  );
+
13981 
+
13982 }
+
13983 
+
13984 template<typename TSeq>
+
13985 inline void Agent<TSeq>::rm_entity(
+
13986  epiworld_fast_uint entity_idx,
+
13987  Model<TSeq> * model,
+
13988  epiworld_fast_int state_new,
+
13989  epiworld_fast_int queue
+
13990 )
+
13991 {
+
13992 
+
13993  if (entity_idx >= n_entities)
+
13994  throw std::range_error(
+
13995  "The Entity you want to remove is out of range. This Agent only has " +
+
13996  std::to_string(n_entities) + " entitites."
+
13997  );
+
13998  else if (n_entities == 0u)
+
13999  throw std::logic_error(
+
14000  "There is entity to remove here!"
+
14001  );
+
14002 
+
14003  CHECK_COALESCE_(state_new, model->entities[entity_idx].state_post, state);
+
14004  CHECK_COALESCE_(queue, model->entities[entity_idx].queue_post, Queue<TSeq>::NoOne);
+
14005 
+
14006  model->actions_add(
+
14007  this, nullptr, nullptr, model->entities[entity_idx], state_new, queue,
+
14008  default_rm_entity<TSeq>, entities_locations[entity_idx], entity_idx
+
14009  );
+
14010 }
+
14011 
+
14012 template<typename TSeq>
+
14013 inline void Agent<TSeq>::rm_entity(
+
14014  Entity<TSeq> & entity,
+
14015  Model<TSeq> * model,
+
14016  epiworld_fast_int state_new,
+
14017  epiworld_fast_int queue
+
14018 )
+
14019 {
14020 
-
14021  if (entity_idx == -1)
-
14022  throw std::logic_error(
-
14023  "The agent " + std::to_string(id) + " is not associated with entity \"" +
-
14024  entity.get_name() + "\"."
-
14025  );
-
14026 
-
14027  CHECK_COALESCE_(state_new, entity.state_post, state);
-
14028  CHECK_COALESCE_(queue, entity.queue_post, Queue<TSeq>::NoOne);
-
14029 
-
14030  model->actions_add(
-
14031  this, nullptr, nullptr, entities[entity_idx], state_new, queue,
-
14032  default_rm_entity<TSeq>, entities_locations[entity_idx], entity_idx
-
14033  );
-
14034 }
-
14035 
-
14036 template<typename TSeq>
-
14037 inline void Agent<TSeq>::rm_agent_by_virus(
-
14038  Model<TSeq> * model,
-
14039  epiworld_fast_int state_new,
-
14040  epiworld_fast_int queue
-
14041 )
-
14042 {
+
14021  // Looking for entity location in the agent
+
14022  int entity_idx = -1;
+
14023  for (size_t i = 0u; i < n_entities; ++i)
+
14024  {
+
14025  if (entities[i] == entity->get_id())
+
14026  entity_idx = i;
+
14027  }
+
14028 
+
14029  if (entity_idx == -1)
+
14030  throw std::logic_error(
+
14031  "The agent " + std::to_string(id) + " is not associated with entity \"" +
+
14032  entity.get_name() + "\"."
+
14033  );
+
14034 
+
14035  CHECK_COALESCE_(state_new, entity.state_post, state);
+
14036  CHECK_COALESCE_(queue, entity.queue_post, Queue<TSeq>::NoOne);
+
14037 
+
14038  model->actions_add(
+
14039  this, nullptr, nullptr, entities[entity_idx], state_new, queue,
+
14040  default_rm_entity<TSeq>, entities_locations[entity_idx], entity_idx
+
14041  );
+
14042 }
14043 
-
14044  CHECK_COALESCE_(state_new, virus->state_removed, state);
-
14045  CHECK_COALESCE_(queue, virus->queue_removed, Queue<TSeq>::Everyone);
-
14046 
-
14047  model->actions_add(
-
14048  this, virus, nullptr, nullptr, state_new, queue,
-
14049  default_rm_virus<TSeq>, -1, -1
-
14050  );
+
14044 template<typename TSeq>
+
14045 inline void Agent<TSeq>::rm_agent_by_virus(
+
14046  Model<TSeq> * model,
+
14047  epiworld_fast_int state_new,
+
14048  epiworld_fast_int queue
+
14049 )
+
14050 {
14051 
-
14052 }
-
14053 
-
14054 template<typename TSeq>
-
14055 inline epiworld_double Agent<TSeq>::get_susceptibility_reduction(
-
14056  VirusPtr<TSeq> v,
-
14057  Model<TSeq> * model
-
14058 ) {
+
14052  CHECK_COALESCE_(state_new, virus->state_removed, state);
+
14053  CHECK_COALESCE_(queue, virus->queue_removed, Queue<TSeq>::Everyone);
+
14054 
+
14055  model->actions_add(
+
14056  this, virus, nullptr, nullptr, state_new, queue,
+
14057  default_rm_virus<TSeq>, -1, -1
+
14058  );
14059 
-
14060  return model->susceptibility_reduction_mixer(this, v, model);
-
14061 }
-
14062 
-
14063 template<typename TSeq>
-
14064 inline epiworld_double Agent<TSeq>::get_transmission_reduction(
-
14065  VirusPtr<TSeq> v,
-
14066  Model<TSeq> * model
-
14067 ) {
-
14068  return model->transmission_reduction_mixer(this, v, model);
+
14060 }
+
14061 
+
14062 template<typename TSeq>
+
14063 inline epiworld_double Agent<TSeq>::get_susceptibility_reduction(
+
14064  VirusPtr<TSeq> v,
+
14065  Model<TSeq> * model
+
14066 ) {
+
14067 
+
14068  return model->susceptibility_reduction_mixer(this, v, model);
14069 }
14070 
14071 template<typename TSeq>
-
14072 inline epiworld_double Agent<TSeq>::get_recovery_enhancer(
+
14072 inline epiworld_double Agent<TSeq>::get_transmission_reduction(
14073  VirusPtr<TSeq> v,
14074  Model<TSeq> * model
14075 ) {
-
14076  return model->recovery_enhancer_mixer(this, v, model);
+
14076  return model->transmission_reduction_mixer(this, v, model);
14077 }
14078 
14079 template<typename TSeq>
-
14080 inline epiworld_double Agent<TSeq>::get_death_reduction(
+
14080 inline epiworld_double Agent<TSeq>::get_recovery_enhancer(
14081  VirusPtr<TSeq> v,
14082  Model<TSeq> * model
14083 ) {
-
14084  return model->death_reduction_mixer(this, v, model);
+
14084  return model->recovery_enhancer_mixer(this, v, model);
14085 }
14086 
14087 template<typename TSeq>
-
14088 inline int Agent<TSeq>::get_id() const
-
14089 {
-
14090  return id;
-
14091 }
-
14092 
-
14093 template<typename TSeq>
-
14094 inline VirusPtr<TSeq> & Agent<TSeq>::get_virus() {
-
14095  return virus;
-
14096 }
-
14097 
-
14098 
-
14099 template<typename TSeq>
-
14100 inline Tools<TSeq> Agent<TSeq>::get_tools() {
-
14101  return Tools<TSeq>(*this);
-
14102 }
-
14103 
-
14104 template<typename TSeq>
-
14105 inline const Tools_const<TSeq> Agent<TSeq>::get_tools() const {
-
14106  return Tools_const<TSeq>(*this);
-
14107 }
-
14108 
-
14109 template<typename TSeq>
-
14110 inline ToolPtr<TSeq> & Agent<TSeq>::get_tool(int i)
-
14111 {
-
14112  return tools.at(i);
-
14113 }
-
14114 
-
14115 template<typename TSeq>
-
14116 inline size_t Agent<TSeq>::get_n_tools() const noexcept
-
14117 {
-
14118  return n_tools;
-
14119 }
-
14120 
-
14121 template<typename TSeq>
-
14122 inline void Agent<TSeq>::mutate_virus()
-
14123 {
-
14124 
-
14125  virus->mutate();
-
14126 
+
14088 inline epiworld_double Agent<TSeq>::get_death_reduction(
+
14089  VirusPtr<TSeq> v,
+
14090  Model<TSeq> * model
+
14091 ) {
+
14092  return model->death_reduction_mixer(this, v, model);
+
14093 }
+
14094 
+
14095 template<typename TSeq>
+
14096 inline int Agent<TSeq>::get_id() const
+
14097 {
+
14098  return id;
+
14099 }
+
14100 
+
14101 template<typename TSeq>
+
14102 inline VirusPtr<TSeq> & Agent<TSeq>::get_virus() {
+
14103  return virus;
+
14104 }
+
14105 
+
14106 
+
14107 template<typename TSeq>
+
14108 inline Tools<TSeq> Agent<TSeq>::get_tools() {
+
14109  return Tools<TSeq>(*this);
+
14110 }
+
14111 
+
14112 template<typename TSeq>
+
14113 inline const Tools_const<TSeq> Agent<TSeq>::get_tools() const {
+
14114  return Tools_const<TSeq>(*this);
+
14115 }
+
14116 
+
14117 template<typename TSeq>
+
14118 inline ToolPtr<TSeq> & Agent<TSeq>::get_tool(int i)
+
14119 {
+
14120  return tools.at(i);
+
14121 }
+
14122 
+
14123 template<typename TSeq>
+
14124 inline size_t Agent<TSeq>::get_n_tools() const noexcept
+
14125 {
+
14126  return n_tools;
14127 }
14128 
14129 template<typename TSeq>
-
14130 inline void Agent<TSeq>::add_neighbor(
-
14131  Agent<TSeq> & p,
-
14132  bool check_source,
-
14133  bool check_target
-
14134 ) {
-
14135  // Can we find the neighbor?
-
14136  bool found = false;
-
14137  if (check_source)
-
14138  {
-
14139 
-
14140  for (auto & n: neighbors)
-
14141  if (static_cast<int>(n) == p.get_id())
-
14142  {
-
14143  found = true;
-
14144  break;
-
14145  }
-
14146 
-
14147  }
-
14148 
-
14149  // Three things going on here:
-
14150  // - Where in the neighbor will this be
-
14151  // - What is the neighbor's id
-
14152  // - Increasing the number of neighbors
-
14153  if (!found)
-
14154  {
-
14155 
-
14156  neighbors_locations.push_back(p.get_n_neighbors());
-
14157  neighbors.push_back(p.get_id());
-
14158  n_neighbors++;
-
14159 
-
14160  }
-
14161 
-
14162 
-
14163  found = false;
-
14164  if (check_target)
-
14165  {
-
14166 
-
14167  for (auto & n: p.neighbors)
-
14168  if (static_cast<int>(n) == id)
-
14169  {
-
14170  found = true;
-
14171  break;
-
14172  }
-
14173 
-
14174  }
-
14175 
-
14176  if (!found)
-
14177  {
-
14178 
-
14179  p.neighbors_locations.push_back(n_neighbors - 1);
-
14180  p.neighbors.push_back(id);
-
14181  p.n_neighbors++;
-
14182 
-
14183  }
-
14184 
-
14185 
-
14186 }
-
14187 
-
14188 template<typename TSeq>
-
14189 inline void Agent<TSeq>::swap_neighbors(
-
14190  Agent<TSeq> & other,
-
14191  size_t n_this,
-
14192  size_t n_other
-
14193 )
-
14194 {
+
14130 inline void Agent<TSeq>::mutate_virus()
+
14131 {
+
14132 
+
14133  virus->mutate();
+
14134 
+
14135 }
+
14136 
+
14137 template<typename TSeq>
+
14138 inline void Agent<TSeq>::add_neighbor(
+
14139  Agent<TSeq> & p,
+
14140  bool check_source,
+
14141  bool check_target
+
14142 ) {
+
14143  // Can we find the neighbor?
+
14144  bool found = false;
+
14145  if (check_source)
+
14146  {
+
14147 
+
14148  for (auto & n: neighbors)
+
14149  if (static_cast<int>(n) == p.get_id())
+
14150  {
+
14151  found = true;
+
14152  break;
+
14153  }
+
14154 
+
14155  }
+
14156 
+
14157  // Three things going on here:
+
14158  // - Where in the neighbor will this be
+
14159  // - What is the neighbor's id
+
14160  // - Increasing the number of neighbors
+
14161  if (!found)
+
14162  {
+
14163 
+
14164  neighbors_locations.push_back(p.get_n_neighbors());
+
14165  neighbors.push_back(p.get_id());
+
14166  n_neighbors++;
+
14167 
+
14168  }
+
14169 
+
14170 
+
14171  found = false;
+
14172  if (check_target)
+
14173  {
+
14174 
+
14175  for (auto & n: p.neighbors)
+
14176  if (static_cast<int>(n) == id)
+
14177  {
+
14178  found = true;
+
14179  break;
+
14180  }
+
14181 
+
14182  }
+
14183 
+
14184  if (!found)
+
14185  {
+
14186 
+
14187  p.neighbors_locations.push_back(n_neighbors - 1);
+
14188  p.neighbors.push_back(id);
+
14189  p.n_neighbors++;
+
14190 
+
14191  }
+
14192 
+
14193 
+
14194 }
14195 
-
14196  // Getting the agents
-
14197  auto & pop = model->population;
-
14198  auto & neigh_this = pop[neighbors[n_this]];
-
14199  auto & neigh_other = pop[other.neighbors[n_other]];
-
14200 
-
14201  // Getting the locations in the neighbors
-
14202  size_t loc_this_in_neigh = neighbors_locations[n_this];
-
14203  size_t loc_other_in_neigh = other.neighbors_locations[n_other];
-
14204 
-
14205  // Changing ids
-
14206  std::swap(neighbors[n_this], other.neighbors[n_other]);
-
14207 
-
14208  if (!model->directed)
-
14209  {
-
14210  std::swap(
-
14211  neigh_this.neighbors[loc_this_in_neigh],
-
14212  neigh_other.neighbors[loc_other_in_neigh]
-
14213  );
-
14214 
-
14215  // Changing the locations
-
14216  std::swap(neighbors_locations[n_this], other.neighbors_locations[n_other]);
-
14217 
+
14196 template<typename TSeq>
+
14197 inline void Agent<TSeq>::swap_neighbors(
+
14198  Agent<TSeq> & other,
+
14199  size_t n_this,
+
14200  size_t n_other
+
14201 )
+
14202 {
+
14203 
+
14204  // Getting the agents
+
14205  auto & pop = model->population;
+
14206  auto & neigh_this = pop[neighbors[n_this]];
+
14207  auto & neigh_other = pop[other.neighbors[n_other]];
+
14208 
+
14209  // Getting the locations in the neighbors
+
14210  size_t loc_this_in_neigh = neighbors_locations[n_this];
+
14211  size_t loc_other_in_neigh = other.neighbors_locations[n_other];
+
14212 
+
14213  // Changing ids
+
14214  std::swap(neighbors[n_this], other.neighbors[n_other]);
+
14215 
+
14216  if (!model->directed)
+
14217  {
14218  std::swap(
-
14219  neigh_this.neighbors_locations[loc_this_in_neigh],
-
14220  neigh_other.neighbors_locations[loc_other_in_neigh]
+
14219  neigh_this.neighbors[loc_this_in_neigh],
+
14220  neigh_other.neighbors[loc_other_in_neigh]
14221  );
-
14222  }
-
14223 
-
14224 }
-
14225 
-
14226 template<typename TSeq>
-
14227 inline std::vector< Agent<TSeq> *> Agent<TSeq>::get_neighbors()
-
14228 {
-
14229  std::vector< Agent<TSeq> * > res(n_neighbors, nullptr);
-
14230  for (size_t i = 0u; i < n_neighbors; ++i)
-
14231  res[i] = &model->population[neighbors[i]];
-
14232 
-
14233  return res;
-
14234 }
-
14235 
-
14236 template<typename TSeq>
-
14237 inline size_t Agent<TSeq>::get_n_neighbors() const
-
14238 {
-
14239  return n_neighbors;
-
14240 }
-
14241 
-
14242 template<typename TSeq>
-
14243 inline void Agent<TSeq>::change_state(
-
14244  Model<TSeq> * model,
-
14245  epiworld_fast_uint new_state,
-
14246  epiworld_fast_int queue
-
14247  )
-
14248 {
+
14222 
+
14223  // Changing the locations
+
14224  std::swap(neighbors_locations[n_this], other.neighbors_locations[n_other]);
+
14225 
+
14226  std::swap(
+
14227  neigh_this.neighbors_locations[loc_this_in_neigh],
+
14228  neigh_other.neighbors_locations[loc_other_in_neigh]
+
14229  );
+
14230  }
+
14231 
+
14232 }
+
14233 
+
14234 template<typename TSeq>
+
14235 inline std::vector< Agent<TSeq> *> Agent<TSeq>::get_neighbors()
+
14236 {
+
14237  std::vector< Agent<TSeq> * > res(n_neighbors, nullptr);
+
14238  for (size_t i = 0u; i < n_neighbors; ++i)
+
14239  res[i] = &model->population[neighbors[i]];
+
14240 
+
14241  return res;
+
14242 }
+
14243 
+
14244 template<typename TSeq>
+
14245 inline size_t Agent<TSeq>::get_n_neighbors() const
+
14246 {
+
14247  return n_neighbors;
+
14248 }
14249 
-
14250  model->actions_add(
-
14251  this, nullptr, nullptr, nullptr, new_state, queue,
-
14252  default_change_state<TSeq>, -1, -1
-
14253  );
-
14254 
-
14255  return;
-
14256 
-
14257 }
-
14258 
-
14259 template<typename TSeq>
-
14260 inline const epiworld_fast_uint & Agent<TSeq>::get_state() const {
-
14261  return state;
-
14262 }
-
14263 
-
14264 template<typename TSeq>
-
14265 inline void Agent<TSeq>::reset()
-
14266 {
-
14267 
-
14268  this->virus = nullptr;
-
14269 
-
14270  this->tools.clear();
-
14271  n_tools = 0u;
-
14272 
-
14273  this->state = 0u;
-
14274  this->state_prev = 0u;
+
14250 template<typename TSeq>
+
14251 inline void Agent<TSeq>::change_state(
+
14252  Model<TSeq> * model,
+
14253  epiworld_fast_uint new_state,
+
14254  epiworld_fast_int queue
+
14255  )
+
14256 {
+
14257 
+
14258  model->actions_add(
+
14259  this, nullptr, nullptr, nullptr, new_state, queue,
+
14260  default_change_state<TSeq>, -1, -1
+
14261  );
+
14262 
+
14263  return;
+
14264 
+
14265 }
+
14266 
+
14267 template<typename TSeq>
+
14268 inline const epiworld_fast_uint & Agent<TSeq>::get_state() const {
+
14269  return state;
+
14270 }
+
14271 
+
14272 template<typename TSeq>
+
14273 inline void Agent<TSeq>::reset()
+
14274 {
14275 
-
14276  this->state_last_changed = -1;
-
14277 
-
14278 }
-
14279 
-
14280 template<typename TSeq>
-
14281 inline bool Agent<TSeq>::has_tool(epiworld_fast_uint t) const
-
14282 {
+
14276  this->virus = nullptr;
+
14277 
+
14278  this->tools.clear();
+
14279  n_tools = 0u;
+
14280 
+
14281  this->state = 0u;
+
14282  this->state_prev = 0u;
14283 
-
14284  for (auto & tool : tools)
-
14285  if (tool->get_id() == static_cast<int>(t))
-
14286  return true;
+
14284  this->state_last_changed = -1;
+
14285 
+
14286 }
14287 
-
14288  return false;
-
14289 
-
14290 }
+
14288 template<typename TSeq>
+
14289 inline bool Agent<TSeq>::has_tool(epiworld_fast_uint t) const
+
14290 {
14291 
-
14292 template<typename TSeq>
-
14293 inline bool Agent<TSeq>::has_tool(std::string name) const
-
14294 {
+
14292  for (auto & tool : tools)
+
14293  if (tool->get_id() == static_cast<int>(t))
+
14294  return true;
14295 
-
14296  for (auto & tool : tools)
-
14297  if (tool->get_name() == name)
-
14298  return true;
+
14296  return false;
+
14297 
+
14298 }
14299 
-
14300  return false;
-
14301 
-
14302 }
+
14300 template<typename TSeq>
+
14301 inline bool Agent<TSeq>::has_tool(std::string name) const
+
14302 {
14303 
-
14304 template<typename TSeq>
-
14305 inline bool Agent<TSeq>::has_tool(const Tool<TSeq> & tool) const
-
14306 {
+
14304  for (auto & tool : tools)
+
14305  if (tool->get_name() == name)
+
14306  return true;
14307 
-
14308  return has_tool(tool.get_id());
+
14308  return false;
14309 
14310 }
14311 
14312 template<typename TSeq>
-
14313 inline bool Agent<TSeq>::has_virus(epiworld_fast_uint t) const
+
14313 inline bool Agent<TSeq>::has_tool(const Tool<TSeq> & tool) const
14314 {
-
14315  if (virus->get_id() == static_cast<int>(t))
-
14316  return true;
+
14315 
+
14316  return has_tool(tool.get_id());
14317 
-
14318  return false;
-
14319 }
-
14320 
-
14321 template<typename TSeq>
-
14322 inline bool Agent<TSeq>::has_virus(std::string name) const
-
14323 {
-
14324 
-
14325  if (virus->get_name() == name)
-
14326  return true;
-
14327 
-
14328  return false;
-
14329 
-
14330 }
-
14331 
-
14332 template<typename TSeq>
-
14333 inline bool Agent<TSeq>::has_virus(const Virus<TSeq> & virus) const
-
14334 {
+
14318 }
+
14319 
+
14320 template<typename TSeq>
+
14321 inline bool Agent<TSeq>::has_virus(epiworld_fast_uint t) const
+
14322 {
+
14323  if (virus->get_id() == static_cast<int>(t))
+
14324  return true;
+
14325 
+
14326  return false;
+
14327 }
+
14328 
+
14329 template<typename TSeq>
+
14330 inline bool Agent<TSeq>::has_virus(std::string name) const
+
14331 {
+
14332 
+
14333  if (virus->get_name() == name)
+
14334  return true;
14335 
-
14336  return has_virus(virus.get_id());
+
14336  return false;
14337 
14338 }
14339 
14340 template<typename TSeq>
-
14341 inline void Agent<TSeq>::print(
-
14342  Model<TSeq> * model,
-
14343  bool compressed
-
14344  ) const
-
14345 {
-
14346 
-
14347  if (compressed)
-
14348  {
-
14349  printf_epiworld(
-
14350  "Agent: %i, state: %s (%lu), Has virus: %s, NTools: %lu, NNeigh: %lu\n",
-
14351  id, model->states_labels[state].c_str(), state,
-
14352  virus == nullptr ? std::string("no").c_str() : std::string("yes").c_str(),
-
14353  n_tools, neighbors.size()
-
14354  );
-
14355  }
-
14356  else {
-
14357 
-
14358  printf_epiworld("Information about agent id %i\n", this->id);
-
14359  printf_epiworld(" State : %s (%lu)\n", model->states_labels[state].c_str(), state);
-
14360  printf_epiworld(" Has virus : %s\n", virus == nullptr ?
-
14361  std::string("no").c_str() : std::string("yes").c_str());
-
14362  printf_epiworld(" Tool count : %lu\n", n_tools);
-
14363  printf_epiworld(" Neigh. count : %lu\n", neighbors.size());
-
14364 
-
14365  size_t nfeats = model->get_agents_data_ncols();
-
14366  if (nfeats > 0)
-
14367  {
-
14368 
-
14369  printf_epiworld("This model includes features (%lu): [ ", nfeats);
-
14370 
-
14371  int max_to_show = static_cast<int>((nfeats > 10)? 10 : nfeats);
+
14341 inline bool Agent<TSeq>::has_virus(const Virus<TSeq> & virus) const
+
14342 {
+
14343 
+
14344  return has_virus(virus.get_id());
+
14345 
+
14346 }
+
14347 
+
14348 template<typename TSeq>
+
14349 inline void Agent<TSeq>::print(
+
14350  Model<TSeq> * model,
+
14351  bool compressed
+
14352  ) const
+
14353 {
+
14354 
+
14355  if (compressed)
+
14356  {
+
14357  printf_epiworld(
+
14358  "Agent: %i, state: %s (%lu), Has virus: %s, NTools: %lu, NNeigh: %lu\n",
+
14359  id, model->states_labels[state].c_str(), state,
+
14360  virus == nullptr ? std::string("no").c_str() : std::string("yes").c_str(),
+
14361  n_tools, neighbors.size()
+
14362  );
+
14363  }
+
14364  else {
+
14365 
+
14366  printf_epiworld("Information about agent id %i\n", this->id);
+
14367  printf_epiworld(" State : %s (%lu)\n", model->states_labels[state].c_str(), state);
+
14368  printf_epiworld(" Has virus : %s\n", virus == nullptr ?
+
14369  std::string("no").c_str() : std::string("yes").c_str());
+
14370  printf_epiworld(" Tool count : %lu\n", n_tools);
+
14371  printf_epiworld(" Neigh. count : %lu\n", neighbors.size());
14372 
-
14373  for (int k = 0; k < max_to_show; ++k)
-
14374  {
-
14375  printf_epiworld("%.2f", this->operator[](k));
+
14373  size_t nfeats = model->get_agents_data_ncols();
+
14374  if (nfeats > 0)
+
14375  {
14376 
-
14377  if (k != (max_to_show - 1))
-
14378  {
-
14379  printf_epiworld(", ");
-
14380  } else {
-
14381  printf_epiworld(" ]\n");
-
14382  }
-
14383 
-
14384  }
-
14385 
-
14386  }
-
14387 
-
14388  }
-
14389 
-
14390  return;
+
14377  printf_epiworld("This model includes features (%lu): [ ", nfeats);
+
14378 
+
14379  int max_to_show = static_cast<int>((nfeats > 10)? 10 : nfeats);
+
14380 
+
14381  for (int k = 0; k < max_to_show; ++k)
+
14382  {
+
14383  printf_epiworld("%.2f", this->operator[](k));
+
14384 
+
14385  if (k != (max_to_show - 1))
+
14386  {
+
14387  printf_epiworld(", ");
+
14388  } else {
+
14389  printf_epiworld(" ]\n");
+
14390  }
14391 
-
14392 }
-
14393 
-
14394 template<typename TSeq>
-
14395 inline double & Agent<TSeq>::operator()(size_t j)
-
14396 {
+
14392  }
+
14393 
+
14394  }
+
14395 
+
14396  }
14397 
-
14398  if (model->agents_data_ncols <= j)
-
14399  throw std::logic_error("The requested feature of the agent is out of range.");
-
14400 
-
14401  return *(model->agents_data + j * model->size() + id);
-
14402 
-
14403 }
-
14404 
-
14405 template<typename TSeq>
-
14406 inline double & Agent<TSeq>::operator[](size_t j)
-
14407 {
-
14408  return *(model->agents_data + j * model->size() + id);
-
14409 }
+
14398  return;
+
14399 
+
14400 }
+
14401 
+
14402 template<typename TSeq>
+
14403 inline double & Agent<TSeq>::operator()(size_t j)
+
14404 {
+
14405 
+
14406  if (model->agents_data_ncols <= j)
+
14407  throw std::logic_error("The requested feature of the agent is out of range.");
+
14408 
+
14409  return *(model->agents_data + j * model->size() + id);
14410 
-
14411 template<typename TSeq>
-
14412 inline double Agent<TSeq>::operator()(size_t j) const
-
14413 {
-
14414 
-
14415  if (model->agents_data_ncols <= j)
-
14416  throw std::logic_error("The requested feature of the agent is out of range.");
-
14417 
-
14418  return *(model->agents_data + j * model->size() + id);
-
14419 
-
14420 }
-
14421 
-
14422 template<typename TSeq>
-
14423 inline double Agent<TSeq>::operator[](size_t j) const
-
14424 {
-
14425  return *(model->agents_data + j * model->size() + id);
-
14426 }
+
14411 }
+
14412 
+
14413 template<typename TSeq>
+
14414 inline double & Agent<TSeq>::operator[](size_t j)
+
14415 {
+
14416  return *(model->agents_data + j * model->size() + id);
+
14417 }
+
14418 
+
14419 template<typename TSeq>
+
14420 inline double Agent<TSeq>::operator()(size_t j) const
+
14421 {
+
14422 
+
14423  if (model->agents_data_ncols <= j)
+
14424  throw std::logic_error("The requested feature of the agent is out of range.");
+
14425 
+
14426  return *(model->agents_data + j * model->size() + id);
14427 
-
14428 template<typename TSeq>
-
14429 inline Entities<TSeq> Agent<TSeq>::get_entities()
-
14430 {
-
14431  return Entities<TSeq>(*this);
-
14432 }
-
14433 
-
14434 template<typename TSeq>
-
14435 inline const Entities_const<TSeq> Agent<TSeq>::get_entities() const
-
14436 {
-
14437  return Entities_const<TSeq>(*this);
-
14438 }
-
14439 
-
14440 template<typename TSeq>
-
14441 inline const Entity<TSeq> & Agent<TSeq>::get_entity(size_t i) const
-
14442 {
-
14443  if (i >= n_entities)
-
14444  throw std::range_error("Trying to get to an agent's entity outside of the range.");
-
14445 
-
14446  return model->entities[entities[i]];
-
14447 }
-
14448 
-
14449 template<typename TSeq>
-
14450 inline Entity<TSeq> & Agent<TSeq>::get_entity(size_t i)
-
14451 {
-
14452  if (i >= n_entities)
-
14453  throw std::range_error("Trying to get to an agent's entity outside of the range.");
-
14454 
-
14455  return model->entities[entities[i]];
-
14456 }
-
14457 
-
14458 template<typename TSeq>
-
14459 inline size_t Agent<TSeq>::get_n_entities() const
-
14460 {
-
14461  return n_entities;
-
14462 }
-
14463 
-
14464 template<typename TSeq>
-
14465 inline bool Agent<TSeq>::operator==(const Agent<TSeq> & other) const
-
14466 {
-
14467 
-
14468  EPI_DEBUG_FAIL_AT_TRUE(
-
14469  n_neighbors != other.n_neighbors,
-
14470  "Agent:: n_eighbors don't match"
-
14471  )
-
14472 
-
14473 
-
14474  for (size_t i = 0u; i < n_neighbors; ++i)
-
14475  {
-
14476  EPI_DEBUG_FAIL_AT_TRUE(
-
14477  neighbors[i] != other.neighbors[i],
-
14478  "Agent:: neighbor[i] don't match"
+
14428 }
+
14429 
+
14430 template<typename TSeq>
+
14431 inline double Agent<TSeq>::operator[](size_t j) const
+
14432 {
+
14433  return *(model->agents_data + j * model->size() + id);
+
14434 }
+
14435 
+
14436 template<typename TSeq>
+
14437 inline Entities<TSeq> Agent<TSeq>::get_entities()
+
14438 {
+
14439  return Entities<TSeq>(*this);
+
14440 }
+
14441 
+
14442 template<typename TSeq>
+
14443 inline const Entities_const<TSeq> Agent<TSeq>::get_entities() const
+
14444 {
+
14445  return Entities_const<TSeq>(*this);
+
14446 }
+
14447 
+
14448 template<typename TSeq>
+
14449 inline const Entity<TSeq> & Agent<TSeq>::get_entity(size_t i) const
+
14450 {
+
14451  if (i >= n_entities)
+
14452  throw std::range_error("Trying to get to an agent's entity outside of the range.");
+
14453 
+
14454  return model->entities[entities[i]];
+
14455 }
+
14456 
+
14457 template<typename TSeq>
+
14458 inline Entity<TSeq> & Agent<TSeq>::get_entity(size_t i)
+
14459 {
+
14460  if (i >= n_entities)
+
14461  throw std::range_error("Trying to get to an agent's entity outside of the range.");
+
14462 
+
14463  return model->entities[entities[i]];
+
14464 }
+
14465 
+
14466 template<typename TSeq>
+
14467 inline size_t Agent<TSeq>::get_n_entities() const
+
14468 {
+
14469  return n_entities;
+
14470 }
+
14471 
+
14472 template<typename TSeq>
+
14473 inline bool Agent<TSeq>::operator==(const Agent<TSeq> & other) const
+
14474 {
+
14475 
+
14476  EPI_DEBUG_FAIL_AT_TRUE(
+
14477  n_neighbors != other.n_neighbors,
+
14478  "Agent:: n_eighbors don't match"
14479  )
-
14480  }
+
14480 
14481 
-
14482  EPI_DEBUG_FAIL_AT_TRUE(
-
14483  n_entities != other.n_entities,
-
14484  "Agent:: n_entities don't match"
-
14485  )
-
14486 
-
14487 
-
14488  for (size_t i = 0u; i < n_entities; ++i)
-
14489  {
-
14490  EPI_DEBUG_FAIL_AT_TRUE(
-
14491  entities[i] != other.entities[i],
-
14492  "Agent:: entities[i] don't match"
+
14482  for (size_t i = 0u; i < n_neighbors; ++i)
+
14483  {
+
14484  EPI_DEBUG_FAIL_AT_TRUE(
+
14485  neighbors[i] != other.neighbors[i],
+
14486  "Agent:: neighbor[i] don't match"
+
14487  )
+
14488  }
+
14489 
+
14490  EPI_DEBUG_FAIL_AT_TRUE(
+
14491  n_entities != other.n_entities,
+
14492  "Agent:: n_entities don't match"
14493  )
-
14494  }
-
14495 
-
14496  EPI_DEBUG_FAIL_AT_TRUE(
-
14497  state != other.state,
-
14498  "Agent:: state don't match"
-
14499  )
-
14500 
-
14501 
-
14502  EPI_DEBUG_FAIL_AT_TRUE(
-
14503  state_prev != other.state_prev,
-
14504  "Agent:: state_prev don't match"
-
14505  )
-
14506 
-
14507 
-
14508  // EPI_DEBUG_FAIL_AT_TRUE(
-
14509  // state_last_changed != other.state_last_changed,
-
14510  // "Agent:: state_last_changed don't match"
-
14511  // ) ///< Last time the agent was updated.
-
14512 
-
14513  EPI_DEBUG_FAIL_AT_TRUE(
-
14514  ((virus == nullptr) && (other.virus != nullptr)) ||
-
14515  ((virus != nullptr) && (other.virus == nullptr)),
-
14516  "Agent:: virus don't match"
-
14517  )
-
14518 
-
14519  if ((virus != nullptr) && (other.virus != nullptr))
-
14520  {
-
14521  EPI_DEBUG_FAIL_AT_TRUE(
-
14522  *virus != *other.virus,
-
14523  "Agent:: virus doesn't match"
-
14524  )
-
14525  }
-
14526 
-
14527  EPI_DEBUG_FAIL_AT_TRUE(n_tools != other.n_tools, "Agent:: n_tools don't match")
-
14528 
-
14529  for (size_t i = 0u; i < n_tools; ++i)
-
14530  {
-
14531 
-
14532  EPI_DEBUG_FAIL_AT_TRUE(
-
14533  tools[i] != other.tools[i],
-
14534  "Agent:: tools[i] don't match"
-
14535  )
-
14536 
-
14537  }
-
14538 
-
14539  return true;
-
14540 
-
14541 }
-
14542 
-
14543 #undef CHECK_COALESCE_
-
14544 
-
14545 #endif
-
14546 /*//////////////////////////////////////////////////////////////////////////////
-
14548 
-
14549  End of -include/epiworld/agent-meat.hpp-
-
14550 
-
14553 
-
14554 
-
14555 
-
14556 /*//////////////////////////////////////////////////////////////////////////////
+
14494 
+
14495 
+
14496  for (size_t i = 0u; i < n_entities; ++i)
+
14497  {
+
14498  EPI_DEBUG_FAIL_AT_TRUE(
+
14499  entities[i] != other.entities[i],
+
14500  "Agent:: entities[i] don't match"
+
14501  )
+
14502  }
+
14503 
+
14504  EPI_DEBUG_FAIL_AT_TRUE(
+
14505  state != other.state,
+
14506  "Agent:: state don't match"
+
14507  )
+
14508 
+
14509 
+
14510  EPI_DEBUG_FAIL_AT_TRUE(
+
14511  state_prev != other.state_prev,
+
14512  "Agent:: state_prev don't match"
+
14513  )
+
14514 
+
14515 
+
14516  // EPI_DEBUG_FAIL_AT_TRUE(
+
14517  // state_last_changed != other.state_last_changed,
+
14518  // "Agent:: state_last_changed don't match"
+
14519  // ) ///< Last time the agent was updated.
+
14520 
+
14521  EPI_DEBUG_FAIL_AT_TRUE(
+
14522  ((virus == nullptr) && (other.virus != nullptr)) ||
+
14523  ((virus != nullptr) && (other.virus == nullptr)),
+
14524  "Agent:: virus don't match"
+
14525  )
+
14526 
+
14527  if ((virus != nullptr) && (other.virus != nullptr))
+
14528  {
+
14529  EPI_DEBUG_FAIL_AT_TRUE(
+
14530  *virus != *other.virus,
+
14531  "Agent:: virus doesn't match"
+
14532  )
+
14533  }
+
14534 
+
14535  EPI_DEBUG_FAIL_AT_TRUE(n_tools != other.n_tools, "Agent:: n_tools don't match")
+
14536 
+
14537  for (size_t i = 0u; i < n_tools; ++i)
+
14538  {
+
14539 
+
14540  EPI_DEBUG_FAIL_AT_TRUE(
+
14541  tools[i] != other.tools[i],
+
14542  "Agent:: tools[i] don't match"
+
14543  )
+
14544 
+
14545  }
+
14546 
+
14547  return true;
+
14548 
+
14549 }
+
14550 
+
14551 #undef CHECK_COALESCE_
+
14552 
+
14553 #endif
+
14554 /*//////////////////////////////////////////////////////////////////////////////
+
14556 
+
14557  End of -include/epiworld/agent-meat.hpp-
14558 
-
14559  Start of -include/epiworld/agentssample-bones.hpp-
-
14560 
+
14561 
+
14562 
14563 
-
14564 
-
14565 #ifndef EPIWORLD_AGENTS_BONES_HPP
-
14566 #define EPIWORLD_AGENTS_BONES_HPP
-
14567 
-
14568 class SAMPLETYPE {
-
14569 public:
-
14570  static const int MODEL = 0;
-
14571  static const int ENTITY = 1;
-
14572  static const int AGENT = 2;
-
14573 };
-
14574 
-
14575 // template<typename TSeq>
-
14576 // class Agent;
-
14577 
-
14578 // template<typename TSeq>
-
14579 // class Model;
-
14580 
-
14581 // template<typename TSeq>
-
14582 // class Entity;
-
14583 
-
14591 template<typename TSeq>
-
14592 class AgentsSample {
-
14593 private:
-
14594 
-
14595  size_t sample_size = 0u;
-
14596 
-
14597  std::vector< Agent<TSeq>* > * agents = nullptr; ///< Pointer to sample of agents
-
14598  size_t * agents_n = nullptr; ///< Size of sample of agents
-
14599 
-
14600  std::vector< size_t > * agents_left = nullptr; ///< Pointer to agents left (iota)
-
14601  size_t * agents_left_n = nullptr; ///< Size of agents left
+
14564 /*//////////////////////////////////////////////////////////////////////////////
+
14566 
+
14567  Start of -include/epiworld/agentssample-bones.hpp-
+
14568 
+
14571 
+
14572 
+
14573 #ifndef EPIWORLD_AGENTS_BONES_HPP
+
14574 #define EPIWORLD_AGENTS_BONES_HPP
+
14575 
+
14576 class SAMPLETYPE {
+
14577 public:
+
14578  static const int MODEL = 0;
+
14579  static const int ENTITY = 1;
+
14580  static const int AGENT = 2;
+
14581 };
+
14582 
+
14583 // template<typename TSeq>
+
14584 // class Agent;
+
14585 
+
14586 // template<typename TSeq>
+
14587 // class Model;
+
14588 
+
14589 // template<typename TSeq>
+
14590 // class Entity;
+
14591 
+
14599 template<typename TSeq>
+
14600 class AgentsSample {
+
14601 private:
14602 
-
14603  Model<TSeq> * model = nullptr; ///< Extracts runif() and (if the case) population.
-
14604  Entity<TSeq> * entity = nullptr; ///
-
14605  Agent<TSeq> * agent = nullptr;
-
14606 
-
14607  int sample_type = SAMPLETYPE::AGENT;
-
14608  std::vector< size_t > states = {};
-
14609 
-
14610  void sample_n(size_t n); ///< Backbone function for sampling
-
14611 
-
14612 
-
14613 public:
-
14614 
-
14615  // Not available (for now)
-
14616  AgentsSample() = delete; ///< Default constructor
-
14617  AgentsSample(const AgentsSample<TSeq> & a) = delete; ///< Copy constructor
-
14618  AgentsSample(AgentsSample<TSeq> && a) = delete; ///< Move constructor
+
14603  size_t sample_size = 0u;
+
14604 
+
14605  std::vector< Agent<TSeq>* > * agents = nullptr; ///< Pointer to sample of agents
+
14606  size_t * agents_n = nullptr; ///< Size of sample of agents
+
14607 
+
14608  std::vector< size_t > * agents_left = nullptr; ///< Pointer to agents left (iota)
+
14609  size_t * agents_left_n = nullptr; ///< Size of agents left
+
14610 
+
14611  Model<TSeq> * model = nullptr; ///< Extracts runif() and (if the case) population.
+
14612  Entity<TSeq> * entity = nullptr; ///
+
14613  Agent<TSeq> * agent = nullptr;
+
14614 
+
14615  int sample_type = SAMPLETYPE::AGENT;
+
14616  std::vector< size_t > states = {};
+
14617 
+
14618  void sample_n(size_t n); ///< Backbone function for sampling
14619 
-
14620  AgentsSample(
-
14621  Model<TSeq> & model_, size_t n,
-
14622  std::vector< size_t > states_ = {},
-
14623  bool truncate = false
-
14624  );
-
14625 
-
14626  AgentsSample(
-
14627  Model<TSeq> * model, Entity<TSeq> & entity_, size_t n,
-
14628  std::vector< size_t > states_ = {},
-
14629  bool truncate = false
-
14630  );
-
14631 
-
14632  AgentsSample(
-
14633  Model<TSeq> * model, Agent<TSeq> & agent_, size_t n,
-
14634  std::vector< size_t > states_ = {},
-
14635  bool truncate = false
-
14636  );
-
14637 
-
14638  ~AgentsSample();
+
14620 
+
14621 public:
+
14622 
+
14623  // Not available (for now)
+
14624  AgentsSample() = delete; ///< Default constructor
+
14625  AgentsSample(const AgentsSample<TSeq> & a) = delete; ///< Copy constructor
+
14626  AgentsSample(AgentsSample<TSeq> && a) = delete; ///< Move constructor
+
14627 
+
14628  AgentsSample(
+
14629  Model<TSeq> & model_, size_t n,
+
14630  std::vector< size_t > states_ = {},
+
14631  bool truncate = false
+
14632  );
+
14633 
+
14634  AgentsSample(
+
14635  Model<TSeq> * model, Entity<TSeq> & entity_, size_t n,
+
14636  std::vector< size_t > states_ = {},
+
14637  bool truncate = false
+
14638  );
14639 
-
14640  typename std::vector< Agent<TSeq> * >::iterator begin();
-
14641  typename std::vector< Agent<TSeq> * >::iterator end();
-
14642 
-
14643  Agent<TSeq> * operator[](size_t n);
-
14644  Agent<TSeq> * operator()(size_t n);
-
14645  size_t size() const noexcept;
-
14646 
-
14647 };
-
14648 
-
14649 template<typename TSeq>
-
14650 inline AgentsSample<TSeq>::AgentsSample(
-
14651  Model<TSeq> & model_,
-
14652  size_t n,
-
14653  std::vector< size_t > states_,
-
14654  bool truncate
-
14655  ) {
+
14640  AgentsSample(
+
14641  Model<TSeq> * model, Agent<TSeq> & agent_, size_t n,
+
14642  std::vector< size_t > states_ = {},
+
14643  bool truncate = false
+
14644  );
+
14645 
+
14646  ~AgentsSample();
+
14647 
+
14648  typename std::vector< Agent<TSeq> * >::iterator begin();
+
14649  typename std::vector< Agent<TSeq> * >::iterator end();
+
14650 
+
14651  Agent<TSeq> * operator[](size_t n);
+
14652  Agent<TSeq> * operator()(size_t n);
+
14653  size_t size() const noexcept;
+
14654 
+
14655 };
14656 
-
14657  states = states_;
-
14658 
-
14659  if (truncate)
-
14660  {
-
14661 
-
14662  if (n > model_.size())
-
14663  n = model_.size();
+
14657 template<typename TSeq>
+
14658 inline AgentsSample<TSeq>::AgentsSample(
+
14659  Model<TSeq> & model_,
+
14660  size_t n,
+
14661  std::vector< size_t > states_,
+
14662  bool truncate
+
14663  ) {
14664 
-
14665  } else if (n > model_.size())
-
14666  throw std::logic_error(
-
14667  "There are only " + std::to_string(model_.size()) + " agents. You cannot " +
-
14668  "sample " + std::to_string(n));
-
14669 
-
14670  sample_size = n;
-
14671  model = &model_;
-
14672  sample_type = SAMPLETYPE::MODEL;
-
14673 
-
14674  agents = &model_.sampled_population;
-
14675  agents_n = &model_.sampled_population_n;
-
14676 
-
14677  agents_left = &model_.population_left;
-
14678  agents_left_n = &model_.population_left_n;
-
14679 
-
14680  sample_n(n);
-
14681 
-
14682  return;
-
14683 
-
14684 }
-
14685 
-
14686 template<typename TSeq>
-
14687 inline AgentsSample<TSeq>::AgentsSample(
-
14688  Model<TSeq> * model,
-
14689  Entity<TSeq> & entity_,
-
14690  size_t n,
-
14691  std::vector< size_t > states_,
-
14692  bool truncate
-
14693  ) {
-
14694 
-
14695  states = states_;
-
14696 
-
14697  if (truncate)
-
14698  {
-
14699 
-
14700  if (n > entity_.size())
-
14701  n = entity_.size();
+
14665  states = states_;
+
14666 
+
14667  if (truncate)
+
14668  {
+
14669 
+
14670  if (n > model_.size())
+
14671  n = model_.size();
+
14672 
+
14673  } else if (n > model_.size())
+
14674  throw std::logic_error(
+
14675  "There are only " + std::to_string(model_.size()) + " agents. You cannot " +
+
14676  "sample " + std::to_string(n));
+
14677 
+
14678  sample_size = n;
+
14679  model = &model_;
+
14680  sample_type = SAMPLETYPE::MODEL;
+
14681 
+
14682  agents = &model_.sampled_population;
+
14683  agents_n = &model_.sampled_population_n;
+
14684 
+
14685  agents_left = &model_.population_left;
+
14686  agents_left_n = &model_.population_left_n;
+
14687 
+
14688  sample_n(n);
+
14689 
+
14690  return;
+
14691 
+
14692 }
+
14693 
+
14694 template<typename TSeq>
+
14695 inline AgentsSample<TSeq>::AgentsSample(
+
14696  Model<TSeq> * model,
+
14697  Entity<TSeq> & entity_,
+
14698  size_t n,
+
14699  std::vector< size_t > states_,
+
14700  bool truncate
+
14701  ) {
14702 
-
14703  } else if (n > entity_.size())
-
14704  throw std::logic_error(
-
14705  "There are only " + std::to_string(entity_.size()) + " agents. You cannot " +
-
14706  "sample " + std::to_string(n));
+
14703  states = states_;
+
14704 
+
14705  if (truncate)
+
14706  {
14707 
-
14708  sample_size = n;
-
14709  model = &entity_.model;
-
14710  sample_type = SAMPLETYPE::ENTITY;
-
14711 
-
14712  agents = &entity_.sampled_agents;
-
14713  agents_n = &entity_.sampled_agents_n;
-
14714 
-
14715  agents_left = &entity_.sampled_agents_left;
-
14716  agents_left_n = &entity_.sampled_agents_left_n;
-
14717 
-
14718  sample_n(n);
+
14708  if (n > entity_.size())
+
14709  n = entity_.size();
+
14710 
+
14711  } else if (n > entity_.size())
+
14712  throw std::logic_error(
+
14713  "There are only " + std::to_string(entity_.size()) + " agents. You cannot " +
+
14714  "sample " + std::to_string(n));
+
14715 
+
14716  sample_size = n;
+
14717  model = &entity_.model;
+
14718  sample_type = SAMPLETYPE::ENTITY;
14719 
-
14720  return;
-
14721 
-
14722 }
-
14723 
-
14736 template<typename TSeq>
-
14737 inline AgentsSample<TSeq>::AgentsSample(
-
14738  Model<TSeq> * model,
-
14739  Agent<TSeq> & agent_,
-
14740  size_t n,
-
14741  std::vector< size_t > states_,
-
14742  bool truncate
-
14743  )
-
14744 {
-
14745 
-
14746  states = states_;
-
14747  sample_type = SAMPLETYPE::AGENT;
-
14748 
-
14749  agent = &agent_;
-
14750 
-
14751  agents = &agent_.sampled_agents;
-
14752  agents_n = &agent_.sampled_agents_n;
+
14720  agents = &entity_.sampled_agents;
+
14721  agents_n = &entity_.sampled_agents_n;
+
14722 
+
14723  agents_left = &entity_.sampled_agents_left;
+
14724  agents_left_n = &entity_.sampled_agents_left_n;
+
14725 
+
14726  sample_n(n);
+
14727 
+
14728  return;
+
14729 
+
14730 }
+
14731 
+
14744 template<typename TSeq>
+
14745 inline AgentsSample<TSeq>::AgentsSample(
+
14746  Model<TSeq> * model,
+
14747  Agent<TSeq> & agent_,
+
14748  size_t n,
+
14749  std::vector< size_t > states_,
+
14750  bool truncate
+
14751  )
+
14752 {
14753 
-
14754  agents_left = &agent_.sampled_agents_left;
-
14755  agents_left_n = &agent_.sampled_agents_left_n;
-
14756 
-
14757  // Computing the cumulative sum of counts across entities
-
14758  size_t agents_in_entities = 0;
-
14759  Entities<TSeq> entities_a = agent->get_entities();
-
14760 
-
14761  std::vector< size_t > cum_agents_count(entities_a.size(), 0);
-
14762  int idx = -1;
-
14763  for (auto & e : entities_a)
-
14764  {
-
14765  if (++idx == 0)
-
14766  cum_agents_count[idx] = (e->size() - 1u);
-
14767  else
-
14768  cum_agents_count[idx] = (
-
14769  (e->size() - 1u) +
-
14770  cum_agents_count[idx - 1]
-
14771  );
-
14772 
-
14773  agents_in_entities += (e->size() - 1u);
-
14774  }
-
14775 
-
14776  if (truncate)
-
14777  {
-
14778 
-
14779  if (n > agents_in_entities)
-
14780  n = agents_in_entities;
-
14781 
-
14782  } else if (n > agents_in_entities)
-
14783  throw std::logic_error(
-
14784  "There are only " + std::to_string(agents_in_entities) +
-
14785  " agents. You cannot " +
-
14786  "sample " + std::to_string(n)
-
14787  );
-
14788 
-
14789  sample_size = n;
-
14790 
-
14791  if (agents->size() < n)
-
14792  agents->resize(n);
-
14793 
-
14794  size_t i_obs = 0u;
-
14795  for (size_t i = 0u; i < agents_in_entities; ++i)
-
14796  {
-
14797  int jth = std::floor(model->runif() * agents_in_entities);
-
14798  for (size_t e = 0u; e < cum_agents_count.size(); ++e)
-
14799  {
-
14800  // Are we in the limit?
-
14801  if (jth <= cum_agents_count[e])
-
14802  {
-
14803  size_t agent_idx = 0u;
-
14804  if (e == 0) // From the first group
-
14805  agent_idx = entities_a[e][jth];
-
14806  else
-
14807  agent_idx = entities_a[e][jth - cum_agents_count[e - 1]];
-
14808 
-
14809  // Getting the state
-
14810  size_t state = model->population[agent_idx].get_state();
-
14811 
-
14812  // Checking if states was specified
-
14813  if (states.size())
-
14814  {
-
14815  if (std::find(states.begin(), states.end(), state) != states.end())
-
14816  continue;
-
14817  }
-
14818 
-
14819  agents->operator[](i_obs++) = agent_idx;
-
14820 
-
14821  break;
-
14822  }
-
14823 
-
14824  }
-
14825  }
-
14826 
-
14827  return;
+
14754  states = states_;
+
14755  sample_type = SAMPLETYPE::AGENT;
+
14756 
+
14757  agent = &agent_;
+
14758 
+
14759  agents = &agent_.sampled_agents;
+
14760  agents_n = &agent_.sampled_agents_n;
+
14761 
+
14762  agents_left = &agent_.sampled_agents_left;
+
14763  agents_left_n = &agent_.sampled_agents_left_n;
+
14764 
+
14765  // Computing the cumulative sum of counts across entities
+
14766  size_t agents_in_entities = 0;
+
14767  Entities<TSeq> entities_a = agent->get_entities();
+
14768 
+
14769  std::vector< size_t > cum_agents_count(entities_a.size(), 0);
+
14770  int idx = -1;
+
14771  for (auto & e : entities_a)
+
14772  {
+
14773  if (++idx == 0)
+
14774  cum_agents_count[idx] = (e->size() - 1u);
+
14775  else
+
14776  cum_agents_count[idx] = (
+
14777  (e->size() - 1u) +
+
14778  cum_agents_count[idx - 1]
+
14779  );
+
14780 
+
14781  agents_in_entities += (e->size() - 1u);
+
14782  }
+
14783 
+
14784  if (truncate)
+
14785  {
+
14786 
+
14787  if (n > agents_in_entities)
+
14788  n = agents_in_entities;
+
14789 
+
14790  } else if (n > agents_in_entities)
+
14791  throw std::logic_error(
+
14792  "There are only " + std::to_string(agents_in_entities) +
+
14793  " agents. You cannot " +
+
14794  "sample " + std::to_string(n)
+
14795  );
+
14796 
+
14797  sample_size = n;
+
14798 
+
14799  if (agents->size() < n)
+
14800  agents->resize(n);
+
14801 
+
14802  size_t i_obs = 0u;
+
14803  for (size_t i = 0u; i < agents_in_entities; ++i)
+
14804  {
+
14805  int jth = std::floor(model->runif() * agents_in_entities);
+
14806  for (size_t e = 0u; e < cum_agents_count.size(); ++e)
+
14807  {
+
14808  // Are we in the limit?
+
14809  if (jth <= cum_agents_count[e])
+
14810  {
+
14811  size_t agent_idx = 0u;
+
14812  if (e == 0) // From the first group
+
14813  agent_idx = entities_a[e][jth];
+
14814  else
+
14815  agent_idx = entities_a[e][jth - cum_agents_count[e - 1]];
+
14816 
+
14817  // Getting the state
+
14818  size_t state = model->population[agent_idx].get_state();
+
14819 
+
14820  // Checking if states was specified
+
14821  if (states.size())
+
14822  {
+
14823  if (std::find(states.begin(), states.end(), state) != states.end())
+
14824  continue;
+
14825  }
+
14826 
+
14827  agents->operator[](i_obs++) = agent_idx;
14828 
-
14829 }
-
14830 
-
14831 template<typename TSeq>
-
14832 inline AgentsSample<TSeq>::~AgentsSample() {}
-
14833 
-
14834 template<typename TSeq>
-
14835 inline size_t AgentsSample<TSeq>::size() const noexcept
-
14836 {
-
14837  return this->sample_size;
-
14838 }
-
14839 
-
14840 template<typename TSeq>
-
14841 inline Agent<TSeq> * AgentsSample<TSeq>::operator[](size_t i)
-
14842 {
-
14843 
-
14844  return agents->operator[](i);
-
14845 
+
14829  break;
+
14830  }
+
14831 
+
14832  }
+
14833  }
+
14834 
+
14835  return;
+
14836 
+
14837 }
+
14838 
+
14839 template<typename TSeq>
+
14840 inline AgentsSample<TSeq>::~AgentsSample() {}
+
14841 
+
14842 template<typename TSeq>
+
14843 inline size_t AgentsSample<TSeq>::size() const noexcept
+
14844 {
+
14845  return this->sample_size;
14846 }
14847 
14848 template<typename TSeq>
-
14849 inline Agent<TSeq> * AgentsSample<TSeq>::operator()(size_t i)
+
14849 inline Agent<TSeq> * AgentsSample<TSeq>::operator[](size_t i)
14850 {
14851 
-
14852  if (i >= this->sample_size)
-
14853  throw std::range_error("The requested agent is out of range.");
-
14854 
-
14855  return agents->operator[](i);
-
14856 
-
14857 }
-
14858 
-
14859 template<typename TSeq>
-
14860 inline typename std::vector< Agent<TSeq> * >::iterator AgentsSample<TSeq>::begin()
-
14861 {
+
14852  return agents->operator[](i);
+
14853 
+
14854 }
+
14855 
+
14856 template<typename TSeq>
+
14857 inline Agent<TSeq> * AgentsSample<TSeq>::operator()(size_t i)
+
14858 {
+
14859 
+
14860  if (i >= this->sample_size)
+
14861  throw std::range_error("The requested agent is out of range.");
14862 
-
14863  if (sample_size > 0u)
-
14864  return agents->begin();
-
14865  else
-
14866  return agents->end();
-
14867 
-
14868 }
-
14869 
-
14870 template<typename TSeq>
-
14871 inline typename std::vector< Agent<TSeq> * >::iterator AgentsSample<TSeq>::end()
-
14872 {
-
14873 
-
14874  return agents->begin() + sample_size;
+
14863  return agents->operator[](i);
+
14864 
+
14865 }
+
14866 
+
14867 template<typename TSeq>
+
14868 inline typename std::vector< Agent<TSeq> * >::iterator AgentsSample<TSeq>::begin()
+
14869 {
+
14870 
+
14871  if (sample_size > 0u)
+
14872  return agents->begin();
+
14873  else
+
14874  return agents->end();
14875 
14876 }
14877 
14878 template<typename TSeq>
-
14879 inline void AgentsSample<TSeq>::sample_n(size_t n)
+
14879 inline typename std::vector< Agent<TSeq> * >::iterator AgentsSample<TSeq>::end()
14880 {
14881 
-
14882  // Reducing size
-
14883  if (states.size())
-
14884  {
-
14885 
-
14886  // Getting the number of agents left
-
14887  agents_left->clear();
-
14888 
-
14889  if (sample_type == SAMPLETYPE::MODEL)
-
14890  {
-
14891 
-
14892  // Making some room
-
14893  agents_left->reserve(model->size());
-
14894 
-
14895  // Iterating through the agents in the population
-
14896  for (size_t a_i = 0u; a_i < model->population.size(); ++a_i)
-
14897  {
-
14898 
-
14899  // If the agent is within the selected set of states,
-
14900  // then we add it to the list of agents left
-
14901  size_t s = model->population[a_i].get_state();
-
14902  if (std::find(states.begin(), states.end(), s) != states.end())
-
14903  agents_left->push_back(a_i);
-
14904 
-
14905  }
+
14882  return agents->begin() + sample_size;
+
14883 
+
14884 }
+
14885 
+
14886 template<typename TSeq>
+
14887 inline void AgentsSample<TSeq>::sample_n(size_t n)
+
14888 {
+
14889 
+
14890  // Reducing size
+
14891  if (states.size())
+
14892  {
+
14893 
+
14894  // Getting the number of agents left
+
14895  agents_left->clear();
+
14896 
+
14897  if (sample_type == SAMPLETYPE::MODEL)
+
14898  {
+
14899 
+
14900  // Making some room
+
14901  agents_left->reserve(model->size());
+
14902 
+
14903  // Iterating through the agents in the population
+
14904  for (size_t a_i = 0u; a_i < model->population.size(); ++a_i)
+
14905  {
14906 
-
14907  }
-
14908  else if (sample_type == SAMPLETYPE::ENTITY)
-
14909  {
-
14910 
-
14911  // Making room
-
14912  agents_left->reserve(entity->size());
-
14913 
-
14914  // Iterating through the agents in the entity
-
14915  for (size_t a_i = 0u; a_i < entity->size(); ++a_i)
-
14916  {
-
14917  size_t s = model->population[entity->agents[a_i]].get_state();
-
14918  if (std::find(states.begin(), states.end(), s) != states.end())
-
14919  agents_left->push_back(a_i);
-
14920 
-
14921  }
-
14922 
-
14923  }
-
14924 
-
14925  } else {
-
14926 
-
14927  // Checking if the size of the entity has changed (or hasn't been initialized)
-
14928  if (sample_type == SAMPLETYPE::MODEL)
-
14929  {
+
14907  // If the agent is within the selected set of states,
+
14908  // then we add it to the list of agents left
+
14909  size_t s = model->population[a_i].get_state();
+
14910  if (std::find(states.begin(), states.end(), s) != states.end())
+
14911  agents_left->push_back(a_i);
+
14912 
+
14913  }
+
14914 
+
14915  }
+
14916  else if (sample_type == SAMPLETYPE::ENTITY)
+
14917  {
+
14918 
+
14919  // Making room
+
14920  agents_left->reserve(entity->size());
+
14921 
+
14922  // Iterating through the agents in the entity
+
14923  for (size_t a_i = 0u; a_i < entity->size(); ++a_i)
+
14924  {
+
14925  size_t s = model->population[entity->agents[a_i]].get_state();
+
14926  if (std::find(states.begin(), states.end(), s) != states.end())
+
14927  agents_left->push_back(a_i);
+
14928 
+
14929  }
14930 
-
14931  if (model->size() != agents_left->size())
-
14932  {
-
14933  agents_left->resize(model->size(), 0u);
-
14934  std::iota(agents_left->begin(), agents_left->end(), 0u);
-
14935  }
-
14936 
-
14937  } else if (sample_type == SAMPLETYPE::ENTITY) {
+
14931  }
+
14932 
+
14933  } else {
+
14934 
+
14935  // Checking if the size of the entity has changed (or hasn't been initialized)
+
14936  if (sample_type == SAMPLETYPE::MODEL)
+
14937  {
14938 
-
14939  if (entity->size() != agents_left->size())
+
14939  if (model->size() != agents_left->size())
14940  {
-
14941 
-
14942  agents_left->resize(entity->size(), 0u);
-
14943  std::iota(agents_left->begin(), agents_left->end(), 0u);
+
14941  agents_left->resize(model->size(), 0u);
+
14942  std::iota(agents_left->begin(), agents_left->end(), 0u);
+
14943  }
14944 
-
14945  }
+
14945  } else if (sample_type == SAMPLETYPE::ENTITY) {
14946 
-
14947  }
-
14948 
-
14949  }
-
14950 
-
14951  // Restart the counter of agents left
-
14952  *agents_left_n = agents_left->size();
-
14953 
-
14954  // Making sure we have enough room for the sample of agents
-
14955  if (agents->size() < sample_size)
-
14956  agents->resize(sample_size, nullptr);
-
14957 
-
14958  if (sample_type == SAMPLETYPE::MODEL)
-
14959  {
-
14960 
-
14961  #ifdef EPI_DEBUG
-
14962  std::vector< bool > __sampled(model->size(), true);
-
14963  for (auto & a_i: *agents_left)
-
14964  __sampled[a_i] = false;
-
14965  #endif
-
14966 
-
14967  for (size_t i = 0u; i < n; ++i)
-
14968  {
-
14969 
-
14970  // Sampling from 0 to (agents_left_n - 1)
-
14971  size_t ith_ = static_cast<size_t>(model->runif() * ((*agents_left_n)--));
-
14972 
-
14973  // Getting the id of the agent and adding it to the list of agents
-
14974  size_t ith = agents_left->operator[](ith_);
-
14975  agents->operator[](i) = &model->population[ith];
-
14976 
-
14977  #ifdef EPI_DEBUG
-
14978  if (__sampled[ith])
-
14979  throw std::logic_error("The same agent was sampled twice.");
-
14980  else
-
14981  __sampled[ith] = true;
-
14982  #endif
-
14983 
-
14984  // Updating list
-
14985  std::swap(
-
14986  agents_left->operator[](ith_),
-
14987  agents_left->operator[](*agents_left_n)
-
14988  );
-
14989 
-
14990  }
+
14947  if (entity->size() != agents_left->size())
+
14948  {
+
14949 
+
14950  agents_left->resize(entity->size(), 0u);
+
14951  std::iota(agents_left->begin(), agents_left->end(), 0u);
+
14952 
+
14953  }
+
14954 
+
14955  }
+
14956 
+
14957  }
+
14958 
+
14959  // Restart the counter of agents left
+
14960  *agents_left_n = agents_left->size();
+
14961 
+
14962  // Making sure we have enough room for the sample of agents
+
14963  if (agents->size() < sample_size)
+
14964  agents->resize(sample_size, nullptr);
+
14965 
+
14966  if (sample_type == SAMPLETYPE::MODEL)
+
14967  {
+
14968 
+
14969  #ifdef EPI_DEBUG
+
14970  std::vector< bool > __sampled(model->size(), true);
+
14971  for (auto & a_i: *agents_left)
+
14972  __sampled[a_i] = false;
+
14973  #endif
+
14974 
+
14975  for (size_t i = 0u; i < n; ++i)
+
14976  {
+
14977 
+
14978  // Sampling from 0 to (agents_left_n - 1)
+
14979  size_t ith_ = static_cast<size_t>(model->runif() * ((*agents_left_n)--));
+
14980 
+
14981  // Getting the id of the agent and adding it to the list of agents
+
14982  size_t ith = agents_left->operator[](ith_);
+
14983  agents->operator[](i) = &model->population[ith];
+
14984 
+
14985  #ifdef EPI_DEBUG
+
14986  if (__sampled[ith])
+
14987  throw std::logic_error("The same agent was sampled twice.");
+
14988  else
+
14989  __sampled[ith] = true;
+
14990  #endif
14991 
-
14992 
-
14993  }
-
14994  else if (sample_type == SAMPLETYPE::ENTITY)
-
14995  {
-
14996 
-
14997  #ifdef EPI_DEBUG
-
14998  std::vector< bool > __sampled(entity->size(), true);
-
14999  for (auto & a_i: *agents_left)
-
15000  __sampled[a_i] = false;
-
15001  #endif
-
15002 
-
15003  for (size_t i = 0u; i < n; ++i)
-
15004  {
-
15005 
-
15006  size_t ith_ = static_cast<size_t>(model->runif() * ((*agents_left_n)--));
-
15007  size_t ith = agents_left->operator[](ith_);
-
15008  agents->operator[](i) = &model->population[entity->agents[ith]];
-
15009 
-
15010  #ifdef EPI_DEBUG
-
15011  if (__sampled[ith])
-
15012  throw std::logic_error("The same agent was sampled twice.");
-
15013  else
-
15014  __sampled[ith] = true;
-
15015  #endif
-
15016 
-
15017  // Updating list
-
15018  std::swap(agents_left->operator[](ith_), agents_left->operator[](*agents_left_n));
-
15019 
-
15020  }
-
15021 
-
15022  }
-
15023 
-
15024  return;
-
15025 
-
15026 }
+
14992  // Updating list
+
14993  std::swap(
+
14994  agents_left->operator[](ith_),
+
14995  agents_left->operator[](*agents_left_n)
+
14996  );
+
14997 
+
14998  }
+
14999 
+
15000 
+
15001  }
+
15002  else if (sample_type == SAMPLETYPE::ENTITY)
+
15003  {
+
15004 
+
15005  #ifdef EPI_DEBUG
+
15006  std::vector< bool > __sampled(entity->size(), true);
+
15007  for (auto & a_i: *agents_left)
+
15008  __sampled[a_i] = false;
+
15009  #endif
+
15010 
+
15011  for (size_t i = 0u; i < n; ++i)
+
15012  {
+
15013 
+
15014  size_t ith_ = static_cast<size_t>(model->runif() * ((*agents_left_n)--));
+
15015  size_t ith = agents_left->operator[](ith_);
+
15016  agents->operator[](i) = &model->population[entity->agents[ith]];
+
15017 
+
15018  #ifdef EPI_DEBUG
+
15019  if (__sampled[ith])
+
15020  throw std::logic_error("The same agent was sampled twice.");
+
15021  else
+
15022  __sampled[ith] = true;
+
15023  #endif
+
15024 
+
15025  // Updating list
+
15026  std::swap(agents_left->operator[](ith_), agents_left->operator[](*agents_left_n));
15027 
-
15028 #endif
-
15029 /*//////////////////////////////////////////////////////////////////////////////
+
15028  }
+
15029 
+
15030  }
15031 
-
15032  End of -include/epiworld/agentssample-bones.hpp-
+
15032  return;
15033 
-
15036 
-
15037 
-
15038 
-
15039 /*//////////////////////////////////////////////////////////////////////////////
+
15034 }
+
15035 
+
15036 #endif
+
15037 /*//////////////////////////////////////////////////////////////////////////////
+
15039 
+
15040  End of -include/epiworld/agentssample-bones.hpp-
15041 
-
15042  Start of -include/epiworld/models/models.hpp-
-
15043 
+
15044 
+
15045 
15046 
-
15047 
-
15048 #ifndef EPIWORLD_MODELS_HPP
-
15049 #define EPIWORLD_MODELS_HPP
-
15050 
-
15051 namespace epimodels {
-
15052 
-
15053 /*//////////////////////////////////////////////////////////////////////////////
+
15047 /*//////////////////////////////////////////////////////////////////////////////
+
15049 
+
15050  Start of -include/epiworld/models/models.hpp-
+
15051 
+
15054 
15055 
-
15056  Start of -include/epiworld//models/init-functions.hpp-
-
15057 
+
15056 #ifndef EPIWORLD_MODELS_HPP
+
15057 #define EPIWORLD_MODELS_HPP
+
15058 
+
15059 namespace epimodels {
15060 
-
15061 
-
15062 #ifndef EPIWORLD_MODELS_INIT_FUNCTIONS_HPP
-
15063 #define EPIWORLD_MODELS_INIT_FUNCTIONS_HPP
-
15064 
-
15069 template<typename TSeq>
-
15070 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_sir(
-
15071  std::vector< double > proportions_
-
15072 ) {
-
15073 
-
15074  // Checking widths
-
15075  if (proportions_.size() != 1u)
-
15076  throw std::invalid_argument(
-
15077  "The vector of proportions must have a single element."
-
15078  );
-
15079 
-
15080  // Proportion should be within [0, 1]
-
15081  if ((proportions_[0] < 0.0) || (proportions_[0] > 1.0))
-
15082  throw std::invalid_argument(
-
15083  "The proportion must be within (0, 1)."
-
15084  );
-
15085 
-
15086  double prop = proportions_[0u];
+
15061 /*//////////////////////////////////////////////////////////////////////////////
+
15063 
+
15064  Start of -include/epiworld//models/init-functions.hpp-
+
15065 
+
15068 
+
15069 
+
15070 #ifndef EPIWORLD_MODELS_INIT_FUNCTIONS_HPP
+
15071 #define EPIWORLD_MODELS_INIT_FUNCTIONS_HPP
+
15072 
+
15077 template<typename TSeq>
+
15078 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_sir(
+
15079  std::vector< double > proportions_
+
15080 ) {
+
15081 
+
15082  // Checking widths
+
15083  if (proportions_.size() != 1u)
+
15084  throw std::invalid_argument(
+
15085  "The vector of proportions must have a single element."
+
15086  );
15087 
-
15088  std::function<void(epiworld::Model<TSeq>*)> fun =
-
15089  [prop] (epiworld::Model<TSeq> * model) -> void {
-
15090 
-
15091  // Figuring out information about the viruses
-
15092  double tot = 0.0;
-
15093  const auto & vpreval = model->get_prevalence_virus();
-
15094  const auto & vprop = model->get_prevalence_virus_as_proportion();
-
15095  double n = static_cast<double>(model->size());
-
15096  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
-
15097  {
-
15098  if (vprop[i])
-
15099  tot += vpreval[i];
-
15100  else
-
15101  tot += vpreval[i] / n;
-
15102  }
-
15103 
-
15104  // Putting the total into context
-
15105  double tot_left = 1.0 - tot;
-
15106 
-
15107  // Since susceptible and infected are "fixed,"
-
15108  // we only need to change recovered
-
15109  size_t nrecovered = prop * tot_left * n;
-
15110 
-
15111  epiworld::AgentsSample<TSeq> sample(
-
15112  *model,
-
15113  nrecovered,
-
15114  {0u},
-
15115  true
-
15116  );
-
15117 
-
15118  // Setting up the initial states
-
15119  for (auto & agent : sample)
-
15120  agent->change_state(model, 2, Queue<TSeq>::NoOne);
-
15121 
-
15122  // Running the actions
-
15123  model->actions_run();
-
15124 
-
15125  return;
-
15126 
-
15127  };
-
15128 
-
15129  return fun;
-
15130 
-
15131 }
+
15088  // Proportion should be within [0, 1]
+
15089  if ((proportions_[0] < 0.0) || (proportions_[0] > 1.0))
+
15090  throw std::invalid_argument(
+
15091  "The proportion must be within (0, 1)."
+
15092  );
+
15093 
+
15094  double prop = proportions_[0u];
+
15095 
+
15096  std::function<void(epiworld::Model<TSeq>*)> fun =
+
15097  [prop] (epiworld::Model<TSeq> * model) -> void {
+
15098 
+
15099  // Figuring out information about the viruses
+
15100  double tot = 0.0;
+
15101  const auto & vpreval = model->get_prevalence_virus();
+
15102  const auto & vprop = model->get_prevalence_virus_as_proportion();
+
15103  double n = static_cast<double>(model->size());
+
15104  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
+
15105  {
+
15106  if (vprop[i])
+
15107  tot += vpreval[i];
+
15108  else
+
15109  tot += vpreval[i] / n;
+
15110  }
+
15111 
+
15112  // Putting the total into context
+
15113  double tot_left = 1.0 - tot;
+
15114 
+
15115  // Since susceptible and infected are "fixed,"
+
15116  // we only need to change recovered
+
15117  size_t nrecovered = prop * tot_left * n;
+
15118 
+
15119  epiworld::AgentsSample<TSeq> sample(
+
15120  *model,
+
15121  nrecovered,
+
15122  {0u},
+
15123  true
+
15124  );
+
15125 
+
15126  // Setting up the initial states
+
15127  for (auto & agent : sample)
+
15128  agent->change_state(model, 2, Queue<TSeq>::NoOne);
+
15129 
+
15130  // Running the actions
+
15131  model->actions_run();
15132 
-
15137 template<typename TSeq>
-
15138 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_sird(
-
15139  std::vector< double > prop
-
15140 ) {
-
15141 
-
15142  // Check length of prop equals two
-
15143  if (prop.size() != 2u)
-
15144  throw std::invalid_argument(
-
15145  "The vector of proportions must have two elements."
-
15146  );
-
15147 
-
15148  // Check elements in prop are within [0, 1] and sum up to 1
-
15149  double tot = 0.0;
-
15150  for (auto & v : prop)
-
15151  {
-
15152  if ((v < 0.0) || (v > 1.0))
-
15153  throw std::invalid_argument(
-
15154  "The proportion must be within (0, 1)."
-
15155  );
-
15156  tot += v;
-
15157  }
-
15158 
-
15159  if (tot >= 1.0)
-
15160  throw std::invalid_argument(
-
15161  "The proportions must sum up to 1."
-
15162  );
-
15163 
-
15164  std::function<void(epiworld::Model<TSeq>*)> fun =
-
15165  [prop] (epiworld::Model<TSeq> * model) -> void {
+
15133  return;
+
15134 
+
15135  };
+
15136 
+
15137  return fun;
+
15138 
+
15139 }
+
15140 
+
15145 template<typename TSeq>
+
15146 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_sird(
+
15147  std::vector< double > prop
+
15148 ) {
+
15149 
+
15150  // Check length of prop equals two
+
15151  if (prop.size() != 2u)
+
15152  throw std::invalid_argument(
+
15153  "The vector of proportions must have two elements."
+
15154  );
+
15155 
+
15156  // Check elements in prop are within [0, 1] and sum up to 1
+
15157  double tot = 0.0;
+
15158  for (auto & v : prop)
+
15159  {
+
15160  if ((v < 0.0) || (v > 1.0))
+
15161  throw std::invalid_argument(
+
15162  "The proportion must be within (0, 1)."
+
15163  );
+
15164  tot += v;
+
15165  }
15166 
-
15167  // Figuring out information about the viruses
-
15168  double tot = 0.0;
-
15169  const auto & vpreval = model->get_prevalence_virus();
-
15170  const auto & vprop = model->get_prevalence_virus_as_proportion();
-
15171  double n = static_cast<double>(model->size());
-
15172  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
-
15173  {
-
15174  if (vprop[i])
-
15175  tot += vpreval[i];
-
15176  else
-
15177  tot += vpreval[i] / n;
-
15178  }
-
15179 
-
15180  // Putting the total into context
-
15181  double tot_left = 1.0 - tot;
-
15182 
-
15183  // Since susceptible and infected are "fixed,"
-
15184  // we only need to change recovered
-
15185  size_t nrecovered = prop[0u] * tot_left * n;
-
15186  size_t ndeceased = prop[01] * tot_left * n;
-
15187 
-
15188  epiworld::AgentsSample<TSeq> sample_recover(
-
15189  *model,
-
15190  nrecovered,
-
15191  {0u},
-
15192  true
-
15193  );
-
15194 
-
15195  // Setting up the initial states
-
15196  for (auto & agent : sample_recover)
-
15197  agent->change_state(model, 2, Queue<TSeq>::NoOne);
-
15198 
-
15199  epiworld::AgentsSample<TSeq> sample_deceased(
-
15200  *model,
-
15201  ndeceased,
-
15202  {0u},
-
15203  true
-
15204  );
-
15205 
-
15206  // Setting up the initial states
-
15207  for (auto & agent : sample_deceased)
-
15208  agent->change_state(model, 3, Queue<TSeq>::NoOne);
-
15209 
-
15210  // Running the actions
-
15211  model->actions_run();
-
15212 
-
15213  return;
-
15214 
-
15215  };
-
15216 
-
15217  return fun;
-
15218 
-
15219 }
+
15167  if (tot >= 1.0)
+
15168  throw std::invalid_argument(
+
15169  "The proportions must sum up to 1."
+
15170  );
+
15171 
+
15172  std::function<void(epiworld::Model<TSeq>*)> fun =
+
15173  [prop] (epiworld::Model<TSeq> * model) -> void {
+
15174 
+
15175  // Figuring out information about the viruses
+
15176  double tot = 0.0;
+
15177  const auto & vpreval = model->get_prevalence_virus();
+
15178  const auto & vprop = model->get_prevalence_virus_as_proportion();
+
15179  double n = static_cast<double>(model->size());
+
15180  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
+
15181  {
+
15182  if (vprop[i])
+
15183  tot += vpreval[i];
+
15184  else
+
15185  tot += vpreval[i] / n;
+
15186  }
+
15187 
+
15188  // Putting the total into context
+
15189  double tot_left = 1.0 - tot;
+
15190 
+
15191  // Since susceptible and infected are "fixed,"
+
15192  // we only need to change recovered
+
15193  size_t nrecovered = prop[0u] * tot_left * n;
+
15194  size_t ndeceased = prop[01] * tot_left * n;
+
15195 
+
15196  epiworld::AgentsSample<TSeq> sample_recover(
+
15197  *model,
+
15198  nrecovered,
+
15199  {0u},
+
15200  true
+
15201  );
+
15202 
+
15203  // Setting up the initial states
+
15204  for (auto & agent : sample_recover)
+
15205  agent->change_state(model, 2, Queue<TSeq>::NoOne);
+
15206 
+
15207  epiworld::AgentsSample<TSeq> sample_deceased(
+
15208  *model,
+
15209  ndeceased,
+
15210  {0u},
+
15211  true
+
15212  );
+
15213 
+
15214  // Setting up the initial states
+
15215  for (auto & agent : sample_deceased)
+
15216  agent->change_state(model, 3, Queue<TSeq>::NoOne);
+
15217 
+
15218  // Running the actions
+
15219  model->actions_run();
15220 
-
15221 
-
15226 template<typename TSeq>
-
15227 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_seir(
-
15228  std::vector< double > proportions_
-
15229 ) {
-
15230 
-
15231  // Checking widths
-
15232  if (proportions_.size() != 2u) {
-
15233  throw std::invalid_argument("-proportions_- must have two entries.");
-
15234  }
-
15235 
-
15236  // proportions_ are values between 0 and 1, otherwise error
-
15237  for (auto & v : proportions_)
-
15238  if ((v < 0.0) || (v > 1.0))
-
15239  throw std::invalid_argument(
-
15240  "-proportions_- must have values between 0 and 1."
-
15241  );
-
15242 
+
15221  return;
+
15222 
+
15223  };
+
15224 
+
15225  return fun;
+
15226 
+
15227 }
+
15228 
+
15229 
+
15234 template<typename TSeq>
+
15235 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_seir(
+
15236  std::vector< double > proportions_
+
15237 ) {
+
15238 
+
15239  // Checking widths
+
15240  if (proportions_.size() != 2u) {
+
15241  throw std::invalid_argument("-proportions_- must have two entries.");
+
15242  }
15243 
-
15244  std::function<void(epiworld::Model<TSeq>*)> fun =
-
15245  [proportions_] (epiworld::Model<TSeq> * model) -> void {
-
15246 
-
15247  // Figuring out information about the viruses
-
15248  double tot = 0.0;
-
15249  const auto & vpreval = model->get_prevalence_virus();
-
15250  const auto & vprop = model->get_prevalence_virus_as_proportion();
-
15251  double n = static_cast<double>(model->size());
-
15252  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
-
15253  {
-
15254  if (vprop[i])
-
15255  tot += vpreval[i];
-
15256  else
-
15257  tot += vpreval[i] / n;
-
15258  }
-
15259 
-
15260  // Putting the total into context
-
15261  double tot_left = 1.0 - tot;
-
15262 
-
15263  // Since susceptible and infected are "fixed,"
-
15264  // we only need to change recovered
-
15265  size_t nexposed = proportions_[0u] * tot * n;
-
15266  size_t nrecovered = proportions_[1u] * tot_left * n;
-
15267 
-
15268  epiworld::AgentsSample<TSeq> sample_suscept(
-
15269  *model,
-
15270  nrecovered,
-
15271  {0u},
-
15272  true
-
15273  );
-
15274 
-
15275  // Setting up the initial states
-
15276  for (auto & agent : sample_suscept)
-
15277  agent->change_state(model, 3, Queue<TSeq>::NoOne);
-
15278 
-
15279  epiworld::AgentsSample<TSeq> sample_exposed(
-
15280  *model,
-
15281  nexposed,
-
15282  {1u},
-
15283  true
-
15284  );
-
15285 
-
15286  // Setting up the initial states
-
15287  for (auto & agent : sample_exposed)
-
15288  agent->change_state(model, 2, Queue<TSeq>::NoOne);
-
15289 
-
15290  // Running the actions
-
15291  model->actions_run();
-
15292 
-
15293  return;
-
15294 
-
15295  };
-
15296 
-
15297  return fun;
-
15298 
-
15299 }
+
15244  // proportions_ are values between 0 and 1, otherwise error
+
15245  for (auto & v : proportions_)
+
15246  if ((v < 0.0) || (v > 1.0))
+
15247  throw std::invalid_argument(
+
15248  "-proportions_- must have values between 0 and 1."
+
15249  );
+
15250 
+
15251 
+
15252  std::function<void(epiworld::Model<TSeq>*)> fun =
+
15253  [proportions_] (epiworld::Model<TSeq> * model) -> void {
+
15254 
+
15255  // Figuring out information about the viruses
+
15256  double tot = 0.0;
+
15257  const auto & vpreval = model->get_prevalence_virus();
+
15258  const auto & vprop = model->get_prevalence_virus_as_proportion();
+
15259  double n = static_cast<double>(model->size());
+
15260  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
+
15261  {
+
15262  if (vprop[i])
+
15263  tot += vpreval[i];
+
15264  else
+
15265  tot += vpreval[i] / n;
+
15266  }
+
15267 
+
15268  // Putting the total into context
+
15269  double tot_left = 1.0 - tot;
+
15270 
+
15271  // Since susceptible and infected are "fixed,"
+
15272  // we only need to change recovered
+
15273  size_t nexposed = proportions_[0u] * tot * n;
+
15274  size_t nrecovered = proportions_[1u] * tot_left * n;
+
15275 
+
15276  epiworld::AgentsSample<TSeq> sample_suscept(
+
15277  *model,
+
15278  nrecovered,
+
15279  {0u},
+
15280  true
+
15281  );
+
15282 
+
15283  // Setting up the initial states
+
15284  for (auto & agent : sample_suscept)
+
15285  agent->change_state(model, 3, Queue<TSeq>::NoOne);
+
15286 
+
15287  epiworld::AgentsSample<TSeq> sample_exposed(
+
15288  *model,
+
15289  nexposed,
+
15290  {1u},
+
15291  true
+
15292  );
+
15293 
+
15294  // Setting up the initial states
+
15295  for (auto & agent : sample_exposed)
+
15296  agent->change_state(model, 2, Queue<TSeq>::NoOne);
+
15297 
+
15298  // Running the actions
+
15299  model->actions_run();
15300 
-
15305 template<typename TSeq>
-
15306 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_seird(
-
15307  std::vector< double > proportions_
-
15308 ) {
-
15309 
-
15310  // Checking widths
-
15311  if (proportions_.size() != 3u) {
-
15312  throw std::invalid_argument("-proportions_- must have three entries.");
-
15313  }
-
15314 
-
15315  // proportions_ are values between 0 and 1, otherwise error
-
15316  for (auto & v : proportions_)
-
15317  if ((v < 0.0) || (v > 1.0))
-
15318  throw std::invalid_argument(
-
15319  "-proportions_- must have values between 0 and 1."
-
15320  );
-
15321 
-
15322  // Last first two terms shouldn't add up to more than 1
-
15323  if ((proportions_[1u] + proportions_[2u]) > 1.0)
-
15324  throw std::invalid_argument(
-
15325  "The last two terms of -proportions_- must add up to less than 1."
-
15326  );
-
15327 
-
15328  std::function<void(epiworld::Model<TSeq>*)> fun =
-
15329  [proportions_] (epiworld::Model<TSeq> * model) -> void {
-
15330 
-
15331  // Figuring out information about the viruses
-
15332  double tot = 0.0;
-
15333  const auto & vpreval = model->get_prevalence_virus();
-
15334  const auto & vprop = model->get_prevalence_virus_as_proportion();
-
15335  double n = static_cast<double>(model->size());
-
15336  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
-
15337  {
-
15338  if (vprop[i])
-
15339  tot += vpreval[i];
-
15340  else
-
15341  tot += vpreval[i] / n;
-
15342  }
-
15343 
-
15344  // Putting the total into context
-
15345  double tot_left = 1.0 - tot;
-
15346 
-
15347  // Since susceptible and infected are "fixed,"
-
15348  // we only need to change recovered
-
15349  size_t nexposed = proportions_[0u] * tot * n;
-
15350  size_t nrecovered = proportions_[1u] * tot_left * n;
-
15351  size_t ndeceased = proportions_[2u] * tot_left * n;
-
15352 
-
15353  epiworld::AgentsSample<TSeq> sample_suscept(
-
15354  *model,
-
15355  nrecovered,
-
15356  {0u},
-
15357  true
-
15358  );
-
15359 
-
15360  // Setting up the initial states
-
15361  for (auto & agent : sample_suscept)
-
15362  agent->change_state(model, 3, Queue<TSeq>::NoOne);
-
15363 
-
15364  epiworld::AgentsSample<TSeq> sample_exposed(
-
15365  *model,
-
15366  nexposed,
-
15367  {1u},
-
15368  true
-
15369  );
-
15370 
-
15371  // Setting up the initial states
-
15372  for (auto & agent : sample_exposed)
-
15373  agent->change_state(model, 2, Queue<TSeq>::NoOne);
-
15374 
-
15375  // Running the actions
-
15376  model->actions_run();
-
15377 
-
15378  // Setting the initial states for the deceased
-
15379  epiworld::AgentsSample<TSeq> sample_deceased(
-
15380  *model,
-
15381  ndeceased,
-
15382  {0u},
-
15383  true
-
15384  );
-
15385 
-
15386  // Setting up the initial states
-
15387  for (auto & agent : sample_deceased)
-
15388  agent->change_state(model, 4, Queue<TSeq>::NoOne);
-
15389 
-
15390  // Running the actions
-
15391  model->actions_run();
-
15392 
-
15393  return;
-
15394 
-
15395  };
-
15396 
-
15397  return fun;
-
15398 
-
15399 }
+
15301  return;
+
15302 
+
15303  };
+
15304 
+
15305  return fun;
+
15306 
+
15307 }
+
15308 
+
15313 template<typename TSeq>
+
15314 inline std::function<void(epiworld::Model<TSeq>*)> create_init_function_seird(
+
15315  std::vector< double > proportions_
+
15316 ) {
+
15317 
+
15318  // Checking widths
+
15319  if (proportions_.size() != 3u) {
+
15320  throw std::invalid_argument("-proportions_- must have three entries.");
+
15321  }
+
15322 
+
15323  // proportions_ are values between 0 and 1, otherwise error
+
15324  for (auto & v : proportions_)
+
15325  if ((v < 0.0) || (v > 1.0))
+
15326  throw std::invalid_argument(
+
15327  "-proportions_- must have values between 0 and 1."
+
15328  );
+
15329 
+
15330  // Last first two terms shouldn't add up to more than 1
+
15331  if ((proportions_[1u] + proportions_[2u]) > 1.0)
+
15332  throw std::invalid_argument(
+
15333  "The last two terms of -proportions_- must add up to less than 1."
+
15334  );
+
15335 
+
15336  std::function<void(epiworld::Model<TSeq>*)> fun =
+
15337  [proportions_] (epiworld::Model<TSeq> * model) -> void {
+
15338 
+
15339  // Figuring out information about the viruses
+
15340  double tot = 0.0;
+
15341  const auto & vpreval = model->get_prevalence_virus();
+
15342  const auto & vprop = model->get_prevalence_virus_as_proportion();
+
15343  double n = static_cast<double>(model->size());
+
15344  for (size_t i = 0u; i < model->get_n_viruses(); ++i)
+
15345  {
+
15346  if (vprop[i])
+
15347  tot += vpreval[i];
+
15348  else
+
15349  tot += vpreval[i] / n;
+
15350  }
+
15351 
+
15352  // Putting the total into context
+
15353  double tot_left = 1.0 - tot;
+
15354 
+
15355  // Since susceptible and infected are "fixed,"
+
15356  // we only need to change recovered
+
15357  size_t nexposed = proportions_[0u] * tot * n;
+
15358  size_t nrecovered = proportions_[1u] * tot_left * n;
+
15359  size_t ndeceased = proportions_[2u] * tot_left * n;
+
15360 
+
15361  epiworld::AgentsSample<TSeq> sample_suscept(
+
15362  *model,
+
15363  nrecovered,
+
15364  {0u},
+
15365  true
+
15366  );
+
15367 
+
15368  // Setting up the initial states
+
15369  for (auto & agent : sample_suscept)
+
15370  agent->change_state(model, 3, Queue<TSeq>::NoOne);
+
15371 
+
15372  epiworld::AgentsSample<TSeq> sample_exposed(
+
15373  *model,
+
15374  nexposed,
+
15375  {1u},
+
15376  true
+
15377  );
+
15378 
+
15379  // Setting up the initial states
+
15380  for (auto & agent : sample_exposed)
+
15381  agent->change_state(model, 2, Queue<TSeq>::NoOne);
+
15382 
+
15383  // Running the actions
+
15384  model->actions_run();
+
15385 
+
15386  // Setting the initial states for the deceased
+
15387  epiworld::AgentsSample<TSeq> sample_deceased(
+
15388  *model,
+
15389  ndeceased,
+
15390  {0u},
+
15391  true
+
15392  );
+
15393 
+
15394  // Setting up the initial states
+
15395  for (auto & agent : sample_deceased)
+
15396  agent->change_state(model, 4, Queue<TSeq>::NoOne);
+
15397 
+
15398  // Running the actions
+
15399  model->actions_run();
15400 
-
15401 
-
15402 #endif
-
15403 /*//////////////////////////////////////////////////////////////////////////////
-
15405 
-
15406  End of -include/epiworld//models/init-functions.hpp-
-
15407 
-
15410 
-
15411 
-
15412 
-
15413 /*//////////////////////////////////////////////////////////////////////////////
+
15401  return;
+
15402 
+
15403  };
+
15404 
+
15405  return fun;
+
15406 
+
15407 }
+
15408 
+
15409 
+
15410 #endif
+
15411 /*//////////////////////////////////////////////////////////////////////////////
+
15413 
+
15414  End of -include/epiworld//models/init-functions.hpp-
15415 
-
15416  Start of -include/epiworld//models/globalactions.hpp-
-
15417 
+
15418 
+
15419 
15420 
-
15421 
-
15422 #ifndef EPIWORLD_GLOBALACTIONS_HPP
-
15423 #define EPIWORLD_GLOBALACTIONS_HPP
-
15424 
-
15425 // This function creates a global action that distributes a tool
-
15426 // to agents with probability p.
-
15435 template<typename TSeq>
-
15436 inline std::function<void(Model<TSeq>*)> globalaction_tool(
-
15437  Tool<TSeq> & tool,
-
15438  double p
-
15439 ) {
-
15440 
-
15441  std::function<void(Model<TSeq>*)> fun = [p,&tool](
-
15442  Model<TSeq> * model
-
15443  ) -> void {
-
15444 
-
15445  for (auto & agent : model->get_agents())
-
15446  {
-
15447 
-
15448  // Check if the agent has the tool
-
15449  if (agent.has_tool(tool))
-
15450  continue;
-
15451 
-
15452  // Adding the tool
-
15453  if (model->runif() < p)
-
15454  agent.add_tool(tool, model);
-
15455 
-
15456 
-
15457  }
-
15458 
-
15459  #ifdef EPIWORLD_DEBUG
-
15460  tool.print();
-
15461  #endif
-
15462 
-
15463  return;
-
15464 
-
15465 
-
15466  };
-
15467 
-
15468  return fun;
-
15469 
-
15470 }
-
15471 
-
15472 // Same function as above, but p is now a function of a vector of coefficients
-
15473 // and a vector of variables.
-
15484 template<typename TSeq>
-
15485 inline std::function<void(Model<TSeq>*)> globalaction_tool_logit(
-
15486  Tool<TSeq> & tool,
-
15487  std::vector< size_t > vars,
-
15488  std::vector< double > coefs
-
15489 ) {
-
15490 
-
15491  std::function<void(Model<TSeq>*)> fun = [coefs,vars,&tool](
-
15492  Model<TSeq> * model
-
15493  ) -> void {
-
15494 
-
15495  for (auto & agent : model->get_agents())
-
15496  {
-
15497 
-
15498  // Check if the agent has the tool
-
15499  if (agent.has_tool(tool))
-
15500  continue;
-
15501 
-
15502  // Computing the probability using a logit. Uses OpenMP reduction
-
15503  // to sum the coefficients.
-
15504  double p = 0.0;
-
15505  #if defined(__OPENMP) || defined(_OPENMP)
-
15506  #pragma omp parallel for reduction(+:p)
-
15507  #endif
-
15508  for (size_t i = 0u; i < coefs.size(); ++i)
-
15509  p += coefs.at(i) * agent(vars[i]);
-
15510 
-
15511  p = 1.0 / (1.0 + std::exp(-p));
-
15512 
-
15513  // Adding the tool
-
15514  if (model->runif() < p)
-
15515  agent.add_tool(tool, model);
-
15516 
-
15517 
-
15518  }
-
15519 
-
15520  #ifdef EPIWORLD_DEBUG
-
15521  tool.print();
-
15522  #endif
-
15523 
-
15524  return;
-
15525 
-
15526 
-
15527  };
-
15528 
-
15529  return fun;
-
15530 
-
15531 }
-
15532 
-
15533 // A global action that updates a parameter in the model.
-
15542 template<typename TSeq>
-
15543 inline std::function<void(Model<TSeq>*)> globalaction_set_param(
-
15544  std::string param,
-
15545  double value
-
15546 ) {
-
15547 
-
15548  std::function<void(Model<TSeq>*)> fun = [value,param](
-
15549  Model<TSeq> * model
-
15550  ) -> void {
-
15551 
-
15552  model->set_param(param, value);
-
15553 
-
15554  return;
-
15555 
-
15556 
-
15557  };
-
15558 
-
15559  return fun;
-
15560 
-
15561 }
-
15562 #endif
-
15563 /*//////////////////////////////////////////////////////////////////////////////
-
15565 
-
15566  End of -include/epiworld//models/globalactions.hpp-
-
15567 
-
15570 
-
15571 
-
15572 /*//////////////////////////////////////////////////////////////////////////////
-
15574 
-
15575  Start of -include/epiworld//models/sis.hpp-
-
15576 
+
15421 /*//////////////////////////////////////////////////////////////////////////////
+
15423 
+
15424  Start of -include/epiworld//models/globalactions.hpp-
+
15425 
+
15428 
+
15429 
+
15430 #ifndef EPIWORLD_GLOBALACTIONS_HPP
+
15431 #define EPIWORLD_GLOBALACTIONS_HPP
+
15432 
+
15433 // This function creates a global action that distributes a tool
+
15434 // to agents with probability p.
+
15443 template<typename TSeq>
+
15444 inline std::function<void(Model<TSeq>*)> globalaction_tool(
+
15445  Tool<TSeq> & tool,
+
15446  double p
+
15447 ) {
+
15448 
+
15449  std::function<void(Model<TSeq>*)> fun = [p,&tool](
+
15450  Model<TSeq> * model
+
15451  ) -> void {
+
15452 
+
15453  for (auto & agent : model->get_agents())
+
15454  {
+
15455 
+
15456  // Check if the agent has the tool
+
15457  if (agent.has_tool(tool))
+
15458  continue;
+
15459 
+
15460  // Adding the tool
+
15461  if (model->runif() < p)
+
15462  agent.add_tool(tool, model);
+
15463 
+
15464 
+
15465  }
+
15466 
+
15467  #ifdef EPIWORLD_DEBUG
+
15468  tool.print();
+
15469  #endif
+
15470 
+
15471  return;
+
15472 
+
15473 
+
15474  };
+
15475 
+
15476  return fun;
+
15477 
+
15478 }
+
15479 
+
15480 // Same function as above, but p is now a function of a vector of coefficients
+
15481 // and a vector of variables.
+
15492 template<typename TSeq>
+
15493 inline std::function<void(Model<TSeq>*)> globalaction_tool_logit(
+
15494  Tool<TSeq> & tool,
+
15495  std::vector< size_t > vars,
+
15496  std::vector< double > coefs
+
15497 ) {
+
15498 
+
15499  std::function<void(Model<TSeq>*)> fun = [coefs,vars,&tool](
+
15500  Model<TSeq> * model
+
15501  ) -> void {
+
15502 
+
15503  for (auto & agent : model->get_agents())
+
15504  {
+
15505 
+
15506  // Check if the agent has the tool
+
15507  if (agent.has_tool(tool))
+
15508  continue;
+
15509 
+
15510  // Computing the probability using a logit. Uses OpenMP reduction
+
15511  // to sum the coefficients.
+
15512  double p = 0.0;
+
15513  #if defined(__OPENMP) || defined(_OPENMP)
+
15514  #pragma omp parallel for reduction(+:p)
+
15515  #endif
+
15516  for (size_t i = 0u; i < coefs.size(); ++i)
+
15517  p += coefs.at(i) * agent(vars[i]);
+
15518 
+
15519  p = 1.0 / (1.0 + std::exp(-p));
+
15520 
+
15521  // Adding the tool
+
15522  if (model->runif() < p)
+
15523  agent.add_tool(tool, model);
+
15524 
+
15525 
+
15526  }
+
15527 
+
15528  #ifdef EPIWORLD_DEBUG
+
15529  tool.print();
+
15530  #endif
+
15531 
+
15532  return;
+
15533 
+
15534 
+
15535  };
+
15536 
+
15537  return fun;
+
15538 
+
15539 }
+
15540 
+
15541 // A global action that updates a parameter in the model.
+
15550 template<typename TSeq>
+
15551 inline std::function<void(Model<TSeq>*)> globalaction_set_param(
+
15552  std::string param,
+
15553  double value
+
15554 ) {
+
15555 
+
15556  std::function<void(Model<TSeq>*)> fun = [value,param](
+
15557  Model<TSeq> * model
+
15558  ) -> void {
+
15559 
+
15560  model->set_param(param, value);
+
15561 
+
15562  return;
+
15563 
+
15564 
+
15565  };
+
15566 
+
15567  return fun;
+
15568 
+
15569 }
+
15570 #endif
+
15571 /*//////////////////////////////////////////////////////////////////////////////
+
15573 
+
15574  End of -include/epiworld//models/globalactions.hpp-
+
15575 
+
15578 
15579 
-
15580 
-
15581 #ifndef EPIWORLD_MODELS_SIS_HPP
-
15582 #define EPIWORLD_MODELS_SIS_HPP
-
15583 
-
15592 template<typename TSeq = int>
-
15593 class ModelSIS : public epiworld::Model<TSeq>
-
15594 {
-
15595 
-
15596 public:
-
15597 
-
15598  static const int SUSCEPTIBLE = 0;
-
15599  static const int INFECTED = 1;
-
15600 
-
15601  ModelSIS() {};
-
15602 
-
15603  ModelSIS(
-
15604  ModelSIS<TSeq> & model,
-
15605  std::string vname,
-
15606  epiworld_double prevalence,
-
15607  epiworld_double transmission_rate,
-
15608  epiworld_double recovery_rate
-
15609  );
+
15580 /*//////////////////////////////////////////////////////////////////////////////
+
15582 
+
15583  Start of -include/epiworld//models/sis.hpp-
+
15584 
+
15587 
+
15588 
+
15589 #ifndef EPIWORLD_MODELS_SIS_HPP
+
15590 #define EPIWORLD_MODELS_SIS_HPP
+
15591 
+
15600 template<typename TSeq = int>
+
15601 class ModelSIS : public epiworld::Model<TSeq>
+
15602 {
+
15603 
+
15604 public:
+
15605 
+
15606  static const int SUSCEPTIBLE = 0;
+
15607  static const int INFECTED = 1;
+
15608 
+
15609  ModelSIS() {};
15610 
15611  ModelSIS(
-
15612  std::string vname,
-
15613  epiworld_double prevalence,
-
15614  epiworld_double transmission_rate,
-
15615  epiworld_double recovery_rate
-
15616  );
-
15617 
-
15618 };
-
15619 
-
15620 template<typename TSeq>
-
15621 inline ModelSIS<TSeq>::ModelSIS(
-
15622  ModelSIS<TSeq> & model,
-
15623  std::string vname,
-
15624  epiworld_double prevalence,
-
15625  epiworld_double transmission_rate,
-
15626  epiworld_double recovery_rate
-
15627  )
-
15628 {
-
15629 
-
15630  model.set_name("Susceptible-Infected-Susceptible (SIS)");
-
15631 
-
15632  // Adding statuses
-
15633  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
-
15634  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
-
15635 
-
15636  // Setting up parameters
-
15637  model.add_param(transmission_rate, "Transmission rate");
-
15638  model.add_param(recovery_rate, "Recovery rate");
+
15612  ModelSIS<TSeq> & model,
+
15613  std::string vname,
+
15614  epiworld_double prevalence,
+
15615  epiworld_double transmission_rate,
+
15616  epiworld_double recovery_rate
+
15617  );
+
15618 
+
15619  ModelSIS(
+
15620  std::string vname,
+
15621  epiworld_double prevalence,
+
15622  epiworld_double transmission_rate,
+
15623  epiworld_double recovery_rate
+
15624  );
+
15625 
+
15626 };
+
15627 
+
15628 template<typename TSeq>
+
15629 inline ModelSIS<TSeq>::ModelSIS(
+
15630  ModelSIS<TSeq> & model,
+
15631  std::string vname,
+
15632  epiworld_double prevalence,
+
15633  epiworld_double transmission_rate,
+
15634  epiworld_double recovery_rate
+
15635  )
+
15636 {
+
15637 
+
15638  model.set_name("Susceptible-Infected-Susceptible (SIS)");
15639 
-
15640  // Preparing the virus -------------------------------------------
-
15641  epiworld::Virus<TSeq> virus(vname);
-
15642  virus.set_state(ModelSIS<TSeq>::INFECTED, ModelSIS<TSeq>::SUSCEPTIBLE, ModelSIS<TSeq>::SUSCEPTIBLE);
-
15643 
-
15644  virus.set_prob_infecting(&model("Transmission rate"));
-
15645  virus.set_prob_recovery(&model("Recovery rate"));
-
15646  virus.set_prob_death(0.0);
-
15647 
-
15648  model.add_virus(virus, prevalence);
-
15649 
-
15650  return;
-
15651 
-
15652 }
-
15653 
-
15654 template<typename TSeq>
-
15655 inline ModelSIS<TSeq>::ModelSIS(
-
15656  std::string vname,
-
15657  epiworld_double prevalence,
-
15658  epiworld_double transmission_rate,
-
15659  epiworld_double recovery_rate
-
15660  )
-
15661 {
-
15662 
-
15663  ModelSIS<TSeq>(
-
15664  *this,
-
15665  vname,
-
15666  prevalence,
-
15667  transmission_rate,
-
15668  recovery_rate
-
15669  );
+
15640  // Adding statuses
+
15641  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
+
15642  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
+
15643 
+
15644  // Setting up parameters
+
15645  model.add_param(transmission_rate, "Transmission rate");
+
15646  model.add_param(recovery_rate, "Recovery rate");
+
15647 
+
15648  // Preparing the virus -------------------------------------------
+
15649  epiworld::Virus<TSeq> virus(vname);
+
15650  virus.set_state(ModelSIS<TSeq>::INFECTED, ModelSIS<TSeq>::SUSCEPTIBLE, ModelSIS<TSeq>::SUSCEPTIBLE);
+
15651 
+
15652  virus.set_prob_infecting(&model("Transmission rate"));
+
15653  virus.set_prob_recovery(&model("Recovery rate"));
+
15654  virus.set_prob_death(0.0);
+
15655 
+
15656  model.add_virus(virus, prevalence);
+
15657 
+
15658  return;
+
15659 
+
15660 }
+
15661 
+
15662 template<typename TSeq>
+
15663 inline ModelSIS<TSeq>::ModelSIS(
+
15664  std::string vname,
+
15665  epiworld_double prevalence,
+
15666  epiworld_double transmission_rate,
+
15667  epiworld_double recovery_rate
+
15668  )
+
15669 {
15670 
-
15671  return;
-
15672 
-
15673 }
-
15674 
-
15675 #endif
-
15676 /*//////////////////////////////////////////////////////////////////////////////
+
15671  ModelSIS<TSeq>(
+
15672  *this,
+
15673  vname,
+
15674  prevalence,
+
15675  transmission_rate,
+
15676  recovery_rate
+
15677  );
15678 
-
15679  End of -include/epiworld//models/sis.hpp-
+
15679  return;
15680 
-
15683 
-
15684 
-
15685 /*//////////////////////////////////////////////////////////////////////////////
-
15687 
-
15688  Start of -include/epiworld//models/sir.hpp-
-
15689 
+
15681 }
+
15682 
+
15683 #endif
+
15684 /*//////////////////////////////////////////////////////////////////////////////
+
15686 
+
15687  End of -include/epiworld//models/sis.hpp-
+
15688 
+
15691 
15692 
-
15693 
-
15694 #ifndef EPIWORLD_SIR_H
-
15695 #define EPIWORLD_SIR_H
-
15696 
-
15706 template<typename TSeq = int>
-
15707 class ModelSIR : public epiworld::Model<TSeq>
-
15708 {
-
15709 public:
-
15710 
-
15711  ModelSIR() {};
-
15712 
-
15713  ModelSIR(
-
15714  ModelSIR<TSeq> & model,
-
15715  std::string vname,
-
15716  epiworld_double prevalence,
-
15717  epiworld_double transmission_rate,
-
15718  epiworld_double recovery_rate
-
15719  );
+
15693 /*//////////////////////////////////////////////////////////////////////////////
+
15695 
+
15696  Start of -include/epiworld//models/sir.hpp-
+
15697 
+
15700 
+
15701 
+
15702 #ifndef EPIWORLD_SIR_H
+
15703 #define EPIWORLD_SIR_H
+
15704 
+
15714 template<typename TSeq = int>
+
15715 class ModelSIR : public epiworld::Model<TSeq>
+
15716 {
+
15717 public:
+
15718 
+
15719  ModelSIR() {};
15720 
15721  ModelSIR(
-
15722  std::string vname,
-
15723  epiworld_double prevalence,
-
15724  epiworld_double transmission_rate,
-
15725  epiworld_double recovery_rate
-
15726  );
-
15727 
-
15733  ModelSIR<TSeq> & initial_states(
-
15734  std::vector< double > proportions_,
-
15735  std::vector< int > queue_ = {}
-
15736  );
-
15737 
-
15738 };
-
15739 
-
15740 template<typename TSeq>
-
15741 inline ModelSIR<TSeq>::ModelSIR(
-
15742  ModelSIR<TSeq> & model,
-
15743  std::string vname,
-
15744  epiworld_double prevalence,
-
15745  epiworld_double transmission_rate,
-
15746  epiworld_double recovery_rate
-
15747  )
-
15748 {
-
15749 
-
15750  // Adding statuses
-
15751  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
-
15752  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
-
15753  model.add_state("Recovered");
-
15754 
-
15755  // Setting up parameters
-
15756  model.add_param(recovery_rate, "Recovery rate");
-
15757  model.add_param(transmission_rate, "Transmission rate");
-
15758 
-
15759  // Preparing the virus -------------------------------------------
-
15760  epiworld::Virus<TSeq> virus(vname);
-
15761  virus.set_state(1,2,2);
-
15762 
-
15763  virus.set_prob_recovery(&model("Recovery rate"));
-
15764  virus.set_prob_infecting(&model("Transmission rate"));
-
15765 
-
15766  model.add_virus(virus, prevalence);
-
15767 
-
15768  model.set_name("Susceptible-Infected-Recovered (SIR)");
-
15769 
-
15770  return;
-
15771 
-
15772 }
-
15773 
-
15774 template<typename TSeq>
-
15775 inline ModelSIR<TSeq>::ModelSIR(
-
15776  std::string vname,
-
15777  epiworld_double prevalence,
-
15778  epiworld_double transmission_rate,
-
15779  epiworld_double recovery_rate
-
15780  )
-
15781 {
-
15782 
-
15783  ModelSIR<TSeq>(
-
15784  *this,
-
15785  vname,
-
15786  prevalence,
-
15787  transmission_rate,
-
15788  recovery_rate
-
15789  );
+
15722  ModelSIR<TSeq> & model,
+
15723  std::string vname,
+
15724  epiworld_double prevalence,
+
15725  epiworld_double transmission_rate,
+
15726  epiworld_double recovery_rate
+
15727  );
+
15728 
+
15729  ModelSIR(
+
15730  std::string vname,
+
15731  epiworld_double prevalence,
+
15732  epiworld_double transmission_rate,
+
15733  epiworld_double recovery_rate
+
15734  );
+
15735 
+
15741  ModelSIR<TSeq> & initial_states(
+
15742  std::vector< double > proportions_,
+
15743  std::vector< int > queue_ = {}
+
15744  );
+
15745 
+
15746 };
+
15747 
+
15748 template<typename TSeq>
+
15749 inline ModelSIR<TSeq>::ModelSIR(
+
15750  ModelSIR<TSeq> & model,
+
15751  std::string vname,
+
15752  epiworld_double prevalence,
+
15753  epiworld_double transmission_rate,
+
15754  epiworld_double recovery_rate
+
15755  )
+
15756 {
+
15757 
+
15758  // Adding statuses
+
15759  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
+
15760  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
+
15761  model.add_state("Recovered");
+
15762 
+
15763  // Setting up parameters
+
15764  model.add_param(recovery_rate, "Recovery rate");
+
15765  model.add_param(transmission_rate, "Transmission rate");
+
15766 
+
15767  // Preparing the virus -------------------------------------------
+
15768  epiworld::Virus<TSeq> virus(vname);
+
15769  virus.set_state(1,2,2);
+
15770 
+
15771  virus.set_prob_recovery(&model("Recovery rate"));
+
15772  virus.set_prob_infecting(&model("Transmission rate"));
+
15773 
+
15774  model.add_virus(virus, prevalence);
+
15775 
+
15776  model.set_name("Susceptible-Infected-Recovered (SIR)");
+
15777 
+
15778  return;
+
15779 
+
15780 }
+
15781 
+
15782 template<typename TSeq>
+
15783 inline ModelSIR<TSeq>::ModelSIR(
+
15784  std::string vname,
+
15785  epiworld_double prevalence,
+
15786  epiworld_double transmission_rate,
+
15787  epiworld_double recovery_rate
+
15788  )
+
15789 {
15790 
-
15791  return;
-
15792 
-
15793 }
-
15794 
-
15795 template<typename TSeq>
-
15796 inline ModelSIR<TSeq> & ModelSIR<TSeq>::initial_states(
-
15797  std::vector< double > proportions_,
-
15798  std::vector< int > /* queue_ */
-
15799 ) {
-
15800 
-
15801  Model<TSeq>::initial_states_fun =
-
15802  create_init_function_sir<TSeq>(proportions_)
-
15803  ;
-
15804 
-
15805  return *this;
-
15806 
-
15807 }
+
15791  ModelSIR<TSeq>(
+
15792  *this,
+
15793  vname,
+
15794  prevalence,
+
15795  transmission_rate,
+
15796  recovery_rate
+
15797  );
+
15798 
+
15799  return;
+
15800 
+
15801 }
+
15802 
+
15803 template<typename TSeq>
+
15804 inline ModelSIR<TSeq> & ModelSIR<TSeq>::initial_states(
+
15805  std::vector< double > proportions_,
+
15806  std::vector< int > /* queue_ */
+
15807 ) {
15808 
-
15809 #endif
-
15810 /*//////////////////////////////////////////////////////////////////////////////
-
15812 
-
15813  End of -include/epiworld//models/sir.hpp-
-
15814 
-
15817 
-
15818 
-
15819 /*//////////////////////////////////////////////////////////////////////////////
-
15821 
-
15822  Start of -include/epiworld//models/seir.hpp-
-
15823 
+
15809  Model<TSeq>::initial_states_fun =
+
15810  create_init_function_sir<TSeq>(proportions_)
+
15811  ;
+
15812 
+
15813  return *this;
+
15814 
+
15815 }
+
15816 
+
15817 #endif
+
15818 /*//////////////////////////////////////////////////////////////////////////////
+
15820 
+
15821  End of -include/epiworld//models/sir.hpp-
+
15822 
+
15825 
15826 
-
15827 
-
15828 #ifndef EPIWORLD_MODELS_SEIR_HPP
-
15829 #define EPIWORLD_MODELS_SEIR_HPP
-
15830 
-
15841 template<typename TSeq = int>
-
15842 class ModelSEIR : public epiworld::Model<TSeq>
-
15843 {
-
15844 
-
15845 public:
-
15846  static const int SUSCEPTIBLE = 0;
-
15847  static const int EXPOSED = 1;
-
15848  static const int INFECTED = 2;
-
15849  static const int REMOVED = 3;
-
15850 
-
15851  ModelSEIR() {};
+
15827 /*//////////////////////////////////////////////////////////////////////////////
+
15829 
+
15830  Start of -include/epiworld//models/seir.hpp-
+
15831 
+
15834 
+
15835 
+
15836 #ifndef EPIWORLD_MODELS_SEIR_HPP
+
15837 #define EPIWORLD_MODELS_SEIR_HPP
+
15838 
+
15849 template<typename TSeq = int>
+
15850 class ModelSEIR : public epiworld::Model<TSeq>
+
15851 {
15852 
-
15853  ModelSEIR(
-
15854  ModelSEIR<TSeq> & model,
-
15855  std::string vname,
-
15856  epiworld_double prevalence,
-
15857  epiworld_double transmission_rate,
-
15858  epiworld_double avg_incubation_days,
-
15859  epiworld_double recovery_rate
-
15860  );
-
15861 
-
15862  ModelSEIR(
+
15853 public:
+
15854  static const int SUSCEPTIBLE = 0;
+
15855  static const int EXPOSED = 1;
+
15856  static const int INFECTED = 2;
+
15857  static const int REMOVED = 3;
+
15858 
+
15859  ModelSEIR() {};
+
15860 
+
15861  ModelSEIR(
+
15862  ModelSEIR<TSeq> & model,
15863  std::string vname,
15864  epiworld_double prevalence,
15865  epiworld_double transmission_rate,
15866  epiworld_double avg_incubation_days,
15867  epiworld_double recovery_rate
15868  );
-
15869 
-
15870  epiworld::UpdateFun<TSeq> update_exposed_seir = [](
-
15871  epiworld::Agent<TSeq> * p,
-
15872  epiworld::Model<TSeq> * m
-
15873  ) -> void {
-
15874 
-
15875  // Getting the virus
-
15876  auto v = p->get_virus();
-
15877 
-
15878  // Does the agent become infected?
-
15879  if (m->runif() < 1.0/(v->get_incubation(m)))
-
15880  p->change_state(m, ModelSEIR<TSeq>::INFECTED);
-
15881 
-
15882  return;
-
15883  };
-
15884 
+
15869 
+
15870  ModelSEIR(
+
15871  std::string vname,
+
15872  epiworld_double prevalence,
+
15873  epiworld_double transmission_rate,
+
15874  epiworld_double avg_incubation_days,
+
15875  epiworld_double recovery_rate
+
15876  );
+
15877 
+
15878  epiworld::UpdateFun<TSeq> update_exposed_seir = [](
+
15879  epiworld::Agent<TSeq> * p,
+
15880  epiworld::Model<TSeq> * m
+
15881  ) -> void {
+
15882 
+
15883  // Getting the virus
+
15884  auto v = p->get_virus();
15885 
-
15886  epiworld::UpdateFun<TSeq> update_infected_seir = [](
-
15887  epiworld::Agent<TSeq> * p,
-
15888  epiworld::Model<TSeq> * m
-
15889  ) -> void {
-
15890  // Does the agent recover?
-
15891  if (m->runif() < (m->par("Recovery rate")))
-
15892  p->rm_virus(m);
+
15886  // Does the agent become infected?
+
15887  if (m->runif() < 1.0/(v->get_incubation(m)))
+
15888  p->change_state(m, ModelSEIR<TSeq>::INFECTED);
+
15889 
+
15890  return;
+
15891  };
+
15892 
15893 
-
15894  return;
-
15895  };
-
15896 
-
15903  ModelSEIR<TSeq> & initial_states(
-
15904  std::vector< double > proportions_,
-
15905  std::vector< int > queue_ = {}
-
15906  );
-
15907 
-
15908 };
-
15909 
-
15910 
-
15911 template<typename TSeq>
-
15912 inline ModelSEIR<TSeq>::ModelSEIR(
-
15913  ModelSEIR<TSeq> & model,
-
15914  std::string vname,
-
15915  epiworld_double prevalence,
-
15916  epiworld_double transmission_rate,
-
15917  epiworld_double avg_incubation_days,
-
15918  epiworld_double recovery_rate
-
15919  )
-
15920 {
-
15921 
-
15922  // Adding statuses
-
15923  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
-
15924  model.add_state("Exposed", model.update_exposed_seir);
-
15925  model.add_state("Infected", model.update_infected_seir);
-
15926  model.add_state("Removed");
-
15927 
-
15928  // Setting up parameters
-
15929  model.add_param(transmission_rate, "Transmission rate");
-
15930  model.add_param(avg_incubation_days, "Incubation days");
-
15931  model.add_param(recovery_rate, "Recovery rate");
-
15932 
-
15933  // Preparing the virus -------------------------------------------
-
15934  epiworld::Virus<TSeq> virus(vname);
-
15935  virus.set_state(ModelSEIR<TSeq>::EXPOSED, ModelSEIR<TSeq>::REMOVED, ModelSEIR<TSeq>::REMOVED);
-
15936 
-
15937  virus.set_prob_infecting(&model("Transmission rate"));
-
15938  virus.set_incubation(&model("Incubation days"));
-
15939  virus.set_prob_recovery(&model("Recovery rate"));
-
15940 
-
15941  // Adding the tool and the virus
-
15942  model.add_virus(virus, prevalence);
-
15943 
-
15944  model.set_name("Susceptible-Exposed-Infected-Removed (SEIR)");
-
15945 
-
15946  return;
-
15947 
-
15948 }
-
15949 
-
15950 template<typename TSeq>
-
15951 inline ModelSEIR<TSeq>::ModelSEIR(
-
15952  std::string vname,
-
15953  epiworld_double prevalence,
-
15954  epiworld_double transmission_rate,
-
15955  epiworld_double avg_incubation_days,
-
15956  epiworld_double recovery_rate
-
15957  )
-
15958 {
-
15959 
-
15960  ModelSEIR<TSeq>(
-
15961  *this,
-
15962  vname,
-
15963  prevalence,
-
15964  transmission_rate,
-
15965  avg_incubation_days,
-
15966  recovery_rate
-
15967  );
-
15968 
-
15969  return;
-
15970 
-
15971 }
-
15972 
-
15973 template<typename TSeq>
-
15974 inline ModelSEIR<TSeq> & ModelSEIR<TSeq>::initial_states(
-
15975  std::vector< double > proportions_,
-
15976  std::vector< int > /**/
-
15977 ) {
-
15978 
-
15979  Model<TSeq>::initial_states_fun =
-
15980  create_init_function_seir<TSeq>(proportions_)
-
15981  ;
-
15982 
-
15983  return *this;
-
15984 
-
15985 }
+
15894  epiworld::UpdateFun<TSeq> update_infected_seir = [](
+
15895  epiworld::Agent<TSeq> * p,
+
15896  epiworld::Model<TSeq> * m
+
15897  ) -> void {
+
15898  // Does the agent recover?
+
15899  if (m->runif() < (m->par("Recovery rate")))
+
15900  p->rm_virus(m);
+
15901 
+
15902  return;
+
15903  };
+
15904 
+
15911  ModelSEIR<TSeq> & initial_states(
+
15912  std::vector< double > proportions_,
+
15913  std::vector< int > queue_ = {}
+
15914  );
+
15915 
+
15916 };
+
15917 
+
15918 
+
15919 template<typename TSeq>
+
15920 inline ModelSEIR<TSeq>::ModelSEIR(
+
15921  ModelSEIR<TSeq> & model,
+
15922  std::string vname,
+
15923  epiworld_double prevalence,
+
15924  epiworld_double transmission_rate,
+
15925  epiworld_double avg_incubation_days,
+
15926  epiworld_double recovery_rate
+
15927  )
+
15928 {
+
15929 
+
15930  // Adding statuses
+
15931  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
+
15932  model.add_state("Exposed", model.update_exposed_seir);
+
15933  model.add_state("Infected", model.update_infected_seir);
+
15934  model.add_state("Removed");
+
15935 
+
15936  // Setting up parameters
+
15937  model.add_param(transmission_rate, "Transmission rate");
+
15938  model.add_param(avg_incubation_days, "Incubation days");
+
15939  model.add_param(recovery_rate, "Recovery rate");
+
15940 
+
15941  // Preparing the virus -------------------------------------------
+
15942  epiworld::Virus<TSeq> virus(vname);
+
15943  virus.set_state(ModelSEIR<TSeq>::EXPOSED, ModelSEIR<TSeq>::REMOVED, ModelSEIR<TSeq>::REMOVED);
+
15944 
+
15945  virus.set_prob_infecting(&model("Transmission rate"));
+
15946  virus.set_incubation(&model("Incubation days"));
+
15947  virus.set_prob_recovery(&model("Recovery rate"));
+
15948 
+
15949  // Adding the tool and the virus
+
15950  model.add_virus(virus, prevalence);
+
15951 
+
15952  model.set_name("Susceptible-Exposed-Infected-Removed (SEIR)");
+
15953 
+
15954  return;
+
15955 
+
15956 }
+
15957 
+
15958 template<typename TSeq>
+
15959 inline ModelSEIR<TSeq>::ModelSEIR(
+
15960  std::string vname,
+
15961  epiworld_double prevalence,
+
15962  epiworld_double transmission_rate,
+
15963  epiworld_double avg_incubation_days,
+
15964  epiworld_double recovery_rate
+
15965  )
+
15966 {
+
15967 
+
15968  ModelSEIR<TSeq>(
+
15969  *this,
+
15970  vname,
+
15971  prevalence,
+
15972  transmission_rate,
+
15973  avg_incubation_days,
+
15974  recovery_rate
+
15975  );
+
15976 
+
15977  return;
+
15978 
+
15979 }
+
15980 
+
15981 template<typename TSeq>
+
15982 inline ModelSEIR<TSeq> & ModelSEIR<TSeq>::initial_states(
+
15983  std::vector< double > proportions_,
+
15984  std::vector< int > /**/
+
15985 ) {
15986 
-
15987 #endif
-
15988 /*//////////////////////////////////////////////////////////////////////////////
-
15990 
-
15991  End of -include/epiworld//models/seir.hpp-
-
15992 
-
15995 
-
15996 
-
15997 /*//////////////////////////////////////////////////////////////////////////////
-
15999 
-
16000  Start of -include/epiworld//models/surveillance.hpp-
-
16001 
+
15987  Model<TSeq>::initial_states_fun =
+
15988  create_init_function_seir<TSeq>(proportions_)
+
15989  ;
+
15990 
+
15991  return *this;
+
15992 
+
15993 }
+
15994 
+
15995 #endif
+
15996 /*//////////////////////////////////////////////////////////////////////////////
+
15998 
+
15999  End of -include/epiworld//models/seir.hpp-
+
16000 
+
16003 
16004 
-
16005 
-
16006 #ifndef EPIWORLD_MODELS_SURVEILLANCE_HPP
-
16007 #define EPIWORLD_MODELS_SURVEILLANCE_HPP
-
16008 
-
16009 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
16010 class ModelSURV : public epiworld::Model<TSeq> {
-
16011 
-
16012 private:
-
16013  // state
-
16014  static const int SUSCEPTIBLE = 0;
-
16015  static const int LATENT = 1;
-
16016  static const int SYMPTOMATIC = 2;
-
16017  static const int SYMPTOMATIC_ISOLATED = 3; // sampled and discovered
-
16018  static const int ASYMPTOMATIC = 4;
-
16019  static const int ASYMPTOMATIC_ISOLATED = 5;
-
16020  static const int RECOVERED = 6;
-
16021  static const int REMOVED = 7;
-
16022 
-
16023 public:
-
16024 
-
16066  ModelSURV() {};
-
16067 
-
16068  ModelSURV(
-
16069  ModelSURV<TSeq> & model,
-
16070  std::string vname,
-
16071  epiworld_fast_uint prevalence = 50,
-
16072  epiworld_double efficacy_vax = 0.9,
-
16073  epiworld_double latent_period = 3u,
-
16074  epiworld_double infect_period = 6u,
-
16075  epiworld_double prob_symptoms = 0.6,
-
16076  epiworld_double prop_vaccinated = 0.25,
-
16077  epiworld_double prop_vax_redux_transm = 0.5,
-
16078  epiworld_double prop_vax_redux_infect = 0.5,
-
16079  epiworld_double surveillance_prob = 0.001,
-
16080  epiworld_double prob_transmission = 1.0,
-
16081  epiworld_double prob_death = 0.001,
-
16082  epiworld_double prob_noreinfect = 0.9
-
16083  );
-
16084 
-
16085  ModelSURV(
-
16086  std::string vname,
-
16087  epiworld_fast_uint prevalence = 50,
-
16088  epiworld_double efficacy_vax = 0.9,
-
16089  epiworld_double latent_period = 3u,
-
16090  epiworld_double infect_period = 6u,
-
16091  epiworld_double prob_symptoms = 0.6,
-
16092  epiworld_double prop_vaccinated = 0.25,
-
16093  epiworld_double prop_vax_redux_transm = 0.5,
-
16094  epiworld_double prop_vax_redux_infect = 0.5,
-
16095  epiworld_double surveillance_prob = 0.001,
-
16096  epiworld_double prob_transmission = 1.0,
-
16097  epiworld_double prob_death = 0.001,
-
16098  epiworld_double prob_noreinfect = 0.9
-
16099  );
-
16101 
-
16102 };
-
16103 
-
16104 template<typename TSeq>
-
16105 inline ModelSURV<TSeq>::ModelSURV(
-
16106  ModelSURV<TSeq> & model,
-
16107  std::string vname,
-
16108  epiworld_fast_uint prevalence,
-
16109  epiworld_double efficacy_vax,
-
16110  epiworld_double latent_period,
-
16111  epiworld_double infect_period,
-
16112  epiworld_double prob_symptoms,
-
16113  epiworld_double prop_vaccinated,
-
16114  epiworld_double prop_vax_redux_transm,
-
16115  epiworld_double prop_vax_redux_infect,
-
16116  epiworld_double surveillance_prob,
-
16117  epiworld_double prob_transmission,
-
16118  epiworld_double prob_death,
-
16119  epiworld_double prob_noreinfect
-
16120  )
-
16121 {
-
16122 
-
16123  EPI_NEW_UPDATEFUN_LAMBDA(surveillance_update_susceptible, TSeq) {
-
16124 
-
16125  // This computes the prob of getting any neighbor variant
-
16126  epiworld_fast_uint nviruses_tmp = 0u;
-
16127  for (auto & neighbor: p->get_neighbors())
-
16128  {
-
16129 
-
16130  auto & v = neighbor->get_virus();
-
16131 
-
16132  if (v == nullptr)
-
16133  continue;
-
16134 
-
16135  /* And it is a function of susceptibility_reduction as well */
-
16136  epiworld_double tmp_transmission =
-
16137  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
16138  v->get_prob_infecting(m) *
-
16139  (1.0 - neighbor->get_transmission_reduction(v, m))
-
16140  ;
-
16141 
-
16142  m->array_double_tmp[nviruses_tmp] = tmp_transmission;
-
16143  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
16144  }
-
16145 
-
16146  // No virus to compute on
-
16147  if (nviruses_tmp == 0)
-
16148  return;
-
16149 
-
16150  // Running the roulette
-
16151  int which = roulette(nviruses_tmp, m);
-
16152 
-
16153  if (which < 0)
-
16154  return;
-
16155 
-
16156  p->set_virus(*m->array_virus_tmp[which], m);
-
16157  return;
-
16158 
-
16159  };
+
16005 /*//////////////////////////////////////////////////////////////////////////////
+
16007 
+
16008  Start of -include/epiworld//models/surveillance.hpp-
+
16009 
+
16012 
+
16013 
+
16014 #ifndef EPIWORLD_MODELS_SURVEILLANCE_HPP
+
16015 #define EPIWORLD_MODELS_SURVEILLANCE_HPP
+
16016 
+
16017 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
16018 class ModelSURV : public epiworld::Model<TSeq> {
+
16019 
+
16020 private:
+
16021  // state
+
16022  static const int SUSCEPTIBLE = 0;
+
16023  static const int LATENT = 1;
+
16024  static const int SYMPTOMATIC = 2;
+
16025  static const int SYMPTOMATIC_ISOLATED = 3; // sampled and discovered
+
16026  static const int ASYMPTOMATIC = 4;
+
16027  static const int ASYMPTOMATIC_ISOLATED = 5;
+
16028  static const int RECOVERED = 6;
+
16029  static const int REMOVED = 7;
+
16030 
+
16031 public:
+
16032 
+
16074  ModelSURV() {};
+
16075 
+
16076  ModelSURV(
+
16077  ModelSURV<TSeq> & model,
+
16078  std::string vname,
+
16079  epiworld_fast_uint prevalence = 50,
+
16080  epiworld_double efficacy_vax = 0.9,
+
16081  epiworld_double latent_period = 3u,
+
16082  epiworld_double infect_period = 6u,
+
16083  epiworld_double prob_symptoms = 0.6,
+
16084  epiworld_double prop_vaccinated = 0.25,
+
16085  epiworld_double prop_vax_redux_transm = 0.5,
+
16086  epiworld_double prop_vax_redux_infect = 0.5,
+
16087  epiworld_double surveillance_prob = 0.001,
+
16088  epiworld_double prob_transmission = 1.0,
+
16089  epiworld_double prob_death = 0.001,
+
16090  epiworld_double prob_noreinfect = 0.9
+
16091  );
+
16092 
+
16093  ModelSURV(
+
16094  std::string vname,
+
16095  epiworld_fast_uint prevalence = 50,
+
16096  epiworld_double efficacy_vax = 0.9,
+
16097  epiworld_double latent_period = 3u,
+
16098  epiworld_double infect_period = 6u,
+
16099  epiworld_double prob_symptoms = 0.6,
+
16100  epiworld_double prop_vaccinated = 0.25,
+
16101  epiworld_double prop_vax_redux_transm = 0.5,
+
16102  epiworld_double prop_vax_redux_infect = 0.5,
+
16103  epiworld_double surveillance_prob = 0.001,
+
16104  epiworld_double prob_transmission = 1.0,
+
16105  epiworld_double prob_death = 0.001,
+
16106  epiworld_double prob_noreinfect = 0.9
+
16107  );
+
16109 
+
16110 };
+
16111 
+
16112 template<typename TSeq>
+
16113 inline ModelSURV<TSeq>::ModelSURV(
+
16114  ModelSURV<TSeq> & model,
+
16115  std::string vname,
+
16116  epiworld_fast_uint prevalence,
+
16117  epiworld_double efficacy_vax,
+
16118  epiworld_double latent_period,
+
16119  epiworld_double infect_period,
+
16120  epiworld_double prob_symptoms,
+
16121  epiworld_double prop_vaccinated,
+
16122  epiworld_double prop_vax_redux_transm,
+
16123  epiworld_double prop_vax_redux_infect,
+
16124  epiworld_double surveillance_prob,
+
16125  epiworld_double prob_transmission,
+
16126  epiworld_double prob_death,
+
16127  epiworld_double prob_noreinfect
+
16128  )
+
16129 {
+
16130 
+
16131  EPI_NEW_UPDATEFUN_LAMBDA(surveillance_update_susceptible, TSeq) {
+
16132 
+
16133  // This computes the prob of getting any neighbor variant
+
16134  epiworld_fast_uint nviruses_tmp = 0u;
+
16135  for (auto & neighbor: p->get_neighbors())
+
16136  {
+
16137 
+
16138  auto & v = neighbor->get_virus();
+
16139 
+
16140  if (v == nullptr)
+
16141  continue;
+
16142 
+
16143  /* And it is a function of susceptibility_reduction as well */
+
16144  epiworld_double tmp_transmission =
+
16145  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
16146  v->get_prob_infecting(m) *
+
16147  (1.0 - neighbor->get_transmission_reduction(v, m))
+
16148  ;
+
16149 
+
16150  m->array_double_tmp[nviruses_tmp] = tmp_transmission;
+
16151  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
16152  }
+
16153 
+
16154  // No virus to compute on
+
16155  if (nviruses_tmp == 0)
+
16156  return;
+
16157 
+
16158  // Running the roulette
+
16159  int which = roulette(nviruses_tmp, m);
16160 
-
16161 
-
16162  epiworld::UpdateFun<TSeq> surveillance_update_exposed =
-
16163  [](epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m) -> void
-
16164  {
-
16165 
-
16166  epiworld::VirusPtr<TSeq> & v = p->get_virus();
-
16167  epiworld_double p_die = v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
-
16168 
-
16169  epiworld_fast_uint days_since_exposed = m->today() - v->get_date();
-
16170  epiworld_fast_uint state = p->get_state();
-
16171 
-
16172  // Figuring out latent period
-
16173  if (v->get_data().size() == 0u)
-
16174  {
-
16175  epiworld_double latent_days = m->rgamma(m->par("Latent period"), 1.0);
-
16176  v->get_data().push_back(latent_days);
-
16177 
-
16178  v->get_data().push_back(
-
16179  m->rgamma(m->par("Infect period"), 1.0) + latent_days
-
16180  );
-
16181  }
-
16182 
-
16183  // If still latent, nothing happens
-
16184  if (days_since_exposed <= v->get_data()[0u])
-
16185  return;
-
16186 
-
16187  // If past days infected + latent, then bye.
-
16188  if (days_since_exposed >= v->get_data()[1u])
-
16189  {
-
16190  p->rm_virus(m);
-
16191  return;
-
16192  }
-
16193 
-
16194  // If it is infected, then it can be asymptomatic or symptomatic
-
16195  if (state == ModelSURV<TSeq>::LATENT)
-
16196  {
-
16197 
-
16198  // Will be symptomatic?
-
16199  if (EPI_RUNIF() < m->par("Prob of symptoms"))
-
16200  p->change_state(m, ModelSURV<TSeq>::SYMPTOMATIC);
-
16201  else
-
16202  p->change_state(m, ModelSURV<TSeq>::ASYMPTOMATIC);
-
16203 
-
16204  return;
+
16161  if (which < 0)
+
16162  return;
+
16163 
+
16164  p->set_virus(*m->array_virus_tmp[which], m);
+
16165  return;
+
16166 
+
16167  };
+
16168 
+
16169 
+
16170  epiworld::UpdateFun<TSeq> surveillance_update_exposed =
+
16171  [](epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m) -> void
+
16172  {
+
16173 
+
16174  epiworld::VirusPtr<TSeq> & v = p->get_virus();
+
16175  epiworld_double p_die = v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
+
16176 
+
16177  epiworld_fast_uint days_since_exposed = m->today() - v->get_date();
+
16178  epiworld_fast_uint state = p->get_state();
+
16179 
+
16180  // Figuring out latent period
+
16181  if (v->get_data().size() == 0u)
+
16182  {
+
16183  epiworld_double latent_days = m->rgamma(m->par("Latent period"), 1.0);
+
16184  v->get_data().push_back(latent_days);
+
16185 
+
16186  v->get_data().push_back(
+
16187  m->rgamma(m->par("Infect period"), 1.0) + latent_days
+
16188  );
+
16189  }
+
16190 
+
16191  // If still latent, nothing happens
+
16192  if (days_since_exposed <= v->get_data()[0u])
+
16193  return;
+
16194 
+
16195  // If past days infected + latent, then bye.
+
16196  if (days_since_exposed >= v->get_data()[1u])
+
16197  {
+
16198  p->rm_virus(m);
+
16199  return;
+
16200  }
+
16201 
+
16202  // If it is infected, then it can be asymptomatic or symptomatic
+
16203  if (state == ModelSURV<TSeq>::LATENT)
+
16204  {
16205 
-
16206  }
-
16207 
-
16208  // Otherwise, it can be removed
-
16209  if (EPI_RUNIF() < p_die)
-
16210  {
-
16211  p->change_state(m, ModelSURV<TSeq>::REMOVED, -1);
+
16206  // Will be symptomatic?
+
16207  if (EPI_RUNIF() < m->par("Prob of symptoms"))
+
16208  p->change_state(m, ModelSURV<TSeq>::SYMPTOMATIC);
+
16209  else
+
16210  p->change_state(m, ModelSURV<TSeq>::ASYMPTOMATIC);
+
16211 
16212  return;
-
16213  }
-
16214 
-
16215  return;
-
16216 
-
16217  };
-
16218 
-
16219  std::vector< epiworld_fast_uint > exposed_state = {
-
16220  SYMPTOMATIC,
-
16221  SYMPTOMATIC_ISOLATED,
-
16222  ASYMPTOMATIC,
-
16223  ASYMPTOMATIC_ISOLATED,
-
16224  LATENT
+
16213 
+
16214  }
+
16215 
+
16216  // Otherwise, it can be removed
+
16217  if (EPI_RUNIF() < p_die)
+
16218  {
+
16219  p->change_state(m, ModelSURV<TSeq>::REMOVED, -1);
+
16220  return;
+
16221  }
+
16222 
+
16223  return;
+
16224 
16225  };
16226 
-
16227  epiworld::GlobalFun<TSeq> surveillance_program =
-
16228  [exposed_state](
-
16229  epiworld::Model<TSeq>* m
-
16230  ) -> void
-
16231  {
-
16232 
-
16233  // How many will we find
-
16234  std::binomial_distribution<> bdist(m->size(), m->par("Surveilance prob."));
-
16235  int nsampled = bdist(m->get_rand_endgine());
-
16236 
-
16237  int to_go = nsampled + 1;
-
16238 
-
16239  epiworld_double ndetected = 0.0;
-
16240  epiworld_double ndetected_asympt = 0.0;
-
16241 
-
16242  auto & pop = m->get_agents();
-
16243  std::vector< bool > sampled(m->size(), false);
-
16244 
-
16245  while (to_go-- > 0)
-
16246  {
-
16247 
-
16248  // Who is the lucky one
-
16249  epiworld_fast_uint i = static_cast<epiworld_fast_uint>(std::floor(EPI_RUNIF() * m->size()));
-
16250 
-
16251  if (sampled[i])
-
16252  continue;
-
16253 
-
16254  sampled[i] = true;
-
16255  epiworld::Agent<TSeq> * p = &pop[i];
-
16256 
-
16257  // If still exposed for the next term
-
16258  if (epiworld::IN(p->get_state(), exposed_state ))
-
16259  {
-
16260 
-
16261  ndetected += 1.0;
-
16262  if (p->get_state() == ModelSURV<TSeq>::ASYMPTOMATIC)
-
16263  {
-
16264  ndetected_asympt += 1.0;
-
16265  p->change_state(m, ModelSURV<TSeq>::ASYMPTOMATIC_ISOLATED);
-
16266  }
-
16267  else
-
16268  {
-
16269  p->change_state(m, ModelSURV<TSeq>::SYMPTOMATIC_ISOLATED);
-
16270  }
-
16271 
-
16272  }
-
16273 
-
16274  }
-
16275 
-
16276  // Writing the user data
-
16277  std::vector< int > totals;
-
16278  m->get_db().get_today_total(nullptr,&totals);
-
16279  m->add_user_data(
-
16280  {
-
16281  static_cast<epiworld_double>(nsampled),
-
16282  ndetected,
-
16283  ndetected_asympt,
-
16284  static_cast<epiworld_double>(totals[ModelSURV<TSeq>::ASYMPTOMATIC])
-
16285  }
-
16286  );
-
16287 
-
16288 
-
16289  };
-
16290 
-
16291  model.add_state("Susceptible", surveillance_update_susceptible);
-
16292  model.add_state("Latent", surveillance_update_exposed);
-
16293  model.add_state("Symptomatic", surveillance_update_exposed);
-
16294  model.add_state("Symptomatic isolated", surveillance_update_exposed);
-
16295  model.add_state("Asymptomatic", surveillance_update_exposed);
-
16296  model.add_state("Asymptomatic isolated", surveillance_update_exposed);
-
16297  model.add_state("Recovered");
-
16298  model.add_state("Removed");
-
16299 
-
16300  // General model parameters
-
16301  model.add_param(latent_period, "Latent period");
-
16302  model.add_param(infect_period, "Infect period");
-
16303  model.add_param(prob_symptoms, "Prob of symptoms");
-
16304  model.add_param(surveillance_prob, "Surveilance prob.");
-
16305  model.add_param(efficacy_vax, "Vax efficacy");
-
16306  model.add_param(prop_vax_redux_transm, "Vax redux transmission");
-
16307  model.add_param(prob_transmission, "Prob of transmission");
-
16308  model.add_param(prob_death, "Prob. death");
-
16309  model.add_param(prob_noreinfect, "Prob. no reinfect");
-
16310 
-
16311  // Virus ------------------------------------------------------------------
-
16312  epiworld::Virus<TSeq> covid("Covid19");
-
16313  covid.set_state(LATENT, RECOVERED, REMOVED);
-
16314  covid.set_post_immunity(&model("Prob. no reinfect"));
-
16315  covid.set_prob_death(&model("Prob. death"));
-
16316 
-
16317  epiworld::VirusFun<TSeq> ptransmitfun = [](
-
16318  epiworld::Agent<TSeq> * p,
-
16319  epiworld::Virus<TSeq> & v,
-
16320  epiworld::Model<TSeq> * m
-
16321  ) -> epiworld_double
-
16322  {
-
16323  // No chance of infecting
-
16324  epiworld_fast_uint s = p->get_state();
-
16325  if (s == ModelSURV<TSeq>::LATENT)
-
16326  return static_cast<epiworld_double>(0.0);
-
16327  else if (s == ModelSURV<TSeq>::SYMPTOMATIC_ISOLATED)
-
16328  return static_cast<epiworld_double>(0.0);
-
16329  else if (s == ModelSURV<TSeq>::ASYMPTOMATIC_ISOLATED)
-
16330  return static_cast<epiworld_double>(0.0);
-
16331 
-
16332  // Otherwise
-
16333  return m->par("Prob of transmission");
-
16334  };
-
16335 
-
16336  covid.set_prob_infecting_fun(ptransmitfun);
-
16337 
-
16338  model.add_virus_n(covid, prevalence);
+
16227  std::vector< epiworld_fast_uint > exposed_state = {
+
16228  SYMPTOMATIC,
+
16229  SYMPTOMATIC_ISOLATED,
+
16230  ASYMPTOMATIC,
+
16231  ASYMPTOMATIC_ISOLATED,
+
16232  LATENT
+
16233  };
+
16234 
+
16235  epiworld::GlobalFun<TSeq> surveillance_program =
+
16236  [exposed_state](
+
16237  epiworld::Model<TSeq>* m
+
16238  ) -> void
+
16239  {
+
16240 
+
16241  // How many will we find
+
16242  std::binomial_distribution<> bdist(m->size(), m->par("Surveilance prob."));
+
16243  int nsampled = bdist(m->get_rand_endgine());
+
16244 
+
16245  int to_go = nsampled + 1;
+
16246 
+
16247  epiworld_double ndetected = 0.0;
+
16248  epiworld_double ndetected_asympt = 0.0;
+
16249 
+
16250  auto & pop = m->get_agents();
+
16251  std::vector< bool > sampled(m->size(), false);
+
16252 
+
16253  while (to_go-- > 0)
+
16254  {
+
16255 
+
16256  // Who is the lucky one
+
16257  epiworld_fast_uint i = static_cast<epiworld_fast_uint>(std::floor(EPI_RUNIF() * m->size()));
+
16258 
+
16259  if (sampled[i])
+
16260  continue;
+
16261 
+
16262  sampled[i] = true;
+
16263  epiworld::Agent<TSeq> * p = &pop[i];
+
16264 
+
16265  // If still exposed for the next term
+
16266  if (epiworld::IN(p->get_state(), exposed_state ))
+
16267  {
+
16268 
+
16269  ndetected += 1.0;
+
16270  if (p->get_state() == ModelSURV<TSeq>::ASYMPTOMATIC)
+
16271  {
+
16272  ndetected_asympt += 1.0;
+
16273  p->change_state(m, ModelSURV<TSeq>::ASYMPTOMATIC_ISOLATED);
+
16274  }
+
16275  else
+
16276  {
+
16277  p->change_state(m, ModelSURV<TSeq>::SYMPTOMATIC_ISOLATED);
+
16278  }
+
16279 
+
16280  }
+
16281 
+
16282  }
+
16283 
+
16284  // Writing the user data
+
16285  std::vector< int > totals;
+
16286  m->get_db().get_today_total(nullptr,&totals);
+
16287  m->add_user_data(
+
16288  {
+
16289  static_cast<epiworld_double>(nsampled),
+
16290  ndetected,
+
16291  ndetected_asympt,
+
16292  static_cast<epiworld_double>(totals[ModelSURV<TSeq>::ASYMPTOMATIC])
+
16293  }
+
16294  );
+
16295 
+
16296 
+
16297  };
+
16298 
+
16299  model.add_state("Susceptible", surveillance_update_susceptible);
+
16300  model.add_state("Latent", surveillance_update_exposed);
+
16301  model.add_state("Symptomatic", surveillance_update_exposed);
+
16302  model.add_state("Symptomatic isolated", surveillance_update_exposed);
+
16303  model.add_state("Asymptomatic", surveillance_update_exposed);
+
16304  model.add_state("Asymptomatic isolated", surveillance_update_exposed);
+
16305  model.add_state("Recovered");
+
16306  model.add_state("Removed");
+
16307 
+
16308  // General model parameters
+
16309  model.add_param(latent_period, "Latent period");
+
16310  model.add_param(infect_period, "Infect period");
+
16311  model.add_param(prob_symptoms, "Prob of symptoms");
+
16312  model.add_param(surveillance_prob, "Surveilance prob.");
+
16313  model.add_param(efficacy_vax, "Vax efficacy");
+
16314  model.add_param(prop_vax_redux_transm, "Vax redux transmission");
+
16315  model.add_param(prob_transmission, "Prob of transmission");
+
16316  model.add_param(prob_death, "Prob. death");
+
16317  model.add_param(prob_noreinfect, "Prob. no reinfect");
+
16318 
+
16319  // Virus ------------------------------------------------------------------
+
16320  epiworld::Virus<TSeq> covid("Covid19");
+
16321  covid.set_state(LATENT, RECOVERED, REMOVED);
+
16322  covid.set_post_immunity(&model("Prob. no reinfect"));
+
16323  covid.set_prob_death(&model("Prob. death"));
+
16324 
+
16325  epiworld::VirusFun<TSeq> ptransmitfun = [](
+
16326  epiworld::Agent<TSeq> * p,
+
16327  epiworld::Virus<TSeq> & v,
+
16328  epiworld::Model<TSeq> * m
+
16329  ) -> epiworld_double
+
16330  {
+
16331  // No chance of infecting
+
16332  epiworld_fast_uint s = p->get_state();
+
16333  if (s == ModelSURV<TSeq>::LATENT)
+
16334  return static_cast<epiworld_double>(0.0);
+
16335  else if (s == ModelSURV<TSeq>::SYMPTOMATIC_ISOLATED)
+
16336  return static_cast<epiworld_double>(0.0);
+
16337  else if (s == ModelSURV<TSeq>::ASYMPTOMATIC_ISOLATED)
+
16338  return static_cast<epiworld_double>(0.0);
16339 
-
16340  model.set_user_data({"nsampled", "ndetected", "ndetected_asympt", "nasymptomatic"});
-
16341  model.add_global_action(surveillance_program, "Surveilance program", -1);
-
16342 
-
16343  // Vaccine tool -----------------------------------------------------------
-
16344  epiworld::Tool<TSeq> vax("Vaccine");
-
16345  vax.set_susceptibility_reduction(&model("Vax efficacy"));
-
16346  vax.set_transmission_reduction(&model("Vax redux transmission"));
-
16347 
-
16348  model.add_tool(vax, prop_vaccinated);
-
16349 
-
16350  model.set_name("Surveillance");
-
16351 
-
16352  return;
-
16353 
-
16354 }
-
16355 
-
16356 template<typename TSeq>
-
16357 inline ModelSURV<TSeq>::ModelSURV(
-
16358  std::string vname,
-
16359  epiworld_fast_uint prevalence,
-
16360  epiworld_double efficacy_vax,
-
16361  epiworld_double latent_period,
-
16362  epiworld_double infect_period,
-
16363  epiworld_double prob_symptoms,
-
16364  epiworld_double prop_vaccinated,
-
16365  epiworld_double prop_vax_redux_transm,
-
16366  epiworld_double prop_vax_redux_infect,
-
16367  epiworld_double surveillance_prob,
-
16368  epiworld_double prob_transmission,
-
16369  epiworld_double prob_death,
-
16370  epiworld_double prob_noreinfect
-
16371  )
-
16372 {
-
16373 
-
16374  ModelSURV(
-
16375  *this,
-
16376  vname,
-
16377  prevalence,
-
16378  efficacy_vax,
-
16379  latent_period,
-
16380  infect_period,
-
16381  prob_symptoms,
-
16382  prop_vaccinated,
-
16383  prop_vax_redux_transm,
-
16384  prop_vax_redux_infect,
-
16385  surveillance_prob,
-
16386  prob_transmission,
-
16387  prob_death,
-
16388  prob_noreinfect
-
16389  );
-
16390 
-
16391  return;
-
16392 
-
16393 }
-
16394 
-
16395 #endif
-
16396 /*//////////////////////////////////////////////////////////////////////////////
-
16398 
-
16399  End of -include/epiworld//models/surveillance.hpp-
-
16400 
-
16403 
-
16404 
-
16405 /*//////////////////////////////////////////////////////////////////////////////
-
16407 
-
16408  Start of -include/epiworld//models/sirconnected.hpp-
-
16409 
+
16340  // Otherwise
+
16341  return m->par("Prob of transmission");
+
16342  };
+
16343 
+
16344  covid.set_prob_infecting_fun(ptransmitfun);
+
16345 
+
16346  model.add_virus_n(covid, prevalence);
+
16347 
+
16348  model.set_user_data({"nsampled", "ndetected", "ndetected_asympt", "nasymptomatic"});
+
16349  model.add_global_action(surveillance_program, "Surveilance program", -1);
+
16350 
+
16351  // Vaccine tool -----------------------------------------------------------
+
16352  epiworld::Tool<TSeq> vax("Vaccine");
+
16353  vax.set_susceptibility_reduction(&model("Vax efficacy"));
+
16354  vax.set_transmission_reduction(&model("Vax redux transmission"));
+
16355 
+
16356  model.add_tool(vax, prop_vaccinated);
+
16357 
+
16358  model.set_name("Surveillance");
+
16359 
+
16360  return;
+
16361 
+
16362 }
+
16363 
+
16364 template<typename TSeq>
+
16365 inline ModelSURV<TSeq>::ModelSURV(
+
16366  std::string vname,
+
16367  epiworld_fast_uint prevalence,
+
16368  epiworld_double efficacy_vax,
+
16369  epiworld_double latent_period,
+
16370  epiworld_double infect_period,
+
16371  epiworld_double prob_symptoms,
+
16372  epiworld_double prop_vaccinated,
+
16373  epiworld_double prop_vax_redux_transm,
+
16374  epiworld_double prop_vax_redux_infect,
+
16375  epiworld_double surveillance_prob,
+
16376  epiworld_double prob_transmission,
+
16377  epiworld_double prob_death,
+
16378  epiworld_double prob_noreinfect
+
16379  )
+
16380 {
+
16381 
+
16382  ModelSURV(
+
16383  *this,
+
16384  vname,
+
16385  prevalence,
+
16386  efficacy_vax,
+
16387  latent_period,
+
16388  infect_period,
+
16389  prob_symptoms,
+
16390  prop_vaccinated,
+
16391  prop_vax_redux_transm,
+
16392  prop_vax_redux_infect,
+
16393  surveillance_prob,
+
16394  prob_transmission,
+
16395  prob_death,
+
16396  prob_noreinfect
+
16397  );
+
16398 
+
16399  return;
+
16400 
+
16401 }
+
16402 
+
16403 #endif
+
16404 /*//////////////////////////////////////////////////////////////////////////////
+
16406 
+
16407  End of -include/epiworld//models/surveillance.hpp-
+
16408 
+
16411 
16412 
-
16413 
-
16414 #ifndef EPIWORLD_MODELS_SIRCONNECTED_HPP
-
16415 #define EPIWORLD_MODELS_SIRCONNECTED_HPP
-
16416 
-
16417 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
16418 class ModelSIRCONN : public epiworld::Model<TSeq>
-
16419 {
-
16420 private:
-
16421  static const int SUSCEPTIBLE = 0;
-
16422  static const int INFECTED = 1;
-
16423  static const int RECOVERED = 2;
+
16413 /*//////////////////////////////////////////////////////////////////////////////
+
16415 
+
16416  Start of -include/epiworld//models/sirconnected.hpp-
+
16417 
+
16420 
+
16421 
+
16422 #ifndef EPIWORLD_MODELS_SIRCONNECTED_HPP
+
16423 #define EPIWORLD_MODELS_SIRCONNECTED_HPP
16424 
-
16425 public:
-
16426 
-
16427  ModelSIRCONN() {};
-
16428 
-
16429  ModelSIRCONN(
-
16430  ModelSIRCONN<TSeq> & model,
-
16431  std::string vname,
-
16432  epiworld_fast_uint n,
-
16433  epiworld_double prevalence,
-
16434  epiworld_double contact_rate,
-
16435  epiworld_double transmission_rate,
-
16436  epiworld_double recovery_rate
-
16437  );
-
16438 
-
16439  ModelSIRCONN(
-
16440  std::string vname,
-
16441  epiworld_fast_uint n,
-
16442  epiworld_double prevalence,
-
16443  epiworld_double contact_rate,
-
16444  epiworld_double transmission_rate,
-
16445  epiworld_double recovery_rate
-
16446  );
-
16447 
-
16448  ModelSIRCONN<TSeq> & run(
-
16449  epiworld_fast_uint ndays,
-
16450  int seed = -1
-
16451  );
-
16452 
-
16453  void reset();
-
16454 
-
16455  Model<TSeq> * clone_ptr();
-
16456 
-
16462  ModelSIRCONN<TSeq> & initial_states(
-
16463  std::vector< double > proportions_,
-
16464  std::vector< int > queue_ = {}
-
16465  );
-
16466 
-
16467 
-
16468 };
-
16469 
-
16470 template<typename TSeq>
-
16471 inline ModelSIRCONN<TSeq> & ModelSIRCONN<TSeq>::run(
-
16472  epiworld_fast_uint ndays,
-
16473  int seed
-
16474 )
-
16475 {
-
16476 
-
16477  Model<TSeq>::run(ndays, seed);
-
16478  return *this;
-
16479 
-
16480 }
-
16481 
-
16482 template<typename TSeq>
-
16483 inline void ModelSIRCONN<TSeq>::reset()
-
16484 {
-
16485 
-
16486  Model<TSeq>::reset();
-
16487  return;
-
16488 
-
16489 }
-
16490 
-
16491 template<typename TSeq>
-
16492 inline Model<TSeq> * ModelSIRCONN<TSeq>::clone_ptr()
-
16493 {
-
16494 
-
16495  ModelSIRCONN<TSeq> * ptr = new ModelSIRCONN<TSeq>(
-
16496  *dynamic_cast<const ModelSIRCONN<TSeq>*>(this)
-
16497  );
+
16425 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
16426 class ModelSIRCONN : public epiworld::Model<TSeq>
+
16427 {
+
16428 private:
+
16429  static const int SUSCEPTIBLE = 0;
+
16430  static const int INFECTED = 1;
+
16431  static const int RECOVERED = 2;
+
16432 
+
16433 public:
+
16434 
+
16435  ModelSIRCONN() {};
+
16436 
+
16437  ModelSIRCONN(
+
16438  ModelSIRCONN<TSeq> & model,
+
16439  std::string vname,
+
16440  epiworld_fast_uint n,
+
16441  epiworld_double prevalence,
+
16442  epiworld_double contact_rate,
+
16443  epiworld_double transmission_rate,
+
16444  epiworld_double recovery_rate
+
16445  );
+
16446 
+
16447  ModelSIRCONN(
+
16448  std::string vname,
+
16449  epiworld_fast_uint n,
+
16450  epiworld_double prevalence,
+
16451  epiworld_double contact_rate,
+
16452  epiworld_double transmission_rate,
+
16453  epiworld_double recovery_rate
+
16454  );
+
16455 
+
16456  ModelSIRCONN<TSeq> & run(
+
16457  epiworld_fast_uint ndays,
+
16458  int seed = -1
+
16459  );
+
16460 
+
16461  void reset();
+
16462 
+
16463  Model<TSeq> * clone_ptr();
+
16464 
+
16470  ModelSIRCONN<TSeq> & initial_states(
+
16471  std::vector< double > proportions_,
+
16472  std::vector< int > queue_ = {}
+
16473  );
+
16474 
+
16475 
+
16476 };
+
16477 
+
16478 template<typename TSeq>
+
16479 inline ModelSIRCONN<TSeq> & ModelSIRCONN<TSeq>::run(
+
16480  epiworld_fast_uint ndays,
+
16481  int seed
+
16482 )
+
16483 {
+
16484 
+
16485  Model<TSeq>::run(ndays, seed);
+
16486  return *this;
+
16487 
+
16488 }
+
16489 
+
16490 template<typename TSeq>
+
16491 inline void ModelSIRCONN<TSeq>::reset()
+
16492 {
+
16493 
+
16494  Model<TSeq>::reset();
+
16495  return;
+
16496 
+
16497 }
16498 
-
16499  return dynamic_cast< Model<TSeq> *>(ptr);
-
16500 
-
16501 }
-
16502 
-
16513 template<typename TSeq>
-
16514 inline ModelSIRCONN<TSeq>::ModelSIRCONN(
-
16515  ModelSIRCONN<TSeq> & model,
-
16516  std::string vname,
-
16517  epiworld_fast_uint n,
-
16518  epiworld_double prevalence,
-
16519  epiworld_double contact_rate,
-
16520  epiworld_double transmission_rate,
-
16521  epiworld_double recovery_rate
-
16522  // epiworld_double prob_reinfection
-
16523  )
-
16524 {
-
16525 
-
16526  epiworld::UpdateFun<TSeq> update_susceptible = [](
-
16527  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
16528  ) -> void
-
16529  {
-
16530 
-
16531  // Sampling how many individuals
-
16532  m->set_rand_binom(
-
16533  m->size(),
-
16534  static_cast<double>(
-
16535  m->par("Contact rate"))/
-
16536  static_cast<double>(m->size())
-
16537  );
+
16499 template<typename TSeq>
+
16500 inline Model<TSeq> * ModelSIRCONN<TSeq>::clone_ptr()
+
16501 {
+
16502 
+
16503  ModelSIRCONN<TSeq> * ptr = new ModelSIRCONN<TSeq>(
+
16504  *dynamic_cast<const ModelSIRCONN<TSeq>*>(this)
+
16505  );
+
16506 
+
16507  return dynamic_cast< Model<TSeq> *>(ptr);
+
16508 
+
16509 }
+
16510 
+
16521 template<typename TSeq>
+
16522 inline ModelSIRCONN<TSeq>::ModelSIRCONN(
+
16523  ModelSIRCONN<TSeq> & model,
+
16524  std::string vname,
+
16525  epiworld_fast_uint n,
+
16526  epiworld_double prevalence,
+
16527  epiworld_double contact_rate,
+
16528  epiworld_double transmission_rate,
+
16529  epiworld_double recovery_rate
+
16530  // epiworld_double prob_reinfection
+
16531  )
+
16532 {
+
16533 
+
16534  epiworld::UpdateFun<TSeq> update_susceptible = [](
+
16535  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
16536  ) -> void
+
16537  {
16538 
-
16539  int ndraw = m->rbinom();
-
16540 
-
16541  if (ndraw == 0)
-
16542  return;
-
16543 
-
16544  // Drawing from the set
-
16545  int nviruses_tmp = 0;
-
16546  for (int i = 0; i < ndraw; ++i)
-
16547  {
-
16548  // Now selecting who is transmitting the disease
-
16549  int which = static_cast<int>(
-
16550  std::floor(m->size() * m->runif())
-
16551  );
-
16552 
-
16553  /* There is a bug in which runif() returns 1.0. It is rare, but
-
16554  * we saw it here. See the Notes section in the C++ manual
-
16555  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
-
16556  * And the reported bug in GCC:
-
16557  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
-
16558  *
-
16559  */
-
16560  if (which == static_cast<int>(m->size()))
-
16561  --which;
-
16562 
-
16563  // Can't sample itself
-
16564  if (which == static_cast<int>(p->get_id()))
-
16565  continue;
-
16566 
-
16567  // If the neighbor is infected, then proceed
-
16568  auto & neighbor = m->get_agents()[which];
-
16569  if (neighbor.get_state() == ModelSIRCONN<TSeq>::INFECTED)
-
16570  {
-
16571 
-
16572  if (neighbor.get_virus() == nullptr)
-
16573  continue;
+
16539  // Sampling how many individuals
+
16540  m->set_rand_binom(
+
16541  m->size(),
+
16542  static_cast<double>(
+
16543  m->par("Contact rate"))/
+
16544  static_cast<double>(m->size())
+
16545  );
+
16546 
+
16547  int ndraw = m->rbinom();
+
16548 
+
16549  if (ndraw == 0)
+
16550  return;
+
16551 
+
16552  // Drawing from the set
+
16553  int nviruses_tmp = 0;
+
16554  for (int i = 0; i < ndraw; ++i)
+
16555  {
+
16556  // Now selecting who is transmitting the disease
+
16557  int which = static_cast<int>(
+
16558  std::floor(m->size() * m->runif())
+
16559  );
+
16560 
+
16561  /* There is a bug in which runif() returns 1.0. It is rare, but
+
16562  * we saw it here. See the Notes section in the C++ manual
+
16563  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
+
16564  * And the reported bug in GCC:
+
16565  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
+
16566  *
+
16567  */
+
16568  if (which == static_cast<int>(m->size()))
+
16569  --which;
+
16570 
+
16571  // Can't sample itself
+
16572  if (which == static_cast<int>(p->get_id()))
+
16573  continue;
16574 
-
16575  auto & v = neighbor.get_virus();
-
16576 
-
16577  #ifdef EPI_DEBUG
-
16578  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
-
16579  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
16580  #endif
-
16581 
-
16582  /* And it is a function of susceptibility_reduction as well */
-
16583  m->array_double_tmp[nviruses_tmp] =
-
16584  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
16585  v->get_prob_infecting(m) *
-
16586  (1.0 - neighbor.get_transmission_reduction(v, m))
-
16587  ;
-
16588 
-
16589  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
16590 
-
16591 
-
16592  }
-
16593  }
-
16594 
-
16595  // No virus to compute
-
16596  if (nviruses_tmp == 0u)
-
16597  return;
-
16598 
-
16599  // Running the roulette
-
16600  int which = roulette(nviruses_tmp, m);
-
16601 
-
16602  if (which < 0)
-
16603  return;
-
16604 
-
16605  p->set_virus(*m->array_virus_tmp[which], m);
+
16575  // If the neighbor is infected, then proceed
+
16576  auto & neighbor = m->get_agents()[which];
+
16577  if (neighbor.get_state() == ModelSIRCONN<TSeq>::INFECTED)
+
16578  {
+
16579 
+
16580  if (neighbor.get_virus() == nullptr)
+
16581  continue;
+
16582 
+
16583  auto & v = neighbor.get_virus();
+
16584 
+
16585  #ifdef EPI_DEBUG
+
16586  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
+
16587  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
16588  #endif
+
16589 
+
16590  /* And it is a function of susceptibility_reduction as well */
+
16591  m->array_double_tmp[nviruses_tmp] =
+
16592  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
16593  v->get_prob_infecting(m) *
+
16594  (1.0 - neighbor.get_transmission_reduction(v, m))
+
16595  ;
+
16596 
+
16597  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
16598 
+
16599 
+
16600  }
+
16601  }
+
16602 
+
16603  // No virus to compute
+
16604  if (nviruses_tmp == 0u)
+
16605  return;
16606 
-
16607  return;
-
16608 
-
16609  };
-
16610 
-
16611 
-
16612  epiworld::UpdateFun<TSeq> update_infected = [](
-
16613  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
16614  ) -> void {
-
16615 
-
16616  auto state = p->get_state();
-
16617 
-
16618  if (state == ModelSIRCONN<TSeq>::INFECTED)
-
16619  {
-
16620 
-
16621 
-
16622  // Odd: Die, Even: Recover
-
16623  epiworld_fast_uint n_events = 0u;
-
16624  // Recover
-
16625  m->array_double_tmp[n_events++] =
-
16626  1.0 - (1.0 - p->get_virus()->get_prob_recovery(m)) *
-
16627  (1.0 - p->get_recovery_enhancer(p->get_virus(), m));
+
16607  // Running the roulette
+
16608  int which = roulette(nviruses_tmp, m);
+
16609 
+
16610  if (which < 0)
+
16611  return;
+
16612 
+
16613  p->set_virus(*m->array_virus_tmp[which], m);
+
16614 
+
16615  return;
+
16616 
+
16617  };
+
16618 
+
16619 
+
16620  epiworld::UpdateFun<TSeq> update_infected = [](
+
16621  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
16622  ) -> void {
+
16623 
+
16624  auto state = p->get_state();
+
16625 
+
16626  if (state == ModelSIRCONN<TSeq>::INFECTED)
+
16627  {
16628 
-
16629  #ifdef EPI_DEBUG
-
16630  if (n_events == 0u)
-
16631  {
-
16632  printf_epiworld(
-
16633  "[epi-debug] agent %i has 0 possible events!!\n",
-
16634  static_cast<int>(p->get_id())
-
16635  );
-
16636  throw std::logic_error("Zero events in exposed.");
-
16637  }
-
16638  #else
-
16639  if (n_events == 0u)
-
16640  return;
-
16641  #endif
-
16642 
-
16643 
-
16644  // Running the roulette
-
16645  int which = roulette(n_events, m);
-
16646 
-
16647  if (which < 0)
+
16629 
+
16630  // Odd: Die, Even: Recover
+
16631  epiworld_fast_uint n_events = 0u;
+
16632  // Recover
+
16633  m->array_double_tmp[n_events++] =
+
16634  1.0 - (1.0 - p->get_virus()->get_prob_recovery(m)) *
+
16635  (1.0 - p->get_recovery_enhancer(p->get_virus(), m));
+
16636 
+
16637  #ifdef EPI_DEBUG
+
16638  if (n_events == 0u)
+
16639  {
+
16640  printf_epiworld(
+
16641  "[epi-debug] agent %i has 0 possible events!!\n",
+
16642  static_cast<int>(p->get_id())
+
16643  );
+
16644  throw std::logic_error("Zero events in exposed.");
+
16645  }
+
16646  #else
+
16647  if (n_events == 0u)
16648  return;
-
16649 
-
16650  // Which roulette happen?
-
16651  p->rm_virus(m);
-
16652 
-
16653  return ;
+
16649  #endif
+
16650 
+
16651 
+
16652  // Running the roulette
+
16653  int which = roulette(n_events, m);
16654 
-
16655  } else
-
16656  throw std::logic_error(
-
16657  "This function can only be applied to infected individuals. (SIR)"
-
16658  ) ;
-
16659 
-
16660  return;
-
16661 
-
16662  };
-
16663 
-
16664  // state
-
16665  model.add_state("Susceptible", update_susceptible);
-
16666  model.add_state("Infected", update_infected);
-
16667  model.add_state("Recovered");
-
16668 
-
16669  // Setting up parameters
-
16670  model.add_param(contact_rate, "Contact rate");
-
16671  model.add_param(transmission_rate, "Transmission rate");
-
16672  model.add_param(recovery_rate, "Recovery rate");
-
16673  // model.add_param(prob_reinfection, "Prob. Reinfection");
-
16674 
-
16675  // Preparing the virus -------------------------------------------
-
16676  epiworld::Virus<TSeq> virus(vname);
-
16677  virus.set_state(1, 2, 2);
-
16678  virus.set_prob_infecting(&model("Transmission rate"));
-
16679  virus.set_prob_recovery(&model("Recovery rate"));
-
16680 
-
16681  model.add_virus(virus, prevalence);
-
16682 
-
16683  model.queuing_off(); // No queuing need
-
16684 
-
16685  model.agents_empty_graph(n);
-
16686 
-
16687  model.set_name("Susceptible-Infected-Removed (SIR) (connected)");
+
16655  if (which < 0)
+
16656  return;
+
16657 
+
16658  // Which roulette happen?
+
16659  p->rm_virus(m);
+
16660 
+
16661  return ;
+
16662 
+
16663  } else
+
16664  throw std::logic_error(
+
16665  "This function can only be applied to infected individuals. (SIR)"
+
16666  ) ;
+
16667 
+
16668  return;
+
16669 
+
16670  };
+
16671 
+
16672  // state
+
16673  model.add_state("Susceptible", update_susceptible);
+
16674  model.add_state("Infected", update_infected);
+
16675  model.add_state("Recovered");
+
16676 
+
16677  // Setting up parameters
+
16678  model.add_param(contact_rate, "Contact rate");
+
16679  model.add_param(transmission_rate, "Transmission rate");
+
16680  model.add_param(recovery_rate, "Recovery rate");
+
16681  // model.add_param(prob_reinfection, "Prob. Reinfection");
+
16682 
+
16683  // Preparing the virus -------------------------------------------
+
16684  epiworld::Virus<TSeq> virus(vname);
+
16685  virus.set_state(1, 2, 2);
+
16686  virus.set_prob_infecting(&model("Transmission rate"));
+
16687  virus.set_prob_recovery(&model("Recovery rate"));
16688 
-
16689  return;
+
16689  model.add_virus(virus, prevalence);
16690 
-
16691 }
+
16691  model.queuing_off(); // No queuing need
16692 
-
16693 template<typename TSeq>
-
16694 inline ModelSIRCONN<TSeq>::ModelSIRCONN(
-
16695  std::string vname,
-
16696  epiworld_fast_uint n,
-
16697  epiworld_double prevalence,
-
16698  epiworld_double contact_rate,
-
16699  epiworld_double transmission_rate,
-
16700  epiworld_double recovery_rate
-
16701  )
-
16702 {
-
16703 
-
16704  ModelSIRCONN(
-
16705  *this,
-
16706  vname,
-
16707  n,
-
16708  prevalence,
-
16709  contact_rate,
-
16710  transmission_rate,
-
16711  recovery_rate
-
16712  );
-
16713 
-
16714  return;
-
16715 
-
16716 }
-
16717 
-
16718 template<typename TSeq>
-
16719 inline ModelSIRCONN<TSeq> & ModelSIRCONN<TSeq>::initial_states(
-
16720  std::vector< double > proportions_,
-
16721  std::vector< int >
-
16722 ) {
+
16693  model.agents_empty_graph(n);
+
16694 
+
16695  model.set_name("Susceptible-Infected-Removed (SIR) (connected)");
+
16696 
+
16697  return;
+
16698 
+
16699 }
+
16700 
+
16701 template<typename TSeq>
+
16702 inline ModelSIRCONN<TSeq>::ModelSIRCONN(
+
16703  std::string vname,
+
16704  epiworld_fast_uint n,
+
16705  epiworld_double prevalence,
+
16706  epiworld_double contact_rate,
+
16707  epiworld_double transmission_rate,
+
16708  epiworld_double recovery_rate
+
16709  )
+
16710 {
+
16711 
+
16712  ModelSIRCONN(
+
16713  *this,
+
16714  vname,
+
16715  n,
+
16716  prevalence,
+
16717  contact_rate,
+
16718  transmission_rate,
+
16719  recovery_rate
+
16720  );
+
16721 
+
16722  return;
16723 
-
16724  Model<TSeq>::initial_states_fun =
-
16725  create_init_function_sir<TSeq>(proportions_)
-
16726  ;
-
16727 
-
16728  return *this;
-
16729 
-
16730 }
+
16724 }
+
16725 
+
16726 template<typename TSeq>
+
16727 inline ModelSIRCONN<TSeq> & ModelSIRCONN<TSeq>::initial_states(
+
16728  std::vector< double > proportions_,
+
16729  std::vector< int >
+
16730 ) {
16731 
-
16732 
-
16733 #endif
-
16734 /*//////////////////////////////////////////////////////////////////////////////
-
16736 
-
16737  End of -include/epiworld//models/sirconnected.hpp-
-
16738 
-
16741 
-
16742 
-
16743 /*//////////////////////////////////////////////////////////////////////////////
-
16745 
-
16746  Start of -include/epiworld//models/seirconnected.hpp-
-
16747 
+
16732  Model<TSeq>::initial_states_fun =
+
16733  create_init_function_sir<TSeq>(proportions_)
+
16734  ;
+
16735 
+
16736  return *this;
+
16737 
+
16738 }
+
16739 
+
16740 
+
16741 #endif
+
16742 /*//////////////////////////////////////////////////////////////////////////////
+
16744 
+
16745  End of -include/epiworld//models/sirconnected.hpp-
+
16746 
+
16749 
16750 
-
16751 
-
16752 #ifndef EPIWORLD_MODELS_SEIRCONNECTED_HPP
-
16753 #define EPIWORLD_MODELS_SEIRCONNECTED_HPP
-
16754 
-
16755 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
16756 class ModelSEIRCONN : public epiworld::Model<TSeq>
-
16757 {
-
16758 public:
+
16751 /*//////////////////////////////////////////////////////////////////////////////
+
16753 
+
16754  Start of -include/epiworld//models/seirconnected.hpp-
+
16755 
+
16758 
16759 
-
16760  static const int SUSCEPTIBLE = 0;
-
16761  static const int EXPOSED = 1;
-
16762  static const int INFECTED = 2;
-
16763  static const int RECOVERED = 3;
-
16764 
-
16765 
-
16766  ModelSEIRCONN() {};
+
16760 #ifndef EPIWORLD_MODELS_SEIRCONNECTED_HPP
+
16761 #define EPIWORLD_MODELS_SEIRCONNECTED_HPP
+
16762 
+
16763 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
16764 class ModelSEIRCONN : public epiworld::Model<TSeq>
+
16765 {
+
16766 public:
16767 
-
16768  ModelSEIRCONN(
-
16769  ModelSEIRCONN<TSeq> & model,
-
16770  std::string vname,
-
16771  epiworld_fast_uint n,
-
16772  epiworld_double prevalence,
-
16773  epiworld_double contact_rate,
-
16774  epiworld_double transmission_rate,
-
16775  epiworld_double avg_incubation_days,
-
16776  epiworld_double recovery_rate
-
16777  );
-
16778 
-
16779  ModelSEIRCONN(
-
16780  std::string vname,
-
16781  epiworld_fast_uint n,
-
16782  epiworld_double prevalence,
-
16783  epiworld_double contact_rate,
-
16784  epiworld_double transmission_rate,
-
16785  epiworld_double avg_incubation_days,
-
16786  epiworld_double recovery_rate
-
16787  );
-
16788 
-
16789  ModelSEIRCONN<TSeq> & run(
-
16790  epiworld_fast_uint ndays,
-
16791  int seed = -1
-
16792  );
-
16793 
-
16794  void reset();
-
16795 
-
16796  Model<TSeq> * clone_ptr();
-
16797 
-
16803  ModelSEIRCONN<TSeq> & initial_states(
-
16804  std::vector< double > proportions_,
-
16805  std::vector< int > queue_ = {}
-
16806  );
-
16807 
-
16808 };
-
16809 
-
16810 template<typename TSeq>
-
16811 inline ModelSEIRCONN<TSeq> & ModelSEIRCONN<TSeq>::run(
-
16812  epiworld_fast_uint ndays,
-
16813  int seed
-
16814 )
-
16815 {
-
16816 
-
16817  Model<TSeq>::run(ndays, seed);
-
16818 
-
16819  return *this;
-
16820 
-
16821 }
-
16822 
-
16823 template<typename TSeq>
-
16824 inline void ModelSEIRCONN<TSeq>::reset()
-
16825 {
+
16768  static const int SUSCEPTIBLE = 0;
+
16769  static const int EXPOSED = 1;
+
16770  static const int INFECTED = 2;
+
16771  static const int RECOVERED = 3;
+
16772 
+
16773 
+
16774  ModelSEIRCONN() {};
+
16775 
+
16776  ModelSEIRCONN(
+
16777  ModelSEIRCONN<TSeq> & model,
+
16778  std::string vname,
+
16779  epiworld_fast_uint n,
+
16780  epiworld_double prevalence,
+
16781  epiworld_double contact_rate,
+
16782  epiworld_double transmission_rate,
+
16783  epiworld_double avg_incubation_days,
+
16784  epiworld_double recovery_rate
+
16785  );
+
16786 
+
16787  ModelSEIRCONN(
+
16788  std::string vname,
+
16789  epiworld_fast_uint n,
+
16790  epiworld_double prevalence,
+
16791  epiworld_double contact_rate,
+
16792  epiworld_double transmission_rate,
+
16793  epiworld_double avg_incubation_days,
+
16794  epiworld_double recovery_rate
+
16795  );
+
16796 
+
16797  ModelSEIRCONN<TSeq> & run(
+
16798  epiworld_fast_uint ndays,
+
16799  int seed = -1
+
16800  );
+
16801 
+
16802  void reset();
+
16803 
+
16804  Model<TSeq> * clone_ptr();
+
16805 
+
16811  ModelSEIRCONN<TSeq> & initial_states(
+
16812  std::vector< double > proportions_,
+
16813  std::vector< int > queue_ = {}
+
16814  );
+
16815 
+
16816 };
+
16817 
+
16818 template<typename TSeq>
+
16819 inline ModelSEIRCONN<TSeq> & ModelSEIRCONN<TSeq>::run(
+
16820  epiworld_fast_uint ndays,
+
16821  int seed
+
16822 )
+
16823 {
+
16824 
+
16825  Model<TSeq>::run(ndays, seed);
16826 
-
16827  Model<TSeq>::reset();
+
16827  return *this;
16828 
-
16829  Model<TSeq>::set_rand_binom(
-
16830  Model<TSeq>::size(),
-
16831  static_cast<double>(
-
16832  Model<TSeq>::par("Contact rate"))/
-
16833  static_cast<double>(Model<TSeq>::size())
-
16834  );
-
16835 
-
16836  return;
-
16837 
-
16838 }
-
16839 
-
16840 template<typename TSeq>
-
16841 inline Model<TSeq> * ModelSEIRCONN<TSeq>::clone_ptr()
-
16842 {
-
16843 
-
16844  ModelSEIRCONN<TSeq> * ptr = new ModelSEIRCONN<TSeq>(
-
16845  *dynamic_cast<const ModelSEIRCONN<TSeq>*>(this)
-
16846  );
+
16829 }
+
16830 
+
16831 template<typename TSeq>
+
16832 inline void ModelSEIRCONN<TSeq>::reset()
+
16833 {
+
16834 
+
16835  Model<TSeq>::reset();
+
16836 
+
16837  Model<TSeq>::set_rand_binom(
+
16838  Model<TSeq>::size(),
+
16839  static_cast<double>(
+
16840  Model<TSeq>::par("Contact rate"))/
+
16841  static_cast<double>(Model<TSeq>::size())
+
16842  );
+
16843 
+
16844  return;
+
16845 
+
16846 }
16847 
-
16848  return dynamic_cast< Model<TSeq> *>(ptr);
-
16849 
-
16850 }
-
16851 
-
16862 template<typename TSeq>
-
16863 inline ModelSEIRCONN<TSeq>::ModelSEIRCONN(
-
16864  ModelSEIRCONN<TSeq> & model,
-
16865  std::string vname,
-
16866  epiworld_fast_uint n,
-
16867  epiworld_double prevalence,
-
16868  epiworld_double contact_rate,
-
16869  epiworld_double transmission_rate,
-
16870  epiworld_double avg_incubation_days,
-
16871  epiworld_double recovery_rate
-
16872  // epiworld_double prob_reinfection
-
16873  )
-
16874 {
-
16875 
-
16876  epiworld::UpdateFun<TSeq> update_susceptible = [](
-
16877  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
16878  ) -> void
-
16879  {
-
16880 
-
16881  // Sampling how many individuals
-
16882  int ndraw = m->rbinom();
+
16848 template<typename TSeq>
+
16849 inline Model<TSeq> * ModelSEIRCONN<TSeq>::clone_ptr()
+
16850 {
+
16851 
+
16852  ModelSEIRCONN<TSeq> * ptr = new ModelSEIRCONN<TSeq>(
+
16853  *dynamic_cast<const ModelSEIRCONN<TSeq>*>(this)
+
16854  );
+
16855 
+
16856  return dynamic_cast< Model<TSeq> *>(ptr);
+
16857 
+
16858 }
+
16859 
+
16870 template<typename TSeq>
+
16871 inline ModelSEIRCONN<TSeq>::ModelSEIRCONN(
+
16872  ModelSEIRCONN<TSeq> & model,
+
16873  std::string vname,
+
16874  epiworld_fast_uint n,
+
16875  epiworld_double prevalence,
+
16876  epiworld_double contact_rate,
+
16877  epiworld_double transmission_rate,
+
16878  epiworld_double avg_incubation_days,
+
16879  epiworld_double recovery_rate
+
16880  // epiworld_double prob_reinfection
+
16881  )
+
16882 {
16883 
-
16884  if (ndraw == 0)
-
16885  return;
-
16886 
-
16887  // Drawing from the set
-
16888  int nviruses_tmp = 0;
-
16889  for (int i = 0; i < ndraw; ++i)
-
16890  {
-
16891  // Now selecting who is transmitting the disease
-
16892  int which = static_cast<int>(
-
16893  std::floor(m->size() * m->runif())
-
16894  );
-
16895 
-
16896  /* There is a bug in which runif() returns 1.0. It is rare, but
-
16897  * we saw it here. See the Notes section in the C++ manual
-
16898  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
-
16899  * And the reported bug in GCC:
-
16900  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
-
16901  *
-
16902  */
-
16903  if (which == static_cast<int>(m->size()))
-
16904  --which;
-
16905 
-
16906  // Can't sample itself
-
16907  if (which == static_cast<int>(p->get_id()))
-
16908  continue;
-
16909 
-
16910  // If the neighbor is infected, then proceed
-
16911  auto & neighbor = m->get_agents()[which];
-
16912  if (neighbor.get_state() == ModelSEIRCONN<TSeq>::INFECTED)
-
16913  {
-
16914 
-
16915  auto & v = neighbor.get_virus();
-
16916 
-
16917  #ifdef EPI_DEBUG
-
16918  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
-
16919  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
16920  #endif
-
16921 
-
16922  /* And it is a function of susceptibility_reduction as well */
-
16923  m->array_double_tmp[nviruses_tmp] =
-
16924  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
16925  v->get_prob_infecting(m) *
-
16926  (1.0 - neighbor.get_transmission_reduction(v, m))
-
16927  ;
-
16928 
-
16929  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
16930 
-
16931  }
-
16932  }
-
16933 
-
16934  // No virus to compute
-
16935  if (nviruses_tmp == 0u)
-
16936  return;
-
16937 
-
16938  // Running the roulette
-
16939  int which = roulette(nviruses_tmp, m);
-
16940 
-
16941  if (which < 0)
-
16942  return;
-
16943 
-
16944  p->set_virus(
-
16945  *m->array_virus_tmp[which],
-
16946  m,
-
16947  ModelSEIRCONN<TSeq>::EXPOSED
-
16948  );
-
16949 
-
16950  return;
+
16884  epiworld::UpdateFun<TSeq> update_susceptible = [](
+
16885  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
16886  ) -> void
+
16887  {
+
16888 
+
16889  // Sampling how many individuals
+
16890  int ndraw = m->rbinom();
+
16891 
+
16892  if (ndraw == 0)
+
16893  return;
+
16894 
+
16895  // Drawing from the set
+
16896  int nviruses_tmp = 0;
+
16897  for (int i = 0; i < ndraw; ++i)
+
16898  {
+
16899  // Now selecting who is transmitting the disease
+
16900  int which = static_cast<int>(
+
16901  std::floor(m->size() * m->runif())
+
16902  );
+
16903 
+
16904  /* There is a bug in which runif() returns 1.0. It is rare, but
+
16905  * we saw it here. See the Notes section in the C++ manual
+
16906  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
+
16907  * And the reported bug in GCC:
+
16908  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
+
16909  *
+
16910  */
+
16911  if (which == static_cast<int>(m->size()))
+
16912  --which;
+
16913 
+
16914  // Can't sample itself
+
16915  if (which == static_cast<int>(p->get_id()))
+
16916  continue;
+
16917 
+
16918  // If the neighbor is infected, then proceed
+
16919  auto & neighbor = m->get_agents()[which];
+
16920  if (neighbor.get_state() == ModelSEIRCONN<TSeq>::INFECTED)
+
16921  {
+
16922 
+
16923  auto & v = neighbor.get_virus();
+
16924 
+
16925  #ifdef EPI_DEBUG
+
16926  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
+
16927  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
16928  #endif
+
16929 
+
16930  /* And it is a function of susceptibility_reduction as well */
+
16931  m->array_double_tmp[nviruses_tmp] =
+
16932  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
16933  v->get_prob_infecting(m) *
+
16934  (1.0 - neighbor.get_transmission_reduction(v, m))
+
16935  ;
+
16936 
+
16937  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
16938 
+
16939  }
+
16940  }
+
16941 
+
16942  // No virus to compute
+
16943  if (nviruses_tmp == 0u)
+
16944  return;
+
16945 
+
16946  // Running the roulette
+
16947  int which = roulette(nviruses_tmp, m);
+
16948 
+
16949  if (which < 0)
+
16950  return;
16951 
-
16952  };
-
16953 
-
16954  epiworld::UpdateFun<TSeq> update_infected = [](
-
16955  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
16956  ) -> void {
+
16952  p->set_virus(
+
16953  *m->array_virus_tmp[which],
+
16954  m,
+
16955  ModelSEIRCONN<TSeq>::EXPOSED
+
16956  );
16957 
-
16958  auto state = p->get_state();
+
16958  return;
16959 
-
16960  if (state == ModelSEIRCONN<TSeq>::EXPOSED)
-
16961  {
-
16962 
-
16963  // Getting the virus
-
16964  auto & v = p->get_virus();
+
16960  };
+
16961 
+
16962  epiworld::UpdateFun<TSeq> update_infected = [](
+
16963  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
16964  ) -> void {
16965 
-
16966  // Does the agent become infected?
-
16967  if (m->runif() < 1.0/(v->get_incubation(m)))
-
16968  {
-
16969 
-
16970  p->change_state(m, ModelSEIRCONN<TSeq>::INFECTED);
-
16971  return;
-
16972 
-
16973  }
-
16974 
-
16975 
-
16976  } else if (state == ModelSEIRCONN<TSeq>::INFECTED)
-
16977  {
-
16978 
-
16979 
-
16980  // Odd: Die, Even: Recover
-
16981  epiworld_fast_uint n_events = 0u;
-
16982  const auto & v = p->get_virus();
+
16966  auto state = p->get_state();
+
16967 
+
16968  if (state == ModelSEIRCONN<TSeq>::EXPOSED)
+
16969  {
+
16970 
+
16971  // Getting the virus
+
16972  auto & v = p->get_virus();
+
16973 
+
16974  // Does the agent become infected?
+
16975  if (m->runif() < 1.0/(v->get_incubation(m)))
+
16976  {
+
16977 
+
16978  p->change_state(m, ModelSEIRCONN<TSeq>::INFECTED);
+
16979  return;
+
16980 
+
16981  }
+
16982 
16983 
-
16984  // Recover
-
16985  m->array_double_tmp[n_events++] =
-
16986  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
+
16984  } else if (state == ModelSEIRCONN<TSeq>::INFECTED)
+
16985  {
+
16986 
16987 
-
16988  #ifdef EPI_DEBUG
-
16989  if (n_events == 0u)
-
16990  {
-
16991  printf_epiworld(
-
16992  "[epi-debug] agent %i has 0 possible events!!\n",
-
16993  static_cast<int>(p->get_id())
-
16994  );
-
16995  throw std::logic_error("Zero events in exposed.");
-
16996  }
-
16997  #else
-
16998  if (n_events == 0u)
-
16999  return;
-
17000  #endif
-
17001 
-
17002 
-
17003  // Running the roulette
-
17004  int which = roulette(n_events, m);
-
17005 
-
17006  if (which < 0)
+
16988  // Odd: Die, Even: Recover
+
16989  epiworld_fast_uint n_events = 0u;
+
16990  const auto & v = p->get_virus();
+
16991 
+
16992  // Recover
+
16993  m->array_double_tmp[n_events++] =
+
16994  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
+
16995 
+
16996  #ifdef EPI_DEBUG
+
16997  if (n_events == 0u)
+
16998  {
+
16999  printf_epiworld(
+
17000  "[epi-debug] agent %i has 0 possible events!!\n",
+
17001  static_cast<int>(p->get_id())
+
17002  );
+
17003  throw std::logic_error("Zero events in exposed.");
+
17004  }
+
17005  #else
+
17006  if (n_events == 0u)
17007  return;
-
17008 
-
17009  // Which roulette happen?
-
17010  p->rm_virus(m);
-
17011 
-
17012  return ;
+
17008  #endif
+
17009 
+
17010 
+
17011  // Running the roulette
+
17012  int which = roulette(n_events, m);
17013 
-
17014  } else
-
17015  throw std::logic_error("This function can only be applied to exposed or infected individuals. (SEIR)") ;
+
17014  if (which < 0)
+
17015  return;
17016 
-
17017  return;
-
17018 
-
17019  };
-
17020 
-
17021  // Setting up parameters
-
17022  model.add_param(contact_rate, "Contact rate");
-
17023  model.add_param(transmission_rate, "Prob. Transmission");
-
17024  model.add_param(recovery_rate, "Prob. Recovery");
-
17025  model.add_param(avg_incubation_days, "Avg. Incubation days");
-
17026 
-
17027  // state
-
17028  model.add_state("Susceptible", update_susceptible);
-
17029  model.add_state("Exposed", update_infected);
-
17030  model.add_state("Infected", update_infected);
-
17031  model.add_state("Recovered");
-
17032 
-
17033 
-
17034  // Preparing the virus -------------------------------------------
-
17035  epiworld::Virus<TSeq> virus(vname);
-
17036  virus.set_state(
-
17037  ModelSEIRCONN<TSeq>::EXPOSED,
-
17038  ModelSEIRCONN<TSeq>::RECOVERED,
-
17039  ModelSEIRCONN<TSeq>::RECOVERED
-
17040  );
+
17017  // Which roulette happen?
+
17018  p->rm_virus(m);
+
17019 
+
17020  return ;
+
17021 
+
17022  } else
+
17023  throw std::logic_error("This function can only be applied to exposed or infected individuals. (SEIR)") ;
+
17024 
+
17025  return;
+
17026 
+
17027  };
+
17028 
+
17029  // Setting up parameters
+
17030  model.add_param(contact_rate, "Contact rate");
+
17031  model.add_param(transmission_rate, "Prob. Transmission");
+
17032  model.add_param(recovery_rate, "Prob. Recovery");
+
17033  model.add_param(avg_incubation_days, "Avg. Incubation days");
+
17034 
+
17035  // state
+
17036  model.add_state("Susceptible", update_susceptible);
+
17037  model.add_state("Exposed", update_infected);
+
17038  model.add_state("Infected", update_infected);
+
17039  model.add_state("Recovered");
+
17040 
17041 
-
17042  virus.set_prob_infecting(&model("Prob. Transmission"));
-
17043  virus.set_prob_recovery(&model("Prob. Recovery"));
-
17044  virus.set_incubation(&model("Avg. Incubation days"));
-
17045 
-
17046  model.add_virus(virus, prevalence);
-
17047 
-
17048  model.queuing_off(); // No queuing need
+
17042  // Preparing the virus -------------------------------------------
+
17043  epiworld::Virus<TSeq> virus(vname);
+
17044  virus.set_state(
+
17045  ModelSEIRCONN<TSeq>::EXPOSED,
+
17046  ModelSEIRCONN<TSeq>::RECOVERED,
+
17047  ModelSEIRCONN<TSeq>::RECOVERED
+
17048  );
17049 
-
17050  // Adding the empty population
-
17051  model.agents_empty_graph(n);
-
17052 
-
17053  model.set_name("Susceptible-Exposed-Infected-Removed (SEIR) (connected)");
-
17054 
-
17055  return;
-
17056 
-
17057 }
-
17058 
-
17059 template<typename TSeq>
-
17060 inline ModelSEIRCONN<TSeq>::ModelSEIRCONN(
-
17061  std::string vname,
-
17062  epiworld_fast_uint n,
-
17063  epiworld_double prevalence,
-
17064  epiworld_double contact_rate,
-
17065  epiworld_double transmission_rate,
-
17066  epiworld_double avg_incubation_days,
-
17067  epiworld_double recovery_rate
-
17068  )
-
17069 {
-
17070 
-
17071  ModelSEIRCONN(
-
17072  *this,
-
17073  vname,
-
17074  n,
-
17075  prevalence,
-
17076  contact_rate,
-
17077  transmission_rate,
-
17078  avg_incubation_days,
-
17079  recovery_rate
-
17080  );
-
17081 
-
17082  return;
-
17083 
-
17084 }
-
17085 
-
17086 template<typename TSeq>
-
17087 inline ModelSEIRCONN<TSeq> & ModelSEIRCONN<TSeq>::initial_states(
-
17088  std::vector< double > proportions_,
-
17089  std::vector< int > /* queue_ */
-
17090 )
-
17091 {
-
17092 
-
17093  Model<TSeq>::initial_states_fun =
-
17094  create_init_function_seir<TSeq>(proportions_)
-
17095  ;
-
17096 
-
17097  return *this;
-
17098 
-
17099 }
+
17050  virus.set_prob_infecting(&model("Prob. Transmission"));
+
17051  virus.set_prob_recovery(&model("Prob. Recovery"));
+
17052  virus.set_incubation(&model("Avg. Incubation days"));
+
17053 
+
17054  model.add_virus(virus, prevalence);
+
17055 
+
17056  model.queuing_off(); // No queuing need
+
17057 
+
17058  // Adding the empty population
+
17059  model.agents_empty_graph(n);
+
17060 
+
17061  model.set_name("Susceptible-Exposed-Infected-Removed (SEIR) (connected)");
+
17062 
+
17063  return;
+
17064 
+
17065 }
+
17066 
+
17067 template<typename TSeq>
+
17068 inline ModelSEIRCONN<TSeq>::ModelSEIRCONN(
+
17069  std::string vname,
+
17070  epiworld_fast_uint n,
+
17071  epiworld_double prevalence,
+
17072  epiworld_double contact_rate,
+
17073  epiworld_double transmission_rate,
+
17074  epiworld_double avg_incubation_days,
+
17075  epiworld_double recovery_rate
+
17076  )
+
17077 {
+
17078 
+
17079  ModelSEIRCONN(
+
17080  *this,
+
17081  vname,
+
17082  n,
+
17083  prevalence,
+
17084  contact_rate,
+
17085  transmission_rate,
+
17086  avg_incubation_days,
+
17087  recovery_rate
+
17088  );
+
17089 
+
17090  return;
+
17091 
+
17092 }
+
17093 
+
17094 template<typename TSeq>
+
17095 inline ModelSEIRCONN<TSeq> & ModelSEIRCONN<TSeq>::initial_states(
+
17096  std::vector< double > proportions_,
+
17097  std::vector< int > /* queue_ */
+
17098 )
+
17099 {
17100 
-
17101 #endif
-
17102 /*//////////////////////////////////////////////////////////////////////////////
-
17104 
-
17105  End of -include/epiworld//models/seirconnected.hpp-
-
17106 
-
17109 
-
17110 
-
17111 /*//////////////////////////////////////////////////////////////////////////////
-
17113 
-
17114  Start of -include/epiworld//models/sird.hpp-
-
17115 
+
17101  Model<TSeq>::initial_states_fun =
+
17102  create_init_function_seir<TSeq>(proportions_)
+
17103  ;
+
17104 
+
17105  return *this;
+
17106 
+
17107 }
+
17108 
+
17109 #endif
+
17110 /*//////////////////////////////////////////////////////////////////////////////
+
17112 
+
17113  End of -include/epiworld//models/seirconnected.hpp-
+
17114 
+
17117 
17118 
-
17119 
-
17120 #ifndef EPIWORLD_SIRD_H
-
17121 #define EPIWORLD_SIRD_H
-
17122 
-
17126 template<typename TSeq = int>
-
17127 class ModelSIRD : public epiworld::Model<TSeq>
-
17128 {
-
17129 public:
+
17119 /*//////////////////////////////////////////////////////////////////////////////
+
17121 
+
17122  Start of -include/epiworld//models/sird.hpp-
+
17123 
+
17126 
+
17127 
+
17128 #ifndef EPIWORLD_SIRD_H
+
17129 #define EPIWORLD_SIRD_H
17130 
-
17131  ModelSIRD() {};
-
17132 
-
17133 
-
17145  ModelSIRD(
-
17146  ModelSIRD<TSeq> & model,
-
17147  std::string vname,
-
17148  epiworld_double prevalence,
-
17149  epiworld_double transmission_rate,
-
17150  epiworld_double recovery_rate,
-
17151  epiworld_double death_rate
-
17152  );
-
17153 
-
17154  ModelSIRD(
+
17134 template<typename TSeq = int>
+
17135 class ModelSIRD : public epiworld::Model<TSeq>
+
17136 {
+
17137 public:
+
17138 
+
17139  ModelSIRD() {};
+
17140 
+
17141 
+
17153  ModelSIRD(
+
17154  ModelSIRD<TSeq> & model,
17155  std::string vname,
17156  epiworld_double prevalence,
17157  epiworld_double transmission_rate,
17158  epiworld_double recovery_rate,
17159  epiworld_double death_rate
17160  );
-
17162 
-
17169  ModelSIRD<TSeq> & initial_states(
-
17170  std::vector< double > proportions_,
-
17171  std::vector< int > queue_ = {}
-
17172  );
-
17173 
-
17174 };
-
17175 
-
17176 template<typename TSeq>
-
17177 inline ModelSIRD<TSeq>::ModelSIRD(
-
17178  ModelSIRD<TSeq> & model,
-
17179  std::string vname,
-
17180  epiworld_double prevalence,
-
17181  epiworld_double transmission_rate,
-
17182  epiworld_double recovery_rate,
-
17183  epiworld_double death_rate
-
17184  )
-
17185 {
-
17186 
-
17187  // Adding statuses
-
17188  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
-
17189  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
-
17190  model.add_state("Recovered"),
-
17191  model.add_state("Deceased")
-
17192  ;
-
17193 
-
17194  // Setting up parameters
-
17195  model.add_param(recovery_rate, "Recovery rate");
-
17196  model.add_param(transmission_rate, "Transmission rate"),
-
17197  model.add_param(death_rate, "Death rate");
-
17198 
-
17199  // Preparing the virus -------------------------------------------
-
17200  epiworld::Virus<TSeq> virus(vname);
-
17201  virus.set_state(1,2,3);
-
17202  virus.set_prob_recovery(&model("Recovery rate"));
-
17203  virus.set_prob_infecting(&model("Transmission rate"));
-
17204  virus.set_prob_death(&model("Death rate"));
-
17205 
-
17206  model.add_virus(virus, prevalence);
-
17207 
-
17208  model.set_name("Susceptible-Infected-Recovered-Deceased (SIRD)");
-
17209 
-
17210  return;
-
17211 
-
17212 }
-
17213 
-
17214 template<typename TSeq>
-
17215 inline ModelSIRD<TSeq>::ModelSIRD(
-
17216  std::string vname,
-
17217  epiworld_double prevalence,
-
17218  epiworld_double transmission_rate,
-
17219  epiworld_double recovery_rate,
-
17220  epiworld_double death_rate
-
17221  )
-
17222 {
-
17223 
-
17224  ModelSIRD<TSeq>(
-
17225  *this,
-
17226  vname,
-
17227  prevalence,
-
17228  transmission_rate,
-
17229  recovery_rate,
-
17230  death_rate
-
17231  );
-
17232 
-
17233  return;
-
17234 
-
17235 }
-
17236 
-
17237 template<typename TSeq>
-
17238 inline ModelSIRD<TSeq> & ModelSIRD<TSeq>::initial_states(
-
17239  std::vector< double > proportions_,
-
17240  std::vector< int > /**/
-
17241 ) {
-
17242 
-
17243  Model<TSeq>::initial_states_fun =
-
17244  create_init_function_sird<TSeq>(proportions_)
-
17245  ;
-
17246 
-
17247  return *this;
-
17248 
-
17249 }
+
17161 
+
17162  ModelSIRD(
+
17163  std::string vname,
+
17164  epiworld_double prevalence,
+
17165  epiworld_double transmission_rate,
+
17166  epiworld_double recovery_rate,
+
17167  epiworld_double death_rate
+
17168  );
+
17170 
+
17177  ModelSIRD<TSeq> & initial_states(
+
17178  std::vector< double > proportions_,
+
17179  std::vector< int > queue_ = {}
+
17180  );
+
17181 
+
17182 };
+
17183 
+
17184 template<typename TSeq>
+
17185 inline ModelSIRD<TSeq>::ModelSIRD(
+
17186  ModelSIRD<TSeq> & model,
+
17187  std::string vname,
+
17188  epiworld_double prevalence,
+
17189  epiworld_double transmission_rate,
+
17190  epiworld_double recovery_rate,
+
17191  epiworld_double death_rate
+
17192  )
+
17193 {
+
17194 
+
17195  // Adding statuses
+
17196  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
+
17197  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
+
17198  model.add_state("Recovered"),
+
17199  model.add_state("Deceased")
+
17200  ;
+
17201 
+
17202  // Setting up parameters
+
17203  model.add_param(recovery_rate, "Recovery rate");
+
17204  model.add_param(transmission_rate, "Transmission rate"),
+
17205  model.add_param(death_rate, "Death rate");
+
17206 
+
17207  // Preparing the virus -------------------------------------------
+
17208  epiworld::Virus<TSeq> virus(vname);
+
17209  virus.set_state(1,2,3);
+
17210  virus.set_prob_recovery(&model("Recovery rate"));
+
17211  virus.set_prob_infecting(&model("Transmission rate"));
+
17212  virus.set_prob_death(&model("Death rate"));
+
17213 
+
17214  model.add_virus(virus, prevalence);
+
17215 
+
17216  model.set_name("Susceptible-Infected-Recovered-Deceased (SIRD)");
+
17217 
+
17218  return;
+
17219 
+
17220 }
+
17221 
+
17222 template<typename TSeq>
+
17223 inline ModelSIRD<TSeq>::ModelSIRD(
+
17224  std::string vname,
+
17225  epiworld_double prevalence,
+
17226  epiworld_double transmission_rate,
+
17227  epiworld_double recovery_rate,
+
17228  epiworld_double death_rate
+
17229  )
+
17230 {
+
17231 
+
17232  ModelSIRD<TSeq>(
+
17233  *this,
+
17234  vname,
+
17235  prevalence,
+
17236  transmission_rate,
+
17237  recovery_rate,
+
17238  death_rate
+
17239  );
+
17240 
+
17241  return;
+
17242 
+
17243 }
+
17244 
+
17245 template<typename TSeq>
+
17246 inline ModelSIRD<TSeq> & ModelSIRD<TSeq>::initial_states(
+
17247  std::vector< double > proportions_,
+
17248  std::vector< int > /**/
+
17249 ) {
17250 
-
17251 #endif
-
17252 /*//////////////////////////////////////////////////////////////////////////////
-
17254 
-
17255  End of -include/epiworld//models/sird.hpp-
-
17256 
-
17259 
-
17260 
-
17261 /*//////////////////////////////////////////////////////////////////////////////
-
17263 
-
17264  Start of -include/epiworld//models/sisd.hpp-
-
17265 
+
17251  Model<TSeq>::initial_states_fun =
+
17252  create_init_function_sird<TSeq>(proportions_)
+
17253  ;
+
17254 
+
17255  return *this;
+
17256 
+
17257 }
+
17258 
+
17259 #endif
+
17260 /*//////////////////////////////////////////////////////////////////////////////
+
17262 
+
17263  End of -include/epiworld//models/sird.hpp-
+
17264 
+
17267 
17268 
-
17269 
-
17270 #ifndef EPIWORLD_MODELS_SISD_HPP
-
17271 #define EPIWORLD_MODELS_SISD_HPP
-
17272 
-
17282 template<typename TSeq = int>
-
17283 class ModelSISD : public epiworld::Model<TSeq>
-
17284 {
-
17285 
-
17286 public:
-
17287 
-
17288  ModelSISD() {};
-
17289 
-
17290  ModelSISD(
-
17291  ModelSISD<TSeq> & model,
-
17292  std::string vname,
-
17293  epiworld_double prevalence,
-
17294  epiworld_double transmission_rate,
-
17295  epiworld_double recovery_rate,
-
17296  epiworld_double death_rate
-
17297  );
-
17298 
-
17299  ModelSISD(
+
17269 /*//////////////////////////////////////////////////////////////////////////////
+
17271 
+
17272  Start of -include/epiworld//models/sisd.hpp-
+
17273 
+
17276 
+
17277 
+
17278 #ifndef EPIWORLD_MODELS_SISD_HPP
+
17279 #define EPIWORLD_MODELS_SISD_HPP
+
17280 
+
17290 template<typename TSeq = int>
+
17291 class ModelSISD : public epiworld::Model<TSeq>
+
17292 {
+
17293 
+
17294 public:
+
17295 
+
17296  ModelSISD() {};
+
17297 
+
17298  ModelSISD(
+
17299  ModelSISD<TSeq> & model,
17300  std::string vname,
17301  epiworld_double prevalence,
17302  epiworld_double transmission_rate,
@@ -15916,1546 +15916,1554 @@
17304  epiworld_double death_rate
17305  );
17306 
-
17307 };
-
17308 
-
17309 template<typename TSeq>
-
17310 inline ModelSISD<TSeq>::ModelSISD(
-
17311  ModelSISD<TSeq> & model,
-
17312  std::string vname,
-
17313  epiworld_double prevalence,
-
17314  epiworld_double transmission_rate,
-
17315  epiworld_double recovery_rate,
-
17316  epiworld_double death_rate
-
17317  )
-
17318 {
-
17319 
-
17320  model.set_name("Susceptible-Infected-Susceptible-Deceased (SISD)");
-
17321 
-
17322  // Adding statuses
-
17323  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
-
17324  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
-
17325  model.add_state("Deceased");
-
17326 
-
17327  // Setting up parameters
-
17328  model.add_param(transmission_rate, "Transmission rate");
-
17329  model.add_param(recovery_rate, "Recovery rate");
-
17330  model.add_param(death_rate, "Death rate");
-
17331 
-
17332  // Preparing the virus -------------------------------------------
-
17333  epiworld::Virus<TSeq> virus(vname);
-
17334  virus.set_state(1,0,2);
-
17335 
-
17336  virus.set_prob_infecting(&model("Transmission rate"));
-
17337  virus.set_prob_recovery(&model("Recovery rate"));
-
17338  virus.set_prob_death(0.01);
-
17339 
-
17340  model.add_virus(virus, prevalence);
-
17341 
-
17342  return;
-
17343 
-
17344 }
-
17345 
-
17346 template<typename TSeq>
-
17347 inline ModelSISD<TSeq>::ModelSISD(
-
17348  std::string vname,
-
17349  epiworld_double prevalence,
-
17350  epiworld_double transmission_rate,
-
17351  epiworld_double recovery_rate,
-
17352  epiworld_double death_rate
-
17353  )
-
17354 {
-
17355 
-
17356  ModelSISD<TSeq>(
-
17357  *this,
-
17358  vname,
-
17359  prevalence,
-
17360  transmission_rate,
-
17361  recovery_rate,
-
17362  death_rate
-
17363  );
-
17364 
-
17365  return;
-
17366 
-
17367 }
-
17368 
-
17369 #endif
-
17370 /*//////////////////////////////////////////////////////////////////////////////
+
17307  ModelSISD(
+
17308  std::string vname,
+
17309  epiworld_double prevalence,
+
17310  epiworld_double transmission_rate,
+
17311  epiworld_double recovery_rate,
+
17312  epiworld_double death_rate
+
17313  );
+
17314 
+
17315 };
+
17316 
+
17317 template<typename TSeq>
+
17318 inline ModelSISD<TSeq>::ModelSISD(
+
17319  ModelSISD<TSeq> & model,
+
17320  std::string vname,
+
17321  epiworld_double prevalence,
+
17322  epiworld_double transmission_rate,
+
17323  epiworld_double recovery_rate,
+
17324  epiworld_double death_rate
+
17325  )
+
17326 {
+
17327 
+
17328  model.set_name("Susceptible-Infected-Susceptible-Deceased (SISD)");
+
17329 
+
17330  // Adding statuses
+
17331  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
+
17332  model.add_state("Infected", epiworld::default_update_exposed<TSeq>);
+
17333  model.add_state("Deceased");
+
17334 
+
17335  // Setting up parameters
+
17336  model.add_param(transmission_rate, "Transmission rate");
+
17337  model.add_param(recovery_rate, "Recovery rate");
+
17338  model.add_param(death_rate, "Death rate");
+
17339 
+
17340  // Preparing the virus -------------------------------------------
+
17341  epiworld::Virus<TSeq> virus(vname);
+
17342  virus.set_state(1,0,2);
+
17343 
+
17344  virus.set_prob_infecting(&model("Transmission rate"));
+
17345  virus.set_prob_recovery(&model("Recovery rate"));
+
17346  virus.set_prob_death(0.01);
+
17347 
+
17348  model.add_virus(virus, prevalence);
+
17349 
+
17350  return;
+
17351 
+
17352 }
+
17353 
+
17354 template<typename TSeq>
+
17355 inline ModelSISD<TSeq>::ModelSISD(
+
17356  std::string vname,
+
17357  epiworld_double prevalence,
+
17358  epiworld_double transmission_rate,
+
17359  epiworld_double recovery_rate,
+
17360  epiworld_double death_rate
+
17361  )
+
17362 {
+
17363 
+
17364  ModelSISD<TSeq>(
+
17365  *this,
+
17366  vname,
+
17367  prevalence,
+
17368  transmission_rate,
+
17369  recovery_rate,
+
17370  death_rate
+
17371  );
17372 
-
17373  End of -include/epiworld//models/sisd.hpp-
+
17373  return;
17374 
-
17377 
-
17378 
-
17379 /*//////////////////////////////////////////////////////////////////////////////
-
17381 
-
17382  Start of -include/epiworld//models/seird.hpp-
-
17383 
+
17375 }
+
17376 
+
17377 #endif
+
17378 /*//////////////////////////////////////////////////////////////////////////////
+
17380 
+
17381  End of -include/epiworld//models/sisd.hpp-
+
17382 
+
17385 
17386 
-
17387 
-
17388 #ifndef EPIWORLD_MODELS_SEIRD_HPP
-
17389 #define EPIWORLD_MODELS_SEIRD_HPP
-
17390 
-
17394 template<typename TSeq = int>
-
17395 class ModelSEIRD : public epiworld::Model<TSeq>
-
17396 {
-
17397 
-
17398 public:
-
17399  static const int SUSCEPTIBLE = 0;
-
17400  static const int EXPOSED = 1;
-
17401  static const int INFECTED = 2;
-
17402  static const int REMOVED = 3;
-
17403  static const int DECEASED = 4;
-
17404 
-
17405  ModelSEIRD() {};
-
17406 
-
17419  ModelSEIRD(
-
17420  ModelSEIRD<TSeq> & model,
-
17421  std::string vname,
-
17422  epiworld_double prevalence,
-
17423  epiworld_double transmission_rate,
-
17424  epiworld_double avg_incubation_days,
-
17425  epiworld_double recovery_rate,
-
17426  epiworld_double death_rate
-
17427  );
-
17428 
-
17439  ModelSEIRD(
-
17440  std::string vname,
-
17441  epiworld_double prevalence,
-
17442  epiworld_double transmission_rate,
-
17443  epiworld_double avg_incubation_days,
-
17444  epiworld_double recovery_rate,
-
17445  epiworld_double death_rate
-
17446  );
-
17447 
-
17448  epiworld::UpdateFun<TSeq> update_exposed_seir = [](
-
17449  epiworld::Agent<TSeq> * p,
-
17450  epiworld::Model<TSeq> * m
-
17451  ) -> void {
-
17452 
-
17453  // Getting the virus
-
17454  auto v = p->get_virus();
-
17455 
-
17456  // Does the agent become infected?
-
17457  if (m->runif() < 1.0/(v->get_incubation(m)))
-
17458  p->change_state(m, ModelSEIRD<TSeq>::INFECTED);
-
17459 
-
17460  return;
-
17461  };
-
17462 
-
17463 
-
17464  epiworld::UpdateFun<TSeq> update_infected = [](
-
17465  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
17466  ) -> void {
-
17467 
-
17468  // Odd: Die, Even: Recover
-
17469  epiworld_fast_uint n_events = 0u;
+
17387 /*//////////////////////////////////////////////////////////////////////////////
+
17389 
+
17390  Start of -include/epiworld//models/seird.hpp-
+
17391 
+
17394 
+
17395 
+
17396 #ifndef EPIWORLD_MODELS_SEIRD_HPP
+
17397 #define EPIWORLD_MODELS_SEIRD_HPP
+
17398 
+
17402 template<typename TSeq = int>
+
17403 class ModelSEIRD : public epiworld::Model<TSeq>
+
17404 {
+
17405 
+
17406 public:
+
17407  static const int SUSCEPTIBLE = 0;
+
17408  static const int EXPOSED = 1;
+
17409  static const int INFECTED = 2;
+
17410  static const int REMOVED = 3;
+
17411  static const int DECEASED = 4;
+
17412 
+
17413  ModelSEIRD() {};
+
17414 
+
17427  ModelSEIRD(
+
17428  ModelSEIRD<TSeq> & model,
+
17429  std::string vname,
+
17430  epiworld_double prevalence,
+
17431  epiworld_double transmission_rate,
+
17432  epiworld_double avg_incubation_days,
+
17433  epiworld_double recovery_rate,
+
17434  epiworld_double death_rate
+
17435  );
+
17436 
+
17447  ModelSEIRD(
+
17448  std::string vname,
+
17449  epiworld_double prevalence,
+
17450  epiworld_double transmission_rate,
+
17451  epiworld_double avg_incubation_days,
+
17452  epiworld_double recovery_rate,
+
17453  epiworld_double death_rate
+
17454  );
+
17455 
+
17456  epiworld::UpdateFun<TSeq> update_exposed_seir = [](
+
17457  epiworld::Agent<TSeq> * p,
+
17458  epiworld::Model<TSeq> * m
+
17459  ) -> void {
+
17460 
+
17461  // Getting the virus
+
17462  auto v = p->get_virus();
+
17463 
+
17464  // Does the agent become infected?
+
17465  if (m->runif() < 1.0/(v->get_incubation(m)))
+
17466  p->change_state(m, ModelSEIRD<TSeq>::INFECTED);
+
17467 
+
17468  return;
+
17469  };
17470 
-
17471  const auto & v = p->get_virus();
-
17472 
-
17473  // Die
-
17474  m->array_double_tmp[n_events++] =
-
17475  v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
-
17476 
-
17477  // Recover
-
17478  m->array_double_tmp[n_events++] =
-
17479  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
-
17480 
-
17481 
-
17482 #ifdef EPI_DEBUG
-
17483  if (n_events == 0u)
-
17484  {
-
17485  printf_epiworld(
-
17486  "[epi-debug] agent %i has 0 possible events!!\n",
-
17487  static_cast<int>(p->get_id())
-
17488  );
-
17489  throw std::logic_error("Zero events in exposed.");
-
17490  }
-
17491 #else
-
17492  if (n_events == 0u)
-
17493  return;
-
17494 #endif
-
17495 
-
17496 
-
17497  // Running the roulette
-
17498  int which = roulette(n_events, m);
-
17499 
-
17500  if (which < 0)
+
17471 
+
17472  epiworld::UpdateFun<TSeq> update_infected = [](
+
17473  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
17474  ) -> void {
+
17475 
+
17476  // Odd: Die, Even: Recover
+
17477  epiworld_fast_uint n_events = 0u;
+
17478 
+
17479  const auto & v = p->get_virus();
+
17480 
+
17481  // Die
+
17482  m->array_double_tmp[n_events++] =
+
17483  v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
+
17484 
+
17485  // Recover
+
17486  m->array_double_tmp[n_events++] =
+
17487  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
+
17488 
+
17489 
+
17490 #ifdef EPI_DEBUG
+
17491  if (n_events == 0u)
+
17492  {
+
17493  printf_epiworld(
+
17494  "[epi-debug] agent %i has 0 possible events!!\n",
+
17495  static_cast<int>(p->get_id())
+
17496  );
+
17497  throw std::logic_error("Zero events in exposed.");
+
17498  }
+
17499 #else
+
17500  if (n_events == 0u)
17501  return;
-
17502 
-
17503  // Which roulette happen?
-
17504  if ((which % 2) == 0) // If odd
-
17505  {
-
17506 
-
17507  p->rm_agent_by_virus(m);
-
17508 
-
17509  } else {
-
17510 
-
17511  p->rm_virus(m);
-
17512 
-
17513  }
-
17514 
-
17515  return ;
+
17502 #endif
+
17503 
+
17504 
+
17505  // Running the roulette
+
17506  int which = roulette(n_events, m);
+
17507 
+
17508  if (which < 0)
+
17509  return;
+
17510 
+
17511  // Which roulette happen?
+
17512  if ((which % 2) == 0) // If odd
+
17513  {
+
17514 
+
17515  p->rm_agent_by_virus(m);
17516 
-
17517 
-
17518 
-
17519  return;
-
17520 
-
17521  };
-
17522 
-
17523  ModelSEIRD<TSeq> & initial_states(
-
17524  std::vector< double > proportions_,
-
17525  std::vector< int > queue_ = {}
-
17526  );
-
17527 
-
17528 };
-
17529 
+
17517  } else {
+
17518 
+
17519  p->rm_virus(m);
+
17520 
+
17521  }
+
17522 
+
17523  return ;
+
17524 
+
17525 
+
17526 
+
17527  return;
+
17528 
+
17529  };
17530 
-
17531 
-
17532 template<typename TSeq>
-
17533 inline ModelSEIRD<TSeq>::ModelSEIRD(
-
17534  ModelSEIRD<TSeq> & model,
-
17535  std::string vname,
-
17536  epiworld_double prevalence,
-
17537  epiworld_double transmission_rate,
-
17538  epiworld_double avg_incubation_days,
-
17539  epiworld_double recovery_rate,
-
17540  epiworld_double death_rate
-
17541 )
-
17542 {
-
17543 
-
17544  // Adding statuses
-
17545  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
-
17546  model.add_state("Exposed", model.update_exposed_seir);
-
17547  model.add_state("Infected", model.update_infected);
-
17548  model.add_state("Removed");
-
17549  model.add_state("Deceased");
-
17550 
-
17551  // Setting up parameters
-
17552  model.add_param(transmission_rate, "Transmission rate");
-
17553  model.add_param(avg_incubation_days, "Incubation days");
-
17554  model.add_param(recovery_rate, "Recovery rate");
-
17555  model.add_param(death_rate, "Death rate");
-
17556 
-
17557  // Preparing the virus -------------------------------------------
-
17558  epiworld::Virus<TSeq> virus(vname);
-
17559  virus.set_state(ModelSEIRD<TSeq>::EXPOSED, ModelSEIRD<TSeq>::REMOVED, ModelSEIRD<TSeq>::DECEASED);
-
17560 
-
17561  virus.set_prob_infecting(&model("Transmission rate"));
-
17562  virus.set_incubation(&model("Incubation days"));
-
17563  virus.set_prob_death(&model("Death rate"));
-
17564  virus.set_prob_recovery(&model("Recovery rate"));
-
17565 
-
17566  // Adding the tool and the virus
-
17567  model.add_virus(virus, prevalence);
+
17531  ModelSEIRD<TSeq> & initial_states(
+
17532  std::vector< double > proportions_,
+
17533  std::vector< int > queue_ = {}
+
17534  );
+
17535 
+
17536 };
+
17537 
+
17538 
+
17539 
+
17540 template<typename TSeq>
+
17541 inline ModelSEIRD<TSeq>::ModelSEIRD(
+
17542  ModelSEIRD<TSeq> & model,
+
17543  std::string vname,
+
17544  epiworld_double prevalence,
+
17545  epiworld_double transmission_rate,
+
17546  epiworld_double avg_incubation_days,
+
17547  epiworld_double recovery_rate,
+
17548  epiworld_double death_rate
+
17549 )
+
17550 {
+
17551 
+
17552  // Adding statuses
+
17553  model.add_state("Susceptible", epiworld::default_update_susceptible<TSeq>);
+
17554  model.add_state("Exposed", model.update_exposed_seir);
+
17555  model.add_state("Infected", model.update_infected);
+
17556  model.add_state("Removed");
+
17557  model.add_state("Deceased");
+
17558 
+
17559  // Setting up parameters
+
17560  model.add_param(transmission_rate, "Transmission rate");
+
17561  model.add_param(avg_incubation_days, "Incubation days");
+
17562  model.add_param(recovery_rate, "Recovery rate");
+
17563  model.add_param(death_rate, "Death rate");
+
17564 
+
17565  // Preparing the virus -------------------------------------------
+
17566  epiworld::Virus<TSeq> virus(vname);
+
17567  virus.set_state(ModelSEIRD<TSeq>::EXPOSED, ModelSEIRD<TSeq>::REMOVED, ModelSEIRD<TSeq>::DECEASED);
17568 
-
17569  model.set_name("Susceptible-Exposed-Infected-Removed-Deceased (SEIRD)");
-
17570 
-
17571  return;
-
17572 
-
17573 }
-
17574 
-
17575 template<typename TSeq>
-
17576 inline ModelSEIRD<TSeq>::ModelSEIRD(
-
17577  std::string vname,
-
17578  epiworld_double prevalence,
-
17579  epiworld_double transmission_rate,
-
17580  epiworld_double avg_incubation_days,
-
17581  epiworld_double recovery_rate,
-
17582  epiworld_double death_rate
-
17583 )
-
17584 {
-
17585 
-
17586  ModelSEIRD<TSeq>(
-
17587  *this,
-
17588  vname,
-
17589  prevalence,
-
17590  transmission_rate,
-
17591  avg_incubation_days,
-
17592  recovery_rate,
-
17593  death_rate
-
17594  );
-
17595 
-
17596  return;
-
17597 
-
17598 }
-
17599 
-
17600 template<typename TSeq>
-
17601 inline ModelSEIRD<TSeq> & ModelSEIRD<TSeq>::initial_states(
-
17602  std::vector< double > proportions_,
-
17603  std::vector< int > /**/
-
17604 ) {
-
17605 
-
17606  Model<TSeq>::initial_states_fun =
-
17607  create_init_function_seird<TSeq>(proportions_)
-
17608  ;
-
17609 
-
17610  return *this;
-
17611 
-
17612 }
+
17569  virus.set_prob_infecting(&model("Transmission rate"));
+
17570  virus.set_incubation(&model("Incubation days"));
+
17571  virus.set_prob_death(&model("Death rate"));
+
17572  virus.set_prob_recovery(&model("Recovery rate"));
+
17573 
+
17574  // Adding the tool and the virus
+
17575  model.add_virus(virus, prevalence);
+
17576 
+
17577  model.set_name("Susceptible-Exposed-Infected-Removed-Deceased (SEIRD)");
+
17578 
+
17579  return;
+
17580 
+
17581 }
+
17582 
+
17583 template<typename TSeq>
+
17584 inline ModelSEIRD<TSeq>::ModelSEIRD(
+
17585  std::string vname,
+
17586  epiworld_double prevalence,
+
17587  epiworld_double transmission_rate,
+
17588  epiworld_double avg_incubation_days,
+
17589  epiworld_double recovery_rate,
+
17590  epiworld_double death_rate
+
17591 )
+
17592 {
+
17593 
+
17594  ModelSEIRD<TSeq>(
+
17595  *this,
+
17596  vname,
+
17597  prevalence,
+
17598  transmission_rate,
+
17599  avg_incubation_days,
+
17600  recovery_rate,
+
17601  death_rate
+
17602  );
+
17603 
+
17604  return;
+
17605 
+
17606 }
+
17607 
+
17608 template<typename TSeq>
+
17609 inline ModelSEIRD<TSeq> & ModelSEIRD<TSeq>::initial_states(
+
17610  std::vector< double > proportions_,
+
17611  std::vector< int > /**/
+
17612 ) {
17613 
-
17614 
-
17615 #endif
-
17616 /*//////////////////////////////////////////////////////////////////////////////
-
17618 
-
17619  End of -include/epiworld//models/seird.hpp-
-
17620 
-
17623 
-
17624 
-
17625 /*//////////////////////////////////////////////////////////////////////////////
-
17627 
-
17628  Start of -include/epiworld//models/sirdconnected.hpp-
-
17629 
+
17614  Model<TSeq>::initial_states_fun =
+
17615  create_init_function_seird<TSeq>(proportions_)
+
17616  ;
+
17617 
+
17618  return *this;
+
17619 
+
17620 }
+
17621 
+
17622 
+
17623 #endif
+
17624 /*//////////////////////////////////////////////////////////////////////////////
+
17626 
+
17627  End of -include/epiworld//models/seird.hpp-
+
17628 
+
17631 
17632 
-
17633 
-
17634 #ifndef EPIWORLD_MODELS_SIRDCONNECTED_HPP
-
17635 #define EPIWORLD_MODELS_SIRDCONNECTED_HPP
-
17636 
-
17637 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
17638 class ModelSIRDCONN : public epiworld::Model<TSeq>
-
17639 {
-
17640 public:
-
17641  static const int SUSCEPTIBLE = 0;
-
17642  static const int INFECTED = 1;
-
17643  static const int RECOVERED = 2;
-
17644  static const int DECEASED = 3;
-
17645 
-
17646  ModelSIRDCONN() {
-
17647 
-
17648  // tracked_agents_infected.reserve(1e4);
-
17649  // tracked_agents_infected_next.reserve(1e4);
-
17650 
-
17651  };
-
17652 
-
17653  ModelSIRDCONN(
-
17654  ModelSIRDCONN<TSeq> & model,
-
17655  std::string vname,
-
17656  epiworld_fast_uint n,
-
17657  epiworld_double prevalence,
-
17658  epiworld_double contact_rate,
-
17659  epiworld_double transmission_rate,
-
17660  epiworld_double recovery_rate,
-
17661  epiworld_double death_rate
-
17662  );
-
17663 
-
17664  ModelSIRDCONN(
-
17665  std::string vname,
-
17666  epiworld_fast_uint n,
-
17667  epiworld_double prevalence,
-
17668  epiworld_double contact_rate,
-
17669  epiworld_double transmission_rate,
-
17670  epiworld_double recovery_rate,
-
17671  epiworld_double death_rate
-
17672  );
-
17673 
-
17674  // Tracking who is infected and who is not
-
17675  // std::vector< epiworld::Agent<TSeq>* > tracked_agents_infected = {};
-
17676  // std::vector< epiworld::Agent<TSeq>* > tracked_agents_infected_next = {};
-
17677  // std::vector< epiworld_double > tracked_agents_weight = {};
-
17678  // std::vector< epiworld_double > tracked_agents_weight_next = {};
-
17679 
-
17680  // int tracked_ninfected = 0;
-
17681  // int tracked_ninfected_next = 0;
-
17682  // epiworld_double tracked_current_infect_prob = 0.0;
-
17683 
-
17684  ModelSIRDCONN<TSeq> & run(
-
17685  epiworld_fast_uint ndays,
-
17686  int seed = -1
-
17687  );
-
17688 
-
17689  void reset();
-
17690 
-
17691  Model<TSeq> * clone_ptr();
-
17692 
-
17693 
-
17694 };
-
17695 
-
17696 template<typename TSeq>
-
17697 inline ModelSIRDCONN<TSeq> & ModelSIRDCONN<TSeq>::run(
-
17698  epiworld_fast_uint ndays,
-
17699  int seed
-
17700 )
-
17701 {
-
17702 
-
17703  Model<TSeq>::run(ndays, seed);
-
17704 
-
17705  return *this;
-
17706 
-
17707 }
-
17708 
-
17709 template<typename TSeq>
-
17710 inline void ModelSIRDCONN<TSeq>::reset()
-
17711 {
+
17633 /*//////////////////////////////////////////////////////////////////////////////
+
17635 
+
17636  Start of -include/epiworld//models/sirdconnected.hpp-
+
17637 
+
17640 
+
17641 
+
17642 #ifndef EPIWORLD_MODELS_SIRDCONNECTED_HPP
+
17643 #define EPIWORLD_MODELS_SIRDCONNECTED_HPP
+
17644 
+
17645 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
17646 class ModelSIRDCONN : public epiworld::Model<TSeq>
+
17647 {
+
17648 public:
+
17649  static const int SUSCEPTIBLE = 0;
+
17650  static const int INFECTED = 1;
+
17651  static const int RECOVERED = 2;
+
17652  static const int DECEASED = 3;
+
17653 
+
17654  ModelSIRDCONN() {
+
17655 
+
17656  // tracked_agents_infected.reserve(1e4);
+
17657  // tracked_agents_infected_next.reserve(1e4);
+
17658 
+
17659  };
+
17660 
+
17661  ModelSIRDCONN(
+
17662  ModelSIRDCONN<TSeq> & model,
+
17663  std::string vname,
+
17664  epiworld_fast_uint n,
+
17665  epiworld_double prevalence,
+
17666  epiworld_double contact_rate,
+
17667  epiworld_double transmission_rate,
+
17668  epiworld_double recovery_rate,
+
17669  epiworld_double death_rate
+
17670  );
+
17671 
+
17672  ModelSIRDCONN(
+
17673  std::string vname,
+
17674  epiworld_fast_uint n,
+
17675  epiworld_double prevalence,
+
17676  epiworld_double contact_rate,
+
17677  epiworld_double transmission_rate,
+
17678  epiworld_double recovery_rate,
+
17679  epiworld_double death_rate
+
17680  );
+
17681 
+
17682  // Tracking who is infected and who is not
+
17683  // std::vector< epiworld::Agent<TSeq>* > tracked_agents_infected = {};
+
17684  // std::vector< epiworld::Agent<TSeq>* > tracked_agents_infected_next = {};
+
17685  // std::vector< epiworld_double > tracked_agents_weight = {};
+
17686  // std::vector< epiworld_double > tracked_agents_weight_next = {};
+
17687 
+
17688  // int tracked_ninfected = 0;
+
17689  // int tracked_ninfected_next = 0;
+
17690  // epiworld_double tracked_current_infect_prob = 0.0;
+
17691 
+
17692  ModelSIRDCONN<TSeq> & run(
+
17693  epiworld_fast_uint ndays,
+
17694  int seed = -1
+
17695  );
+
17696 
+
17697  void reset();
+
17698 
+
17699  Model<TSeq> * clone_ptr();
+
17700 
+
17701 
+
17702 };
+
17703 
+
17704 template<typename TSeq>
+
17705 inline ModelSIRDCONN<TSeq> & ModelSIRDCONN<TSeq>::run(
+
17706  epiworld_fast_uint ndays,
+
17707  int seed
+
17708 )
+
17709 {
+
17710 
+
17711  Model<TSeq>::run(ndays, seed);
17712 
-
17713  Model<TSeq>::reset();
+
17713  return *this;
17714 
-
17715  // Model<TSeq>::set_rand_binom(
-
17716  // Model<TSeq>::size(),
-
17717  // static_cast<double>(
-
17718  // Model<TSeq>::par("Contact rate"))/
-
17719  // static_cast<double>(Model<TSeq>::size())
-
17720  // );
-
17721 
-
17722  return;
-
17723 
-
17724 }
-
17725 
-
17726 template<typename TSeq>
-
17727 inline Model<TSeq> * ModelSIRDCONN<TSeq>::clone_ptr()
-
17728 {
-
17729 
-
17730  ModelSIRDCONN<TSeq> * ptr = new ModelSIRDCONN<TSeq>(
-
17731  *dynamic_cast<const ModelSIRDCONN<TSeq>*>(this)
-
17732  );
+
17715 }
+
17716 
+
17717 template<typename TSeq>
+
17718 inline void ModelSIRDCONN<TSeq>::reset()
+
17719 {
+
17720 
+
17721  Model<TSeq>::reset();
+
17722 
+
17723  // Model<TSeq>::set_rand_binom(
+
17724  // Model<TSeq>::size(),
+
17725  // static_cast<double>(
+
17726  // Model<TSeq>::par("Contact rate"))/
+
17727  // static_cast<double>(Model<TSeq>::size())
+
17728  // );
+
17729 
+
17730  return;
+
17731 
+
17732 }
17733 
-
17734  return dynamic_cast< Model<TSeq> *>(ptr);
-
17735 
-
17736 }
-
17737 
-
17749 template<typename TSeq>
-
17750 inline ModelSIRDCONN<TSeq>::ModelSIRDCONN(
-
17751  ModelSIRDCONN<TSeq> & model,
-
17752  std::string vname,
-
17753  epiworld_fast_uint n,
-
17754  epiworld_double prevalence,
-
17755  epiworld_double contact_rate,
-
17756  epiworld_double transmission_rate,
-
17757  epiworld_double recovery_rate,
-
17758  epiworld_double death_rate
-
17759  // epiworld_double prob_reinfection
-
17760  )
-
17761 {
-
17762 
-
17763 
-
17764 
-
17765  epiworld::UpdateFun<TSeq> update_susceptible = [](
-
17766  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
17767  ) -> void
-
17768  {
-
17769 
-
17770  // Sampling how many individuals
-
17771  m->set_rand_binom(
-
17772  m->size(),
-
17773  static_cast<double>(
-
17774  m->par("Contact rate"))/
-
17775  static_cast<double>(m->size())
-
17776  );
+
17734 template<typename TSeq>
+
17735 inline Model<TSeq> * ModelSIRDCONN<TSeq>::clone_ptr()
+
17736 {
+
17737 
+
17738  ModelSIRDCONN<TSeq> * ptr = new ModelSIRDCONN<TSeq>(
+
17739  *dynamic_cast<const ModelSIRDCONN<TSeq>*>(this)
+
17740  );
+
17741 
+
17742  return dynamic_cast< Model<TSeq> *>(ptr);
+
17743 
+
17744 }
+
17745 
+
17757 template<typename TSeq>
+
17758 inline ModelSIRDCONN<TSeq>::ModelSIRDCONN(
+
17759  ModelSIRDCONN<TSeq> & model,
+
17760  std::string vname,
+
17761  epiworld_fast_uint n,
+
17762  epiworld_double prevalence,
+
17763  epiworld_double contact_rate,
+
17764  epiworld_double transmission_rate,
+
17765  epiworld_double recovery_rate,
+
17766  epiworld_double death_rate
+
17767  // epiworld_double prob_reinfection
+
17768  )
+
17769 {
+
17770 
+
17771 
+
17772 
+
17773  epiworld::UpdateFun<TSeq> update_susceptible = [](
+
17774  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
17775  ) -> void
+
17776  {
17777 
-
17778  int ndraw = m->rbinom();
-
17779 
-
17780  if (ndraw == 0)
-
17781  return;
-
17782 
-
17783  // Drawing from the set
-
17784  int nviruses_tmp = 0;
-
17785  for (int i = 0; i < ndraw; ++i)
-
17786  {
-
17787  // Now selecting who is transmitting the disease
-
17788  int which = static_cast<int>(
-
17789  std::floor(m->size() * m->runif())
-
17790  );
-
17791 
-
17792  /* There is a bug in which runif() returns 1.0. It is rare, but
-
17793  * we saw it here. See the Notes section in the C++ manual
-
17794  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
-
17795  * And the reported bug in GCC:
-
17796  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
-
17797  *
-
17798  */
-
17799  if (which == static_cast<int>(m->size()))
-
17800  --which;
-
17801 
-
17802  // Can't sample itself
-
17803  if (which == static_cast<int>(p->get_id()))
-
17804  continue;
-
17805 
-
17806  // If the neighbor is infected, then proceed
-
17807  auto & neighbor = m->get_agents()[which];
-
17808  if (neighbor.get_state() == ModelSIRDCONN<TSeq>::INFECTED)
-
17809  {
-
17810 
-
17811  const auto & v = neighbor.get_virus();
-
17812 
-
17813  #ifdef EPI_DEBUG
-
17814  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
-
17815  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
17816  #endif
-
17817 
-
17818  /* And it is a function of susceptibility_reduction as well */
-
17819  m->array_double_tmp[nviruses_tmp] =
-
17820  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
17821  v->get_prob_infecting(m) *
-
17822  (1.0 - neighbor.get_transmission_reduction(v, m))
-
17823  ;
-
17824 
-
17825  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
17826 
-
17827  }
-
17828  }
-
17829 
-
17830  // No virus to compute
-
17831  if (nviruses_tmp == 0u)
-
17832  return;
-
17833 
-
17834  // Running the roulette
-
17835  int which = roulette(nviruses_tmp, m);
-
17836 
-
17837  if (which < 0)
-
17838  return;
-
17839 
-
17840  p->set_virus(*m->array_virus_tmp[which], m);
+
17778  // Sampling how many individuals
+
17779  m->set_rand_binom(
+
17780  m->size(),
+
17781  static_cast<double>(
+
17782  m->par("Contact rate"))/
+
17783  static_cast<double>(m->size())
+
17784  );
+
17785 
+
17786  int ndraw = m->rbinom();
+
17787 
+
17788  if (ndraw == 0)
+
17789  return;
+
17790 
+
17791  // Drawing from the set
+
17792  int nviruses_tmp = 0;
+
17793  for (int i = 0; i < ndraw; ++i)
+
17794  {
+
17795  // Now selecting who is transmitting the disease
+
17796  int which = static_cast<int>(
+
17797  std::floor(m->size() * m->runif())
+
17798  );
+
17799 
+
17800  /* There is a bug in which runif() returns 1.0. It is rare, but
+
17801  * we saw it here. See the Notes section in the C++ manual
+
17802  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
+
17803  * And the reported bug in GCC:
+
17804  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
+
17805  *
+
17806  */
+
17807  if (which == static_cast<int>(m->size()))
+
17808  --which;
+
17809 
+
17810  // Can't sample itself
+
17811  if (which == static_cast<int>(p->get_id()))
+
17812  continue;
+
17813 
+
17814  // If the neighbor is infected, then proceed
+
17815  auto & neighbor = m->get_agents()[which];
+
17816  if (neighbor.get_state() == ModelSIRDCONN<TSeq>::INFECTED)
+
17817  {
+
17818 
+
17819  const auto & v = neighbor.get_virus();
+
17820 
+
17821  #ifdef EPI_DEBUG
+
17822  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
+
17823  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
17824  #endif
+
17825 
+
17826  /* And it is a function of susceptibility_reduction as well */
+
17827  m->array_double_tmp[nviruses_tmp] =
+
17828  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
17829  v->get_prob_infecting(m) *
+
17830  (1.0 - neighbor.get_transmission_reduction(v, m))
+
17831  ;
+
17832 
+
17833  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
17834 
+
17835  }
+
17836  }
+
17837 
+
17838  // No virus to compute
+
17839  if (nviruses_tmp == 0u)
+
17840  return;
17841 
-
17842  return;
-
17843 
-
17844  };
-
17845 
-
17846 
-
17847  epiworld::UpdateFun<TSeq> update_infected = [](
-
17848  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
17849  ) -> void {
-
17850 
-
17851  auto state = p->get_state();
-
17852 
-
17853  if (state == ModelSIRDCONN<TSeq>::INFECTED)
-
17854  {
-
17855 
-
17856 
-
17857  // Odd: Die, Even: Recover
-
17858  epiworld_fast_uint n_events = 0u;
-
17859  const auto & v = p->get_virus();
-
17860 
-
17861  // Die
-
17862  m->array_double_tmp[n_events++] =
-
17863  v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
-
17864 
-
17865  // Recover
-
17866  m->array_double_tmp[n_events++] =
-
17867  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
-
17868 
-
17869  #ifdef EPI_DEBUG
-
17870  if (n_events == 0u)
-
17871  {
-
17872  printf_epiworld(
-
17873  "[epi-debug] agent %i has 0 possible events!!\n",
-
17874  static_cast<int>(p->get_id())
-
17875  );
-
17876  throw std::logic_error("Zero events in exposed.");
-
17877  }
-
17878  #else
-
17879  if (n_events == 0u)
-
17880  return;
-
17881  #endif
-
17882 
-
17883 
-
17884  // Running the roulette
-
17885  int which = roulette(n_events, m);
-
17886 
-
17887  if (which < 0)
+
17842  // Running the roulette
+
17843  int which = roulette(nviruses_tmp, m);
+
17844 
+
17845  if (which < 0)
+
17846  return;
+
17847 
+
17848  p->set_virus(*m->array_virus_tmp[which], m);
+
17849 
+
17850  return;
+
17851 
+
17852  };
+
17853 
+
17854 
+
17855  epiworld::UpdateFun<TSeq> update_infected = [](
+
17856  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
17857  ) -> void {
+
17858 
+
17859  auto state = p->get_state();
+
17860 
+
17861  if (state == ModelSIRDCONN<TSeq>::INFECTED)
+
17862  {
+
17863 
+
17864 
+
17865  // Odd: Die, Even: Recover
+
17866  epiworld_fast_uint n_events = 0u;
+
17867  const auto & v = p->get_virus();
+
17868 
+
17869  // Die
+
17870  m->array_double_tmp[n_events++] =
+
17871  v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
+
17872 
+
17873  // Recover
+
17874  m->array_double_tmp[n_events++] =
+
17875  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
+
17876 
+
17877  #ifdef EPI_DEBUG
+
17878  if (n_events == 0u)
+
17879  {
+
17880  printf_epiworld(
+
17881  "[epi-debug] agent %i has 0 possible events!!\n",
+
17882  static_cast<int>(p->get_id())
+
17883  );
+
17884  throw std::logic_error("Zero events in exposed.");
+
17885  }
+
17886  #else
+
17887  if (n_events == 0u)
17888  return;
-
17889 
-
17890  // Which roulette happen?
-
17891  if ((which % 2) == 0) // If odd
-
17892  {
-
17893 
-
17894  p->rm_agent_by_virus(m);
-
17895 
-
17896  } else {
-
17897 
-
17898  p->rm_virus(m);
-
17899 
-
17900  }
-
17901 
-
17902  return ;
-
17903 
-
17904  } else
-
17905  throw std::logic_error("This function can only be applied to infected individuals. (SIR)") ;
-
17906 
-
17907  return;
-
17908 
-
17909  };
-
17910 
-
17911  // state
-
17912  model.add_state("Susceptible", update_susceptible);
-
17913  model.add_state("Infected", update_infected);
-
17914  model.add_state("Recovered");
-
17915  model.add_state("Deceased");
-
17916 
-
17917 
-
17918  // Setting up parameters
-
17919  model.add_param(contact_rate, "Contact rate");
-
17920  model.add_param(transmission_rate, "Transmission rate");
-
17921  model.add_param(recovery_rate, "Recovery rate");
-
17922  model.add_param(death_rate, "Death rate");
-
17923  // model.add_param(prob_reinfection, "Prob. Reinfection");
-
17924 
-
17925  // Preparing the virus -------------------------------------------
-
17926  epiworld::Virus<TSeq> virus(vname);
-
17927  virus.set_state(1, 2, 3);
-
17928  virus.set_prob_infecting(&model("Transmission rate"));
-
17929  virus.set_prob_recovery(&model("Recovery rate"));
-
17930  virus.set_prob_death(&model("Death rate"));
-
17931 
-
17932  model.add_virus(virus, prevalence);
-
17933 
-
17934  model.queuing_off(); // No queuing need
-
17935 
-
17936  model.agents_empty_graph(n);
-
17937 
-
17938  model.set_name("Susceptible-Infected-Removed-Deceased (SIRD) (connected)");
-
17939 
-
17940  return;
+
17889  #endif
+
17890 
+
17891 
+
17892  // Running the roulette
+
17893  int which = roulette(n_events, m);
+
17894 
+
17895  if (which < 0)
+
17896  return;
+
17897 
+
17898  // Which roulette happen?
+
17899  if ((which % 2) == 0) // If odd
+
17900  {
+
17901 
+
17902  p->rm_agent_by_virus(m);
+
17903 
+
17904  } else {
+
17905 
+
17906  p->rm_virus(m);
+
17907 
+
17908  }
+
17909 
+
17910  return ;
+
17911 
+
17912  } else
+
17913  throw std::logic_error("This function can only be applied to infected individuals. (SIR)") ;
+
17914 
+
17915  return;
+
17916 
+
17917  };
+
17918 
+
17919  // state
+
17920  model.add_state("Susceptible", update_susceptible);
+
17921  model.add_state("Infected", update_infected);
+
17922  model.add_state("Recovered");
+
17923  model.add_state("Deceased");
+
17924 
+
17925 
+
17926  // Setting up parameters
+
17927  model.add_param(contact_rate, "Contact rate");
+
17928  model.add_param(transmission_rate, "Transmission rate");
+
17929  model.add_param(recovery_rate, "Recovery rate");
+
17930  model.add_param(death_rate, "Death rate");
+
17931  // model.add_param(prob_reinfection, "Prob. Reinfection");
+
17932 
+
17933  // Preparing the virus -------------------------------------------
+
17934  epiworld::Virus<TSeq> virus(vname);
+
17935  virus.set_state(1, 2, 3);
+
17936  virus.set_prob_infecting(&model("Transmission rate"));
+
17937  virus.set_prob_recovery(&model("Recovery rate"));
+
17938  virus.set_prob_death(&model("Death rate"));
+
17939 
+
17940  model.add_virus(virus, prevalence);
17941 
-
17942 }
+
17942  model.queuing_off(); // No queuing need
17943 
-
17944 template<typename TSeq>
-
17945 inline ModelSIRDCONN<TSeq>::ModelSIRDCONN(
-
17946  std::string vname,
-
17947  epiworld_fast_uint n,
-
17948  epiworld_double prevalence,
-
17949  epiworld_double contact_rate,
-
17950  epiworld_double transmission_rate,
-
17951  epiworld_double recovery_rate,
-
17952  epiworld_double death_rate
-
17953  )
-
17954 {
-
17955 
-
17956  ModelSIRDCONN(
-
17957  *this,
-
17958  vname,
-
17959  n,
-
17960  prevalence,
-
17961  contact_rate,
-
17962  transmission_rate,
-
17963  recovery_rate,
-
17964  death_rate
-
17965  );
-
17966 
-
17967  return;
-
17968 
-
17969 }
-
17970 
-
17971 
-
17972 #endif
-
17973 /*//////////////////////////////////////////////////////////////////////////////
-
17975 
-
17976  End of -include/epiworld//models/sirdconnected.hpp-
-
17977 
-
17980 
-
17981 
-
17982 /*//////////////////////////////////////////////////////////////////////////////
-
17984 
-
17985  Start of -include/epiworld//models/seirdconnected.hpp-
-
17986 
+
17944  model.agents_empty_graph(n);
+
17945 
+
17946  model.set_name("Susceptible-Infected-Removed-Deceased (SIRD) (connected)");
+
17947 
+
17948  return;
+
17949 
+
17950 }
+
17951 
+
17952 template<typename TSeq>
+
17953 inline ModelSIRDCONN<TSeq>::ModelSIRDCONN(
+
17954  std::string vname,
+
17955  epiworld_fast_uint n,
+
17956  epiworld_double prevalence,
+
17957  epiworld_double contact_rate,
+
17958  epiworld_double transmission_rate,
+
17959  epiworld_double recovery_rate,
+
17960  epiworld_double death_rate
+
17961  )
+
17962 {
+
17963 
+
17964  ModelSIRDCONN(
+
17965  *this,
+
17966  vname,
+
17967  n,
+
17968  prevalence,
+
17969  contact_rate,
+
17970  transmission_rate,
+
17971  recovery_rate,
+
17972  death_rate
+
17973  );
+
17974 
+
17975  return;
+
17976 
+
17977 }
+
17978 
+
17979 
+
17980 #endif
+
17981 /*//////////////////////////////////////////////////////////////////////////////
+
17983 
+
17984  End of -include/epiworld//models/sirdconnected.hpp-
+
17985 
+
17988 
17989 
-
17990 
-
17991 #ifndef EPIWORLD_MODELS_SEIRDCONNECTED_HPP
-
17992 #define EPIWORLD_MODELS_SEIRDCONNECTED_HPP
-
17993 
-
17994 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
17995 class ModelSEIRDCONN : public epiworld::Model<TSeq>
-
17996 {
-
17997 public:
+
17990 /*//////////////////////////////////////////////////////////////////////////////
+
17992 
+
17993  Start of -include/epiworld//models/seirdconnected.hpp-
+
17994 
+
17997 
17998 
-
17999  static const int SUSCEPTIBLE = 0;
-
18000  static const int EXPOSED = 1;
-
18001  static const int INFECTED = 2;
-
18002  static const int REMOVED = 3;
-
18003  static const int DECEASED = 4;
-
18004 
-
18005 
-
18006  ModelSEIRDCONN() {};
-
18007 
-
18008  ModelSEIRDCONN(
-
18009  ModelSEIRDCONN<TSeq> & model,
-
18010  std::string vname,
-
18011  epiworld_fast_uint n,
-
18012  epiworld_double prevalence,
-
18013  epiworld_double contact_rate,
-
18014  epiworld_double transmission_rate,
-
18015  epiworld_double avg_incubation_days,
-
18016  epiworld_double recovery_rate,
-
18017  epiworld_double death_rate
-
18018  );
-
18019 
-
18020  ModelSEIRDCONN(
-
18021  std::string vname,
-
18022  epiworld_fast_uint n,
-
18023  epiworld_double prevalence,
-
18024  epiworld_double contact_rate,
-
18025  epiworld_double transmission_rate,
-
18026  epiworld_double avg_incubation_days,
-
18027  epiworld_double recovery_rate,
-
18028  epiworld_double death_rate
-
18029  );
-
18030 
-
18031  ModelSEIRDCONN<TSeq> & run(
-
18032  epiworld_fast_uint ndays,
-
18033  int seed = -1
-
18034  );
-
18035 
-
18036  void reset();
-
18037 
-
18038  Model<TSeq> * clone_ptr();
-
18039 
-
18046  ModelSEIRDCONN<TSeq> & initial_states(
-
18047  std::vector< double > proportions_,
-
18048  std::vector< int > queue_ = {}
-
18049  );
-
18050 
-
18051 };
-
18052 
-
18053 template<typename TSeq>
-
18054 inline ModelSEIRDCONN<TSeq> & ModelSEIRDCONN<TSeq>::run(
-
18055  epiworld_fast_uint ndays,
-
18056  int seed
-
18057 )
-
18058 {
-
18059 
-
18060  Model<TSeq>::run(ndays, seed);
-
18061 
-
18062  return *this;
-
18063 
-
18064 }
-
18065 
-
18066 template<typename TSeq>
-
18067 inline void ModelSEIRDCONN<TSeq>::reset()
-
18068 {
+
17999 #ifndef EPIWORLD_MODELS_SEIRDCONNECTED_HPP
+
18000 #define EPIWORLD_MODELS_SEIRDCONNECTED_HPP
+
18001 
+
18002 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
18003 class ModelSEIRDCONN : public epiworld::Model<TSeq>
+
18004 {
+
18005 public:
+
18006 
+
18007  static const int SUSCEPTIBLE = 0;
+
18008  static const int EXPOSED = 1;
+
18009  static const int INFECTED = 2;
+
18010  static const int REMOVED = 3;
+
18011  static const int DECEASED = 4;
+
18012 
+
18013 
+
18014  ModelSEIRDCONN() {};
+
18015 
+
18016  ModelSEIRDCONN(
+
18017  ModelSEIRDCONN<TSeq> & model,
+
18018  std::string vname,
+
18019  epiworld_fast_uint n,
+
18020  epiworld_double prevalence,
+
18021  epiworld_double contact_rate,
+
18022  epiworld_double transmission_rate,
+
18023  epiworld_double avg_incubation_days,
+
18024  epiworld_double recovery_rate,
+
18025  epiworld_double death_rate
+
18026  );
+
18027 
+
18028  ModelSEIRDCONN(
+
18029  std::string vname,
+
18030  epiworld_fast_uint n,
+
18031  epiworld_double prevalence,
+
18032  epiworld_double contact_rate,
+
18033  epiworld_double transmission_rate,
+
18034  epiworld_double avg_incubation_days,
+
18035  epiworld_double recovery_rate,
+
18036  epiworld_double death_rate
+
18037  );
+
18038 
+
18039  ModelSEIRDCONN<TSeq> & run(
+
18040  epiworld_fast_uint ndays,
+
18041  int seed = -1
+
18042  );
+
18043 
+
18044  void reset();
+
18045 
+
18046  Model<TSeq> * clone_ptr();
+
18047 
+
18054  ModelSEIRDCONN<TSeq> & initial_states(
+
18055  std::vector< double > proportions_,
+
18056  std::vector< int > queue_ = {}
+
18057  );
+
18058 
+
18059 };
+
18060 
+
18061 template<typename TSeq>
+
18062 inline ModelSEIRDCONN<TSeq> & ModelSEIRDCONN<TSeq>::run(
+
18063  epiworld_fast_uint ndays,
+
18064  int seed
+
18065 )
+
18066 {
+
18067 
+
18068  Model<TSeq>::run(ndays, seed);
18069 
-
18070  Model<TSeq>::reset();
+
18070  return *this;
18071 
-
18072  Model<TSeq>::set_rand_binom(
-
18073  Model<TSeq>::size(),
-
18074  static_cast<double>(
-
18075  Model<TSeq>::par("Contact rate"))/
-
18076  static_cast<double>(Model<TSeq>::size())
-
18077  );
-
18078 
-
18079  return;
-
18080 
-
18081 }
-
18082 
-
18083 template<typename TSeq>
-
18084 inline Model<TSeq> * ModelSEIRDCONN<TSeq>::clone_ptr()
-
18085 {
-
18086 
-
18087  ModelSEIRDCONN<TSeq> * ptr = new ModelSEIRDCONN<TSeq>(
-
18088  *dynamic_cast<const ModelSEIRDCONN<TSeq>*>(this)
-
18089  );
+
18072 }
+
18073 
+
18074 template<typename TSeq>
+
18075 inline void ModelSEIRDCONN<TSeq>::reset()
+
18076 {
+
18077 
+
18078  Model<TSeq>::reset();
+
18079 
+
18080  Model<TSeq>::set_rand_binom(
+
18081  Model<TSeq>::size(),
+
18082  static_cast<double>(
+
18083  Model<TSeq>::par("Contact rate"))/
+
18084  static_cast<double>(Model<TSeq>::size())
+
18085  );
+
18086 
+
18087  return;
+
18088 
+
18089 }
18090 
-
18091  return dynamic_cast< Model<TSeq> *>(ptr);
-
18092 
-
18093 }
-
18094 
-
18106 template<typename TSeq>
-
18107 inline ModelSEIRDCONN<TSeq>::ModelSEIRDCONN(
-
18108  ModelSEIRDCONN<TSeq> & model,
-
18109  std::string vname,
-
18110  epiworld_fast_uint n,
-
18111  epiworld_double prevalence,
-
18112  epiworld_double contact_rate,
-
18113  epiworld_double transmission_rate,
-
18114  epiworld_double avg_incubation_days,
-
18115  epiworld_double recovery_rate,
-
18116  epiworld_double death_rate
-
18117  // epiworld_double prob_reinfection
-
18118  )
-
18119 {
-
18120 
-
18121  epiworld::UpdateFun<TSeq> update_susceptible = [](
-
18122  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
18123  ) -> void
-
18124  {
-
18125 
-
18126  // Sampling how many individuals
-
18127  int ndraw = m->rbinom();
+
18091 template<typename TSeq>
+
18092 inline Model<TSeq> * ModelSEIRDCONN<TSeq>::clone_ptr()
+
18093 {
+
18094 
+
18095  ModelSEIRDCONN<TSeq> * ptr = new ModelSEIRDCONN<TSeq>(
+
18096  *dynamic_cast<const ModelSEIRDCONN<TSeq>*>(this)
+
18097  );
+
18098 
+
18099  return dynamic_cast< Model<TSeq> *>(ptr);
+
18100 
+
18101 }
+
18102 
+
18114 template<typename TSeq>
+
18115 inline ModelSEIRDCONN<TSeq>::ModelSEIRDCONN(
+
18116  ModelSEIRDCONN<TSeq> & model,
+
18117  std::string vname,
+
18118  epiworld_fast_uint n,
+
18119  epiworld_double prevalence,
+
18120  epiworld_double contact_rate,
+
18121  epiworld_double transmission_rate,
+
18122  epiworld_double avg_incubation_days,
+
18123  epiworld_double recovery_rate,
+
18124  epiworld_double death_rate
+
18125  // epiworld_double prob_reinfection
+
18126  )
+
18127 {
18128 
-
18129  if (ndraw == 0)
-
18130  return;
-
18131 
-
18132  // Drawing from the set
-
18133  int nviruses_tmp = 0;
-
18134  for (int i = 0; i < ndraw; ++i)
-
18135  {
-
18136  // Now selecting who is transmitting the disease
-
18137  int which = static_cast<int>(
-
18138  std::floor(m->size() * m->runif())
-
18139  );
-
18140 
-
18141  /* There is a bug in which runif() returns 1.0. It is rare, but
-
18142  * we saw it here. See the Notes section in the C++ manual
-
18143  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
-
18144  * And the reported bug in GCC:
-
18145  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
-
18146  *
-
18147  */
-
18148  if (which == static_cast<int>(m->size()))
-
18149  --which;
-
18150 
-
18151  // Can't sample itself
-
18152  if (which == static_cast<int>(p->get_id()))
-
18153  continue;
-
18154 
-
18155  // If the neighbor is infected, then proceed
-
18156  auto & neighbor = m->get_agents()[which];
-
18157  if (neighbor.get_state() == ModelSEIRDCONN<TSeq>::INFECTED)
-
18158  {
-
18159 
-
18160  const auto & v = neighbor.get_virus();
-
18161 
-
18162 
-
18163  #ifdef EPI_DEBUG
-
18164  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
-
18165  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
18166  #endif
-
18167 
-
18168  /* And it is a function of susceptibility_reduction as well */
-
18169  m->array_double_tmp[nviruses_tmp] =
-
18170  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
18171  v->get_prob_infecting(m) *
-
18172  (1.0 - neighbor.get_transmission_reduction(v, m))
-
18173  ;
-
18174 
-
18175  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
18176 
-
18177  }
-
18178  }
-
18179 
-
18180  // No virus to compute
-
18181  if (nviruses_tmp == 0u)
-
18182  return;
-
18183 
-
18184  // Running the roulette
-
18185  int which = roulette(nviruses_tmp, m);
-
18186 
-
18187  if (which < 0)
-
18188  return;
-
18189 
-
18190  p->set_virus(
-
18191  *m->array_virus_tmp[which],
-
18192  m,
-
18193  ModelSEIRDCONN<TSeq>::EXPOSED
-
18194  );
-
18195 
-
18196  return;
+
18129  epiworld::UpdateFun<TSeq> update_susceptible = [](
+
18130  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
18131  ) -> void
+
18132  {
+
18133 
+
18134  // Sampling how many individuals
+
18135  int ndraw = m->rbinom();
+
18136 
+
18137  if (ndraw == 0)
+
18138  return;
+
18139 
+
18140  // Drawing from the set
+
18141  int nviruses_tmp = 0;
+
18142  for (int i = 0; i < ndraw; ++i)
+
18143  {
+
18144  // Now selecting who is transmitting the disease
+
18145  int which = static_cast<int>(
+
18146  std::floor(m->size() * m->runif())
+
18147  );
+
18148 
+
18149  /* There is a bug in which runif() returns 1.0. It is rare, but
+
18150  * we saw it here. See the Notes section in the C++ manual
+
18151  * https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/random/uniform_real_distribution&oldid=133329
+
18152  * And the reported bug in GCC:
+
18153  * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63176
+
18154  *
+
18155  */
+
18156  if (which == static_cast<int>(m->size()))
+
18157  --which;
+
18158 
+
18159  // Can't sample itself
+
18160  if (which == static_cast<int>(p->get_id()))
+
18161  continue;
+
18162 
+
18163  // If the neighbor is infected, then proceed
+
18164  auto & neighbor = m->get_agents()[which];
+
18165  if (neighbor.get_state() == ModelSEIRDCONN<TSeq>::INFECTED)
+
18166  {
+
18167 
+
18168  const auto & v = neighbor.get_virus();
+
18169 
+
18170 
+
18171  #ifdef EPI_DEBUG
+
18172  if (nviruses_tmp >= static_cast<int>(m->array_virus_tmp.size()))
+
18173  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
18174  #endif
+
18175 
+
18176  /* And it is a function of susceptibility_reduction as well */
+
18177  m->array_double_tmp[nviruses_tmp] =
+
18178  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
18179  v->get_prob_infecting(m) *
+
18180  (1.0 - neighbor.get_transmission_reduction(v, m))
+
18181  ;
+
18182 
+
18183  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
18184 
+
18185  }
+
18186  }
+
18187 
+
18188  // No virus to compute
+
18189  if (nviruses_tmp == 0u)
+
18190  return;
+
18191 
+
18192  // Running the roulette
+
18193  int which = roulette(nviruses_tmp, m);
+
18194 
+
18195  if (which < 0)
+
18196  return;
18197 
-
18198  };
-
18199 
-
18200  epiworld::UpdateFun<TSeq> update_infected = [](
-
18201  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
18202  ) -> void {
+
18198  p->set_virus(
+
18199  *m->array_virus_tmp[which],
+
18200  m,
+
18201  ModelSEIRDCONN<TSeq>::EXPOSED
+
18202  );
18203 
-
18204  auto state = p->get_state();
+
18204  return;
18205 
-
18206  if (state == ModelSEIRDCONN<TSeq>::EXPOSED)
-
18207  {
-
18208 
-
18209  // Getting the virus
-
18210  auto & v = p->get_virus();
+
18206  };
+
18207 
+
18208  epiworld::UpdateFun<TSeq> update_infected = [](
+
18209  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
18210  ) -> void {
18211 
-
18212  // Does the agent become infected?
-
18213  if (m->runif() < 1.0/(v->get_incubation(m)))
-
18214  {
-
18215 
-
18216  p->change_state(m, ModelSEIRDCONN<TSeq>::INFECTED);
-
18217  return;
-
18218 
-
18219  }
-
18220 
-
18221 
-
18222  } else if (state == ModelSEIRDCONN<TSeq>::INFECTED)
-
18223  {
-
18224 
-
18225  // Odd: Die, Even: Recover
-
18226  epiworld_fast_uint n_events = 0u;
-
18227  const auto & v = p->get_virus();
-
18228 
-
18229  // Die
-
18230  m->array_double_tmp[n_events++] =
-
18231  v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
-
18232 
-
18233  // Recover
-
18234  m->array_double_tmp[n_events++] =
-
18235  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
-
18236 
-
18237  #ifdef EPI_DEBUG
-
18238  if (n_events == 0u)
-
18239  {
-
18240  printf_epiworld(
-
18241  "[epi-debug] agent %i has 0 possible events!!\n",
-
18242  static_cast<int>(p->get_id())
-
18243  );
-
18244  throw std::logic_error("Zero events in exposed.");
-
18245  }
-
18246  #else
-
18247  if (n_events == 0u)
-
18248  return;
-
18249  #endif
-
18250 
-
18251 
-
18252  // Running the roulette
-
18253  int which = roulette(n_events, m);
-
18254 
-
18255  if (which < 0)
+
18212  auto state = p->get_state();
+
18213 
+
18214  if (state == ModelSEIRDCONN<TSeq>::EXPOSED)
+
18215  {
+
18216 
+
18217  // Getting the virus
+
18218  auto & v = p->get_virus();
+
18219 
+
18220  // Does the agent become infected?
+
18221  if (m->runif() < 1.0/(v->get_incubation(m)))
+
18222  {
+
18223 
+
18224  p->change_state(m, ModelSEIRDCONN<TSeq>::INFECTED);
+
18225  return;
+
18226 
+
18227  }
+
18228 
+
18229 
+
18230  } else if (state == ModelSEIRDCONN<TSeq>::INFECTED)
+
18231  {
+
18232 
+
18233  // Odd: Die, Even: Recover
+
18234  epiworld_fast_uint n_events = 0u;
+
18235  const auto & v = p->get_virus();
+
18236 
+
18237  // Die
+
18238  m->array_double_tmp[n_events++] =
+
18239  v->get_prob_death(m) * (1.0 - p->get_death_reduction(v, m));
+
18240 
+
18241  // Recover
+
18242  m->array_double_tmp[n_events++] =
+
18243  1.0 - (1.0 - v->get_prob_recovery(m)) * (1.0 - p->get_recovery_enhancer(v, m));
+
18244 
+
18245  #ifdef EPI_DEBUG
+
18246  if (n_events == 0u)
+
18247  {
+
18248  printf_epiworld(
+
18249  "[epi-debug] agent %i has 0 possible events!!\n",
+
18250  static_cast<int>(p->get_id())
+
18251  );
+
18252  throw std::logic_error("Zero events in exposed.");
+
18253  }
+
18254  #else
+
18255  if (n_events == 0u)
18256  return;
-
18257 
-
18258  // Which roulette happen?
-
18259  if ((which % 2) == 0) // If odd
-
18260  {
-
18261 
-
18262  p->rm_agent_by_virus(m);
-
18263 
-
18264  } else {
+
18257  #endif
+
18258 
+
18259 
+
18260  // Running the roulette
+
18261  int which = roulette(n_events, m);
+
18262 
+
18263  if (which < 0)
+
18264  return;
18265 
-
18266  p->rm_virus(m);
-
18267 
-
18268  }
-
18269 
-
18270  return ;
-
18271 
-
18272  } else
-
18273  throw std::logic_error("This function can only be applied to exposed or infected individuals. (SEIRD)") ;
-
18274 
-
18275  return;
-
18276 
-
18277  };
-
18278 
-
18279  // Setting up parameters
-
18280  model.add_param(contact_rate, "Contact rate");
-
18281  model.add_param(transmission_rate, "Prob. Transmission");
-
18282  model.add_param(recovery_rate, "Prob. Recovery");
-
18283  model.add_param(avg_incubation_days, "Avg. Incubation days");
-
18284  model.add_param(death_rate, "Death rate");
-
18285 
-
18286  // state
-
18287  model.add_state("Susceptible", update_susceptible);
-
18288  model.add_state("Exposed", update_infected);
-
18289  model.add_state("Infected", update_infected);
-
18290  model.add_state("Removed");
-
18291  model.add_state("Deceased");
-
18292 
-
18293 
-
18294  // Preparing the virus -------------------------------------------
-
18295  epiworld::Virus<TSeq> virus(vname);
-
18296  virus.set_state(
-
18297  ModelSEIRDCONN<TSeq>::EXPOSED,
-
18298  ModelSEIRDCONN<TSeq>::REMOVED,
-
18299  ModelSEIRDCONN<TSeq>::DECEASED
-
18300  );
+
18266  // Which roulette happen?
+
18267  if ((which % 2) == 0) // If odd
+
18268  {
+
18269 
+
18270  p->rm_agent_by_virus(m);
+
18271 
+
18272  } else {
+
18273 
+
18274  p->rm_virus(m);
+
18275 
+
18276  }
+
18277 
+
18278  return ;
+
18279 
+
18280  } else
+
18281  throw std::logic_error("This function can only be applied to exposed or infected individuals. (SEIRD)") ;
+
18282 
+
18283  return;
+
18284 
+
18285  };
+
18286 
+
18287  // Setting up parameters
+
18288  model.add_param(contact_rate, "Contact rate");
+
18289  model.add_param(transmission_rate, "Prob. Transmission");
+
18290  model.add_param(recovery_rate, "Prob. Recovery");
+
18291  model.add_param(avg_incubation_days, "Avg. Incubation days");
+
18292  model.add_param(death_rate, "Death rate");
+
18293 
+
18294  // state
+
18295  model.add_state("Susceptible", update_susceptible);
+
18296  model.add_state("Exposed", update_infected);
+
18297  model.add_state("Infected", update_infected);
+
18298  model.add_state("Removed");
+
18299  model.add_state("Deceased");
+
18300 
18301 
-
18302  virus.set_prob_infecting(&model("Prob. Transmission"));
-
18303  virus.set_prob_recovery(&model("Prob. Recovery"));
-
18304  virus.set_incubation(&model("Avg. Incubation days"));
-
18305  virus.set_prob_death(&model("Death rate"));
-
18306  model.add_virus(virus, prevalence);
-
18307 
-
18308  model.queuing_off(); // No queuing need
+
18302  // Preparing the virus -------------------------------------------
+
18303  epiworld::Virus<TSeq> virus(vname);
+
18304  virus.set_state(
+
18305  ModelSEIRDCONN<TSeq>::EXPOSED,
+
18306  ModelSEIRDCONN<TSeq>::REMOVED,
+
18307  ModelSEIRDCONN<TSeq>::DECEASED
+
18308  );
18309 
-
18310  // Adding the empty population
-
18311  model.agents_empty_graph(n);
-
18312 
-
18313  model.set_name("Susceptible-Exposed-Infected-Removed-Deceased (SEIRD) (connected)");
-
18314 
-
18315  return;
-
18316 
-
18317 }
-
18318 
-
18319 template<typename TSeq>
-
18320 inline ModelSEIRDCONN<TSeq>::ModelSEIRDCONN(
-
18321  std::string vname,
-
18322  epiworld_fast_uint n,
-
18323  epiworld_double prevalence,
-
18324  epiworld_double contact_rate,
-
18325  epiworld_double transmission_rate,
-
18326  epiworld_double avg_incubation_days,
-
18327  epiworld_double recovery_rate,
-
18328  epiworld_double death_rate
-
18329  )
-
18330 {
-
18331 
-
18332  ModelSEIRDCONN(
-
18333  *this,
-
18334  vname,
-
18335  n,
-
18336  prevalence,
-
18337  contact_rate,
-
18338  transmission_rate,
-
18339  avg_incubation_days,
-
18340  recovery_rate,
-
18341  death_rate
-
18342  );
-
18343 
-
18344  return;
-
18345 
-
18346 }
-
18347 
-
18348 template<typename TSeq>
-
18349 inline ModelSEIRDCONN<TSeq> & ModelSEIRDCONN<TSeq>::initial_states(
-
18350  std::vector< double > proportions_,
-
18351  std::vector< int >
-
18352 ) {
+
18310  virus.set_prob_infecting(&model("Prob. Transmission"));
+
18311  virus.set_prob_recovery(&model("Prob. Recovery"));
+
18312  virus.set_incubation(&model("Avg. Incubation days"));
+
18313  virus.set_prob_death(&model("Death rate"));
+
18314  model.add_virus(virus, prevalence);
+
18315 
+
18316  model.queuing_off(); // No queuing need
+
18317 
+
18318  // Adding the empty population
+
18319  model.agents_empty_graph(n);
+
18320 
+
18321  model.set_name("Susceptible-Exposed-Infected-Removed-Deceased (SEIRD) (connected)");
+
18322 
+
18323  return;
+
18324 
+
18325 }
+
18326 
+
18327 template<typename TSeq>
+
18328 inline ModelSEIRDCONN<TSeq>::ModelSEIRDCONN(
+
18329  std::string vname,
+
18330  epiworld_fast_uint n,
+
18331  epiworld_double prevalence,
+
18332  epiworld_double contact_rate,
+
18333  epiworld_double transmission_rate,
+
18334  epiworld_double avg_incubation_days,
+
18335  epiworld_double recovery_rate,
+
18336  epiworld_double death_rate
+
18337  )
+
18338 {
+
18339 
+
18340  ModelSEIRDCONN(
+
18341  *this,
+
18342  vname,
+
18343  n,
+
18344  prevalence,
+
18345  contact_rate,
+
18346  transmission_rate,
+
18347  avg_incubation_days,
+
18348  recovery_rate,
+
18349  death_rate
+
18350  );
+
18351 
+
18352  return;
18353 
-
18354  Model<TSeq>::initial_states_fun =
-
18355  create_init_function_seir<TSeq>(proportions_)
-
18356  ;
-
18357 
-
18358  return *this;
-
18359 
-
18360 }
+
18354 }
+
18355 
+
18356 template<typename TSeq>
+
18357 inline ModelSEIRDCONN<TSeq> & ModelSEIRDCONN<TSeq>::initial_states(
+
18358  std::vector< double > proportions_,
+
18359  std::vector< int >
+
18360 ) {
18361 
-
18362 #endif
-
18363 /*//////////////////////////////////////////////////////////////////////////////
-
18365 
-
18366  End of -include/epiworld//models/seirdconnected.hpp-
-
18367 
-
18370 
-
18371 
-
18372 /*//////////////////////////////////////////////////////////////////////////////
-
18374 
-
18375  Start of -include/epiworld//models/sirlogit.hpp-
-
18376 
+
18362  Model<TSeq>::initial_states_fun =
+
18363  create_init_function_seird<TSeq>(proportions_)
+
18364  ;
+
18365 
+
18366  return *this;
+
18367 
+
18368 }
+
18369 
+
18370 #endif
+
18371 /*//////////////////////////////////////////////////////////////////////////////
+
18373 
+
18374  End of -include/epiworld//models/seirdconnected.hpp-
+
18375 
+
18378 
18379 
-
18380 
-
18381 // #include "../epiworld.hpp"
+
18380 /*//////////////////////////////////////////////////////////////////////////////
18382 
-
18383 #ifndef EPIWORLD_MODELS_SIRLOGIT_HPP
-
18384 #define EPIWORLD_MODELS_SIRLOGIT_HPP
-
18385 
-
18386 template<typename TSeq = EPI_DEFAULT_TSEQ>
-
18387 class ModelSIRLogit : public epiworld::Model<TSeq>
-
18388 {
-
18389 private:
-
18390  static const int SUSCEPTIBLE = 0;
-
18391  static const int INFECTED = 1;
-
18392  static const int RECOVERED = 2;
+
18383  Start of -include/epiworld//models/sirlogit.hpp-
+
18384 
+
18387 
+
18388 
+
18389 // #include "../epiworld.hpp"
+
18390 
+
18391 #ifndef EPIWORLD_MODELS_SIRLOGIT_HPP
+
18392 #define EPIWORLD_MODELS_SIRLOGIT_HPP
18393 
-
18394 public:
-
18395 
-
18396  ModelSIRLogit() {};
-
18397 
-
18407  ModelSIRLogit(
-
18408  ModelSIRLogit<TSeq> & model,
-
18409  std::string vname,
-
18410  double * data,
-
18411  size_t ncols,
-
18412  std::vector< double > coefs_infect,
-
18413  std::vector< double > coefs_recover,
-
18414  std::vector< size_t > coef_infect_cols,
-
18415  std::vector< size_t > coef_recover_cols,
-
18416  epiworld_double transmission_rate,
-
18417  epiworld_double recovery_rate,
-
18418  epiworld_double prevalence
-
18419  );
-
18420 
-
18421  ModelSIRLogit(
-
18422  std::string vname,
-
18423  double * data,
-
18424  size_t ncols,
-
18425  std::vector< double > coefs_infect,
-
18426  std::vector< double > coefs_recover,
-
18427  std::vector< size_t > coef_infect_cols,
-
18428  std::vector< size_t > coef_recover_cols,
-
18429  epiworld_double transmission_rate,
-
18430  epiworld_double recovery_rate,
-
18431  epiworld_double prevalence
-
18432  );
-
18433 
-
18434  ModelSIRLogit<TSeq> & run(
-
18435  epiworld_fast_uint ndays,
-
18436  int seed = -1
-
18437  );
-
18438 
-
18439  Model<TSeq> * clone_ptr();
-
18440 
-
18441  void reset();
-
18442 
-
18443  std::vector< double > coefs_infect;
-
18444  std::vector< double > coefs_recover;
-
18445  std::vector< size_t > coef_infect_cols;
-
18446  std::vector< size_t > coef_recover_cols;
-
18447 
-
18448 };
-
18449 
-
18450 
-
18451 
-
18452 template<typename TSeq>
-
18453 inline ModelSIRLogit<TSeq> & ModelSIRLogit<TSeq>::run(
-
18454  epiworld_fast_uint ndays,
-
18455  int seed
-
18456 )
-
18457 {
+
18394 template<typename TSeq = EPI_DEFAULT_TSEQ>
+
18395 class ModelSIRLogit : public epiworld::Model<TSeq>
+
18396 {
+
18397 private:
+
18398  static const int SUSCEPTIBLE = 0;
+
18399  static const int INFECTED = 1;
+
18400  static const int RECOVERED = 2;
+
18401 
+
18402 public:
+
18403 
+
18404  ModelSIRLogit() {};
+
18405 
+
18415  ModelSIRLogit(
+
18416  ModelSIRLogit<TSeq> & model,
+
18417  std::string vname,
+
18418  double * data,
+
18419  size_t ncols,
+
18420  std::vector< double > coefs_infect,
+
18421  std::vector< double > coefs_recover,
+
18422  std::vector< size_t > coef_infect_cols,
+
18423  std::vector< size_t > coef_recover_cols,
+
18424  epiworld_double transmission_rate,
+
18425  epiworld_double recovery_rate,
+
18426  epiworld_double prevalence
+
18427  );
+
18428 
+
18429  ModelSIRLogit(
+
18430  std::string vname,
+
18431  double * data,
+
18432  size_t ncols,
+
18433  std::vector< double > coefs_infect,
+
18434  std::vector< double > coefs_recover,
+
18435  std::vector< size_t > coef_infect_cols,
+
18436  std::vector< size_t > coef_recover_cols,
+
18437  epiworld_double transmission_rate,
+
18438  epiworld_double recovery_rate,
+
18439  epiworld_double prevalence
+
18440  );
+
18441 
+
18442  ModelSIRLogit<TSeq> & run(
+
18443  epiworld_fast_uint ndays,
+
18444  int seed = -1
+
18445  );
+
18446 
+
18447  Model<TSeq> * clone_ptr();
+
18448 
+
18449  void reset();
+
18450 
+
18451  std::vector< double > coefs_infect;
+
18452  std::vector< double > coefs_recover;
+
18453  std::vector< size_t > coef_infect_cols;
+
18454  std::vector< size_t > coef_recover_cols;
+
18455 
+
18456 };
+
18457 
18458 
-
18459  Model<TSeq>::run(ndays, seed);
-
18460  return *this;
-
18461 
-
18462 }
-
18463 
-
18464 template<typename TSeq>
-
18465 inline Model<TSeq> * ModelSIRLogit<TSeq>::clone_ptr()
-
18466 {
-
18467 
-
18468  ModelSIRLogit<TSeq> * ptr = new ModelSIRLogit<TSeq>(
-
18469  *dynamic_cast<const ModelSIRLogit<TSeq>*>(this)
-
18470  );
+
18459 
+
18460 template<typename TSeq>
+
18461 inline ModelSIRLogit<TSeq> & ModelSIRLogit<TSeq>::run(
+
18462  epiworld_fast_uint ndays,
+
18463  int seed
+
18464 )
+
18465 {
+
18466 
+
18467  Model<TSeq>::run(ndays, seed);
+
18468  return *this;
+
18469 
+
18470 }
18471 
-
18472  return dynamic_cast< Model<TSeq> *>(ptr);
-
18473 
-
18474 }
-
18475 
-
18476 template<typename TSeq>
-
18477 inline void ModelSIRLogit<TSeq>::reset()
-
18478 {
+
18472 template<typename TSeq>
+
18473 inline Model<TSeq> * ModelSIRLogit<TSeq>::clone_ptr()
+
18474 {
+
18475 
+
18476  ModelSIRLogit<TSeq> * ptr = new ModelSIRLogit<TSeq>(
+
18477  *dynamic_cast<const ModelSIRLogit<TSeq>*>(this)
+
18478  );
18479 
-
18480  /* Checking specified columns in the model */
-
18481  for (const auto & c : coef_infect_cols)
-
18482  {
-
18483  if (c >= Model<TSeq>::agents_data_ncols)
-
18484  throw std::range_error("Columns specified in coef_infect_cols out of range.");
-
18485  }
-
18486 
-
18487  for (const auto & c : coef_recover_cols)
-
18488  {
-
18489  if (c >= Model<TSeq>::agents_data_ncols)
-
18490  throw std::range_error("Columns specified in coef_recover_cols out of range.");
-
18491  }
-
18492 
-
18493  /* Checking attributes */
-
18494  if (coefs_infect.size() != (coef_infect_cols.size() + 1u))
-
18495  throw std::logic_error(
-
18496  "The number of coefficients (infection) doesn't match the number of features. It must be as many features of the agents plus 1 (exposure.)"
-
18497  );
-
18498 
-
18499  if (coefs_recover.size() != coef_recover_cols.size())
-
18500  throw std::logic_error(
-
18501  "The number of coefficients (recovery) doesn't match the number of features. It must be as many features of the agents."
-
18502  );
-
18503 
-
18504  Model<TSeq>::reset();
-
18505 
-
18506  return;
-
18507 
-
18508 }
-
18509 
-
18520 template<typename TSeq>
-
18521 inline ModelSIRLogit<TSeq>::ModelSIRLogit(
-
18522  ModelSIRLogit<TSeq> & model,
-
18523  std::string vname,
-
18524  double * data,
-
18525  size_t ncols,
-
18526  std::vector< double > coefs_infect,
-
18527  std::vector< double > coefs_recover,
-
18528  std::vector< size_t > coef_infect_cols,
-
18529  std::vector< size_t > coef_recover_cols,
-
18530  epiworld_double transmission_rate,
-
18531  epiworld_double recovery_rate,
-
18532  epiworld_double prevalence
-
18533  )
-
18534 {
-
18535 
-
18536  if (coef_infect_cols.size() == 0u)
-
18537  throw std::logic_error("No columns specified for coef_infect_cols.");
-
18538 
-
18539  if (coef_recover_cols.size() == 0u)
-
18540  throw std::logic_error("No columns specified for coef_recover_cols.");
-
18541 
-
18542  // Saving the variables
-
18543  model.set_agents_data(
-
18544  data, ncols
-
18545  );
+
18480  return dynamic_cast< Model<TSeq> *>(ptr);
+
18481 
+
18482 }
+
18483 
+
18484 template<typename TSeq>
+
18485 inline void ModelSIRLogit<TSeq>::reset()
+
18486 {
+
18487 
+
18488  /* Checking specified columns in the model */
+
18489  for (const auto & c : coef_infect_cols)
+
18490  {
+
18491  if (c >= Model<TSeq>::agents_data_ncols)
+
18492  throw std::range_error("Columns specified in coef_infect_cols out of range.");
+
18493  }
+
18494 
+
18495  for (const auto & c : coef_recover_cols)
+
18496  {
+
18497  if (c >= Model<TSeq>::agents_data_ncols)
+
18498  throw std::range_error("Columns specified in coef_recover_cols out of range.");
+
18499  }
+
18500 
+
18501  /* Checking attributes */
+
18502  if (coefs_infect.size() != (coef_infect_cols.size() + 1u))
+
18503  throw std::logic_error(
+
18504  "The number of coefficients (infection) doesn't match the number of features. It must be as many features of the agents plus 1 (exposure.)"
+
18505  );
+
18506 
+
18507  if (coefs_recover.size() != coef_recover_cols.size())
+
18508  throw std::logic_error(
+
18509  "The number of coefficients (recovery) doesn't match the number of features. It must be as many features of the agents."
+
18510  );
+
18511 
+
18512  Model<TSeq>::reset();
+
18513 
+
18514  return;
+
18515 
+
18516 }
+
18517 
+
18528 template<typename TSeq>
+
18529 inline ModelSIRLogit<TSeq>::ModelSIRLogit(
+
18530  ModelSIRLogit<TSeq> & model,
+
18531  std::string vname,
+
18532  double * data,
+
18533  size_t ncols,
+
18534  std::vector< double > coefs_infect,
+
18535  std::vector< double > coefs_recover,
+
18536  std::vector< size_t > coef_infect_cols,
+
18537  std::vector< size_t > coef_recover_cols,
+
18538  epiworld_double transmission_rate,
+
18539  epiworld_double recovery_rate,
+
18540  epiworld_double prevalence
+
18541  )
+
18542 {
+
18543 
+
18544  if (coef_infect_cols.size() == 0u)
+
18545  throw std::logic_error("No columns specified for coef_infect_cols.");
18546 
-
18547  model.coefs_infect = coefs_infect;
-
18548  model.coefs_recover = coefs_recover;
-
18549  model.coef_infect_cols = coef_infect_cols;
-
18550  model.coef_recover_cols = coef_recover_cols;
-
18551 
-
18552  epiworld::UpdateFun<TSeq> update_susceptible = [](
-
18553  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
18554  ) -> void
-
18555  {
-
18556 
-
18557  // Getting the right type
-
18558  ModelSIRLogit<TSeq> * _m = dynamic_cast<ModelSIRLogit<TSeq>*>(m);
+
18547  if (coef_recover_cols.size() == 0u)
+
18548  throw std::logic_error("No columns specified for coef_recover_cols.");
+
18549 
+
18550  // Saving the variables
+
18551  model.set_agents_data(
+
18552  data, ncols
+
18553  );
+
18554 
+
18555  model.coefs_infect = coefs_infect;
+
18556  model.coefs_recover = coefs_recover;
+
18557  model.coef_infect_cols = coef_infect_cols;
+
18558  model.coef_recover_cols = coef_recover_cols;
18559 
-
18560  // Exposure coefficient
-
18561  const double coef_exposure = _m->coefs_infect[0u];
-
18562 
-
18563  // This computes the prob of getting any neighbor variant
-
18564  size_t nviruses_tmp = 0u;
-
18565 
-
18566  double baseline = 0.0;
-
18567  for (size_t k = 0u; k < _m->coef_infect_cols.size(); ++k)
-
18568  baseline += p->operator[](k) * _m->coefs_infect[k + 1u];
-
18569 
-
18570  for (auto & neighbor: p->get_neighbors())
-
18571  {
-
18572 
-
18573  if (neighbor->get_virus() == nullptr)
-
18574  continue;
-
18575 
-
18576  auto & v = neighbor->get_virus();
+
18560  epiworld::UpdateFun<TSeq> update_susceptible = [](
+
18561  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
18562  ) -> void
+
18563  {
+
18564 
+
18565  // Getting the right type
+
18566  ModelSIRLogit<TSeq> * _m = dynamic_cast<ModelSIRLogit<TSeq>*>(m);
+
18567 
+
18568  // Exposure coefficient
+
18569  const double coef_exposure = _m->coefs_infect[0u];
+
18570 
+
18571  // This computes the prob of getting any neighbor variant
+
18572  size_t nviruses_tmp = 0u;
+
18573 
+
18574  double baseline = 0.0;
+
18575  for (size_t k = 0u; k < _m->coef_infect_cols.size(); ++k)
+
18576  baseline += p->operator[](k) * _m->coefs_infect[k + 1u];
18577 
-
18578  #ifdef EPI_DEBUG
-
18579  if (nviruses_tmp >= m->array_virus_tmp.size())
-
18580  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
-
18581  #endif
-
18582 
-
18583  /* And it is a function of susceptibility_reduction as well */
-
18584  m->array_double_tmp[nviruses_tmp] =
-
18585  baseline +
-
18586  (1.0 - p->get_susceptibility_reduction(v, m)) *
-
18587  v->get_prob_infecting(m) *
-
18588  (1.0 - neighbor->get_transmission_reduction(v, m)) *
-
18589  coef_exposure
-
18590  ;
-
18591 
-
18592  // Applying the plogis function
-
18593  m->array_double_tmp[nviruses_tmp] = 1.0/
-
18594  (1.0 + std::exp(-m->array_double_tmp[nviruses_tmp]));
-
18595 
-
18596  m->array_virus_tmp[nviruses_tmp++] = &(*v);
-
18597 
-
18598  }
+
18578  for (auto & neighbor: p->get_neighbors())
+
18579  {
+
18580 
+
18581  if (neighbor->get_virus() == nullptr)
+
18582  continue;
+
18583 
+
18584  auto & v = neighbor->get_virus();
+
18585 
+
18586  #ifdef EPI_DEBUG
+
18587  if (nviruses_tmp >= m->array_virus_tmp.size())
+
18588  throw std::logic_error("Trying to add an extra element to a temporal array outside of the range.");
+
18589  #endif
+
18590 
+
18591  /* And it is a function of susceptibility_reduction as well */
+
18592  m->array_double_tmp[nviruses_tmp] =
+
18593  baseline +
+
18594  (1.0 - p->get_susceptibility_reduction(v, m)) *
+
18595  v->get_prob_infecting(m) *
+
18596  (1.0 - neighbor->get_transmission_reduction(v, m)) *
+
18597  coef_exposure
+
18598  ;
18599 
-
18600  // No virus to compute
-
18601  if (nviruses_tmp == 0u)
-
18602  return;
-
18603 
-
18604  // Running the roulette
-
18605  int which = roulette(nviruses_tmp, m);
-
18606 
-
18607  if (which < 0)
-
18608  return;
-
18609 
-
18610  p->set_virus(*m->array_virus_tmp[which], m);
+
18600  // Applying the plogis function
+
18601  m->array_double_tmp[nviruses_tmp] = 1.0/
+
18602  (1.0 + std::exp(-m->array_double_tmp[nviruses_tmp]));
+
18603 
+
18604  m->array_virus_tmp[nviruses_tmp++] = &(*v);
+
18605 
+
18606  }
+
18607 
+
18608  // No virus to compute
+
18609  if (nviruses_tmp == 0u)
+
18610  return;
18611 
-
18612  return;
-
18613 
-
18614  };
-
18615 
-
18616  epiworld::UpdateFun<TSeq> update_infected = [](
-
18617  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
18618  ) -> void
-
18619  {
-
18620 
-
18621  // Getting the right type
-
18622  ModelSIRLogit<TSeq> * _m = dynamic_cast<ModelSIRLogit<TSeq>*>(m);
+
18612  // Running the roulette
+
18613  int which = roulette(nviruses_tmp, m);
+
18614 
+
18615  if (which < 0)
+
18616  return;
+
18617 
+
18618  p->set_virus(*m->array_virus_tmp[which], m);
+
18619 
+
18620  return;
+
18621 
+
18622  };
18623 
-
18624  // Computing recovery probability once
-
18625  double prob = 0.0;
-
18626  #if defined(__OPENMP) || defined(_OPENMP)
-
18627  #pragma omp simd reduction(+:prob)
-
18628  #endif
-
18629  for (size_t i = 0u; i < _m->coefs_recover.size(); ++i)
-
18630  prob += p->operator[](i) * _m->coefs_recover[i];
+
18624  epiworld::UpdateFun<TSeq> update_infected = [](
+
18625  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
18626  ) -> void
+
18627  {
+
18628 
+
18629  // Getting the right type
+
18630  ModelSIRLogit<TSeq> * _m = dynamic_cast<ModelSIRLogit<TSeq>*>(m);
18631 
-
18632  // Computing logis
-
18633  prob = 1.0/(1.0 + std::exp(-prob));
-
18634 
-
18635  if (prob > m->runif())
-
18636  p->rm_virus(m);
-
18637 
-
18638  return;
+
18632  // Computing recovery probability once
+
18633  double prob = 0.0;
+
18634  #if defined(__OPENMP) || defined(_OPENMP)
+
18635  #pragma omp simd reduction(+:prob)
+
18636  #endif
+
18637  for (size_t i = 0u; i < _m->coefs_recover.size(); ++i)
+
18638  prob += p->operator[](i) * _m->coefs_recover[i];
18639 
-
18640  };
-
18641 
-
18642  // state
-
18643  model.add_state("Susceptible", update_susceptible);
-
18644  model.add_state("Infected", update_infected);
-
18645  model.add_state("Recovered");
-
18646 
-
18647  // Setting up parameters
-
18648  // model.add_param(contact_rate, "Contact rate");
-
18649  model.add_param(transmission_rate, "Transmission rate");
-
18650  model.add_param(recovery_rate, "Recovery rate");
-
18651  // model.add_param(prob_reinfection, "Prob. Reinfection");
-
18652 
-
18653  // Preparing the virus -------------------------------------------
-
18654  epiworld::Virus<TSeq> virus(vname);
-
18655  virus.set_state(
-
18656  ModelSIRLogit<TSeq>::INFECTED,
-
18657  ModelSIRLogit<TSeq>::RECOVERED,
-
18658  ModelSIRLogit<TSeq>::RECOVERED
-
18659  );
-
18660 
-
18661  virus.set_prob_infecting(&model("Transmission rate"));
-
18662  virus.set_prob_recovery(&model("Recovery rate"));
-
18663 
-
18664  // virus.set_prob
-
18665 
-
18666  model.add_virus(virus, prevalence);
-
18667 
-
18668  model.set_name("Susceptible-Infected-Removed (SIR) (logit)");
-
18669 
-
18670  return;
+
18640  // Computing logis
+
18641  prob = 1.0/(1.0 + std::exp(-prob));
+
18642 
+
18643  if (prob > m->runif())
+
18644  p->rm_virus(m);
+
18645 
+
18646  return;
+
18647 
+
18648  };
+
18649 
+
18650  // state
+
18651  model.add_state("Susceptible", update_susceptible);
+
18652  model.add_state("Infected", update_infected);
+
18653  model.add_state("Recovered");
+
18654 
+
18655  // Setting up parameters
+
18656  // model.add_param(contact_rate, "Contact rate");
+
18657  model.add_param(transmission_rate, "Transmission rate");
+
18658  model.add_param(recovery_rate, "Recovery rate");
+
18659  // model.add_param(prob_reinfection, "Prob. Reinfection");
+
18660 
+
18661  // Preparing the virus -------------------------------------------
+
18662  epiworld::Virus<TSeq> virus(vname);
+
18663  virus.set_state(
+
18664  ModelSIRLogit<TSeq>::INFECTED,
+
18665  ModelSIRLogit<TSeq>::RECOVERED,
+
18666  ModelSIRLogit<TSeq>::RECOVERED
+
18667  );
+
18668 
+
18669  virus.set_prob_infecting(&model("Transmission rate"));
+
18670  virus.set_prob_recovery(&model("Recovery rate"));
18671 
-
18672 }
+
18672  // virus.set_prob
18673 
-
18674 template<typename TSeq>
-
18675 inline ModelSIRLogit<TSeq>::ModelSIRLogit(
-
18676  std::string vname,
-
18677  double * data,
-
18678  size_t ncols,
-
18679  std::vector< double > coefs_infect,
-
18680  std::vector< double > coefs_recover,
-
18681  std::vector< size_t > coef_infect_cols,
-
18682  std::vector< size_t > coef_recover_cols,
-
18683  epiworld_double transmission_rate,
-
18684  epiworld_double recovery_rate,
-
18685  epiworld_double prevalence
-
18686  )
-
18687 {
-
18688 
-
18689  ModelSIRLogit(
-
18690  *this,
-
18691  vname,
-
18692  data,
-
18693  ncols,
-
18694  coefs_infect,
-
18695  coefs_recover,
-
18696  coef_infect_cols,
-
18697  coef_recover_cols,
-
18698  transmission_rate,
-
18699  recovery_rate,
-
18700  prevalence
-
18701  );
-
18702 
-
18703  return;
-
18704 
-
18705 }
-
18706 
-
18707 
-
18708 #endif
-
18709 /*//////////////////////////////////////////////////////////////////////////////
-
18711 
-
18712  End of -include/epiworld//models/sirlogit.hpp-
-
18713 
-
18716 
-
18717 
-
18718 /*//////////////////////////////////////////////////////////////////////////////
-
18720 
-
18721  Start of -include/epiworld//models/diffnet.hpp-
-
18722 
+
18674  model.add_virus(virus, prevalence);
+
18675 
+
18676  model.set_name("Susceptible-Infected-Removed (SIR) (logit)");
+
18677 
+
18678  return;
+
18679 
+
18680 }
+
18681 
+
18682 template<typename TSeq>
+
18683 inline ModelSIRLogit<TSeq>::ModelSIRLogit(
+
18684  std::string vname,
+
18685  double * data,
+
18686  size_t ncols,
+
18687  std::vector< double > coefs_infect,
+
18688  std::vector< double > coefs_recover,
+
18689  std::vector< size_t > coef_infect_cols,
+
18690  std::vector< size_t > coef_recover_cols,
+
18691  epiworld_double transmission_rate,
+
18692  epiworld_double recovery_rate,
+
18693  epiworld_double prevalence
+
18694  )
+
18695 {
+
18696 
+
18697  ModelSIRLogit(
+
18698  *this,
+
18699  vname,
+
18700  data,
+
18701  ncols,
+
18702  coefs_infect,
+
18703  coefs_recover,
+
18704  coef_infect_cols,
+
18705  coef_recover_cols,
+
18706  transmission_rate,
+
18707  recovery_rate,
+
18708  prevalence
+
18709  );
+
18710 
+
18711  return;
+
18712 
+
18713 }
+
18714 
+
18715 
+
18716 #endif
+
18717 /*//////////////////////////////////////////////////////////////////////////////
+
18719 
+
18720  End of -include/epiworld//models/sirlogit.hpp-
+
18721 
+
18724 
18725 
-
18726 
-
18727 #ifndef EPIWORLD_DIFFNET_H
-
18728 #define EPIWORLD_DIFFNET_H
-
18729 
-
18739 template<typename TSeq = int>
-
18740 class ModelDiffNet : public epiworld::Model<TSeq>
-
18741 {
-
18742 private:
-
18743 public:
-
18744 
-
18745  ModelDiffNet() {};
-
18746 
-
18747  ModelDiffNet(
-
18748  ModelDiffNet<TSeq> & model,
-
18749  std::string innovation_name,
-
18750  epiworld_double prevalence,
-
18751  epiworld_double prob_adopt,
-
18752  bool normalize_exposure = true,
-
18753  double * agents_data = nullptr,
-
18754  size_t data_ncols = 0u,
-
18755  std::vector< size_t > data_cols = {},
-
18756  std::vector< double > params = {}
-
18757  );
-
18758 
-
18759  ModelDiffNet(
-
18760  std::string innovation_name,
-
18761  epiworld_double prevalence,
-
18762  epiworld_double prob_adopt,
-
18763  bool normalize_exposure = true,
-
18764  double * agents_data = nullptr,
-
18765  size_t data_ncols = 0u,
-
18766  std::vector< size_t > data_cols = {},
-
18767  std::vector< double > params = {}
-
18768  );
-
18769 
-
18770  static const int NONADOPTER = 0;
-
18771  static const int ADOPTER = 1;
-
18772 
-
18773  bool normalize_exposure = true;
-
18774  std::vector< size_t > data_cols;
-
18775  std::vector< double > params;
-
18776 };
-
18777 
-
18778 template<typename TSeq>
-
18779 inline ModelDiffNet<TSeq>::ModelDiffNet(
-
18780  ModelDiffNet<TSeq> & model,
-
18781  std::string innovation_name,
-
18782  epiworld_double prevalence,
-
18783  epiworld_double prob_adopt,
-
18784  bool normalize_exposure,
-
18785  double * agents_data,
-
18786  size_t data_ncols,
-
18787  std::vector< size_t > data_cols,
-
18788  std::vector< double > params
-
18789  )
-
18790 {
-
18791 
-
18792  // Adding additional parameters
-
18793  this->normalize_exposure = normalize_exposure;
-
18794  this->data_cols = data_cols;
-
18795  this->params = params;
-
18796 
-
18797  epiworld::UpdateFun<TSeq> update_non_adopters = [](
-
18798  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
-
18799  ) -> void {
-
18800 
-
18801  // Measuring exposure
-
18802  // If the neighbor is infected, then proceed
-
18803  size_t nviruses = m->get_n_viruses();
-
18804  std::vector< Virus<TSeq>* > innovations(nviruses, {});
-
18805  std::vector< bool > stored(nviruses, false);
-
18806  std::vector< double > exposure(nviruses, 0.0);
-
18807 
-
18808  ModelDiffNet<TSeq> * diffmodel = dynamic_cast<ModelDiffNet<TSeq>*>(m);
-
18809 
-
18810  Agent<TSeq> & agent = *p;
-
18811 
-
18812  // For each one of the possible innovations, we have to compute
-
18813  // the adoption probability, which is a function of exposure
-
18814  for (auto & neighbor: agent.get_neighbors())
-
18815  {
-
18816 
-
18817  if (neighbor->get_state() == ModelDiffNet<TSeq>::ADOPTER)
-
18818  {
+
18726 /*//////////////////////////////////////////////////////////////////////////////
+
18728 
+
18729  Start of -include/epiworld//models/diffnet.hpp-
+
18730 
+
18733 
+
18734 
+
18735 #ifndef EPIWORLD_DIFFNET_H
+
18736 #define EPIWORLD_DIFFNET_H
+
18737 
+
18747 template<typename TSeq = int>
+
18748 class ModelDiffNet : public epiworld::Model<TSeq>
+
18749 {
+
18750 private:
+
18751 public:
+
18752 
+
18753  ModelDiffNet() {};
+
18754 
+
18755  ModelDiffNet(
+
18756  ModelDiffNet<TSeq> & model,
+
18757  std::string innovation_name,
+
18758  epiworld_double prevalence,
+
18759  epiworld_double prob_adopt,
+
18760  bool normalize_exposure = true,
+
18761  double * agents_data = nullptr,
+
18762  size_t data_ncols = 0u,
+
18763  std::vector< size_t > data_cols = {},
+
18764  std::vector< double > params = {}
+
18765  );
+
18766 
+
18767  ModelDiffNet(
+
18768  std::string innovation_name,
+
18769  epiworld_double prevalence,
+
18770  epiworld_double prob_adopt,
+
18771  bool normalize_exposure = true,
+
18772  double * agents_data = nullptr,
+
18773  size_t data_ncols = 0u,
+
18774  std::vector< size_t > data_cols = {},
+
18775  std::vector< double > params = {}
+
18776  );
+
18777 
+
18778  static const int NONADOPTER = 0;
+
18779  static const int ADOPTER = 1;
+
18780 
+
18781  bool normalize_exposure = true;
+
18782  std::vector< size_t > data_cols;
+
18783  std::vector< double > params;
+
18784 };
+
18785 
+
18786 template<typename TSeq>
+
18787 inline ModelDiffNet<TSeq>::ModelDiffNet(
+
18788  ModelDiffNet<TSeq> & model,
+
18789  std::string innovation_name,
+
18790  epiworld_double prevalence,
+
18791  epiworld_double prob_adopt,
+
18792  bool normalize_exposure,
+
18793  double * agents_data,
+
18794  size_t data_ncols,
+
18795  std::vector< size_t > data_cols,
+
18796  std::vector< double > params
+
18797  )
+
18798 {
+
18799 
+
18800  // Adding additional parameters
+
18801  this->normalize_exposure = normalize_exposure;
+
18802  this->data_cols = data_cols;
+
18803  this->params = params;
+
18804 
+
18805  epiworld::UpdateFun<TSeq> update_non_adopters = [](
+
18806  epiworld::Agent<TSeq> * p, epiworld::Model<TSeq> * m
+
18807  ) -> void {
+
18808 
+
18809  // Measuring exposure
+
18810  // If the neighbor is infected, then proceed
+
18811  size_t nviruses = m->get_n_viruses();
+
18812  std::vector< Virus<TSeq>* > innovations(nviruses, {});
+
18813  std::vector< bool > stored(nviruses, false);
+
18814  std::vector< double > exposure(nviruses, 0.0);
+
18815 
+
18816  ModelDiffNet<TSeq> * diffmodel = dynamic_cast<ModelDiffNet<TSeq>*>(m);
+
18817 
+
18818  Agent<TSeq> & agent = *p;
18819 
-
18820  auto & v = neighbor->get_virus();
-
18821 
-
18822  if (v == nullptr)
-
18823  continue;
-
18824 
-
18825  /* And it is a function of susceptibility_reduction as well */
-
18826  double p_i =
-
18827  (1.0 - agent.get_susceptibility_reduction(v, m)) *
-
18828  (1.0 - agent.get_transmission_reduction(v, m))
-
18829  ;
-
18830 
-
18831  size_t vid = v->get_id();
-
18832  if (!stored[vid])
-
18833  {
-
18834  stored[vid] = true;
-
18835  innovations[vid] = &(*v);
-
18836  }
-
18837  exposure[vid] += p_i;
-
18838 
-
18839 
-
18840  }
-
18841 
-
18842  }
-
18843 
-
18844  // Computing probability of adoption
-
18845  for (size_t i = 0u; i < nviruses; ++i)
-
18846  {
+
18820  // For each one of the possible innovations, we have to compute
+
18821  // the adoption probability, which is a function of exposure
+
18822  for (auto & neighbor: agent.get_neighbors())
+
18823  {
+
18824 
+
18825  if (neighbor->get_state() == ModelDiffNet<TSeq>::ADOPTER)
+
18826  {
+
18827 
+
18828  auto & v = neighbor->get_virus();
+
18829 
+
18830  if (v == nullptr)
+
18831  continue;
+
18832 
+
18833  /* And it is a function of susceptibility_reduction as well */
+
18834  double p_i =
+
18835  (1.0 - agent.get_susceptibility_reduction(v, m)) *
+
18836  (1.0 - agent.get_transmission_reduction(v, m))
+
18837  ;
+
18838 
+
18839  size_t vid = v->get_id();
+
18840  if (!stored[vid])
+
18841  {
+
18842  stored[vid] = true;
+
18843  innovations[vid] = &(*v);
+
18844  }
+
18845  exposure[vid] += p_i;
+
18846 
18847 
-
18848  if (diffmodel->normalize_exposure)
-
18849  exposure.at(i) /= agent.get_n_neighbors();
-
18850 
-
18851  for (auto & j: diffmodel->data_cols)
-
18852  exposure.at(i) += agent(j) * diffmodel->params.at(j);
-
18853 
-
18854  // Baseline probability of adoption
-
18855  double p = m->get_viruses()[i]->get_prob_infecting(m);
-
18856  exposure.at(i) += std::log(p) - std::log(1.0 - p);
-
18857 
-
18858  // Computing as log
-
18859  exposure.at(i) = 1.0/(1.0 + std::exp(-exposure.at(i)));
-
18860 
-
18861  }
-
18862 
-
18863  // Running the roulette to see is an innovation is adopted
-
18864  int which = roulette<int>(exposure, m);
+
18848  }
+
18849 
+
18850  }
+
18851 
+
18852  // Computing probability of adoption
+
18853  for (size_t i = 0u; i < nviruses; ++i)
+
18854  {
+
18855 
+
18856  if (diffmodel->normalize_exposure)
+
18857  exposure.at(i) /= agent.get_n_neighbors();
+
18858 
+
18859  for (auto & j: diffmodel->data_cols)
+
18860  exposure.at(i) += agent(j) * diffmodel->params.at(j);
+
18861 
+
18862  // Baseline probability of adoption
+
18863  double p = m->get_viruses()[i]->get_prob_infecting(m);
+
18864  exposure.at(i) += std::log(p) - std::log(1.0 - p);
18865 
-
18866  // No innovation was adopted
-
18867  if (which < 0)
-
18868  return;
-
18869 
-
18870  // Otherwise, it is adopted from any of the neighbors
-
18871  agent.set_virus(
-
18872  *innovations.at(which),
-
18873  m,
-
18874  ModelDiffNet::ADOPTER
-
18875  );
-
18876 
-
18877  return;
-
18878 
-
18879  };
-
18880 
-
18881  // Adding agents data
-
18882  model.set_agents_data(agents_data, data_ncols);
-
18883 
-
18884  // Adding statuses
-
18885  model.add_state("Non adopters", update_non_adopters);
-
18886  model.add_state("Adopters");
-
18887 
-
18888  // Adding parameters
-
18889  std::string parname = std::string("Prob. Adopting ") + innovation_name;
-
18890  model.add_param(prob_adopt, parname);
-
18891 
-
18892  // Preparing the virus -------------------------------------------
-
18893  epiworld::Virus<TSeq> innovation(innovation_name);
-
18894  innovation.set_state(1,1,1);
-
18895 
-
18896  innovation.set_prob_infecting(&model(parname));
-
18897 
-
18898  model.add_virus(innovation, prevalence);
+
18866  // Computing as log
+
18867  exposure.at(i) = 1.0/(1.0 + std::exp(-exposure.at(i)));
+
18868 
+
18869  }
+
18870 
+
18871  // Running the roulette to see is an innovation is adopted
+
18872  int which = roulette<int>(exposure, m);
+
18873 
+
18874  // No innovation was adopted
+
18875  if (which < 0)
+
18876  return;
+
18877 
+
18878  // Otherwise, it is adopted from any of the neighbors
+
18879  agent.set_virus(
+
18880  *innovations.at(which),
+
18881  m,
+
18882  ModelDiffNet::ADOPTER
+
18883  );
+
18884 
+
18885  return;
+
18886 
+
18887  };
+
18888 
+
18889  // Adding agents data
+
18890  model.set_agents_data(agents_data, data_ncols);
+
18891 
+
18892  // Adding statuses
+
18893  model.add_state("Non adopters", update_non_adopters);
+
18894  model.add_state("Adopters");
+
18895 
+
18896  // Adding parameters
+
18897  std::string parname = std::string("Prob. Adopting ") + innovation_name;
+
18898  model.add_param(prob_adopt, parname);
18899 
-
18900  model.set_name(
-
18901  std::string("Diffusion of Innovations - ") + innovation_name);
-
18902 
-
18903  return;
-
18904 
-
18905 }
-
18906 
-
18907 template<typename TSeq>
-
18908 inline ModelDiffNet<TSeq>::ModelDiffNet(
-
18909  std::string innovation_name,
-
18910  epiworld_double prevalence,
-
18911  epiworld_double prob_adopt,
-
18912  bool normalize_exposure,
-
18913  double * agents_data,
-
18914  size_t data_ncols,
-
18915  std::vector< size_t > data_cols,
-
18916  std::vector< double > params
-
18917  )
-
18918 {
-
18919 
-
18920  ModelDiffNet<TSeq>(
-
18921  *this,
-
18922  innovation_name,
-
18923  prevalence,
-
18924  prob_adopt,
-
18925  normalize_exposure,
-
18926  agents_data,
-
18927  data_ncols,
-
18928  data_cols,
-
18929  params
-
18930  );
-
18931 
-
18932  return;
-
18933 
-
18934 }
-
18935 
-
18936 #endif
-
18937 /*//////////////////////////////////////////////////////////////////////////////
-
18939 
-
18940  End of -include/epiworld//models/diffnet.hpp-
-
18941 
-
18944 
-
18945 
-
18946 
+
18900  // Preparing the virus -------------------------------------------
+
18901  epiworld::Virus<TSeq> innovation(innovation_name);
+
18902  innovation.set_state(1,1,1);
+
18903 
+
18904  innovation.set_prob_infecting(&model(parname));
+
18905 
+
18906  model.add_virus(innovation, prevalence);
+
18907 
+
18908  model.set_name(
+
18909  std::string("Diffusion of Innovations - ") + innovation_name);
+
18910 
+
18911  return;
+
18912 
+
18913 }
+
18914 
+
18915 template<typename TSeq>
+
18916 inline ModelDiffNet<TSeq>::ModelDiffNet(
+
18917  std::string innovation_name,
+
18918  epiworld_double prevalence,
+
18919  epiworld_double prob_adopt,
+
18920  bool normalize_exposure,
+
18921  double * agents_data,
+
18922  size_t data_ncols,
+
18923  std::vector< size_t > data_cols,
+
18924  std::vector< double > params
+
18925  )
+
18926 {
+
18927 
+
18928  ModelDiffNet<TSeq>(
+
18929  *this,
+
18930  innovation_name,
+
18931  prevalence,
+
18932  prob_adopt,
+
18933  normalize_exposure,
+
18934  agents_data,
+
18935  data_ncols,
+
18936  data_cols,
+
18937  params
+
18938  );
+
18939 
+
18940  return;
+
18941 
+
18942 }
+
18943 
+
18944 #endif
+
18945 /*//////////////////////////////////////////////////////////////////////////////
18947 
-
18948 }
+
18948  End of -include/epiworld//models/diffnet.hpp-
18949 
-
18950 #endif
-
18951 /*//////////////////////////////////////////////////////////////////////////////
+
18952 
18953 
-
18954  End of -include/epiworld/models/models.hpp-
+
18954 
18955 
-
18958 
-
18959 
-
18960 
-
18961 }
-
18962 
-
18963 #endif
+
18956 }
+
18957 
+
18958 #endif
+
18959 /*//////////////////////////////////////////////////////////////////////////////
+
18961 
+
18962  End of -include/epiworld/models/models.hpp-
+
18963 
+
18966 
+
18967 
+
18968 
+
18969 }
+
18970 
+
18971 #endif
AdjList
Definition: adjlist-bones.hpp:4
AdjList::vcount
size_t vcount() const
Number of vertices/nodes in the network.
Definition: adjlist-meat.hpp:203
Agent
Agent (agents)
Definition: agent-bones.hpp:66
@@ -17491,52 +17499,52 @@
Virus
Virus.
Definition: virus-bones.hpp:24
epiworld::AdjList
Definition: epiworld.hpp:4776
epiworld::AdjList::read_edgelist
void read_edgelist(std::string fn, int size, int skip=0, bool directed=true)
Read an edgelist.
Definition: epiworld.hpp:4956
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
-
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14088
-
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14037
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
+
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14096
+
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14045
epiworld::DataBase
Statistical data about the process.
Definition: epiworld.hpp:2670
-
epiworld::Entity
Definition: epiworld.hpp:11912
+
epiworld::Entity
Definition: epiworld.hpp:11920
epiworld::GlobalAction
Template for a Global Action.
Definition: epiworld.hpp:5809
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
epiworld::Model::get_agents
std::vector< Agent< TSeq > > & get_agents()
Returns a reference to the vector of agents.
Definition: epiworld.hpp:7311
epiworld::Model::get_agents_viruses
std::vector< Viruses_const< TSeq > > get_agents_viruses() const
Returns a const vector with the viruses of the agents.
Definition: epiworld.hpp:7327
-
epiworld::Model::set_agents_data
void set_agents_data(double *data_, size_t ncols_)
Set the agents data object.
Definition: epiworld.hpp:9644
+
epiworld::Model::set_agents_data
void set_agents_data(double *data_, size_t ncols_)
Set the agents data object.
Definition: epiworld.hpp:9652
epiworld::Model::actions_add
void actions_add(Agent< TSeq > *agent_, VirusPtr< TSeq > virus_, ToolPtr< TSeq > tool_, Entity< TSeq > *entity_, epiworld_fast_int new_state_, epiworld_fast_int queue_, ActionFun< TSeq > call_, int idx_agent_, int idx_object_)
Construct a new Action object.
Definition: epiworld.hpp:6863
-
epiworld::Model::queuing_on
void queuing_on()
Activates the queuing system (default.)
Definition: epiworld.hpp:9572
+
epiworld::Model::queuing_on
void queuing_on()
Activates the queuing system (default.)
Definition: epiworld.hpp:9580
epiworld::Model::actions_run
void actions_run()
Executes the stored action.
Definition: epiworld.hpp:6914
-
epiworld::Model::get_global_action
GlobalAction< TSeq > & get_global_action(std::string name)
Retrieve a global action by name.
Definition: epiworld.hpp:9499
-
epiworld::Model::is_queuing_on
bool is_queuing_on() const
Query if the queuing system is on.
Definition: epiworld.hpp:9585
+
epiworld::Model::get_global_action
GlobalAction< TSeq > & get_global_action(std::string name)
Retrieve a global action by name.
Definition: epiworld.hpp:9507
+
epiworld::Model::is_queuing_on
bool is_queuing_on() const
Query if the queuing system is on.
Definition: epiworld.hpp:9593
epiworld::Model::run_multiple
void run_multiple(epiworld_fast_uint ndays, epiworld_fast_uint nexperiments, int seed_=-1, std::function< void(size_t, Model< TSeq > *)> fun=make_save_run< TSeq >(), bool reset=true, bool verbose=true, int nthreads=1)
Definition: epiworld.hpp:8284
-
epiworld::Model::get_queue
Queue< TSeq > & get_queue()
Retrieve the Queue object.
Definition: epiworld.hpp:9591
-
epiworld::Model::set_name
void set_name(std::string name)
Set the name object.
Definition: epiworld.hpp:9662
+
epiworld::Model::get_queue
Queue< TSeq > & get_queue()
Retrieve the Queue object.
Definition: epiworld.hpp:9599
+
epiworld::Model::set_name
void set_name(std::string name)
Set the name object.
Definition: epiworld.hpp:9670
epiworld::Model::load_agents_entities_ties
void load_agents_entities_ties(std::string fn, int skip)
Associate agents-entities from a file.
Definition: epiworld.hpp:7991
-
epiworld::Model::rm_global_action
void rm_global_action(size_t i)
Remove a global action by index.
Definition: epiworld.hpp:9547
+
epiworld::Model::rm_global_action
void rm_global_action(size_t i)
Remove a global action by index.
Definition: epiworld.hpp:9555
epiworld::Model::get_n_tools
size_t get_n_tools() const
Number of tools in the model.
Definition: epiworld.hpp:8558
epiworld::Model::write_data
void write_data(std::string fn_virus_info, std::string fn_virus_hist, std::string fn_tool_info, std::string fn_tool_hist, std::string fn_total_hist, std::string fn_transmission, std::string fn_transition, std::string fn_reproductive_number, std::string fn_generation_time) const
Wrapper of DataBase::write_data
Definition: epiworld.hpp:8629
-
epiworld::Model::queuing_off
Model< TSeq > & queuing_off()
Deactivates the queuing system.
Definition: epiworld.hpp:9578
+
epiworld::Model::queuing_off
Model< TSeq > & queuing_off()
Deactivates the queuing system.
Definition: epiworld.hpp:9586
epiworld::Model::reset
virtual void reset()
Reset the model.
Definition: epiworld.hpp:8733
epiworld::Model::get_agents_states
std::vector< epiworld_fast_uint > get_agents_states() const
Returns a vector with the states of the agents.
Definition: epiworld.hpp:7317
-
epiworld::Model::add_global_action
void add_global_action(std::function< void(Model< TSeq > *)> fun, std::string name="A global action", int date=-99)
Set a global action.
Definition: epiworld.hpp:9473
-
epiworld::Model::get_global_action
GlobalAction< TSeq > & get_global_action(size_t i)
Retrieve a global action by index.
Definition: epiworld.hpp:9513
-
epiworld::Model::rm_global_action
void rm_global_action(std::string name)
Remove a global action by name.
Definition: epiworld.hpp:9527
+
epiworld::Model::add_global_action
void add_global_action(std::function< void(Model< TSeq > *)> fun, std::string name="A global action", int date=-99)
Set a global action.
Definition: epiworld.hpp:9481
+
epiworld::Model::get_global_action
GlobalAction< TSeq > & get_global_action(size_t i)
Retrieve a global action by index.
Definition: epiworld.hpp:9521
+
epiworld::Model::rm_global_action
void rm_global_action(std::string name)
Remove a global action by name.
Definition: epiworld.hpp:9535
epiworld::Model::today
int today() const
The current time of the model.
Definition: epiworld.hpp:8151
epiworld::Model::run
virtual Model< TSeq > & run(epiworld_fast_uint ndays, int seed=-1)
Runs the simulation (after initialization)
Definition: epiworld.hpp:8173
epiworld::Model::get_n_viruses
size_t get_n_viruses() const
Number of viruses in the model.
Definition: epiworld.hpp:8553
epiworld::Model::get_agents_viruses
std::vector< Viruses< TSeq > > get_agents_viruses()
Returns a vector with the viruses of the agents.
Definition: epiworld.hpp:7340
-
epiworld::Model::set_user_data
void set_user_data(std::vector< std::string > names)
[@
Definition: epiworld.hpp:9449
+
epiworld::Model::set_user_data
void set_user_data(std::vector< std::string > names)
[@
Definition: epiworld.hpp:9457
epiworld::Model::clone_ptr
virtual Model< TSeq > * clone_ptr()
Advanced usage: Makes a copy of data and returns it as undeleted pointer.
Definition: epiworld.hpp:7064
epiworld::Progress
A simple progress bar.
Definition: epiworld.hpp:749
epiworld::Queue
Controls which agents are verified at each step.
Definition: epiworld.hpp:5669
-
epiworld::Tool
Tools for defending the agent against the virus.
Definition: epiworld.hpp:11266
+
epiworld::Tool
Tools for defending the agent against the virus.
Definition: epiworld.hpp:11274
epiworld::UserData
Personalized data by the user.
Definition: epiworld.hpp:2186
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
-
epiworld::epimodels::ModelSEIRCONN
Definition: epiworld.hpp:16757
-
epiworld::epimodels::ModelSEIRDCONN
Definition: epiworld.hpp:17996
-
epiworld::epimodels::ModelSIRCONN
Definition: epiworld.hpp:16419
-
epiworld::epimodels::ModelSIRDCONN
Definition: epiworld.hpp:17639
-
epiworld::epimodels::ModelSIRLogit
Definition: epiworld.hpp:18388
-
epiworld::sampler::sample_virus_single
Virus< TSeq > * sample_virus_single(Agent< TSeq > *p, Model< TSeq > *m)
Sample from neighbors pool of viruses (at most one)
Definition: epiworld.hpp:12857
-
epiworld::sampler::make_sample_virus_neighbors
std::function< Virus< TSeq > *(Agent< TSeq > *, Model< TSeq > *)> make_sample_virus_neighbors(std::vector< epiworld_fast_uint > exclude={})
Make a function to sample from neighbors.
Definition: epiworld.hpp:12689
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
+
epiworld::epimodels::ModelSEIRCONN
Definition: epiworld.hpp:16765
+
epiworld::epimodels::ModelSEIRDCONN
Definition: epiworld.hpp:18004
+
epiworld::epimodels::ModelSIRCONN
Definition: epiworld.hpp:16427
+
epiworld::epimodels::ModelSIRDCONN
Definition: epiworld.hpp:17647
+
epiworld::epimodels::ModelSIRLogit
Definition: epiworld.hpp:18396
+
epiworld::sampler::sample_virus_single
Virus< TSeq > * sample_virus_single(Agent< TSeq > *p, Model< TSeq > *m)
Sample from neighbors pool of viruses (at most one)
Definition: epiworld.hpp:12865
+
epiworld::sampler::make_sample_virus_neighbors
std::function< Virus< TSeq > *(Agent< TSeq > *, Model< TSeq > *)> make_sample_virus_neighbors(std::vector< epiworld_fast_uint > exclude={})
Make a function to sample from neighbors.
Definition: epiworld.hpp:12697
sampler
Functions for sampling viruses.
Definition: agent-meat-virus-sampling.hpp:8
diff --git a/init-functions_8hpp_source.html b/init-functions_8hpp_source.html index aff3d723..5c8c9568 100644 --- a/init-functions_8hpp_source.html +++ b/init-functions_8hpp_source.html @@ -396,7 +396,7 @@
340 
341 #endif
Queue
Controls which agents are verified at each step.
Definition: queue-bones.hpp:16
-
epiworld::AgentsSample
Sample of agents.
Definition: epiworld.hpp:14592
+
epiworld::AgentsSample
Sample of agents.
Definition: epiworld.hpp:14600
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
diff --git a/latex/agent-meat-state_8hpp__dep__incl.pdf b/latex/agent-meat-state_8hpp__dep__incl.pdf index 8b9a7575..cd6d6daf 100644 Binary files a/latex/agent-meat-state_8hpp__dep__incl.pdf and b/latex/agent-meat-state_8hpp__dep__incl.pdf differ diff --git a/latex/agent-meat-state_8hpp__incl.pdf b/latex/agent-meat-state_8hpp__incl.pdf index 6c379a73..cfdced07 100644 Binary files a/latex/agent-meat-state_8hpp__incl.pdf and b/latex/agent-meat-state_8hpp__incl.pdf differ diff --git a/latex/class_model__coll__graph.pdf b/latex/class_model__coll__graph.pdf index cd56bb5a..f5cc8b98 100644 Binary files a/latex/class_model__coll__graph.pdf and b/latex/class_model__coll__graph.pdf differ diff --git a/latex/class_model_diff_net__coll__graph.pdf b/latex/class_model_diff_net__coll__graph.pdf index b4229595..ab8dcbb3 100644 Binary files a/latex/class_model_diff_net__coll__graph.pdf and b/latex/class_model_diff_net__coll__graph.pdf differ diff --git a/latex/class_model_diff_net__inherit__graph.pdf b/latex/class_model_diff_net__inherit__graph.pdf index 596f8a8e..ab8dcbb3 100644 Binary files a/latex/class_model_diff_net__inherit__graph.pdf and b/latex/class_model_diff_net__inherit__graph.pdf differ diff --git a/latex/class_model_s_e_i_r__coll__graph.pdf b/latex/class_model_s_e_i_r__coll__graph.pdf index 4b25942f..65a04a64 100644 Binary files a/latex/class_model_s_e_i_r__coll__graph.pdf and b/latex/class_model_s_e_i_r__coll__graph.pdf differ diff --git a/latex/class_model_s_e_i_r__inherit__graph.pdf b/latex/class_model_s_e_i_r__inherit__graph.pdf index 4b25942f..65a04a64 100644 Binary files a/latex/class_model_s_e_i_r__inherit__graph.pdf and b/latex/class_model_s_e_i_r__inherit__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_c_o_n_n__coll__graph.pdf b/latex/class_model_s_e_i_r_c_o_n_n__coll__graph.pdf index fc271466..ecd395d0 100644 Binary files a/latex/class_model_s_e_i_r_c_o_n_n__coll__graph.pdf and b/latex/class_model_s_e_i_r_c_o_n_n__coll__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_c_o_n_n__inherit__graph.pdf b/latex/class_model_s_e_i_r_c_o_n_n__inherit__graph.pdf index fc271466..ecd395d0 100644 Binary files a/latex/class_model_s_e_i_r_c_o_n_n__inherit__graph.pdf and b/latex/class_model_s_e_i_r_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_c_o_n_n_logit__coll__graph.pdf b/latex/class_model_s_e_i_r_c_o_n_n_logit__coll__graph.pdf index f8df6503..fe5a7fdc 100644 Binary files a/latex/class_model_s_e_i_r_c_o_n_n_logit__coll__graph.pdf and b/latex/class_model_s_e_i_r_c_o_n_n_logit__coll__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_c_o_n_n_logit__inherit__graph.pdf b/latex/class_model_s_e_i_r_c_o_n_n_logit__inherit__graph.pdf index f8df6503..fe5a7fdc 100644 Binary files a/latex/class_model_s_e_i_r_c_o_n_n_logit__inherit__graph.pdf and b/latex/class_model_s_e_i_r_c_o_n_n_logit__inherit__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_d__coll__graph.pdf b/latex/class_model_s_e_i_r_d__coll__graph.pdf index 477eef5b..939d1bb9 100644 Binary files a/latex/class_model_s_e_i_r_d__coll__graph.pdf and b/latex/class_model_s_e_i_r_d__coll__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_d__inherit__graph.pdf b/latex/class_model_s_e_i_r_d__inherit__graph.pdf index 477eef5b..939d1bb9 100644 Binary files a/latex/class_model_s_e_i_r_d__inherit__graph.pdf and b/latex/class_model_s_e_i_r_d__inherit__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf b/latex/class_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf index 8bde880d..5e6e46ce 100644 Binary files a/latex/class_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf and b/latex/class_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf differ diff --git a/latex/class_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf b/latex/class_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf index 8bde880d..5e6e46ce 100644 Binary files a/latex/class_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf and b/latex/class_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_r__coll__graph.pdf b/latex/class_model_s_i_r__coll__graph.pdf index e6e8756d..6057bd4c 100644 Binary files a/latex/class_model_s_i_r__coll__graph.pdf and b/latex/class_model_s_i_r__coll__graph.pdf differ diff --git a/latex/class_model_s_i_r__inherit__graph.pdf b/latex/class_model_s_i_r__inherit__graph.pdf index e6e8756d..6057bd4c 100644 Binary files a/latex/class_model_s_i_r__inherit__graph.pdf and b/latex/class_model_s_i_r__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_r_c_o_n_n__coll__graph.pdf b/latex/class_model_s_i_r_c_o_n_n__coll__graph.pdf index 369e0485..75841f80 100644 Binary files a/latex/class_model_s_i_r_c_o_n_n__coll__graph.pdf and b/latex/class_model_s_i_r_c_o_n_n__coll__graph.pdf differ diff --git a/latex/class_model_s_i_r_c_o_n_n__inherit__graph.pdf b/latex/class_model_s_i_r_c_o_n_n__inherit__graph.pdf index 369e0485..75841f80 100644 Binary files a/latex/class_model_s_i_r_c_o_n_n__inherit__graph.pdf and b/latex/class_model_s_i_r_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_r_d__coll__graph.pdf b/latex/class_model_s_i_r_d__coll__graph.pdf index d14562d5..e6b15ce2 100644 Binary files a/latex/class_model_s_i_r_d__coll__graph.pdf and b/latex/class_model_s_i_r_d__coll__graph.pdf differ diff --git a/latex/class_model_s_i_r_d__inherit__graph.pdf b/latex/class_model_s_i_r_d__inherit__graph.pdf index d14562d5..e6b15ce2 100644 Binary files a/latex/class_model_s_i_r_d__inherit__graph.pdf and b/latex/class_model_s_i_r_d__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_r_d_c_o_n_n__coll__graph.pdf b/latex/class_model_s_i_r_d_c_o_n_n__coll__graph.pdf index 0c47a08e..2302f97b 100644 Binary files a/latex/class_model_s_i_r_d_c_o_n_n__coll__graph.pdf and b/latex/class_model_s_i_r_d_c_o_n_n__coll__graph.pdf differ diff --git a/latex/class_model_s_i_r_d_c_o_n_n__inherit__graph.pdf b/latex/class_model_s_i_r_d_c_o_n_n__inherit__graph.pdf index 0c47a08e..2302f97b 100644 Binary files a/latex/class_model_s_i_r_d_c_o_n_n__inherit__graph.pdf and b/latex/class_model_s_i_r_d_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_r_logit__coll__graph.pdf b/latex/class_model_s_i_r_logit__coll__graph.pdf index c264e2a3..704d0e3b 100644 Binary files a/latex/class_model_s_i_r_logit__coll__graph.pdf and b/latex/class_model_s_i_r_logit__coll__graph.pdf differ diff --git a/latex/class_model_s_i_r_logit__inherit__graph.pdf b/latex/class_model_s_i_r_logit__inherit__graph.pdf index c264e2a3..704d0e3b 100644 Binary files a/latex/class_model_s_i_r_logit__inherit__graph.pdf and b/latex/class_model_s_i_r_logit__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_s__coll__graph.pdf b/latex/class_model_s_i_s__coll__graph.pdf index 419a9378..df1739d1 100644 Binary files a/latex/class_model_s_i_s__coll__graph.pdf and b/latex/class_model_s_i_s__coll__graph.pdf differ diff --git a/latex/class_model_s_i_s__inherit__graph.pdf b/latex/class_model_s_i_s__inherit__graph.pdf index 419a9378..df1739d1 100644 Binary files a/latex/class_model_s_i_s__inherit__graph.pdf and b/latex/class_model_s_i_s__inherit__graph.pdf differ diff --git a/latex/class_model_s_i_s_d__coll__graph.pdf b/latex/class_model_s_i_s_d__coll__graph.pdf index b28a6e4b..ca21cc5a 100644 Binary files a/latex/class_model_s_i_s_d__coll__graph.pdf and b/latex/class_model_s_i_s_d__coll__graph.pdf differ diff --git a/latex/class_model_s_i_s_d__inherit__graph.pdf b/latex/class_model_s_i_s_d__inherit__graph.pdf index b28a6e4b..ca21cc5a 100644 Binary files a/latex/class_model_s_i_s_d__inherit__graph.pdf and b/latex/class_model_s_i_s_d__inherit__graph.pdf differ diff --git a/latex/class_model_s_u_r_v__coll__graph.pdf b/latex/class_model_s_u_r_v__coll__graph.pdf index ffef8203..56fa2ede 100644 Binary files a/latex/class_model_s_u_r_v__coll__graph.pdf and b/latex/class_model_s_u_r_v__coll__graph.pdf differ diff --git a/latex/class_model_s_u_r_v__inherit__graph.pdf b/latex/class_model_s_u_r_v__inherit__graph.pdf index ffef8203..56fa2ede 100644 Binary files a/latex/class_model_s_u_r_v__inherit__graph.pdf and b/latex/class_model_s_u_r_v__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1_model__coll__graph.pdf b/latex/classepiworld_1_1_model__coll__graph.pdf index e2ec3f6e..2fd11389 100644 Binary files a/latex/classepiworld_1_1_model__coll__graph.pdf and b/latex/classepiworld_1_1_model__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_diff_net__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_diff_net__coll__graph.pdf index 0da81adb..b4786685 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_diff_net__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_diff_net__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_diff_net__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_diff_net__inherit__graph.pdf index 0da81adb..b4786685 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_diff_net__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_diff_net__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__coll__graph.pdf index cbef10e0..b6c8e3d9 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__inherit__graph.pdf index cbef10e0..b6c8e3d9 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__coll__graph.pdf index 1122f6bb..07bb838c 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__inherit__graph.pdf index 1122f6bb..07bb838c 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__coll__graph.pdf index 869e1b43..40fe41a6 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__inherit__graph.pdf index 869e1b43..40fe41a6 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf index f451ea8b..bfb23339 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf index f451ea8b..bfb23339 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_e_i_r_d_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__coll__graph.pdf index 46fcd496..a49a51b0 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__inherit__graph.pdf index 46fcd496..a49a51b0 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__coll__graph.pdf index 8cc4805e..b3dba5ed 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__inherit__graph.pdf index 8cc4805e..b3dba5ed 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__coll__graph.pdf index 5f6da605..0cc7d3f4 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__inherit__graph.pdf index 5f6da605..0cc7d3f4 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__coll__graph.pdf index 13d70d77..7e0ef982 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__inherit__graph.pdf index 13d70d77..7e0ef982 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_d_c_o_n_n__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__coll__graph.pdf index f765bcdf..27e006b4 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__inherit__graph.pdf index f765bcdf..27e006b4 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_r_logit__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__coll__graph.pdf index 5b7b38b5..fb803b4b 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__inherit__graph.pdf index 5b7b38b5..fb803b4b 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__coll__graph.pdf index e495074b..27496169 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__inherit__graph.pdf index e495074b..27496169 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_i_s_d__inherit__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__coll__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__coll__graph.pdf index 95ea8cb3..22647756 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__coll__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__coll__graph.pdf differ diff --git a/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__inherit__graph.pdf b/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__inherit__graph.pdf index 95ea8cb3..22647756 100644 Binary files a/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__inherit__graph.pdf and b/latex/classepiworld_1_1epimodels_1_1_model_s_u_r_v__inherit__graph.pdf differ diff --git a/latex/refman.log b/latex/refman.log index c5d7c2e3..a3c83b4d 100644 --- a/latex/refman.log +++ b/latex/refman.log @@ -1,4 +1,4 @@ -This is pdfTeX, Version 3.14159265-2.6-1.40.21 (TeX Live 2020/Alpine Linux) (preloaded format=pdflatex 2023.12.1) 1 DEC 2023 15:23 +This is pdfTeX, Version 3.14159265-2.6-1.40.21 (TeX Live 2020/Alpine Linux) (preloaded format=pdflatex 2023.12.6) 6 DEC 2023 20:59 entering extended mode restricted \write18 enabled. %&-line parsing enabled. @@ -3560,7 +3560,7 @@ e1/urw/helvetic/uhvb8a.pfb> -Output written on refman.pdf (206 pages, 972434 bytes). +Output written on refman.pdf (206 pages, 972438 bytes). PDF statistics: 7485 PDF objects out of 8907 (max. 8388607) 6928 compressed objects within 70 object streams diff --git a/latex/refman.pdf b/latex/refman.pdf index c06fdbd4..b3481e1e 100644 Binary files a/latex/refman.pdf and b/latex/refman.pdf differ diff --git a/model-meat-print_8hpp_source.html b/model-meat-print_8hpp_source.html index 617f6de9..21492451 100644 --- a/model-meat-print_8hpp_source.html +++ b/model-meat-print_8hpp_source.html @@ -256,151 +256,159 @@
184 
185  }
186 
-
187  if (viruses.size() == 0u)
-
188  {
-
189  printf_epiworld(" (none)\n");
-
190  }
-
191 
-
192  printf_epiworld("\nTool(s):\n");
-
193  size_t n_tools_model = tools.size();
-
194  for (size_t i = 0u; i < tools.size(); ++i)
-
195  {
-
196 
-
197  if ((n_tools_model > 10) && (i >= 10))
-
198  {
-
199  printf_epiworld(" ...and %li more tools...\n", n_tools_model - i);
-
200  break;
-
201  }
-
202 
-
203  if (i < n_tools_model)
-
204  {
-
205  if (prevalence_tool_as_proportion[i])
-
206  {
-
207 
-
208  printf_epiworld(
-
209  " - %s (baseline prevalence: %.2f%%)\n",
-
210  tools[i]->get_name().c_str(),
-
211  prevalence_tool[i] * 100.0
-
212  );
-
213 
-
214  }
-
215  else
-
216  {
-
217 
-
218  printf_epiworld(
-
219  " - %s (baseline prevalence: %i seeds)\n",
-
220  tools[i]->get_name().c_str(),
-
221  static_cast<int>(prevalence_tool[i])
-
222  );
-
223 
-
224  }
+
187  auto nvariants = db.get_n_viruses() - n_viruses_model;
+
188  if (nvariants > 0)
+
189  {
+
190 
+
191  printf_epiworld(" ...and %li more variants...\n", nvariants);
+
192 
+
193  }
+
194 
+
195  if (viruses.size() == 0u)
+
196  {
+
197  printf_epiworld(" (none)\n");
+
198  }
+
199 
+
200  printf_epiworld("\nTool(s):\n");
+
201  size_t n_tools_model = tools.size();
+
202  for (size_t i = 0u; i < tools.size(); ++i)
+
203  {
+
204 
+
205  if ((n_tools_model > 10) && (i >= 10))
+
206  {
+
207  printf_epiworld(" ...and %li more tools...\n", n_tools_model - i);
+
208  break;
+
209  }
+
210 
+
211  if (i < n_tools_model)
+
212  {
+
213  if (prevalence_tool_as_proportion[i])
+
214  {
+
215 
+
216  printf_epiworld(
+
217  " - %s (baseline prevalence: %.2f%%)\n",
+
218  tools[i]->get_name().c_str(),
+
219  prevalence_tool[i] * 100.0
+
220  );
+
221 
+
222  }
+
223  else
+
224  {
225 
-
226  } else {
-
227 
-
228  printf_epiworld(
-
229  " - %s (originated in the model...)\n",
-
230  tools[i]->get_name().c_str()
-
231  );
-
232 
-
233  }
-
234 
+
226  printf_epiworld(
+
227  " - %s (baseline prevalence: %i seeds)\n",
+
228  tools[i]->get_name().c_str(),
+
229  static_cast<int>(prevalence_tool[i])
+
230  );
+
231 
+
232  }
+
233 
+
234  } else {
235 
-
236  }
-
237 
-
238  if (tools.size() == 0u)
-
239  {
-
240  printf_epiworld(" (none)\n");
-
241  }
-
242 
-
243  // Information about the parameters included
-
244  printf_epiworld("\nModel parameters:\n");
-
245  epiworld_fast_uint nchar = 0u;
-
246  for (auto & p : parameters)
-
247  if (p.first.length() > nchar)
-
248  nchar = p.first.length();
-
249 
-
250  std::string fmt = " - %-" + std::to_string(nchar + 1) + "s: ";
-
251  for (auto & p : parameters)
-
252  {
-
253  std::string fmt_tmp = fmt;
-
254  if (std::fabs(p.second) < 0.0001)
-
255  fmt_tmp += "%.1e\n";
-
256  else
-
257  fmt_tmp += "%.4f\n";
-
258 
-
259  printf_epiworld(
-
260  fmt_tmp.c_str(),
-
261  p.first.c_str(),
-
262  p.second
-
263  );
-
264 
-
265  }
+
236  printf_epiworld(
+
237  " - %s (originated in the model...)\n",
+
238  tools[i]->get_name().c_str()
+
239  );
+
240 
+
241  }
+
242 
+
243 
+
244  }
+
245 
+
246  if (tools.size() == 0u)
+
247  {
+
248  printf_epiworld(" (none)\n");
+
249  }
+
250 
+
251  // Information about the parameters included
+
252  printf_epiworld("\nModel parameters:\n");
+
253  epiworld_fast_uint nchar = 0u;
+
254  for (auto & p : parameters)
+
255  if (p.first.length() > nchar)
+
256  nchar = p.first.length();
+
257 
+
258  std::string fmt = " - %-" + std::to_string(nchar + 1) + "s: ";
+
259  for (auto & p : parameters)
+
260  {
+
261  std::string fmt_tmp = fmt;
+
262  if (std::fabs(p.second) < 0.0001)
+
263  fmt_tmp += "%.1e\n";
+
264  else
+
265  fmt_tmp += "%.4f\n";
266 
-
267  if (parameters.size() == 0u)
-
268  {
-
269  printf_epiworld(" (none)\n");
-
270  }
-
271 
-
272  nchar = 0u;
-
273  for (auto & p : states_labels)
-
274  if (p.length() > nchar)
-
275  nchar = p.length();
-
276 
-
277 
-
278 
-
279  if (today() != 0)
-
280  {
-
281  fmt =
-
282  std::string(" - (%") +
-
283  std::to_string(std::to_string(nstates).length()) +
-
284  std::string("d) %-") + std::to_string(nchar) +
-
285  std::string("s : %") +
-
286  std::to_string(std::to_string(size()).length()) +
-
287  std::string("i -> %i\n");
-
288  } else {
+
267  printf_epiworld(
+
268  fmt_tmp.c_str(),
+
269  p.first.c_str(),
+
270  p.second
+
271  );
+
272 
+
273  }
+
274 
+
275  if (parameters.size() == 0u)
+
276  {
+
277  printf_epiworld(" (none)\n");
+
278  }
+
279 
+
280  nchar = 0u;
+
281  for (auto & p : states_labels)
+
282  if (p.length() > nchar)
+
283  nchar = p.length();
+
284 
+
285 
+
286 
+
287  if (today() != 0)
+
288  {
289  fmt =
290  std::string(" - (%") +
291  std::to_string(std::to_string(nstates).length()) +
292  std::string("d) %-") + std::to_string(nchar) +
-
293  std::string("s : %i\n");
-
294  }
-
295 
-
296  if (today() != 0)
-
297  {
-
298  printf_epiworld("\nDistribution of the population at time %i:\n", today());
-
299  for (size_t s = 0u; s < nstates; ++s)
-
300  {
-
301 
-
302  printf_epiworld(
-
303  fmt.c_str(),
-
304  s,
-
305  states_labels[s].c_str(),
-
306  db.hist_total_counts[s],
-
307  db.today_total[ s ]
-
308  );
+
293  std::string("s : %") +
+
294  std::to_string(std::to_string(size()).length()) +
+
295  std::string("i -> %i\n");
+
296  } else {
+
297  fmt =
+
298  std::string(" - (%") +
+
299  std::to_string(std::to_string(nstates).length()) +
+
300  std::string("d) %-") + std::to_string(nchar) +
+
301  std::string("s : %i\n");
+
302  }
+
303 
+
304  if (today() != 0)
+
305  {
+
306  printf_epiworld("\nDistribution of the population at time %i:\n", today());
+
307  for (size_t s = 0u; s < nstates; ++s)
+
308  {
309 
-
310  }
-
311  // else
-
312  // {
-
313 
-
314  // printf_epiworld(
-
315  // fmt.c_str(),
-
316  // s,
-
317  // states_labels[s].c_str(),
-
318  // db.today_total[ s ]
-
319  // );
-
320 
-
321  // }
-
322  }
-
323 
-
324  if (today() != 0)
-
325  (void) db.transition_probability(true);
-
326 
-
327  return *this;
+
310  printf_epiworld(
+
311  fmt.c_str(),
+
312  s,
+
313  states_labels[s].c_str(),
+
314  db.hist_total_counts[s],
+
315  db.today_total[ s ]
+
316  );
+
317 
+
318  }
+
319  // else
+
320  // {
+
321 
+
322  // printf_epiworld(
+
323  // fmt.c_str(),
+
324  // s,
+
325  // states_labels[s].c_str(),
+
326  // db.today_total[ s ]
+
327  // );
328 
-
329 }
-
330 
-
331 #endif
+
329  // }
+
330  }
+
331 
+
332  if (today() != 0)
+
333  (void) db.transition_probability(true);
+
334 
+
335  return *this;
+
336 
+
337 }
+
338 
+
339 #endif
Model
Core class of epiworld.
Definition: model-bones.hpp:91
diff --git a/seir_8hpp_source.html b/seir_8hpp_source.html index 70834cfe..8a77af1d 100644 --- a/seir_8hpp_source.html +++ b/seir_8hpp_source.html @@ -217,9 +217,9 @@
Model
Core class of epiworld.
Definition: model-bones.hpp:91
ModelSEIR
Template for a Susceptible-Exposed-Infected-Removed (SEIR) model.
Definition: seir.hpp:16
ModelSEIR::initial_states
ModelSEIR< TSeq > & initial_states(std::vector< double > proportions_, std::vector< int > queue_={})
Set up the initial states of the model.
Definition: seir.hpp:147
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/seirconnected_8hpp_source.html b/seirconnected_8hpp_source.html index ac05e5da..32f4d0e4 100644 --- a/seirconnected_8hpp_source.html +++ b/seirconnected_8hpp_source.html @@ -413,10 +413,10 @@
ModelSEIRCONN::clone_ptr
Model< TSeq > * clone_ptr()
Advanced usage: Makes a copy of data and returns it as undeleted pointer.
Definition: seirconnected.hpp:90
ModelSEIRCONN::initial_states
ModelSEIRCONN< TSeq > & initial_states(std::vector< double > proportions_, std::vector< int > queue_={})
Set the initial states of the model.
Definition: seirconnected.hpp:336
ModelSEIRCONN::run
ModelSEIRCONN< TSeq > & run(epiworld_fast_uint ndays, int seed=-1)
Runs the simulation (after initialization)
Definition: seirconnected.hpp:60
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
-
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14088
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
+
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14096
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/seirconnected__logit_8hpp_source.html b/seirconnected__logit_8hpp_source.html index f6a61d8f..ba246ee0 100644 --- a/seirconnected__logit_8hpp_source.html +++ b/seirconnected__logit_8hpp_source.html @@ -394,9 +394,9 @@
332 
333 #endif
ModelSEIRCONNLogit
Definition: seirconnected_logit.hpp:6
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/seird_8hpp_source.html b/seird_8hpp_source.html index dd075bb1..3e67d32b 100644 --- a/seird_8hpp_source.html +++ b/seird_8hpp_source.html @@ -275,11 +275,11 @@
228 #endif
Model
Core class of epiworld.
Definition: model-bones.hpp:91
ModelSEIRD
Template for a Susceptible-Exposed-Infected-Removed-Deceased (SEIRD) model.
Definition: seird.hpp:9
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
-
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14088
-
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14037
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
+
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14096
+
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14045
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/seirdconnected_8hpp_source.html b/seirdconnected_8hpp_source.html index b3bd73b9..957f4f6c 100644 --- a/seirdconnected_8hpp_source.html +++ b/seirdconnected_8hpp_source.html @@ -433,11 +433,11 @@
ModelSEIRDCONN::initial_states
ModelSEIRDCONN< TSeq > & initial_states(std::vector< double > proportions_, std::vector< int > queue_={})
Set up the initial states of the model.
Definition: seirdconnected.hpp:359
ModelSEIRDCONN::run
ModelSEIRDCONN< TSeq > & run(epiworld_fast_uint ndays, int seed=-1)
Runs the simulation (after initialization)
Definition: seirdconnected.hpp:64
ModelSEIRDCONN::reset
void reset()
Reset the model.
Definition: seirdconnected.hpp:77
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
-
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14088
-
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14037
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
+
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14096
+
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14045
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sir_8hpp_source.html b/sir_8hpp_source.html index 0e67aa37..29fd1009 100644 --- a/sir_8hpp_source.html +++ b/sir_8hpp_source.html @@ -176,7 +176,7 @@
ModelSIR
Template for a Susceptible-Infected-Removed (SIR) model.
Definition: sir.hpp:15
ModelSIR::initial_states
ModelSIR< TSeq > & initial_states(std::vector< double > proportions_, std::vector< int > queue_={})
Set the initial states of the model.
Definition: sir.hpp:103
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sirconnected_8hpp_source.html b/sirconnected_8hpp_source.html index 40dc8d34..fa6185ef 100644 --- a/sirconnected_8hpp_source.html +++ b/sirconnected_8hpp_source.html @@ -383,10 +383,10 @@
ModelSIRCONN::clone_ptr
Model< TSeq > * clone_ptr()
Advanced usage: Makes a copy of data and returns it as undeleted pointer.
Definition: sirconnected.hpp:79
ModelSIRCONN::initial_states
ModelSIRCONN< TSeq > & initial_states(std::vector< double > proportions_, std::vector< int > queue_={})
Set the initial states of the model.
Definition: sirconnected.hpp:306
ModelSIRCONN::reset
void reset()
Reset the model.
Definition: sirconnected.hpp:70
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
-
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14088
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
+
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14096
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sird_8hpp_source.html b/sird_8hpp_source.html index 61e22c89..03d612e2 100644 --- a/sird_8hpp_source.html +++ b/sird_8hpp_source.html @@ -185,7 +185,7 @@
ModelSIRD
Template for a Susceptible-Infected-Removed-Deceased (SIRD) model.
Definition: sird.hpp:9
ModelSIRD::initial_states
ModelSIRD< TSeq > & initial_states(std::vector< double > proportions_, std::vector< int > queue_={})
Set the initial states of the model.
Definition: sird.hpp:119
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sirdconnected_8hpp_source.html b/sirdconnected_8hpp_source.html index 276afa47..a813f80d 100644 --- a/sirdconnected_8hpp_source.html +++ b/sirdconnected_8hpp_source.html @@ -405,11 +405,11 @@
ModelSIRDCONN::clone_ptr
Model< TSeq > * clone_ptr()
Advanced usage: Makes a copy of data and returns it as undeleted pointer.
Definition: sirdconnected.hpp:94
ModelSIRDCONN::reset
void reset()
Reset the model.
Definition: sirdconnected.hpp:77
ModelSIRDCONN::run
ModelSIRDCONN< TSeq > & run(epiworld_fast_uint ndays, int seed=-1)
Runs the simulation (after initialization)
Definition: sirdconnected.hpp:64
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
-
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14088
-
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14037
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
+
epiworld::Agent::get_id
int get_id() const
Id of the individual.
Definition: epiworld.hpp:14096
+
epiworld::Agent::rm_agent_by_virus
void rm_agent_by_virus(Model< TSeq > *model, epiworld_fast_int state_new=-99, epiworld_fast_int queue=-99)
Agent removed by virus.
Definition: epiworld.hpp:14045
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sirlogit_8hpp_source.html b/sirlogit_8hpp_source.html index cd9b7a26..b877b216 100644 --- a/sirlogit_8hpp_source.html +++ b/sirlogit_8hpp_source.html @@ -386,9 +386,9 @@
ModelSIRLogit::clone_ptr
Model< TSeq > * clone_ptr()
Advanced usage: Makes a copy of data and returns it as undeleted pointer.
Definition: sirlogit.hpp:85
ModelSIRLogit::reset
void reset()
Reset the model.
Definition: sirlogit.hpp:97
ModelSIRLogit::run
ModelSIRLogit< TSeq > & run(epiworld_fast_uint ndays, int seed=-1)
Runs the simulation (after initialization)
Definition: sirlogit.hpp:73
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sis_8hpp_source.html b/sis_8hpp_source.html index 3dca3647..582aead4 100644 --- a/sis_8hpp_source.html +++ b/sis_8hpp_source.html @@ -159,7 +159,7 @@
95 #endif
ModelSIS
Template for a Susceptible-Infected-Susceptible (SIS) model.
Definition: sis.hpp:14
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/sisd_8hpp_source.html b/sisd_8hpp_source.html index 48012666..82ee4d04 100644 --- a/sisd_8hpp_source.html +++ b/sisd_8hpp_source.html @@ -163,7 +163,7 @@
100 #endif
ModelSISD
Template for a Susceptible-Infected-Susceptible-Deceased (SISD) model.
Definition: sisd.hpp:15
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159
diff --git a/surveillance_8hpp_source.html b/surveillance_8hpp_source.html index 934ce59e..4a2c6c0d 100644 --- a/surveillance_8hpp_source.html +++ b/surveillance_8hpp_source.html @@ -419,10 +419,10 @@
389 
390 #endif
ModelSURV
Definition: surveillance.hpp:5
-
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13091
+
epiworld::Agent
Agent (agents)
Definition: epiworld.hpp:13099
epiworld::Model
Core class of epiworld.
Definition: epiworld.hpp:6053
-
epiworld::Tool
Tools for defending the agent against the virus.
Definition: epiworld.hpp:11266
-
epiworld::Virus
Virus.
Definition: epiworld.hpp:10151
+
epiworld::Tool
Tools for defending the agent against the virus.
Definition: epiworld.hpp:11274
+
epiworld::Virus
Virus.
Definition: epiworld.hpp:10159