In Matlab you can do these operations in a vectorized way using the commands reshape, shiftdim, and permute. The essential idea is that contraction of a tensor with a vector is equivalent to matrix multiplication of that vector with an unfolded version of the tensor. For the first example in the question, the command is:
a = z*reshape(y*reshape(shiftdim(T,1), n, n*n), n, n);
where $y$, $z$, and $c$ are row vectors. This computes:
$$a_i = \sum_{j=1}^n \sum_{k=1}^n T_{ijk} y_j z_k.$$
The reason for using row vectors and multiplying them from the right (rather than using column vectors and multiplying them from the left) is that MATLAB stores tensors in column-first order, so when reshaping and multiplying, you access elements of the tensor in the same order as it is stored in memory. This way it is more efficient in terms of cache usage and so on.
Explanation:
Let's break it down as follows:
(5) a = z* ;
(4) reshape( n, n)
(3) y*
(2) reshape( n, n*n)
(1) shiftdim(T,1)
(1) The shiftdim(T,1) shifts all the modes to the left, wrapping around. That is,
$$T_{ijk} \rightarrow T_{jki}.$$
(2) The innermost reshape unfolds the 3-tensor into a $n$-by-$n^2$ matrix where the $j$ mode is exposed on the left:
$$\underbrace{T_{jki}}_{3-\text{tensor}} \rightarrow \underbrace{T_{(j)(ki)}}_{\text{matrix}}.$$
(3) Multiplying on the left by $y$ contracts $y$ with the $j$ mode, creating a temporary row vector of length $n^2$, lets call it $p$, which is a vectorized version of the tensor after contracting it with the $y$.
$$p_{ki} = \sum_j y_j T_{jki}$$
(4) The second reshape refolds $p$ into a matrix to expose the $k$ mode:
$$\underbrace{p_{(ki)}}_{\text{row vector}} \rightarrow \underbrace{p_{(k)(i)}}_{\text{matrix}}.$$
(5) The final multiplication by $z$ contracts $v$ with the $k$'th mode:
$$a_k = \sum_k z_k p_{ki}$$
In general, you can perform any sequence of tensor-vector or tensor-tensor contractions by unfolding the tensors into matrices that expose the modes being contracted over, then performing matrix multiplication, then folding the result back up into a tensor again.
The vectorized operations in Matlab that allow you to do this are shiftdim and permute to shift or permute the modes of the tensor (to bring the desired modes to the front or the back, or do the reverse later), and reshape to unfold and fold the tensor.
In Python with numpy, you can use the built in commands tensordot or einsum, which do this under the hood.
Timing example:
Here's a timing example you can run to get you an idea of how much faster this is:
n = 250;
T = randn(n,n,n);
y = randn(1,n);
z = randn(1,n);
disp('Vectorized:')
tic
a1 = z*reshape(y*reshape(shiftdim(T,1), n, n*n), n, n);
toc
a2 = zeros(1,n);
disp('Unvectorized:')
tic
for ii=1:n
for jj=1:n
for kk=1:n
a2(ii) = a2(ii) + T(ii,jj,kk)*y(jj)*z(kk);
end
end
end
toc
disp('Error:')
disp(norm(a2-a1))
On my laptop this displays the following results:
Vectorized:
Elapsed time is 0.056645 seconds.
Unvectorized:
Elapsed time is 1.781048 seconds.
Error:
3.1182e-11
