Question

I’m implementing the outer product using a templated representation of a Tensor.

The basic prototype of the tensor looks like:

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

With a specialization for Tensor<1> to degrade to a simple vector. My Outer function is defined as:

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;
}

The outer product of a tensor A of order N and of a tensor B of order M is simply the outer product of each element of A with the B tensor. The outer product of any tensor of order N with a tensor of order 1 is defined similarly.

The base case is simply the outer product of two order 1 tensors (vectors). Except, as defined above I’m getting a C1202 error in MSVC:

error C1202: recursive type or function dependency context too complex

What did I do wrong in my definition of an outer product?

Answer 1

This builds cleanly for me:

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);
}

The notable changes are:

1. The Tensor<1> specialization needs to be defined before any of the Outer overloads.
2. The Tensor<1> specialization needs to be default-constructible, since Tensor<2> will attempt to default-construct its x, y, and z data members.
3. A template<int N> Tensor<N + 1> Outer(const Tensor<1> &lhs, const Tensor<N> &rhs) overload is needed for symmetry with template<int N> Tensor<N + 1> Outer(const Tensor<N> &lhs, const Tensor<1> &rhs), or you need to add an overload that takes a double for lhs.
4. Remove template<> from the Tensor<2> Outer(const Tensor<1> &lhs, const Tensor<1> &rhs) overload – we’re overloading here, not specializing.