Performing array operation without looping on a function involving 2 vectors

Question

I have a function that takes one vector as its input, uses another function to create a derivative vector from the input, and then compares the two vectors to produce its output vector. I currently have it working with a for loop as follows:

function [parentIndexVec] = computeParentIndex(nameVec)

    parentNameVec = computeParentName(nameVec);
    for i=1:length(parentNameVec)
        parentIndexVec(i) = find(strcmp(nameVec, parentNameVec{i}));
    end

end

The computeParentName function essentially returns a copy of nameVec with its last letter removed. The cell arrays preceding the loop then appear as follows:

nameVec       = ''    'a'    'b'    'aa'    'ab'    'ba'    'aba'    'abb'
parentNameVec = ''    ''     ''     'a'     'a'     'b'     'ab'     'ab'

The goal of this function is to find the indices of where each element in parentNameVec appears in nameVec, and its output is thus as follows:

parentIndexVec = 1     1     1     2     2     3     5     5

I attempted to make a cellfun to accomplish this, but was unable to get it to operate as the two vectors must be compared at each point.

My questions are as follows:

1. Is there a way to do this by eliminating the loops?
2. Is it truly faster to have matrix operations rather than loops in most cases?
3. If so, does cellfun compare in speed to pure matrix operations or would it be as slow as a loop?

Thanks for any assistance!

Answer 1

1. You can use ismember to find the occurrences of the strings in parentNameVec within nameVec

   nameVec = {''    'a'    'b'    'aa'    'ab'    'ba'    'aba'    'abb'};
   parentNameVec = {''    ''     ''     'a'     'a'     'b'     'ab'     'ab'};
   
   [~, parentIndexVec] = ismember(parentNameVec, nameVec)
   %   1   1   1   2   2   3   5   5
   

2. For matrix operations, the operation is almost certainly going to be faster than the for loop. The differential between the two methods has decreased over time but it still exists. Unfortunately, in your examples you are using cell arrays which don't have matrix operations.

3. cellfun is almost always slower than a for loop because MATLAB's JIT compiler is better able to optimize the contents of a for loop. This is particularly true in newer versions of MATLAB (R2015b+) in which the execution engine was reworked and provides much better acceleration.

All of that being said, a built-in function is almost always going to be superior to your own implementation of an algorithm (for loop or otherwise) because it has been optimized by the Mathworks to yield decent performance, robust error checking, and sometimes it is implemented at a lower level.