MATLAB中无循环的矩阵计算

Question

I have an issue with a code performing some array operations. It is too slow, because I use loops and input data are quite big. It was the easiest way for me, but now I am looking for something faster than for loops. I was trying to optimize or rewrite code, but unsuccessful. I really aprecciate Your help.

In my code I have three arrays x1 , y1 (coordinates of points in grid), g1 (values in the points) and for example their size is 300 x 300. I treat each matrix as composition of 9 and I make calculation for points in the middle one. For example I start with g1(101,101) , but I am using data from g1(1:201,1:201)=g2 . I need to calculate distance from each point of g1(1:201,1:201) to g1(101,101) ( ll matrix), then I calculate nn as it is in the code, next I find value for g1(101,101) from nn and put it in N array. Then I go to g1(101,102) and so on until g1(200,200) , where in this last case g2=g1(99:300,99:300) .

As i said, this code is not very efficient, even I have to use larger arrays than I gave in the example, it takes too much time. I hope I explain enough clearly what I expect from the code. I was thinking of using arrayfun, but I have never worked with this function, so I don't know how should use it, however it seems to me it won't handle. Maybe there are other solutions, however I couldn't find anything apropriate.

tic
x1=randn(300,300);
y1=randn(300,300);
g1=randn(300,300);
m=size(g1,1);
n=size(g1,2);
w=1/3*m;
k=1/3*n;
N=zeros(w,k);
for i=w+1:2*w 
    for j=k+1:2*k 
        x=x1(i,j);
        y=y1(i,j);
        x2=y1(i-k:i+k,j-w:j+w);
        y2=y1(i-k:i+k,j-w:j+w);
        g2=g1(i-k:i+k,j-w:j+w);
        ll=1./sqrt((x2-x).^2+(y2-y).^2);
        ll(isinf(ll))=0;
        nn=ifft2(fft2(g2).*fft2(ll));
        N(i-w,j-k)=nn(w+1,k+1);
      end
  end
  czas=toc;

Answer 1

For what it's worth, arrayfun() is just a wrapper for a for loop, so it wouldn't lead to any performance improvements. Also, you probably have a typo in the definition of x2 , I'll assume that it depends on x1 . Otherwise it would be a superfluous variable. Also, your i<->w/k , j<->k/w pairing seems inconsistent, you should check that as well. Also also, just timing with tic/toc is rarely accurate. When profiling your code, put it in a function and run the timing multiple times, and exclude the variable generation from the timing. Even better: use the built-in profiler.

Disclaimer: this solution will likely not help for your actual problem due to its huge memory need. For your input of 300x300 matrices this works with arrays of size 300x300x100x100, which is usually a no-go. Still, it's here for reference with a smaller input size. I wanted to add a solution based on nlfilter(), but your problem seems to be too convoluted to be able to use that.

As always with vectorization, you can do it faster if you can spare the memory for it. You are trying to work with matrices of size [2*k+1,2*w+1] for each [i,j] index. This calls for 4d arrays, of shape [2*k+1,2*w+1,w,k] . For each element [i,j] you have a matrix with indices [:,:,i,j] to treat together with the corresponding elements of x1 and y1 . It also helps that fft2 accepts multidimensional arrays.

Here's what I mean:

tic
x1 = randn(30,30);  %// smaller input for tractability
y1 = randn(30,30);
g1 = randn(30,30);
m = size(g1,1);
n = size(g1,2);
w = 1/3*m;
k = 1/3*n;

%// these will be indexed on the fly:    
%//x = x1(w+1:2*w,k+1:2*k);     %// size [w,k]
%//y = x1(w+1:2*w,k+1:2*k);     %// size [w,k]

x2 = zeros(2*k+1,2*w+1,w,k); %// size [2*k+1,2*w+1,w,k]
y2 = zeros(2*k+1,2*w+1,w,k); %// size [2*k+1,2*w+1,w,k]
g2 = zeros(2*k+1,2*w+1,w,k); %// size [2*k+1,2*w+1,w,k]

%// manual definition for now, maybe could be done smarter:
for ii=w+1:2*w       %// don't use i and j as variables
    for jj=k+1:2*k   %// don't use i and j as variables
        x2(:,:,ii-w,jj-k) = x1(ii-k:ii+k,jj-w:jj+w);  %// check w vs k here
        y2(:,:,ii-w,jj-k) = y1(ii-k:ii+k,jj-w:jj+w);  %// check w vs k here
        g2(:,:,ii-w,jj-k) = g1(ii-k:ii+k,jj-w:jj+w);  %// check w vs k here
    end
end

%// use bsxfun to operate on [2*k+1,2*w+1,w,k] vs [w,k]-sized arrays
%// need to introduce leading singletons with permute() in the latter
%// in order to have shape [1,1,w,k] compatible with the first array
ll = 1./sqrt(bsxfun(@minus,x2,permute(x1(w+1:2*w,k+1:2*k),[3,4,1,2])).^2 ...
           + bsxfun(@minus,y2,permute(y1(w+1:2*w,k+1:2*k),[3,4,1,2])).^2);
ll(isinf(ll)) = 0;

%// compute fft2, operating on [2*k+1,2*w+1,w,k]
%// will return fft2 for each index in the [w,k] subspace
nn = ifft2(fft2(g2).*fft2(ll));

%// we need nn(w+1,k+1,:,:) which is exactly of size [w,k] as needed
N = reshape(nn(w+1,k+1,:,:),[w,k]);  %// quicker than squeeze()
N = real(N);  %// this solution leaves an imaginary part of around 1e-12

czas=toc;