# More efficient alternative to the find function?

52 views (last 30 days)
Canberk Suat Gurel on 8 Mar 2018
Commented: Walter Roberson on 9 Mar 2018
Hi all,
I am working on a path planning algorithm. I have generated a matrix A (consists of 1s and 0s.) which stores the neighbor node information. Using the following code I am finding the available neighbors and storing them in vector F.
F = find(A(current,:)==1);
However, unfortunately I found out that this line of code takes the longest time in my code (from 0.004018 to 0.023119s). (A matrix is a 37901 by 37901 matrix.)
Is there a more computationally efficient method to do this?
Thanks!
This is what the A matrix looks like:

James Tursa on 9 Mar 2018
It is not clear from your post if A always has the pattern you show, but if it does then why not just this:
F = [current-1,current+1];
F(F<1|F>size(A,2)) = [];

Canberk Suat Gurel on 9 Mar 2018
Hello James. Thank you for the answer. It certainly follows a pattern.
I need to check [current-1, current+1, current+250, current-250, current+251, current-251, current+252, current-252];
Any suggestions on how to do this more efficiently compared to using F = find(A(current,:)); ? Thanks!
Walter Roberson on 9 Mar 2018
locs = current+[-1, 1, -250, 250, -251, 251, -252, 252];
F = locs( logical(A(current, locs)) );
You can rearrange locs however is suitable.
The result in F is a list of indices, in the same order as you used to create locs.
You could improve performance by originally storing A as logical instead of as double.
Have you considered using diag() to extract the data for all of the rows at the same time? With a small bit of padding and some diag() you could build a 37901 x 8 matrix that focused on just the entries that might have useful information.

Walter Roberson on 8 Mar 2018
You can improve a little by using
F = find(A(current,:));
Your A values are only 0 and 1, so comparing to 1 is going to give you exactly the same as A since == returns 0 and 1.

#### 1 Comment

Canberk Suat Gurel on 9 Mar 2018
Hello Walter, your suggestion reduced the time taken to 0.00162 - 0.004878 range. But as James suggested, the order of 1s and 0s are following a pattern. Please check my comment on his post.