Variadic template for multidimensional splines - c++

Question

I am currently struggling with writing a function for multidimensional spline interpolation on an N-dimensional grid of points. I have written the following to handle multidimensional splines:
template <class integral_constant_M, class integral_constant_K>
struct spline_MK_t {
integral_constant_M M;
integral_constant_K K;
};
template <class V, class C, class MK, class... MKs> class spline {
public:
constexpr static int M = decltype(MK::M)();
constexpr static int K = decltype(MK::K)();
typedef std::integral_constant<int, M + K> M_plus_K;
typedef typename spline<V, C, MKs...>::coefs_array_t Vs;
typedef my_array<Vs, M_plus_K> coefs_array_t;
spline() = default;
spline(const coefs_array_t & my_coefs): coefs(my_coefs) {}
coefs_array_t get_coefs() const { return(coefs); }
V operator()(const my_array<C, std::integral_constant<int, 1 + sizeof...(MKs)>> & x) const;
private:
coefs_array_t coefs;
};
template <class V, class C, class MK> class spline<V, C, MK> {
public:
constexpr static int M = decltype(MK::M)();
constexpr static int K = decltype(MK::K)();
typedef std::integral_constant<int, M + K> M_plus_K;
typedef my_array<V, M_plus_K> coefs_array_t;
spline() = default;
spline(const coefs_array_t & my_coefs): coefs(my_coefs) {}
coefs_array_t get_coefs() const { return(coefs); }
V operator()(const my_array<C, std::integral_constant<int, 1>> & x) const;
V operator()(const C & x) const;
private:
coefs_array_t coefs;
};
The struct spline_MK_t is used to specify pairs of integers from which extended knot vectors are calculated (I am not worried about calculating the knot vectors right now). The n-th pair of integers would correspond to the n-th dimension (hence, the number of pairs would also define the dimensionality of the spline). My original hope was to use std::pair in a variadic template, but I learned pretty fast of the restrictions on non-type template parameters, and I resorted to the last suggestion provided here.
The class my_array allows to define multidimensional arrays, and it is as follows:
template <class T, class N, class... Ns> class my_array {
public:
typedef typename my_array<T, Ns...>::type Ts;
typedef Ts type[N()];
Ts & operator [](std::size_t n) { return(data[n]); }
const Ts & operator [](std::size_t n) const { return(data[n]); }
Ts * begin() { return(& data[0]); }
Ts * end() { return(& data[N()]); }
const Ts * begin() const { return(& data[0]); }
const Ts * end() const { return(& data[N()]); }
Ts data[N()];
};
template <class T, class N> class my_array<T, N> {
public:
typedef T type[N()];
T & operator [](std::size_t n) { return(data[n]); }
const T & operator [](std::size_t n) const { return(data[n]); }
T * begin() { return(& data[0]); }
T * end() { return(& data[N()]); }
const T * begin() const { return(& data[0]); }
const T * end() const { return(& data[N()]); }
T data[N()];
};
I would like to be able to calculate an N-dimensional interpolating spline from either an N-dimensional object of type my_array and N 1-dimensional arrays (also defined by instantiating my_array) or a nested my_array (with the number of nestings corresponding to the dimensionality N) and N 1-dimensional arrays.
In other words, I am looking for the declaration of spapi so that either block of code below would compile (the same function has to handle any dimensionality greater than 1, not just 2 as shown below):
#define MX 3
#define KX 4
#define MY 2
#define KY 7
int main(int argc, char **argv) {
my_array<float, std::integral_constant<int, MX + KX>, std::integral_constant<int, MY + KY>> v;
my_array<float, std::integral_constant<int, MX + KX>> x;
my_array<float, std::integral_constant<int, MY + KY>> y;
... // initialize v, x, y
spline<float, float,
spline_MK_t<std::integral_constant<int, MX>, std::integral_constant<int, KX>>,
spline_MK_t<std::integral_constant<int, MY>, std::integral_constant<int, KY>>> s =
spapi<float, float,
spline_MK_t<std::integral_constant<int, MX>, std::integral_constant<int, KX>>,
spline_MK_t<std::integral_constant<int, MY>, std::integral_constant<int, KY>>>(v, x, y);
return 0;
}
OR
#define MX 3
#define KX 4
#define MY 2
#define KY 7
int main(int argc, char **argv) {
my_array<my_array<float, std::integral_constant<int, MY + KY>>,
std::integral_constant<int, MX + KX>> v;
my_array<float, std::integral_constant<int, MX + KX>> x;
my_array<float, std::integral_constant<int, MY + KY>> y;
... // initialize v, x, y
spline<float, float,
spline_MK_t<std::integral_constant<int, MX>, std::integral_constant<int, KX>>,
spline_MK_t<std::integral_constant<int, MY>, std::integral_constant<int, KY>>> s =
spapi<float, float,
spline_MK_t<std::integral_constant<int, MX>, std::integral_constant<int, KX>>,
spline_MK_t<std::integral_constant<int, MY>, std::integral_constant<int, KY>>>(v, x, y);
return 0;
}