Как я могу сжато написать множество явных экземпляров шаблонов функций?

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

// forward declarations in a header file
template<typename T>
T square(T num);

template<typename T>
T add(T left, T right);

// implementations and instantiations in a single implementation file
template<typename T>
T square(T num) {
    return num * num;
}

template<typename T>
T add(T left, T right) {
    return left + right;
}

// instantiations for specific types
#include <tuple>

template<typename... Ts>
auto instantiate() {
    static auto funcs = std::tuple_cat(std::make_tuple(
        add<Ts>,
        square<Ts>
    )...);

    return &funcs;
}

template auto instantiate<int, double>();

Накладные расходы здесь — это единый массив указателей на все созданные функции, например, на godbolt.

Для этого и созданы Макросы X. Это работает довольно просто.

У вас есть файл, содержащий все типы, к которым вы хотите применить это. Назовем его "type_list.inc". Это будет выглядеть так:

X(float)
X(double)
X(long double)

Когда вы хотите выполнить какую-либо операцию над этим списком типов, вы #include файл, но вокруг точки включения вы #define макрос X для выполнения операции, которую вы хотите выполнить:

#define X(T) \
    template T calculate_a<T>(T x); \
    template T calculate_b<T>(T x, T y); \
    // ...
#include "type_list.inc"
#undef X

Вам все равно придется поддерживать два набора прототипов функций. Но вам нужно поддерживать только один список типов.

Я не ясно выразил свое намерение в вопросе. Цель моих явных экземпляров не в том, чтобы ограничить типы, с которыми могут быть вызваны эти функции, а в том, чтобы проинформировать компилятор о создании исполняемого кода для float, double и long double.

Ну... если все ваши типы являются конструктивными по умолчанию (как float, double и long double)... используя свертывание в функции шаблона foo() следующим образом

template <typename ... Ts>
void foo ()
 { ((calculate_a(Ts{}), calculate_b(Ts{}, Ts{})), ...); }

и вызов foo() с желаемыми типами

foo<float, double, long double>();

должно работать, я полагаю.

Ниже приведен полный пример компиляции

template <typename T>
T calculate_a (T x)
 { return x; }

template <typename T>
T calculate_b (T x, T y)
 { return x+y; }

template <typename ... Ts>
void foo ()
 { ((calculate_a(Ts{}), calculate_b(Ts{}, Ts{})), ...); }

int main ()
 {
   foo<float, double, long double>();
 }

Используйте обычную перегрузку для нужных вам типов, чтобы они вызывали шаблон функции, например:

float calculate_a(float x) { return calculate_a<float>(x); }
float calculate_b(float x, float y) { return calculate_b<float>(x, y); }

double calculate_a(double x) { return calculate_a<double>(x); }
double calculate_b(double x, double y) { return calculate_b<double>(x, y); }

long double calculate_a(long double x) { return calculate_a<long double>(x); }
long double calculate_b(long double x, long double y) { return calculate_b<long double>(x, y); }