Вложенные операторы переключения для аргументов шаблона

Возможно, вы могли бы использовать таблицу указателей функций, например:

#include <iostream>

typedef double (*SomeFunc)(double*, double*, double*);

template<int a, int b>
auto f1(double* x, double* y, double* z) {
    return a + b + *x + *y + *z;
}

SomeFunc table[] = {
    f1<1, 1>,
    f1<1, 2>,
    f1<2, 1>,
    f1<2, 2>,
};

auto DecideFuncPtr(int A, int B) {
    return table[(A-1)*2 + B-1];
}

int main(int argc, const char * argv[]) {

    double x = 1, y = 3, z = 5;
    
    for (int a = 1; a < 3; ++a)
        for (int b = 1; b < 3; ++b)
            std::cout << DecideFuncPtr(a, b)(&x, &y, &z) << std::endl;
    
    return 0;
}

Предполагая, что желаемый диапазон a и b является смежным или вы не против создания экземпляров дыр, вы можете создать (2d) массив указателей на функции, а затем индексировать его во время выполнения.

auto DecideFuncPtr(int A, int B) {
    static constexpr auto FuncPtrs = [=]<int... Xs>(std::integer_sequence<int, Xs...>) {
        return std::array{
        [=]<int X, int...Ys>(std::integral_constant<int, X>, std::integer_sequence<int, Ys...>) {
            return std::array<FuncPtr, MaxB - MinB>{ &SomeFunc<MinA + X, MinB + Ys>... };
        }(std::integral_constant<int, Xs>(), std::make_integer_sequence<int, MaxB - MinB>())... };
    }(std::make_integer_sequence<int, MaxA - MinA>());

    return FuncPtrs[A - MinA][B - MinB];
}

Если вас устраивают 0, то MinA и MinB вам не нужны.

Ссылка на Колиру

С другой стороны, если значения находятся повсюду, лучше использовать поиск по карте.

constexpr std::integer_sequence<int, 2, 5, 9, 42> As;
constexpr std::integer_sequence<int, 4, 18, 21, 69> Bs;

auto DecideFuncPtr(int A, int B) {
    static const auto FuncPtrs = [=]<int... Xs>(std::integer_sequence<int, Xs...>) {
        std::map<std::pair<int, int>, FuncPtr> result;
        (result.merge([=]<int X, int...Ys>(std::integral_constant<int, X>, std::integer_sequence<int, Ys...>) {
            return std::map<std::pair<int, int>, FuncPtr>{ { {X, Ys}, &SomeFunc<X, Ys> }... };
        }(std::integral_constant<int, Xs>(), Bs)), ...);
        return result;
    }(As);

    return FuncPtrs.at({A, B});
}

Где числа в типах As и Bs — это значения, которые у вас есть.

Ссылка на Колиру

Один из способов превратить значение времени выполнения в значение времени компиляции — использовать std::variant:

std::variant<
    std::integral_constant<enumA, enumA::Value0>,
    std::integral_constant<enumA, enumA::Value1>,
    std::integral_constant<enumA, enumA::Value2>
    // ...
> to_variant(enumA a) {
    switch (a) {
        case enumA::Value0: return std::integral_constant<enumA, enumA::Value0>{};
        case enumA::Value1: return std::integral_constant<enumA, enumA::Value1>{};
        case enumA::Value2: return std::integral_constant<enumA, enumA::Value2>{};
// ...
    }
    std::unreachable(); // Or throw
}

// Similar for enumB

Вы делаете это один раз по типу. вам не нужно самостоятельно вычислять декартово произведение.

Затем вы можете использовать std::visit, чтобы сделать всю работу за вас:

auto foo(enumA a, enumB b)
-> void (*)(double*, double*, double*)
{
    return std::visit([](auto a, auto b){ return &SomeFunc<a(), b()>; },
                      to_variant(a), to_variant(b));
}
// or directly
void foo(enumA a, enumB b, double* x, double* y, double* z)
{
    std::visit([&](auto a, auto b){ return SomeFunc<a(), b()>(x, y, z); },
               to_variant(a), to_variant(b));
}

Примечание. Здесь я использовал enum вместо int, так как это лучше выражает, чем возможные значения «ограничены», но вы можете сделать это с int, если хотите.