30 #ifndef MICROSIMULATION_H
31 #define MICROSIMULATION_H
36 #include <RcppCommon.h>
37 #include <boost/tuple/tuple.hpp>
38 #include <boost/tuple/tuple_comparison.hpp>
39 #include <boost/unordered_map.hpp>
49 template <class Tuple, size_t Index = length<Tuple>::value - 1>
52 static void apply(
size_t& seed, Tuple
const& tuple)
55 boost::hash_combine(seed, get<Index>(tuple));
58 template <
class Tuple>
61 static void apply(
size_t& seed, Tuple
const& tuple)
63 boost::hash_combine(seed, get<0>(tuple));
67 template <
class Tuple>
80 template <
class T1,
class T2>
81 SEXP
wrap(
const std::vector<std::pair<T1,T2> > v);
84 template <
class T1,
class T2>
85 SEXP
wrap(
const std::vector<boost::tuple<T1,T2> > v);
87 template <
class T1,
class T2,
class T3>
88 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3> > v);
90 template <
class T1,
class T2,
class T3,
class T4>
91 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4> > v);
93 template <
class T1,
class T2,
class T3,
class T4,
class T5>
94 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4,T5> > v);
96 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6>
97 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4,T5,T6> > v);
99 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7>
100 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7> > v);
102 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8>
103 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8> > v);
105 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9>
106 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> > v);
108 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10>
109 SEXP
wrap(
const std::vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> > v);
112 template <
class T1,
class T2>
113 SEXP
wrap_map(
const std::map<T1,T2> v);
115 template <
class T1a,
class T1b,
class T2>
116 SEXP
wrap_map(
const std::map<std::pair<T1a,T1b>,T2> v,
117 std::string key, std::string name1, std::string name2);
119 template <
class T1a,
class T1b,
class T1c,
class T2>
120 SEXP
wrap_map(
const std::map<boost::tuple<T1a,T1b,T1c>,T2> v,
121 std::string key, std::string name1, std::string name2, std::string name3);
123 template <
class T1,
class T2,
class T3,
class T4,
class T5>
124 SEXP
wrap_map(
const std::map<std::pair<boost::tuple<T1,T2,T3>,T4>,T5> v,
125 std::string key, std::string name1, std::string name2);
128 template <
class T1,
class T2>
129 SEXP
wrap_map(
const boost::unordered_map<T1,T2> v);
131 template <
class T1a,
class T1b,
class T2>
132 SEXP
wrap_map(
const boost::unordered_map<std::pair<T1a,T1b>,T2> v,
133 std::string key, std::string name1, std::string name2);
135 template <
class T1a,
class T1b,
class T1c,
class T2>
136 SEXP
wrap_map(
const boost::unordered_map<boost::tuple<T1a,T1b,T1c>,T2> v,
137 std::string key, std::string name1, std::string name2, std::string name3);
139 template <
class T1,
class T2,
class T3,
class T4,
class T5>
140 SEXP
wrap_map(
const boost::unordered_map<std::pair<boost::tuple<T1,T2,T3>,T4>,T5> v,
141 std::string key, std::string name1, std::string name2);
149 #include <Rdefines.h>
150 #include <R_ext/Random.h>
159 #include <functional>
162 #include <boost/bind.hpp>
163 #include <boost/functional.hpp>
180 #define WithRNG(rng,expr) (rng->set(), expr)
203 std::ostringstream stringStream;
204 stringStream <<
"kind=";
205 stringStream <<
kind;
206 stringStream <<
",name=";
207 stringStream <<
name;
208 string str = stringStream.str();
216 return (msg != 0 && pred(msg));
221 return (msg != 0 && msg->
name == s);
226 return (msg != 0 && msg->
kind == k);
242 if ((msg =
dynamic_cast<const cMessage *
>(e)) != 0) {
247 REprintf(
"cProcess is only written to receive cMessage events\n");
261 virtual void init() = 0;
310 _sum += (
long double) value;
311 _sumsq += (
long double)value * (
long double)value;
315 return Rcpp::DataFrame::create(_(
"n")=
n(),
319 _(
"se")=
sd()/sqrt(
n()),
339 Rpexp(
double *hin,
double *tin,
int nin) :
n(nin) {
344 H[0]=0.0;
h[0]=hin[0];
t[0]=tin[0];
347 h[i]=hin[i];
t[i]=tin[i];
348 H[i] =
H[i-1]+(
t[i]-
t[i-1])*
h[i-1];
362 double rand(
double u,
double from = 0.0) {
363 double v = 0.0, H0 = 0.0, tstar = 0.0;
366 i0 = (from >=
t[
n-1]) ? (
n-1) : int(lower_bound(
t.begin(),
t.end(), from) -
t.begin())-1;
367 H0 =
H[i0] + (from -
t[i0])*
h[i0];
370 i = (v >=
H[
n-1]) ? (
n-1) : int(lower_bound(
H.begin(),
H.end(), v) -
H.begin())-1;
371 tstar =
t[i]+(v-
H[i])/
h[i];
384 double rweibullHR(
double shape,
double scale,
double hr);
462 if (discountRate == 0.0)
return end - start;
464 else return (pow(1.0+discountRate,-start) - pow(1.0+discountRate,-end)) / log(1.0+discountRate);
475 std::vector<std::vector<T> >
transpose(
const std::vector<std::vector<T> > data) {
476 std::vector<std::vector<T> > result(data[0].size(),
477 std::vector<T>(data.size()));
478 for (
typename std::vector<T>::size_type i = 0; i < data[0].size(); i++)
479 for (
typename std::vector<T>::size_type j = 0; j < data.size(); j++) {
480 result[i][j] = data[j][i];
489 template<
class State,
class Event,
class Time =
double,
class Utility =
double>
494 typedef std::pair<State,Time>
Pair;
495 typedef boost::unordered_map<pair<State,Time>,
int >
PrevMap;
496 typedef boost::unordered_map<pair<State,Time>, Utility >
UtilityMap;
497 typedef boost::unordered_map<pair<State,Time>,
Time >
PtMap;
498 typedef boost::unordered_map<boost::tuple<State,Event,Time>,
int >
EventsMap;
511 const Time maxTime =
Time(1.0e100)) {
537 REprintf(
"Vector too small in EventReport: use resize(int) method");
546 else if (a==b)
return 0.0;
549 return utility/alpha*(exp(-a*alpha) - exp(-b*alpha));
552 REprintf(
"discountRate less than zero.");
560 void add(
const State state,
const Event event,
const Time lhs,
const Time rhs,
const Utility utility = 1,
int index = 0 ) {
566 ++
_events[boost::make_tuple(state,event,*hi)];
568 for(
it = lo, iterating =
true; iterating; iterating = (
it != hi), --
it) {
569 if (lhs<=(*
it) && (*it)<rhs)
576 _pt[
Pair(state,*
it)] += rhs - std::max<Time>(lhs,*
it);
584 _pt[
Pair(state,*
it)] += std::min<Time>(rhs,next_value) - std::max<Time>(lhs,*
it);
590 typename T::iterator
it;
591 for (
it = new_map.begin();
it != new_map.end(); ++
it)
592 base_map[
it->first] +=
it->second;
597 append_map<PtMap>(
_pt,er.
_pt);
598 append_map<UtilityMap>(
_ut,er.
_ut);
602 using namespace Rcpp;
603 if (
_events.size() == 0)
return List::create();
605 return List::create(_(
"pt") = wrap_map<State,Time,Time>(
_pt,
"Key",
"age",
"pt"),
606 _(
"ut") = wrap_map<State,Time,Utility>(
_ut,
"Key",
"age",
"utility"),
607 _(
"events") = wrap_map<State,Event,Time,int>(
_events,
"Key",
"event",
"age",
"number"),
608 _(
"prev") = wrap_map<State,Time,int>(
_prev,
"Key",
"age",
"number"));
610 return List::create(_(
"pt") = wrap_map<State,Time,Time>(
_pt,
"Key",
"age",
"pt"),
611 _(
"events") = wrap_map<State,Event,Time,int>(
_events,
"Key",
"event",
"age",
"number"),
612 _(
"prev") = wrap_map<State,Time,int>(
_prev,
"Key",
"age",
"number"));
637 template<
class State,
class Event =
short,
class Time =
double,
class Utility =
double,
class Cost =
double>
642 typedef std::pair<State,Time>
Pair;
643 typedef boost::unordered_map<pair<State,Time>,
int >
PrevMap;
644 typedef boost::unordered_map<pair<State,Time>, Utility >
UtilityMap;
645 typedef boost::unordered_map<pair<State,Time>,
Time >
PtMap;
646 typedef boost::unordered_map<boost::tuple<State,Event,Time>,
int >
EventMap;
647 typedef boost::unordered_map<pair<State,Time>, Cost >
CostMap;
657 _indivUtilities.resize(size);
658 _indivCosts.resize(size);
666 utilityAlpha = log(1.0+utilityDiscountRate);
670 costAlpha = log(1.0+costDiscountRate);
676 const Time maxTime =
Time(1.0e100)) {
682 this->utility = _utility;
694 _indivUtilities.clear();
697 void add(
const State state,
const Event event,
const Time lhs,
const Time rhs,
int index = 0) {
700 if (!indivp) index = 0;
705 ++
_events[boost::make_tuple(state,event,*hi)];
707 for(
it = lo, iterating =
true; iterating; iterating = (
it != hi), --
it) {
708 if (lhs<=(*
it) && (*it)<rhs)
711 Utility u = discountedUtilityInterval(std::max<Time>(lhs,*
it), rhs, utility);
713 _indivUtilities[index] += u;
714 Cost c = discountedCostInterval(std::max<Time>(lhs,*
it), rhs, cost);
715 _costs[
Pair(state,*
it)] += c;
716 _indivCosts[index] += c;
717 _pt[
Pair(state,*
it)] += rhs - std::max<Time>(lhs,*
it);
721 Utility u = discountedUtilityInterval(std::max<Time>(lhs,*
it), std::min<Time>(rhs,next_value), utility);
723 _indivUtilities[index] += u;
724 Cost c = discountedCostInterval(std::max<Time>(lhs,*
it), std::min<Time>(rhs,next_value), cost);
725 _costs[
Pair(state,*
it)] += c;
726 _indivCosts[index] += c;
727 _pt[
Pair(state,*
it)] += std::min<Time>(rhs,next_value) - std::max<Time>(lhs,*
it);
733 if (!indivp) index = 0;
736 Cost c = discountedCost(time,cost);
737 _costs[
Pair(state,time_lhs)] += c;
738 _indivCosts[index] += c;
743 append_map<PtMap>(
_pt,er.
_pt);
744 append_map<UtilityMap>(
_ut,er.
_ut);
745 append_map<CostMap>(_costs,er.
_costs);
750 using namespace Rcpp;
751 if (
_events.size() == 0)
return List::create();
752 Rcpp::DataFrame
indiv =
753 Rcpp::DataFrame::create(_(
"utilities")=_indivUtilities,
754 _(
"costs")=_indivCosts);
755 Rcpp::List out = List::create(_(
"pt") = wrap_map<State,Time,Time>(
_pt,
"Key",
"age",
"pt"),
756 _(
"ut") = wrap_map<State,Time,Utility>(
_ut,
"Key",
"age",
"utility"),
757 _(
"events") = wrap_map<State,Event,Time,int>(
_events,
"Key",
"event",
"age",
"number"),
758 _(
"prev") = wrap_map<State,Time,int>(
_prev,
"Key",
"age",
"number"),
759 _(
"costs") = wrap_map<State,Time,Cost>(_costs,
"Key",
"age",
"cost"),
762 _(
"utilityDiscountRate")=utilityDiscountRate,
763 _(
"costDiscountRate")=costDiscountRate,
765 out.attr(
"class")=
"SummaryReport";
769 if (a == b || utility == 0.0)
return 0.0;
770 else if (utilityDiscountRate == 0.0)
return utility * (b-a);
771 else if (utilityDiscountRate>0.0) {
772 return utility/utilityAlpha*(exp(-a*utilityAlpha) - exp(-b*utilityAlpha));
775 REprintf(
"utilityDiscountRate less than zero: %f.\n", utilityDiscountRate);
780 if (a == b || cost == 0.0)
return 0.0;
781 else if (costDiscountRate == 0.0)
return cost * (b-a);
782 else if (costDiscountRate>0.0) {
783 return cost/costAlpha*(exp(-a*costAlpha) - exp(-b*costAlpha));
786 REprintf(
"costDiscountRate less than zero: %f.\n", costDiscountRate);
791 if (cost == 0.0)
return 0.0;
792 else if (costDiscountRate == 0.0)
return cost;
793 else if (costDiscountRate>0)
794 return cost*exp(-a*costAlpha);
796 REprintf(
"costDiscountRate less than zero: %f.\n", costDiscountRate);
802 typename T::iterator
it;
803 for (
it = new_map.begin();
it != new_map.end(); ++
it)
804 base_map[
it->first] +=
it->second;
824 template<
class State,
class Time =
double,
class Cost =
double>
828 typedef std::pair<State,Time>
Pair;
830 typedef boost::unordered_map<pair<State,Time>, Cost >
Table;
840 REprintf(
"Vector too small in CostReport: use resize(int) method");
859 REprintf(
"discountRate less than zero.");
867 const Time maxTime =
Time(1.0e100)) {
882 typename Table::iterator
it;
885 _table[
it->first] +=
it->second;
888 void add(
const State state,
const Time time,
const Cost cost,
const int index = 0 ) {
890 Cost c = discountedCost(time,cost);
891 _table[
Pair(state,time_lhs)] += c;
905 return mean_costs.wrap();
920 template<
class T =
double>
926 typedef map<string,vector<T> >
Map;
931 _data[field].push_back(value);
938 if (!_data[field].empty())
939 _data[field].pop_back();
940 _data[field].push_back(value);
956 for(
typename Map::iterator
it = obj.
_data.begin();
it != obj.
_data.end(); ++
it) {
957 _data[
it->first].insert(_data[
it->first].end(),
it->second.begin(),
it->second.end());
970 template <
class T1,
class T2>
971 SEXP
wrap(
const vector<pair<T1,T2> > v) {
974 typename vector<pair<T1,T2> >::const_iterator
it;
975 for (
it=v.begin();
it<v.end(); ++
it) {
976 v1.push_back(
it->first);
977 v2.push_back(
it->second);
979 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2));
982 template <
class T1,
class T2>
983 SEXP
wrap(
const vector<boost::tuple<T1,T2> > v) {
987 typename vector<boost::tuple<T1,T2> >::const_iterator
it;
988 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
989 v1[i] = boost::get<0>(*
it);
990 v2[i] = boost::get<1>(*
it);
992 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2));
995 template <
class T1,
class T2,
class T3>
996 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3> > v) {
1001 typename vector<boost::tuple<T1,T2,T3> >::const_iterator
it;
1002 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1003 v1[i] = boost::get<0>(*
it);
1004 v2[i] = boost::get<1>(*
it);
1005 v3[i] = boost::get<2>(*
it);
1007 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),_(
"Var3")=
wrap(v3));
1011 template <
class T1,
class T2,
class T3,
class T4>
1012 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4> > v) {
1018 typename vector<boost::tuple<T1,T2,T3,T4> >::const_iterator
it;
1019 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1020 v1[i] = boost::get<0>(*
it);
1021 v2[i] = boost::get<1>(*
it);
1022 v3[i] = boost::get<2>(*
it);
1023 v4[i] = boost::get<3>(*
it);
1025 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1026 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4));
1029 template <
class T1,
class T2,
class T3,
class T4,
class T5>
1030 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4,T5> > v) {
1037 typename vector<boost::tuple<T1,T2,T3,T4,T5> >::const_iterator
it;
1038 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1039 v1[i] = boost::get<0>(*
it);
1040 v2[i] = boost::get<1>(*
it);
1041 v3[i] = boost::get<2>(*
it);
1042 v4[i] = boost::get<3>(*
it);
1043 v5[i] = boost::get<4>(*
it);
1045 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1046 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1047 _(
"Var5")=
wrap(v5));
1050 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6>
1051 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4,T5,T6> > v) {
1059 typename vector<boost::tuple<T1,T2,T3,T4,T5,T6> >::const_iterator
it;
1060 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1061 v1[i] = boost::get<0>(*
it);
1062 v2[i] = boost::get<1>(*
it);
1063 v3[i] = boost::get<2>(*
it);
1064 v4[i] = boost::get<3>(*
it);
1065 v5[i] = boost::get<4>(*
it);
1066 v6[i] = boost::get<5>(*
it);
1068 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1069 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1070 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6));
1073 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7>
1074 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7> > v) {
1083 typename vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7> >::const_iterator
it;
1084 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1085 v1[i] = boost::get<0>(*
it);
1086 v2[i] = boost::get<1>(*
it);
1087 v3[i] = boost::get<2>(*
it);
1088 v4[i] = boost::get<3>(*
it);
1089 v5[i] = boost::get<4>(*
it);
1090 v6[i] = boost::get<5>(*
it);
1091 v7[i] = boost::get<6>(*
it);
1093 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1094 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1095 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1096 _(
"Var7")=
wrap(v7));
1099 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8>
1100 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8> > v) {
1110 typename vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8> >::const_iterator
it;
1111 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1112 v1[i] = boost::get<0>(*
it);
1113 v2[i] = boost::get<1>(*
it);
1114 v3[i] = boost::get<2>(*
it);
1115 v4[i] = boost::get<3>(*
it);
1116 v5[i] = boost::get<4>(*
it);
1117 v6[i] = boost::get<5>(*
it);
1118 v7[i] = boost::get<6>(*
it);
1119 v8[i] = boost::get<7>(*
it);
1121 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1122 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1123 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1124 _(
"Var7")=
wrap(v7),_(
"Var8")=
wrap(v8));
1127 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9>
1128 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> > v) {
1139 typename vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9> >::const_iterator
it;
1140 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1141 v1[i] = boost::get<0>(*
it);
1142 v2[i] = boost::get<1>(*
it);
1143 v3[i] = boost::get<2>(*
it);
1144 v4[i] = boost::get<3>(*
it);
1145 v5[i] = boost::get<4>(*
it);
1146 v6[i] = boost::get<5>(*
it);
1147 v7[i] = boost::get<6>(*
it);
1148 v8[i] = boost::get<7>(*
it);
1149 v9[i] = boost::get<8>(*
it);
1151 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1152 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1153 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1154 _(
"Var7")=
wrap(v7),_(
"Var8")=
wrap(v8),
1155 _(
"Var9")=
wrap(v9));
1158 template <
class T1,
class T2,
class T3,
class T4,
class T5,
class T6,
class T7,
class T8,
class T9,
class T10>
1159 SEXP
wrap(
const vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> > v) {
1171 typename vector<boost::tuple<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::const_iterator
it;
1172 for (
it=v.begin(), i=0;
it<v.end(); ++
it, ++i) {
1173 v1[i] = boost::get<0>(*
it);
1174 v2[i] = boost::get<1>(*
it);
1175 v3[i] = boost::get<2>(*
it);
1176 v4[i] = boost::get<3>(*
it);
1177 v5[i] = boost::get<4>(*
it);
1178 v6[i] = boost::get<5>(*
it);
1179 v7[i] = boost::get<6>(*
it);
1180 v8[i] = boost::get<7>(*
it);
1181 v9[i] = boost::get<8>(*
it);
1182 v10[i] = boost::get<9>(*
it);
1184 return List::create(_(
"Var1")=
wrap(v1),_(
"Var2")=
wrap(v2),
1185 _(
"Var3")=
wrap(v3),_(
"Var4")=
wrap(v4),
1186 _(
"Var5")=
wrap(v5),_(
"Var6")=
wrap(v6),
1187 _(
"Var7")=
wrap(v7),_(
"Var8")=
wrap(v8),
1188 _(
"Var9")=
wrap(v9),_(
"Var10")=
wrap(v10));
1192 template <
class T1,
class T2>
1198 typename std::map<T1,T2>::const_iterator
it;
1199 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1201 y[i] = (*it).second;
1203 return DataFrame::create(_(
"Key")=
wrap(x),_(
"Value")=
wrap(y));
1212 template <
class T1a,
class T1b,
class T1c,
class T2>
1213 SEXP
wrap_map(
const std::map<boost::tuple<T1a,T1b,T1c>,T2> v,
1214 std::string key, std::string name1, std::string name2, std::string name3) {
1215 typedef boost::tuple<T1a,T1b,T1c> Tuple;
1222 typename std::map<Tuple,T2>::const_iterator
it;
1223 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1224 xa[i] = get<0>((*it).first);
1225 xb[i] = get<1>((*it).first);
1226 xc[i] = get<2>((*it).first);
1227 y[i] = (*it).second;
1234 template <
class T1a,
class T1b,
class T2>
1236 std::string key, std::string name1, std::string name2) {
1237 typedef std::pair<T1a,T1b>
Pair;
1243 typename std::map<Pair,T2>::const_iterator
it;
1244 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1245 xa[i] = (*it).first.first;
1246 xb[i] = (*it).first.second;
1247 y[i] = (*it).second;
1254 template <
class T1,
class T2>
1256 std::map<T1,T2> v(ov.begin(), ov.end());
1257 return wrap_map<T1,T2>(v);
1260 template <
class T1a,
class T1b,
class T1c,
class T2>
1261 SEXP
wrap_map(
const boost::unordered_map<boost::tuple<T1a,T1b,T1c>,T2> ov,
1262 std::string key, std::string name1, std::string name2, std::string name3) {
1263 std::map<boost::tuple<T1a,T1b,T1c>,T2> v(ov.begin(), ov.end());
1264 return wrap_map<T1a, T1b, T1c, T2>(v, key, name1, name2, name3);
1267 template <
class T1a,
class T1b,
class T2>
1268 SEXP
wrap_map(
const boost::unordered_map<std::pair<T1a,T1b>,T2> ov,
1269 std::string key, std::string name1, std::string name2) {
1270 std::map<std::pair<T1a,T1b>,T2> v(ov.begin(), ov.end());
1271 return wrap_map<T1a, T1b, T2>(v, key, name1, name2);
1274 template <
class T1,
class T2,
class T3,
class T4,
class T5>
1275 SEXP
wrap_map(
const std::map<std::pair<boost::tuple<T1,T2,T3>,T4>,T5> v,
1276 std::string name1, std::string name2) {
1277 typedef boost::tuple<T1,T2,T3> Tuple;
1278 typedef std::pair<Tuple,T4>
Pair;
1286 typename std::map<Pair,T5>::const_iterator
it;
1287 for (
it=v.begin(), i=0;
it != v.end(); ++
it, ++i) {
1288 Tuple tuple = (*it).first.first;
1289 x1[i] = boost::get<0>(tuple);
1290 x2[i] = boost::get<1>(tuple);
1291 x3[i] = boost::get<2>(tuple);
1292 x4[i] = (*it).first.second;
1293 y[i] = (*it).second;
1295 DataFrame out = Rcpp::DataFrame::create(Rcpp::Named(
"col1")=
wrap(x1),
1296 Rcpp::Named(
"col2")=
wrap(x2),
1297 Rcpp::Named(
"col3")=
wrap(x3),
1298 Rcpp::Named(name1)=
wrap(x4),
1299 Rcpp::Named(name2)=
wrap(y));
1303 template <
class T1,
class T2,
class T3,
class T4,
class T5>
1304 SEXP
wrap_map(
const boost::unordered_map<std::pair<boost::tuple<T1,T2,T3>,T4>,T5> ov,
1305 std::string name1, std::string name2) {
1306 std::map<std::pair<boost::tuple<T1,T2,T3>,T4>,T5> v(ov.begin(), ov.end());
1307 return wrap_map<T1,T2,T3,T4,T5>(v, name1, name2);
1320 double rnormPos(
double mean,
double sd);
1326 double rllogis(
double shape,
double scale);
1332 double rllogis_trunc(
double shape,
double scale,
double left);