Convert variadic template to constexpr - c++

Question

I'm wondering if it's possible to convert simple loop that is invoked through a parameter pack into a constexpr with simpler code. This example code demonstrates what I'm trying to do
struct Student {
AgeCategory age;
Income income;
bool is_student;
CreditRating credit_rating;
bool buys_computer;
};
auto find_probability(const double x, const double mean, const double stdev) -> double;
typedef std::tuple<double, double> MeanStdDev;
typedef std::vector<MeanStdDev> MeanStdDevVec;
// This code seems verbose to me. Is there a simpler way to express this
// loop which iterates over a vector and parameter pack, possibly
// using constexpr. C++14/17 idioms are fine.
template<typename Attr>
auto get_probability(const MeanStdDevVec& v, const size_t n, const Student& s, Attr attr) -> double {
double mean, stdev;
std::tie(mean, stdev) = v[n];
return find_probability(static_cast<double>(std::invoke(attr, s)), mean, stdev);
}
template<typename First, typename... Attr>
auto get_probability(const MeanStdDevVec& v, const size_t n, const Student& s, First f, Attr... attr) -> double {
double mean, stdev;
std::tie(mean, stdev) = v[n];
return find_probability(static_cast<double>(std::invoke(f,s)), mean, stdev) * get_probability(v, n + 1, s, attr...);
}
template<typename ...Attr>
auto calculate_class_probability(const std::map<bool, MeanStdDevVec>& summaries, const Student& s, Attr... attributes) {
for (const auto& i : summaries) {
get_probability(i.second, 0L, s, attributes...);
}
}
called from
Student s;
calculate_class_probability(class_summaries, s , &Student::age, &Student::income, &Student::credit_rating, &Student::is_student);

Answer 1

It doesn't necessarily make the code shorter as a whole, but it does separate out a generic part that you can reuse easily, and IMHO makes the code clearer. The key in this particular case is a function that maps packs into arrays of a certain type:
template <class T, class F, class ... Args>
std::array<T, sizeof...(Args)> pack_to_array(F f, Args&& ... args) {
return {(f(std::forward<Args>(args)))...};
}
In your case, this isn't quite enough, as you want to zip it with a vector. So a useful modification of this, would be to make the integer index of the pack element available and pass it to the function:
template <class T, class F, class ... Args>
std::array<T, sizeof...(Args)> index_pack_to_array(F f, Args&& ... args) {
std::size_t i = 0;
return {(f(i++, std::forward<Args>(args)))...};
}
Now, you can use this function like so:
template<typename... Attr>
double get_probability(const MeanStdDevVec& v, const Student& s, Attr... attr) {
assert(v.size() == sizeof...(Attr));
auto probs = index_pack_to_array<double>(
[&] (std::size_t i, auto&& a) -> double {
return // ... (get probability from v[i], s, and a)
},
std::forward<Attr>(attr)...);
return std::accumulate(probs.begin(), probs.end(), 1.0,
[] (double p1, double p2) { return p1 * p2; });
}

Answer 2

Not sure to understand what do you want, but I suppose you can throw away your getProbability() and rewrite calculate_class_probability() as follows
template <typename ... Attr>
auto calculate_class_probability
(std::map<bool, MeanStdDevVec> const & summaries,
Student const & s, Attr ... attributes)
{
using unusedT = int[];
for ( const auto & i : summaries )
{
double mean, stdev;
double prob {1.0};
std::size_t n {0};
(void)unusedT { (std::tie(mean, stdev) = i.second[n++],
prob *= find_probability(static_cast<double>(std::invoke(attributes,s)), mean, stdev),
0)... };
// in prob the calculate value
}
}
But: no: I don't think it's possible to write this as constexpr; the operator[] for std::vector<> isn't constexpr