CODEWITHSUNDEEP
matlabnested-loops
Rajesh D
Rajesh D

Reputation: 311

How to programmatically compute this summation

enter image description here

I want to compute the above summation, for a given 'x'. The summation is to be carried out over a block of lengths specified by an array , for example block_length = [5 4 3]. The summation is carried as follows: from -5 to 5 across one dimension, -4 to 4 in the second dimension and -3 to 3 in the last dimension.

The pseudo code will be something like this:

sum = 0;
for i = -5:5
for j = -4:4
for k = -3:3

      vec = [i j k];

      tv = vec * vec';

      sum = sum + 1/(1+tv)*cos(2*pi*x*vec'));

end
end
end

The problem is that I want to find the sum when the number of dimensions are not known ahead of time, using some kind of variable nested loops hopefully. Matlab uses combvec, but it returns all possible combinations of vectors, which is not required as we only compute the sum. When there are many dimensions, combvec returning all combinations is not feasible memory wise.

Appreciate any ideas towards solutions.

PS: I want to do this at high number of dimensions, for example 650, as in machine learning.

Upvotes: 0

Views: 83

Answers (1)

picchiolu
picchiolu

Reputation: 1130

Based on https://www.mathworks.com/matlabcentral/answers/345551-function-with-varying-number-of-for-loops I came up with the following code (I haven't tested it for very large number of indices!):

function sum = fun(x, block_length)

sum = 0;
n = numel(block_length);   % Number of loops
vec = -ones(1, n) .* block_length;   % Index vector

ready = false;
while ~ready
    
    tv = vec * vec';
    
    sum = sum + 1/(1+tv)*cos(2*pi*x*vec');
    
    % Update the index vector:
    ready = true;    % Assume that the WHILE loop is ready
    for k = 1:n
        vec(k) = vec(k) + 1;
        if vec(k) <= block_length(k)
            ready = false;
            break;    % v(k) increased successfully, leave "for k" loop
        end
        vec(k) = -1 * block_length(k);    % v(k) reached the limit, reset it
    end
end
end

where x and block_length should be both 1-x-n vectors.

The idea is that, instead of using explicitly nested loops, we use a vector of indices.

How good/efficient is this when tackling the suggested use case where block_length can have 650 elements? Not much! Here's a "quick" test using merely 16 dimensions and a [-1, 1] range for the indices:

N = 16; tic; in = 0.1 * ones(1, N); sum = fun(in, ones(size(in))), toc;

which yields an elapsed time of 12.7 seconds on my laptop.

Upvotes: 1

Related Questions