|
Microsimulation API
|
#include <RcppCommon.h>#include <boost/tuple/tuple.hpp>#include <boost/tuple/tuple_comparison.hpp>#include <boost/unordered_map.hpp>#include <vector>#include <utility>#include <map>#include <string>#include <Rcpp.h>#include <R.h>#include <Rmath.h>#include <Rdefines.h>#include <R_ext/Random.h>#include <siena/ssim.h>#include <RngStream.h>#include <rcpp_table.h>#include <algorithm>#include <functional>#include <set>#include <boost/bind.hpp>#include <boost/functional.hpp>

Go to the source code of this file.
Classes | |
| struct | boost::tuples::detail::HashValueImpl< Tuple, Index > |
| struct | boost::tuples::detail::HashValueImpl< Tuple, 0 > |
| class | ssim::cMessage |
| cMessage class for OMNET++ API compatibility. This provides a heavier message class than Sim::Event, with short 'kind' and std::string 'name' attributes. The events by default are scheduled using cProcess::scheduleAt(), and handled using cProcess::handleMessage() (as per OMNET++). NB: cProcess::scheduleAt() uses simulation time rather than time in state (which is used by Sim::self_signal_event()). More... | |
| class | ssim::cProcess |
| cProcess class for OMNET++ API compatibility. This provides a default for Process::process_event() that calls cProcess::handleMessage(). This class also provides scheduleAt() methods for insert cMessages into the process event queue. More... | |
| class | ssim::Means |
| Utility class to incrementally add values to calculate the mean, sum, variance and standard deviation. This could be replaced by boost::accumulator. More... | |
| class | ssim::Rpexp |
| Rpexp is a random number generator class for piecewise constant hazards. Given time lower bounds t and piecewise constant hazards h, rand() returns a random time. The random number is calculated using the inversion formula. Constructors provided for arrays. More... | |
| class | ssim::Rng |
| class | ssim::EventReport< State, Event, Time, Utility > |
| EventReport class for collecting statistics on person-time, prevalence and numbers of events. More... | |
| class | ssim::SummaryReport< State, Event, Time, Utility, Cost > |
| SummaryReport class for collecting statistics on person-time, prevalence, events and costs. More... | |
| class | ssim::CostReport< State, Time, Cost > |
| CostReport class for collecting statistics on costs. More... | |
| class | ssim::SimpleReport< T > |
| SimpleReport class for collecting data for homogeneous fields of type T with string names. More... | |
Namespaces | |
| boost | |
| boost::tuples | |
| boost::tuples::detail | |
| Rcpp | |
| ssim | |
| name space for the Siena simulator. | |
| R | |
Macros | |
| #define | WithRNG(rng, expr) (rng->set(), expr) |
| WithRNG is a macro for using the random number generator rng and then evaluating the expression expr. More... | |
Typedefs | |
| typedef Time | ssim::simtime_t |
| simtime_t typedef for OMNET++ API compatibility More... | |
Functions | |
| template<class Tuple > | |
| size_t | boost::tuples::hash_value (Tuple const &tuple) |
| template<class T1 , class T2 > | |
| SEXP | Rcpp::wrap (const std::vector< std::pair< T1, T2 > > v) |
| template<class T1 , class T2 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2 > > v) |
| template<class T1 , class T2 , class T3 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3 > > v) |
| template<class T1 , class T2 , class T3 , class T4 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4, T5 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4, T5, T6 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4, T5, T6, T7 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4, T5, T6, T7, T8 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 > | |
| SEXP | Rcpp::wrap (const std::vector< boost::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 > > v) |
| template<class T1 , class T2 > | |
| SEXP | Rcpp::wrap_map (const std::map< T1, T2 > v) |
| template<class T1a , class T1b , class T2 > | |
| SEXP | Rcpp::wrap_map (const std::map< std::pair< T1a, T1b >, T2 > v, std::string key, std::string name1, std::string name2) |
| template<class T1a , class T1b , class T1c , class T2 > | |
| SEXP | Rcpp::wrap_map (const std::map< boost::tuple< T1a, T1b, T1c >, T2 > v, std::string key, std::string name1, std::string name2, std::string name3) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 > | |
| SEXP | Rcpp::wrap_map (const std::map< std::pair< boost::tuple< T1, T2, T3 >, T4 >, T5 > v, std::string key, std::string name1, std::string name2) |
| template<class T1 , class T2 > | |
| SEXP | Rcpp::wrap_map (const boost::unordered_map< T1, T2 > v) |
| template<class T1a , class T1b , class T2 > | |
| SEXP | Rcpp::wrap_map (const boost::unordered_map< std::pair< T1a, T1b >, T2 > v, std::string key, std::string name1, std::string name2) |
| template<class T1a , class T1b , class T1c , class T2 > | |
| SEXP | Rcpp::wrap_map (const boost::unordered_map< boost::tuple< T1a, T1b, T1c >, T2 > v, std::string key, std::string name1, std::string name2, std::string name3) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 > | |
| SEXP | Rcpp::wrap_map (const boost::unordered_map< std::pair< boost::tuple< T1, T2, T3 >, T4 >, T5 > v, std::string key, std::string name1, std::string name2) |
| bool | ssim::cMessagePred (const ssim::Event *e, boost::function< bool(const cMessage *msg)> pred) |
| bool | ssim::cMessageNamePred (const ssim::Event *e, const string s) |
| bool | ssim::cMessageKindPred (const ssim::Event *e, const short k) |
| void | ssim::RemoveKind (short kind) |
| RemoveKind is a function to remove messages with the given kind from the queue (NB: void) More... | |
| void | ssim::RemoveName (string name) |
| RemoveName is a function to remove messages with the given name from the queue (NB: void) More... | |
| Time | ssim::simTime () |
| simTime() function for OMNET++ API compatibility More... | |
| Time | ssim::now () |
| now() function for compatibility with C++SIM More... | |
| double | ssim::rweibullHR (double shape, double scale, double hr) |
| Random Weibull distribution for a given shape, scale and hazard ratio. More... | |
| void | ssim::r_create_current_stream () |
| A utility function to create the current_stream. Used when initialising the microsimulation package in R. More... | |
| void | ssim::r_remove_current_stream () |
| A utility function to remove the current_stream. Used when finalising the microsimulation package in R. More... | |
| void | ssim::r_set_user_random_seed (double *seed) |
| A utility function to set the user random seed for the simulation. More... | |
| void | ssim::r_get_user_random_seed (double *seed) |
| A utility function to set the user random seed for the simulation. More... | |
| void | ssim::r_next_rng_substream () |
| A utility function to move to the next user random stream for the simulation. More... | |
| void | ssim::r_rng_advance_substream (double *seed, int *n) |
| A utility function to advance the random sub-stream n steps for a specified seed. More... | |
| void | ssim::test_rstream2 (double *x) |
| Simple test of the random streams (with a stupid name) More... | |
| double | ssim::discountedInterval (double start, double end, double discountRate) |
| Simple function to calculate the integral between the start and end times for (1+kappa)^(-u), where kappa is the discountRate (e.g. 0.03) More... | |
| template<class T > | |
| std::vector< std::vector< T > > | ssim::transpose (const std::vector< std::vector< T > > data) |
| Function to transpose a vector of vectors. This assumes that all inner vectors have the same size and allocates space for the complete result in advance. From http://stackoverflow.com/questions/6009782/how-to-pivot-a-vector-of-vectors. More... | |
| template<class T1 , class T2 > | |
| SEXP | Rcpp::wrap (const vector< pair< T1, T2 > > v) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 > | |
| SEXP | Rcpp::wrap_map (const std::map< std::pair< boost::tuple< T1, T2, T3 >, T4 >, T5 > v, std::string name1, std::string name2) |
| template<class T1 , class T2 , class T3 , class T4 , class T5 > | |
| SEXP | Rcpp::wrap_map (const boost::unordered_map< std::pair< boost::tuple< T1, T2, T3 >, T4 >, T5 > ov, std::string name1, std::string name2) |
| double | R::rnormPos (double mean, double sd) |
| rnorm function constrained to be positive. This uses brute-force re-sampling rather than conditioning on the distribution function. More... | |
| double | R::rllogis (double shape, double scale) |
| rllogis function for a random covariate from a log-logistic distribution with shape and scale. S(t) = 1/(1+(t/scale)^shape). More... | |
| double | R::rllogis_trunc (double shape, double scale, double left) |
| rllogis_trunc function for a random covariate from a log-logistic distribution with shape and scale with minimum time left. S(t|t>x)=S(t)/S(x) where S(t)=1/(1+(t/scale)^shape). More... | |
Variables | |
| static int | ssim::counter_id = 0 |
| C++ wrapper class for the RngStream library. set() sets the current R random number stream to this stream. This is compliant with being a Boost random number generator. More... | |
This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details at http://www.gnu.org/copyleft/gpl.html
cMessage and cProcess classes, providing some compatability between SSIM and the OMNET++ API. This is specialised for use as an R package.
It also provides several utility classes: Means for statistical collection and Rpexp for piecewise constant exponential random number generation. It also provides a utility function rweibullHR().
Definition in file microsimulation.h.
| #define WithRNG | ( | rng, | |
| expr | |||
| ) | (rng->set(), expr) |
WithRNG is a macro for using the random number generator rng and then evaluating the expression expr.
Definition at line 180 of file microsimulation.h.
1.8.17