I'm having trouble visualizing how to vectorize this set of loops. Any guidance would be appreciated.
ind_1 = [1,2,3];
ind_2 = [1,2,4];
K = zeros(3,3,3,3,3,3,3,3,3);
pp = rand(4,4,4);
for s = 1:3
for t = 1:3
for k = 1:3
for l = 1:3
for m = 1:3
for n = 1:3
for o = 1:3
for p = 1:3
for r = 1:3
% the following loops are singular valued except when
% y=3 for ind_x(y) in this case
for a_s = ind_1(s):ind_2(s)
for a_t = ind_1(t):ind_2(t)
for a_k = ind_1(k):ind_2(k)
for a_l = ind_1(l):ind_2(l)
for a_m = ind_1(m):ind_2(m)
for a_n = ind_1(n):ind_2(n)
for a_o = ind_1(o):ind_2(o)
for a_p = ind_1(p):ind_2(p)
for a_r = ind_1(r):ind_2(r)
K(s,t,k,l,m,n,o,p,r) = K(s,t,k,l,m,n,o,p,r) + ...
pp(a_s, a_t, a_r) * pp(a_k, a_l, a_r) * ...
pp(a_n, a_m, a_s) * pp(a_o, a_n, a_t) * ...
pp(a_p, a_o, a_k) * pp(a_m, a_p, a_l);
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
EDIT:
The code is creating a rank-9 tensor with indices from 1 to 3 by summing the values of a product of pp
s one or two times for each index, depending on the value of ind_1
and ind_2
.
EDIT:
Here is a 3d example, though bear in mind that the fact that the indices of pp
are simply permuted is not preserved in the 9d version:
ind_1 = [1,2,3];
ind_2 = [1,2,4];
K = zeros(3,3,3);
pp = rand(4,4,4);
for s = 1:3
for t = 1:3
for k = 1:3
% the following loops are singular valued except when
% y=3 for ind_x(y) in this case
for a_s = ind_1(s):ind_2(s)
for a_t = ind_1(t):ind_2(t)
for a_k = ind_1(k):ind_2(k)
K(s,t,k) = K(s,t,k) + ...
pp(a_s, a_t, a_r) * pp(a_t, a_s, a_k) * ...
pp(a_k, a_t, a_s) * pp(a_k, a_s, a_t);
end
end
end
end
end
end
Woh ! Pretty simple solution, but wasn't easy to find. By the way I wonder where does your formula comes from.
If you don't mind temporarily losing a bit a memory (2 times 4^9 arrays vs 3^9 previously), you may defer accumulation of 3rd and 4th hyperplanes at the very end.
Testing with octave 3.2.4 on a unix box, it drops from 23s (67Mb) to 0.17s (98Mb).
function K = tensor9_opt(pp)
ppp = repmat(pp, [1 1 1 4 4 4 4 4 4]) ;
% The 3 first numbers are variable indices (eg 1 for a_s to 9 for a_r)
% Other numbers must complete 1:9 indices in any order
T = ipermute(ppp, [1 2 9 3 4 5 6 7 8]) .* ...
ipermute(ppp, [3 4 9 1 2 5 6 7 8]) .* ...
ipermute(ppp, [6 5 1 2 3 4 7 8 9]) .* ...
ipermute(ppp, [7 6 2 1 3 4 5 8 9]) .* ...
ipermute(ppp, [8 7 3 1 2 4 5 6 9]) .* ...
ipermute(ppp, [5 8 4 1 2 3 6 7 9]) ;
% I have not found how to manipulate 'multi-ranges' programmatically.
T1 = T (:,:,:,:,:,:,:,:,1:end-1) ; T1(:,:,:,:,:,:,:,:,end) += T (:,:,:,:,:,:,:,:,end) ;
T = T1(:,:,:,:,:,:,:,1:end-1,:) ; T (:,:,:,:,:,:,:,end,:) += T1(:,:,:,:,:,:,:,end,:) ;
T1 = T (:,:,:,:,:,:,1:end-1,:,:) ; T1(:,:,:,:,:,:,end,:,:) += T (:,:,:,:,:,:,end,:,:) ;
T = T1(:,:,:,:,:,1:end-1,:,:,:) ; T (:,:,:,:,:,end,:,:,:) += T1(:,:,:,:,:,end,:,:,:) ;
T1 = T (:,:,:,:,1:end-1,:,:,:,:) ; T1(:,:,:,:,end,:,:,:,:) += T (:,:,:,:,end,:,:,:,:) ;
T = T1(:,:,:,1:end-1,:,:,:,:,:) ; T (:,:,:,end,:,:,:,:,:) += T1(:,:,:,end,:,:,:,:,:) ;
T1 = T (:,:,1:end-1,:,:,:,:,:,:) ; T1(:,:,end,:,:,:,:,:,:) += T (:,:,end,:,:,:,:,:,:) ;
T = T1(:,1:end-1,:,:,:,:,:,:,:) ; T (:,end,:,:,:,:,:,:,:) += T1(:,end,:,:,:,:,:,:,:) ;
K = T (1:end-1,:,:,:,:,:,:,:,:) ; K (end,:,:,:,:,:,:,:,:) += T (end,:,:,:,:,:,:,:,:) ;
endfunction
pp = rand(4,4,4);
K = tensor9_opt(pp) ;
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With