Writing a multi-dimensional "MathFunction"class by using C++11 variadic templates

Question

I'd like to write a C++11 class that mimics the behavior of a mathematical function. The class takes as an input the sets upon which the function is defined, and it is possible to set and get the value associated with a specific point in the domain.

Since the number of sets that comprise the function domain is not know a priori, I'd like to use C++11 variadic templates to define the class as follows:

template<typename first_set_type, typename... additional_sets_type> class Function;

So that a new function can be created as follows:

Function<int, std::string, double> three_dim_function(S1, S2, S3);

where S1, S2 and S3 are std::set<int>, std::set<std::string> and std::set<double>, respectively. Setting and getting a value should resemble what happens with std::tuple:

three_dim_function.set<1, "a", 1.23>(12);
double twelve = three_dim_function.get<1, "a", 1.23>();

Most probably, std::unordered_map is the ideal data member to store the binding between domain and codomain:

std::unordered_map<std::tuple<first_set_type, additional_set_types...>, double> data_;

I tried to adapt the code from Initialzing and accessing members of a variadic class template, even though the two problems are not identical (in my case I may not need to store each single std::set).

EDIT #1: I'll try to better stress the issue I'm facing. In the linked question, the class is created by means of recursive calls. However, in my case I'm having troubles in understanding how to implement the constructor, i.e., how to set the domain of the function starting from the input sets. One possible way would be to use the constructor to pre-fill all the keys generated by the Cartesian product of the input sets for the data_ data member. The problem is that I don't know how to iterate over the parameter pack.

Tentative solution #1

Here's a tentative implementation: pastebin.com/FMRzc4DZ based on the contribution of @robert-mason. Unfortunately, it does not compile (clang 4.1, OSX 10.8.4) as soon as is_in_domain() is called. However, at first sight everything seems fine. What could be wrong?

Answer 1

I'm leaving my original answer below, but I'll try to address your question with variadic templates.

With a variadic function template, you do not iterate over the parameter pack. You must instead use a recursive function.

What I would use then would be something like:

template <class FirstDomain, class ...Domains>
class Function {
public:
    typedef std::tuple<FirstDomain, Domains...> domain_t;
    static constexpr size_t dimension = sizeof...(Domains) + 1; //+1 for FirstDomain
private:
    std::tuple<std::set<FirstDomain>, std::set<Domains>...> domain;
    std::unordered_map<domain_t, double> map;

    template <size_t index = 0>
    typename std::enable_if<(index < dimension), bool>::type
    is_in_domain(const domain_t& t) const {
        const auto& set = std::get<index>(domain);
        if (set.find(std::get<index>(t)) != set.end()) {
            return is_in_domain<index + 1>(t);
        }
        return false;
    }
    template <size_t index = 0>
    typename std::enable_if<!(index < dimension), bool>::type
    is_in_domain(const domain_t& t) const {
        return true;
    }
public:
    Function(std::set<FirstDomain> f, std::set<Domains>... ds) :
        : domain(f, ds...) {}
};

The trick is the combination of recursion and SFINAE. We need std::enable_if<> to prevent the compiler from expanding the calls to std::get<>(), as the index checking for get is done statically and will cause a compile error even if it will never be executed.

Possible areas of improvement would be making construction more efficient by moving the sets if you can. This would require perfect forwarding and other template magic, since you'd have to let template argument deduction deduce the types so that reference collapsing kicks in and then use a static_assert() to error when the deduced type is not the expected type (i.e. !(std::is_same<T, std::remove_cv<std::remove_reference<FirstDomain>::type>::type>::value), but in variadic form) and then forwarding to the set with std::forward().

---

(original answer)

In this case, you don't want to use the parameters as template arguments. There are all sorts of rules concerning template arguments that you don't want to have to deal with - specifically that all of the arguments have to be integral constant expressions.

You just want to use "normal" arguments, so that you can easily pass them in to the std::unordered_map, can be of any type, and can be runtime-defined:

I would recommend something like:

three_dim_function.set(1, "a", 1.23, 12);
double twelve = three_dim_function.get(1, "a", 1.23);

You can do some syntactic sugar if you like to make this look nicer:

template <class first_type, class ...addl_types>
class Function {
public:
    //...
    //left as an exercise for the reader
    void set(std::tuple<first_type, addl_types...>, double);

    class set_proxy {
        friend class Function<first_type, addl_types...>;
        std::tuple<first_type, addl_types...> input;
        Function<first_type, addl_types...>& parent;
        set_proxy(std::tuple<first_type, addl_types...> t, Function<first_type, addl_types...>& f)
            : input(t), parent(f) {}
        set_proxy(const set_proxy&) = delete;
        set_proxy& operator=(const set_proxy&) = delete;
    public:
        //yes, I know this isn't the right return type, but I'm not sure what's idiomatic
        void operator=(double d) {
            parent.set(input, d);
        }
    };

    set_proxy set(first_type f, addl_types... addl) {
        return set_proxy{std::make_tuple(f, addl...), *this};
    }
};

Which lets you then do:

Function<int, std::string, double> three_dim_function;
three_dim_function.set(1, "a", 1.23) = 12;