30 #ifndef MICROSIMULATION_H
31 #define MICROSIMULATION_H
33 #include <RcppCommon.h>
34 #include <unordered_map>
53 inline void hash_combine(std::size_t& seed, T
const& v)
55 seed ^= std::hash<T>()(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
58 template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
61 static void apply(
size_t& seed, Tuple
const& tuple)
63 HashValueImpl<Tuple, Index-1>::apply(seed, tuple);
64 hash_combine(seed, std::get<Index>(tuple));
67 template <
class Tuple>
68 struct HashValueImpl<Tuple,0>
70 static void apply(
size_t& seed, Tuple
const& tuple)
72 hash_combine(seed, std::get<0>(tuple));
76 template <
typename ... TT>
77 struct hash<std::tuple<TT...>>
83 HashValueImpl<std::tuple<TT...> >::apply(seed, tt);
87 template <
typename T1,
typename T2>
88 struct hash<std::pair<T1,T2>>
94 hash_combine(seed, p.first);
95 hash_combine(seed, p.second);
104 template <
class T1,
class T2>
105 SEXP
wrap(
const std::vector<std::pair<T1,T2> > v);
108 template <
class T1,
class T2>
109 SEXP
wrap(
const std::vector<std::tuple<T1,T2> > v);
111 template <
class T1,
class T2,
class T3>
112 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3> > v);
114 template <
class T1,
class T2,
class T3,
class T4>
115 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4> > v);
117 template <
class T1,
class T2,
class T3,
class T4,
class T5>
118 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4,T5> > v);
120 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6>
121 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4,T5,T6> > v);
123 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7>
124 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4,T5,T6,T7> > v);
126 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8>
127 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8> > v);
129 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9>
130 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> > v);
132 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10>
133 SEXP
wrap(
const std::vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> > v);
136 template <
class T1,
class T2>
137 SEXP
wrap_map(
const std::map<T1,T2> v);
139 template <
class T1a,
class T1b,
class T2>
140 SEXP
wrap_map(
const std::map<std::pair<T1a,T1b>,T2> v,
141 std::string key, std::string name1, std::string name2);
143 template <
class T1a,
class T1b,
class T1c,
class T2>
144 SEXP
wrap_map(
const std::map<std::tuple<T1a,T1b,T1c>,T2> v,
145 std::string key, std::string name1, std::string name2, std::string name3);
147 template <
class T1,
class T2,
class T3,
class T4,
class T5>
148 SEXP
wrap_map(
const std::map<std::pair<std::tuple<T1,T2,T3>,T4>,T5> v,
149 std::string key, std::string name1, std::string name2);
152 template <
class T1,
class T2>
153 SEXP
wrap_map(
const std::unordered_map<T1,T2> v);
155 template <
class T1a,
class T1b,
class T2>
156 SEXP
wrap_map(
const std::unordered_map<std::pair<T1a,T1b>,T2> v,
157 std::string key, std::string name1, std::string name2);
159 template <
class T1a,
class T1b,
class T1c,
class T2>
160 SEXP
wrap_map(
const std::unordered_map<std::tuple<T1a,T1b,T1c>,T2> v,
161 std::string key, std::string name1, std::string name2, std::string name3);
163 template <
class T1,
class T2,
class T3,
class T4,
class T5>
164 SEXP
wrap_map(
const std::unordered_map<std::pair<std::tuple<T1,T2,T3>,T4>,T5> v,
165 std::string key, std::string name1, std::string name2);
173 #include <Rdefines.h>
174 #include <R_ext/Random.h>
182 #include <functional>
200 #define WithRNG(rng,expr) (rng->set(), expr)
227 std::ostringstream stringStream;
228 stringStream <<
"kind=";
229 stringStream <<
kind;
230 stringStream <<
",name=";
231 stringStream <<
name;
232 string str = stringStream.str();
247 return (msg != 0 && pred(msg));
325 virtual void init() = 0;
386 return msg->
kind == kind &&
395 return msg->
name == name &&
426 if ((msg =
dynamic_cast<const cMessage *
>(e)) != 0) {
431 REprintf(
"cProcess is only written to receive cMessage events\n");
465 _sum += (
long double) value;
466 _sumsq += (
long double)value * (
long double)value;
470 return Rcpp::DataFrame::create(_(
"n")=
n(),
474 _(
"se")=
sd()/sqrt(
n()),
494 Rpexp(
double *hin,
double *tin,
int nin) :
n(nin) {
499 H[0]=0.0;
h[0]=hin[0];
t[0]=tin[0];
502 h[i]=hin[i];
t[i]=tin[i];
503 H[i] =
H[i-1]+(
t[i]-
t[i-1])*
h[i-1];
517 double rand(
double u,
double from = 0.0) {
518 double v = 0.0, H0 = 0.0, tstar = 0.0;
521 i0 = (from >=
t[
n-1]) ? (
n-1) : int(lower_bound(
t.begin(),
t.end(), from) -
t.begin())-1;
522 H0 =
H[i0] + (from -
t[i0])*
h[i0];
525 i = (v >=
H[
n-1]) ? (
n-1) : int(lower_bound(
H.begin(),
H.end(), v) -
H.begin())-1;
526 tstar =
t[i]+(v-
H[i])/
h[i];
539 double rweibullHR(
double shape,
double scale,
double hr);
617 if (discountRate == 0.0)
return end - start;
618 else return (pow(1.0+discountRate,-start) - pow(1.0+discountRate,-end)) / log(1.0+discountRate);
626 if (discountRate == 0.0)
return y*(end - start);
627 else return y*(pow(1.0+discountRate,-start) - pow(1.0+discountRate,-end)) / log(1.0+discountRate);
634 return discountRate <= 0.0 ? 1.0 : pow(1.0+discountRate,-time);
640 return discountRate <= 0.0 ? y : y*pow(1.0+discountRate,-time);
651 std::vector<std::vector<T> >
transpose(
const std::vector<std::vector<T> > data) {
652 std::vector<std::vector<T> > result(data[0].size(),
653 std::vector<T>(data.size()));
654 for (
typename std::vector<T>::size_type i = 0; i < data[0].size(); i++)
655 for (
typename std::vector<T>::size_type j = 0; j < data.size(); j++) {
656 result[i][j] = data[j][i];
665 template<
class State,
class Event,
class Time =
double,
class Utility =
double>
670 typedef std::pair<State,Time>
Pair;
671 typedef std::unordered_map<pair<State,Time>,
int >
PrevMap;
672 typedef std::unordered_map<pair<State,Time>, Utility >
UtilityMap;
673 typedef std::unordered_map<pair<State,Time>,
Time >
PtMap;
674 typedef std::unordered_map<std::tuple<State,Event,Time>,
int >
EventsMap;
688 const Time delta = 1.0,
689 const Time maxTime =
Time(1.0e100)) {
715 REprintf(
"Vector too small in EventReport: use resize(int) method");
724 else if (a==b)
return 0.0;
727 return utility/alpha*(exp(-a*alpha) - exp(-b*alpha));
730 REprintf(
"discountRate less than zero.");
738 void add(
const State state,
const Event event,
const Time lhs,
const Time rhs,
const Utility utility = 1,
int index = 0 ) {
744 ++
_events[std::make_tuple(state,event,*hi)];
746 for(
it = lo, iterating =
true; iterating; iterating = (
it != hi), --
it) {
747 if (lhs<=(*
it) && (*it)<rhs)
754 _pt[
Pair(state,*
it)] += rhs - std::max<Time>(lhs,*
it);
762 _pt[
Pair(state,*
it)] += std::min<Time>(rhs,next_value) - std::max<Time>(lhs,*
it);
768 typename T::iterator
it;
769 for (
it = new_map.begin();
it != new_map.end(); ++
it)
770 base_map[
it->first] +=
it->second;
775 append_map<PtMap>(
_pt,er.
_pt);
776 append_map<UtilityMap>(
_ut,er.
_ut);
780 using namespace Rcpp;
781 if (
_events.size() == 0)
return List::create();
783 return List::create(_(
"pt") = wrap_map<State,Time,Time>(
_pt,
"Key",
"age",
"pt"),
784 _(
"ut") = wrap_map<State,Time,Utility>(
_ut,
"Key",
"age",
"utility"),
785 _(
"events") = wrap_map<State,Event,Time,int>(
_events,
"Key",
"event",
"age",
"number"),
786 _(
"prev") = wrap_map<State,Time,int>(
_prev,
"Key",
"age",
"number"));
788 return List::create(_(
"pt") = wrap_map<State,Time,Time>(
_pt,
"Key",
"age",
"pt"),
789 _(
"events") = wrap_map<State,Event,Time,int>(
_events,
"Key",
"event",
"age",
"number"),
790 _(
"prev") = wrap_map<State,Time,int>(
_prev,
"Key",
"age",
"number"));
815 template<
class State,
class Event =
short,
class Time =
double,
class Utility =
double,
class Cost =
double>
820 typedef std::pair<State,Time>
Pair;
821 typedef std::unordered_map<pair<State,Time>,
int >
PrevMap;
822 typedef std::unordered_map<pair<State,Time>, Utility >
UtilityMap;
823 typedef std::unordered_map<pair<State,Time>,
Time >
PtMap;
824 typedef std::unordered_map<std::tuple<State,Event,Time>,
int >
EventMap;
825 typedef std::unordered_map<pair<State,Time>, Cost >
CostMap;
835 _indivUtilities.resize(size);
836 _indivCosts.resize(size);
844 utilityAlpha = log(1.0+utilityDiscountRate);
848 costAlpha = log(1.0+costDiscountRate);
854 const Time maxTime =
Time(1.0e100)) {
860 this->utility = _utility;
872 _indivUtilities.clear();
875 void add(
const State state,
const Event event,
const Time lhs,
const Time rhs,
int index = 0) {
878 if (!indivp) index = 0;
883 ++
_events[std::make_tuple(state,event,*hi)];
885 for(
it = lo, iterating =
true; iterating; iterating = (
it != hi), --
it) {
886 if (lhs<=(*
it) && (*it)<rhs)
889 Utility u = discountedUtilityInterval(std::max<Time>(lhs,*
it), rhs, utility);
891 _indivUtilities[index] += u;
892 Cost c = discountedCostInterval(std::max<Time>(lhs,*
it), rhs, cost);
893 _costs[
Pair(state,*
it)] += c;
894 _indivCosts[index] += c;
895 _pt[
Pair(state,*
it)] += rhs - std::max<Time>(lhs,*
it);
899 Utility u = discountedUtilityInterval(std::max<Time>(lhs,*
it), std::min<Time>(rhs,next_value), utility);
901 _indivUtilities[index] += u;
902 Cost c = discountedCostInterval(std::max<Time>(lhs,*
it), std::min<Time>(rhs,next_value), cost);
903 _costs[
Pair(state,*
it)] += c;
904 _indivCosts[index] += c;
905 _pt[
Pair(state,*
it)] += std::min<Time>(rhs,next_value) - std::max<Time>(lhs,*
it);
911 if (!indivp) index = 0;
914 Cost c = discountedCost(time,cost);
915 _costs[
Pair(state,time_lhs)] += c;
916 _indivCosts[index] += c;
921 append_map<PtMap>(
_pt,er.
_pt);
922 append_map<UtilityMap>(
_ut,er.
_ut);
923 append_map<CostMap>(_costs,er.
_costs);
928 using namespace Rcpp;
929 if (
_events.size() == 0)
return List::create();
930 Rcpp::DataFrame
indiv =
931 Rcpp::DataFrame::create(_(
"utilities")=_indivUtilities,
932 _(
"costs")=_indivCosts);
933 Rcpp::List out = List::create(_(
"pt") = wrap_map<State,Time,Time>(
_pt,
"Key",
"age",
"pt"),
934 _(
"ut") = wrap_map<State,Time,Utility>(
_ut,
"Key",
"age",
"utility"),
935 _(
"events") = wrap_map<State,Event,Time,int>(
_events,
"Key",
"event",
"age",
"number"),
936 _(
"prev") = wrap_map<State,Time,int>(
_prev,
"Key",
"age",
"number"),
937 _(
"costs") = wrap_map<State,Time,Cost>(_costs,
"Key",
"age",
"cost"),
940 _(
"utilityDiscountRate")=utilityDiscountRate,
941 _(
"costDiscountRate")=costDiscountRate,
943 out.attr(
"class")=
"SummaryReport";
947 if (a == b || utility == 0.0)
return 0.0;
948 else if (utilityDiscountRate == 0.0)
return utility * (b-a);
949 else if (utilityDiscountRate>0.0) {
950 return utility/utilityAlpha*(exp(-a*utilityAlpha) - exp(-b*utilityAlpha));
953 REprintf(
"utilityDiscountRate less than zero: %f.\n", utilityDiscountRate);
958 if (a == b || cost == 0.0)
return 0.0;
959 else if (costDiscountRate == 0.0)
return cost * (b-a);
960 else if (costDiscountRate>0.0) {
961 return cost/costAlpha*(exp(-a*costAlpha) - exp(-b*costAlpha));
964 REprintf(
"costDiscountRate less than zero: %f.\n", costDiscountRate);
969 if (cost == 0.0)
return 0.0;
970 else if (costDiscountRate == 0.0)
return cost;
971 else if (costDiscountRate>0)
972 return cost*exp(-a*costAlpha);
974 REprintf(
"costDiscountRate less than zero: %f.\n", costDiscountRate);
980 typename T::iterator
it;
981 for (
it = new_map.begin();
it != new_map.end(); ++
it)
982 base_map[
it->first] +=
it->second;
1002 template<
class State,
class Time =
double,
class Cost =
double>
1006 typedef std::pair<State,Time>
Pair;
1008 typedef std::unordered_map<pair<State,Time>, Cost >
Table;
1015 mean_costs += double(
current);
1018 REprintf(
"Vector too small in CostReport: use resize(int) method");
1037 REprintf(
"discountRate less than zero.");
1045 const Time maxTime =
Time(1.0e100)) {
1060 typename Table::iterator
it;
1063 _table[
it->first] +=
it->second;
1066 void add(
const State state,
const Time time,
const Cost cost,
const int index = 0 ) {
1068 Cost c = discountedCost(time,cost);
1069 _table[
Pair(state,time_lhs)] += c;
1083 return mean_costs.wrap();
1098 template<
class T =
double>
1104 typedef map<string,vector<T> >
Map;
1109 _data[field].push_back(value);
1116 if (!_data[field].empty())
1117 _data[field].pop_back();
1118 _data[field].push_back(value);
1134 for(
typename Map::iterator
it = obj.
_data.begin();
it != obj.
_data.end(); ++
it) {
1135 _data[
it->first].insert(_data[
it->first].end(),
it->second.begin(),
it->second.end());
1148 template <
class T1,
class T2>
1149 SEXP
wrap(
const vector<pair<T1,T2> > v) {
1152 typename vector<pair<T1,T2> >::const_iterator
it;
1153 for (
it=v.begin();
it<v.end(); ++
it) {
1154 v1.push_back(
it->first);
1155 v2.push_back(
it->second);
1157 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2));
1160 template <
class T1,
class T2>
1161 SEXP
wrap(
const vector<std::tuple<T1,T2> > v) {
1165 typename vector<std::tuple<T1,T2> >::const_iterator
it;
1166 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1167 v1[i] = std::get<0>(*
it);
1168 v2[i] = std::get<1>(*
it);
1170 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2));
1173 template <
class T1,
class T2,
class T3>
1174 SEXP
wrap(
const vector<std::tuple<T1,T2,T3> > v) {
1179 typename vector<std::tuple<T1,T2,T3> >::const_iterator
it;
1180 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1181 v1[i] = std::get<0>(*
it);
1182 v2[i] = std::get<1>(*
it);
1183 v3[i] = std::get<2>(*
it);
1185 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),_(
"Var3")=
wrap(v3));
1189 template <
class T1,
class T2,
class T3,
class T4>
1190 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4> > v) {
1196 typename vector<std::tuple<T1,T2,T3,T4> >::const_iterator
it;
1197 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1198 v1[i] = std::get<0>(*
it);
1199 v2[i] = std::get<1>(*
it);
1200 v3[i] = std::get<2>(*
it);
1201 v4[i] = std::get<3>(*
it);
1203 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1204 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4));
1207 template <
class T1,
class T2,
class T3,
class T4,
class T5>
1208 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4,T5> > v) {
1215 typename vector<std::tuple<T1,T2,T3,T4,T5> >::const_iterator
it;
1216 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1217 v1[i] = std::get<0>(*
it);
1218 v2[i] = std::get<1>(*
it);
1219 v3[i] = std::get<2>(*
it);
1220 v4[i] = std::get<3>(*
it);
1221 v5[i] = std::get<4>(*
it);
1223 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1224 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1225 _(
"Var5")=
wrap(v5));
1228 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6>
1229 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4,T5,T6> > v) {
1237 typename vector<std::tuple<T1,T2,T3,T4,T5,T6> >::const_iterator
it;
1238 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1239 v1[i] = std::get<0>(*
it);
1240 v2[i] = std::get<1>(*
it);
1241 v3[i] = std::get<2>(*
it);
1242 v4[i] = std::get<3>(*
it);
1243 v5[i] = std::get<4>(*
it);
1244 v6[i] = std::get<5>(*
it);
1246 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1247 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1248 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6));
1251 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7>
1252 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4,T5,T6,T7> > v) {
1261 typename vector<std::tuple<T1,T2,T3,T4,T5,T6,T7> >::const_iterator
it;
1262 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1263 v1[i] = std::get<0>(*
it);
1264 v2[i] = std::get<1>(*
it);
1265 v3[i] = std::get<2>(*
it);
1266 v4[i] = std::get<3>(*
it);
1267 v5[i] = std::get<4>(*
it);
1268 v6[i] = std::get<5>(*
it);
1269 v7[i] = std::get<6>(*
it);
1271 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1272 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1273 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1274 _(
"Var7")=
wrap(v7));
1277 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8>
1278 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8> > v) {
1288 typename vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >::const_iterator
it;
1289 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1290 v1[i] = std::get<0>(*
it);
1291 v2[i] = std::get<1>(*
it);
1292 v3[i] = std::get<2>(*
it);
1293 v4[i] = std::get<3>(*
it);
1294 v5[i] = std::get<4>(*
it);
1295 v6[i] = std::get<5>(*
it);
1296 v7[i] = std::get<6>(*
it);
1297 v8[i] = std::get<7>(*
it);
1299 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1300 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1301 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1302 _(
"Var7")=
wrap(v7),_(
"Var8")=
wrap(v8));
1305 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9>
1306 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> > v) {
1317 typename vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::const_iterator
it;
1318 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1319 v1[i] = std::get<0>(*
it);
1320 v2[i] = std::get<1>(*
it);
1321 v3[i] = std::get<2>(*
it);
1322 v4[i] = std::get<3>(*
it);
1323 v5[i] = std::get<4>(*
it);
1324 v6[i] = std::get<5>(*
it);
1325 v7[i] = std::get<6>(*
it);
1326 v8[i] = std::get<7>(*
it);
1327 v9[i] = std::get<8>(*
it);
1329 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1330 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1331 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1332 _(
"Var7")=
wrap(v7),_(
"Var8")=
wrap(v8),
1333 _(
"Var9")=
wrap(v9));
1336 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10>
1337 SEXP
wrap(
const vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> > v) {
1349 typename vector<std::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::const_iterator
it;
1350 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1351 v1[i] = std::get<0>(*
it);
1352 v2[i] = std::get<1>(*
it);
1353 v3[i] = std::get<2>(*
it);
1354 v4[i] = std::get<3>(*
it);
1355 v5[i] = std::get<4>(*
it);
1356 v6[i] = std::get<5>(*
it);
1357 v7[i] = std::get<6>(*
it);
1358 v8[i] = std::get<7>(*
it);
1359 v9[i] = std::get<8>(*
it);
1360 v10[i] = std::get<9>(*
it);
1362 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1363 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1364 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1365 _(
"Var7")=
wrap(v7),_(
"Var8")=
wrap(v8),
1366 _(
"Var9")=
wrap(v9),_(
"Var10")=
wrap(v10));
1370 template <
class T1,
class T2>
1376 typename std::map<T1,T2>::const_iterator
it;
1377 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1379 y[i] = (*it).second;
1381 return DataFrame::create(_(
"Key")=
wrap(x),_(
"Value")=
wrap(y));
1390 template <
class T1a,
class T1b,
class T1c,
class T2>
1391 SEXP
wrap_map(
const std::map<std::tuple<T1a,T1b,T1c>,T2> v,
1392 std::string key, std::string name1, std::string name2, std::string name3) {
1393 typedef std::tuple<T1a,T1b,T1c> Tuple;
1400 typename std::map<Tuple,T2>::const_iterator
it;
1401 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1402 xa[i] = get<0>((*it).first);
1403 xb[i] = get<1>((*it).first);
1404 xc[i] = get<2>((*it).first);
1405 y[i] = (*it).second;
1412 template <
class T1a,
class T1b,
class T2>
1414 std::string key, std::string name1, std::string name2) {
1415 typedef std::pair<T1a,T1b>
Pair;
1421 typename std::map<Pair,T2>::const_iterator
it;
1422 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1423 xa[i] = (*it).first.first;
1424 xb[i] = (*it).first.second;
1425 y[i] = (*it).second;
1432 template <
class T1,
class T2>
1434 std::map<T1,T2> v(ov.begin(), ov.end());
1435 return wrap_map<T1,T2>(v);
1438 template <
class T1a,
class T1b,
class T1c,
class T2>
1439 SEXP
wrap_map(
const std::unordered_map<std::tuple<T1a,T1b,T1c>,T2> ov,
1440 std::string key, std::string name1, std::string name2, std::string name3) {
1441 std::map<std::tuple<T1a,T1b,T1c>,T2> v(ov.begin(), ov.end());
1442 return wrap_map<T1a, T1b, T1c, T2>(v, key, name1, name2, name3);
1445 template <
class T1a,
class T1b,
class T2>
1446 SEXP
wrap_map(
const std::unordered_map<std::pair<T1a,T1b>,T2> ov,
1447 std::string key, std::string name1, std::string name2) {
1448 std::map<std::pair<T1a,T1b>,T2> v(ov.begin(), ov.end());
1449 return wrap_map<T1a, T1b, T2>(v, key, name1, name2);
1452 template <
class T1,
class T2,
class T3,
class T4,
class T5>
1453 SEXP
wrap_map(
const std::map<std::pair<std::tuple<T1,T2,T3>,T4>,T5> v,
1454 std::string name1, std::string name2) {
1455 typedef std::tuple<T1,T2,T3> Tuple;
1456 typedef std::pair<Tuple,T4>
Pair;
1464 typename std::map<Pair,T5>::const_iterator
it;
1465 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1466 Tuple tuple = (*it).first.first;
1467 x1[i] = std::get<0>(tuple);
1468 x2[i] = std::get<1>(tuple);
1469 x3[i] = std::get<2>(tuple);
1470 x4[i] = (*it).first.second;
1471 y[i] = (*it).second;
1473 DataFrame out = Rcpp::DataFrame::create(Rcpp::Named(
"col1")=
wrap(x1),
1474 Rcpp::Named(
"col2")=
wrap(x2),
1475 Rcpp::Named(
"col3")=
wrap(x3),
1476 Rcpp::Named(name1)=
wrap(x4),
1477 Rcpp::Named(name2)=
wrap(y));
1481 template <
class T1,
class T2,
class T3,
class T4,
class T5>
1482 SEXP
wrap_map(
const std::unordered_map<std::pair<std::tuple<T1,T2,T3>,T4>,T5> ov,
1483 std::string name1, std::string name2) {
1484 std::map<std::pair<std::tuple<T1,T2,T3>,T4>,T5> v(ov.begin(), ov.end());
1485 return wrap_map<T1,T2,T3,T4,T5>(v, name1, name2);
1499 double rnormPos(
double mean,
double sd);
1506 double rllogis(
double shape,
double scale);
1512 double rllogis_trunc(
double shape,
double scale,
double left);
1521 double rgompertz(
double shape = 1.0,
double rate = 1.0);