2

我正在使用张量的模板表示来实现外部产品。

张量的基本原型如下所示：

template <int N>
struct Tensor
{
    Tensor<N - 1> x;
    Tensor<N - 1> y;
    Tensor<N - 1> z;
};

专门用于Tensor<1>降级为简单向量。我的Outer功能定义为：

template <int N, int M>
Tensor<N + M> Outer(const Tensor<N> &lhs, const Tensor<M> &rhs)
{
    Tensor<N + M> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template <int N>
Tensor<N + 1> Outer(const Tensor<N> &lhs, const Tensor<1> &rhs)
{
    Tensor<N + 1> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template <>
Tensor<2> Outer(const Tensor<1> &lhs, const Tensor<1> &rhs)
{
    Tensor<2> result;

    result.x.x = lhs.x * rhs.x;
    result.x.y = lhs.x * rhs.y;
    result.x.z = lhs.x * rhs.z;

    // and so on

    return result;
}

阶张量A和阶N张量B的M外积只是每个元素A与B张量的外积。N任何阶张量与阶张量的外积的1定义类似。

基本情况只是两个阶1张量（向量）的外积。除了，如上所述，我C1202在 MSVC 中遇到错误：

错误 C1202：递归类型或函数依赖上下文太复杂

我对外部产品的定义做错了什么？

4

1 回答 1

3

这对我来说很干净：

template<int N>
struct Tensor
{
    Tensor<N - 1> x;
    Tensor<N - 1> y;
    Tensor<N - 1> z;

    Tensor() { }

    Tensor(const Tensor<N-1>& X, const Tensor<N-1>& Y, const Tensor<N-1>& Z)
      : x(X), y(Y), z(Z)
    { }
};

template<>
struct Tensor<1>
{
    double x;
    double y;
    double z;

    Tensor() : x(), y(), z() { }
    Tensor(double x, double y, double z) : x(x), y(y), z(z)
    { }
};

template<int N, int M>
Tensor<N + M> Outer(const Tensor<N>& lhs, const Tensor<M>& rhs)
{
    Tensor<N + M> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template<int N>
Tensor<N + 1> Outer(const Tensor<N>& lhs, const Tensor<1>& rhs)
{
    Tensor<N + 1> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template<int N>
Tensor<N + 1> Outer(const Tensor<1>& lhs, const Tensor<N>& rhs)
{
    return Outer(rhs, lhs);
}

Tensor<2> Outer(const Tensor<1>& lhs, const Tensor<1>& rhs)
{
    Tensor<2> result;

    result.x.x = lhs.x * rhs.x;
    result.x.y = lhs.x * rhs.y;
    result.x.z = lhs.x * rhs.z;
    result.y.x = lhs.y * rhs.x;
    result.y.y = lhs.y * rhs.y;
    result.y.z = lhs.y * rhs.z;
    result.z.x = lhs.z * rhs.x;
    result.z.y = lhs.z * rhs.y;
    result.z.z = lhs.z * rhs.z;

    return result;
}

int main()
{
    Tensor<4> a;
    Tensor<4> b;
    Outer(a, b);
}

显着的变化是：

  1. Tensor<1>需要在任何Outer重载之前定义特化。
  2. 特Tensor<1>化必须是可默认构造的，因为Tensor<2>将尝试默认构造其x、y和z数据成员。
  3. template<int N> Tensor<N + 1> Outer(const Tensor<1> &lhs, const Tensor<N> &rhs)与 对称需要template<int N> Tensor<N + 1> Outer(const Tensor<N> &lhs, const Tensor<1> &rhs)重载，或者您需要添加采用doublefor的重载lhs。
  4. template<>从重载中移除Tensor<2> Outer(const Tensor<1> &lhs, const Tensor<1> &rhs)——我们在这里重载，而不是专门化。
于 2012-05-01T21:43:08.087 回答