c++ - 嵌套参数包扩展

Question

请参阅下面的代码片段(矩阵乘法的实现)。
是否可以使用 nested pack expansion 来简化它们？有类似
{{((a[r][k] * b[k][c]) + ...)...}...的东西？

#include <array>
#include <utility>

template<typename T, size_t R, size_t C>
using Matrix = std::array<std::array<T, C>, R>;

template<typename A, typename B>
using mul_el_t = decltype(std::declval<A>()[0][0] * std::declval<B>()[0][0]);

帮助计算单个元素。

template<size_t R1, size_t C2, size_t... C1_R2, typename A, typename B>
auto _mat_mul_element(const A &a, const B &b, std::index_sequence<C1_R2...>)
{
    return ((a[R1][C1_R2] * b[C1_R2][C2]) + ...);
}

帮助计算特定行。

template<size_t R1, size_t... C2, typename C1_R2, typename A, typename B>
auto _mat_mul_row(const A &a, const B &b, std::index_sequence<C2...>, C1_R2 c1_r2)
-> std::array<mul_el_t<A, B>, sizeof...(C2)>
{
    return {_mat_mul_element<R1, C2>(a, b, c1_r2)...};
}

这使用参数包计算整个矩阵。

template<size_t... R1, typename C2, typename C1_R2, typename A, typename B>
auto _mat_mul(const A &a, const B &b, std::index_sequence<R1...>, C2 c2, C1_R2 c1_r2)
-> Matrix<mul_el_t<A, B>, sizeof...(R1), C2::size()>
{
    return {_mat_mul_row<R1>(a, b, c2, c1_r2)...};
}

和实际界面。

template<typename T, size_t R1, size_t C1_R2, size_t C2>
Matrix<T, R1, C2> operator*(const Matrix<T, R1, C1_R2> &a, const Matrix<T, C1_R2, C2> &b)
{
    return _mat_mul(
            a, b,
            std::make_index_sequence<R1>{},
            std::make_index_sequence<C2>{},
            std::make_index_sequence<C1_R2>{}
    );
};

更新(看起来我不清楚我遇到的实际问题)

当我尝试将 _mat_mul 替换为:

template<size_t... R1, size_t...  C2, size_t...  C1_R2, typename A, typename B>
auto _mat_mul(const A &a, const B &b,
                std::index_sequence<R1...>,
                std::index_sequence<C2...>,
                std::index_sequence<C1_R2...>)
-> Matrix<mul_el_t<A, B>, sizeof...(R1), sizeof...(C2)>
{
    return {{((a[R1][C1_R2] * b[C1_R2][C2]) + ...)...}...};
}

使用 Apple LLVM 版本 9.1.0 (clang-902.0.39.1) 编译失败:

[ 50%] Building CXX object CMakeFiles/main.cpp.o
main.cpp:38:51: error: pack expansion does not contain any unexpanded parameter packs
    return {{((a[R1][C1_R2] * b[C1_R2][C2]) + ...)...}...};
             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^

我认为失败是意料之中的，因为编译器不知道在每次展开时要展开哪个包(R1、C2 或 C1_R2)堵塞。在这种情况下如何提示编译器(注意，我可以使用任何编译器)？

Answer 1

根据文档，嵌套包扩展可以看作是从最里面的包扩展 [3 点] 开始的迭代过程。每个包扩展都会扩展该包扩展包含的子表达式中的所有参数包。

因此 {{((a[R1][C1_R2] * b[C1_R2][C2]) + ...)...}...}第一步变成
{{(a[0][0] * b[0][0] + a[1][1] * b[1][1])...}...} ( R1/C2/C1_R2 是 index_sequence<2> )。所以接下来的两个扩展包就没有什么可扩展的了。

天真的解决方案

可以同时将每个参数包移动到所需的子表达式，而将其携带的实际值留在所需位置。可以使用 FP 的模拟 let ... in表达式:

auto let = [](auto a, auto f) { return f(a); };

这样原来的表达式就变成了:

{let(R1, [&](auto r1) {
    return std::array<T, sizeof...(C2)>{let(C2, [&](auto c2) {
        return ((a[r1][C1_R2] * b[C1_R2][c2]) + ...);
    })...};
})...};

这可能已经足够好了，但可能需要一些时间来破译那里发生的事情。此外，仍然需要在范围内引入这些参数包。

更好的解决方案

可以尝试通过抽象参数包引入/扩展来提高可读性。使用以下效用函数。

template<typename H, typename F, typename T, T... I>
decltype(auto) repack(std::integer_sequence<T, I...>, H h, F f)
{
    return h(f(std::integral_constant<T, I>{})...);
}

此函数采用携带一些包的值(可以对 std::integer_sequence 以外的内容进行重载)，函数 f它应用于包的每个元素，函数 h用于将最终包转换为某个值。

因此完整的乘法例程变成了

template<typename T, size_t R1, size_t C1_R2, size_t C2>
Matrix<T, R1, C2> operator*(const Matrix<T, R1, C1_R2> &a, const Matrix<T, C1_R2, C2> &b)
{
    std::make_index_sequence<R1> r1{};
    std::make_index_sequence<C2> c2{};
    std::make_index_sequence<C1_R2> c1_r2{};

    return repack(r1, ctor<Matrix<T, R1, C2>>(), [&](auto r1) {
        return repack(c2, ctor<std::array<T, C2>>(), [&](auto c2) {
            return repack(c1_r2, sum, [&](auto c1_r2) {
                return a[r1][c1_r2] * b[c1_r2][c2];
            });
        });
    });
}

哪里ctor是

template<typename H>
auto ctor()
{
    return [](auto... xs) { return H{xs...}; };
}

和sum = [](auto... xs) { return (xs +...); }; .

疯狂的解决方案

表达式中可能有 spot 模式，嵌套了 3 个 repack的，因此乘法例程可能变成:

template<typename T, size_t R1, size_t C1_R2, size_t C2>
Matrix<T, R1, C2> operator*(const Matrix<T, R1, C1_R2> &a, const Matrix<T, C1_R2, C2> &b)
{
    auto item = [&](auto r1, auto c2, auto c1_r2) { return a[r1][c1_r2] * b[c1_r2][c2]; };
    auto curried_repack = curry(POLY(repack));
    auto m = curried_repack(std::make_index_sequence<R1>{}, ctor<Matrix<T, R1, C2>>());
    auto r = curried_repack(std::make_index_sequence<C2>{}, ctor<std::array<T, C2>>());
    auto e = curried_repack(std::make_index_sequence<C1_R2>{}, sum);

    auto op = [](auto w, auto f) {
        return compose(w, curry(f));
    };
    return foldr(op, m, r, e, item)();
}

使用实用程序:

template<typename F>
auto curry(F f)
{
    return [=](auto... a) {
        return [=](auto... b) { return f(a..., b...); };
    };
};

template<typename F, typename G>
auto compose(F f, G g)
{
    return [=](auto... xs) {
        return f(g(xs...));
    };
};

和将模板函数转换为值的宏

#define POLY(f) ([](auto... a){ return f(a...); })

和foldr留作作业。

编译笔记

所有解决方案在产生相同二进制文件的意义上都是等价的。