Increasing efficiency of for loop cycling through 2 vectors

I have code which decreases the value of certain cells in a matrix by a specific value every iteration for 336 iterations. In order to find the indices of the cells that must be decreased, I first determine the unique values in the vector "random_patches", and how many cells with these unique values ("counts") must be decreased. Then I must find out the indices of ALL of the cells with the unique values from the matrix "weighted_cost2", and select x random indices as determined by the corresponding value in "counts". Below is the code that I am using for this. The problem that I am having is that this section of the code is extremely slow, probably because I am cycling through each of the values in vector "edges", selecting x random indices as determined in vector "count", and then joining these indices to the rest in "random_patches_indexes". Does anyone know of a more efficient way of doing what I described? The code below must be iterated through 336 times.

edges = unique(random_patches);
counts = histc(random_patches(:), edges);
random_patches_indexes=0;
for d=1:length(edges);
  edges_count=find(weighted_cost2==(edges(d)));
  edges_indexes=edges_count(randperm(numel(edges_count), counts(d)));
  random_patches_indexes=[random_patches_indexes edges_indexes'];
end

[dpb]

I don't have time to really think about this in depth but probably the most time-consuming part of the problem is that in

   random_patches_indexes=[random_patches_indexes edges_indexes'];

you're "growing" the random_patches_indexes array dynamically. This requires copying the new elements into the existing, then reallocating and copying the new elements into the existing array space every iteration. Undoubtedly the editor will flag this line with a warning of being bad idea...

Preallocate an array of sufficient size initially, then populate it by keeping a separate counter of the locations to be filled each iteration. This is simply the cumulative sum of the sizes so far plus one for the beginning position of each iteration.

[Stephanie Diaz]

Thanks @dpb, one question though, what do you mean by a counter?

[dpb]

A counter is just a variable used for bookkeeping. In this case you need the running total of the next location to be written into the array in order to populate an existing array rather than dynamically reallocating every pass

Answer 1

[dpb]

I did find a few minutes -- here's one approach that may or may not actually be quicker; I didn't have time for timing exercises and all...I used shorter variable names; I have trouble keep track of long names when they don't mean anything to me :) ...

[u,~,ir]=unique(R);                              % find the unique values and indices in R
nu=accumarray(ir,1);                             % replace histc overhead w/ accumarray for counts
ixW2=arrayfun(@(r) find(W2==r),u,'uniform',0);   % the index array in the second array
rndnP=cellfun(@(ix,n) ix(randperm(numel(ix),n)),ixW2,num2cell(nu),'uniform',0);  % your random_patches_indexes

The above returns a cell array of numel(u) elements, each of which is the associated array of randomized indices from the corresponding value located in the weighted_cost2 array (that I called W2 for brevity) and of course R is your random_patches.

Depending on the next step, it may be as convenient to leave them as cell array and continue down the path outlined above of using cellfun to process each. Alternatively, you can convert back to the vector representation of concatenating them all into the vector as you had by

rndnP=cell2mat(rndnP);

[dpb]

Oh, I tested the above on a small contrived dataset...

>> A=randi(3,5);  A2=randi(3,10);  % the two arrays
>> nu          % the sums of how many/group
nu =
     7
    10
     8
>> arrayfun(@(a) find(A2==a),u,'uniform',0)  % how big the population?
ans = 
    [31x1 double]
    [35x1 double]
    [34x1 double]

% show the result of the randperm for n out of N elements...
>> cellfun(@(ix,n) (randperm(numel(ix),n)),ixA2,num2cell(nu),'uniform',0)
ans = 
    [1x7  double]
    [1x10 double]
    [1x8  double]
>> ans{:}
ans =
    28    25    19    18    14    11    13
ans =
    24    11    23    32    30    28    34    29    10    15
ans =
    20     4    25    14     6    17    26    28

% then the selected subset from the larger population
>> cellfun(@(ix,n) ix(randperm(numel(ix),n)),ixA2,num2cell(nu),'uniform',0)
ans = 
    [ 7x1 double]
    [10x1 double]
    [ 8x1 double]
>> ans{:}
ans =
    37
    24
    55
   100
    72
    67
    76
ans =
    12
    35
    90
    51
    16
    23
    28
    15
    86
     6
ans =
    63
    13
    65
     9
    48
    62
    73
    18
>>

[Stephanie Diaz]

Thank you! I will run this on my own data! What is "ix" in the code? Did you mean "ixW2"?

[Stephanie Diaz]

Also, is "R" the same as "r"?

[Stephanie Diaz]

Nevermind, this works! Thank you!

[dpb]

ix and r are the argument dummy variable in the anonymous functions evaluated by arrayfun and cellfun, respectively (as well as n in the latter). They have scope only within the anonymous functions; they are where the array/cell argument values are passed into the function for evaluation. Thus, r is u(i) for each array value of u in turn or the value of the match in the find call; similarly ix and n are the values of the cell variables ixW2 and nu. NB: the cast of the array nu to the cell array so it could be used in the cellfun argument list.

See and read up on arrayfun and cellfun in the documentation for each; they are essentially the same thing excepting one operates on the elements of an array one-at-a-time while the other works on the contents of a cell array, one-cell-at-a-time. One has to use cell arrays because there won't be the same number of elements so arrays won't work to hold more than one set of values at a time.