Check appearance counts of multiple patters in a cell matrix

I have 2 cell matrixs:

A =

  m×1 cell array

    {'abc'}
    {'def'}
    {'123'}
    ......

B =

  n×1 cell array

    {'abcsafadefs2'}
    {'dsabcdsdef11'}
    {'abcssp123'}
    ......

I want a output matrix of whether patterns in A has appear 7 times in B:

C =

  m×1 logical array

    {true}
    {true}
    {false}
    ......

So in this example pattern "abc" have matches in exactaly 7 elements in B, so does "def", but not "123".

I now do this with a for loop

for i=1:length(A)
    C(i)= (nnz(contains({B}, A(i)))==7);
end

Any way to vectorize the code?

Answer 1

[Guillaume]

Any way to vectorize the code?

Not really, you could cellfun it, but that's not vectorisation (cellfun is just a loop in disguise):

C = cellfun(@(a) nnz(contains(B, a)) == 7, A);

Note that if you use a loop, you should preallocate the output:

C = false(size(A));
for i = 1:numel(A)
    C(i) = ...
end

[Yi-xiao Liu]

What is the non-capital "a" in the cellfun example?

And based on your description cellfun does not provide any performance advantage?

Good point on prefilling the output. I already got a line to initilize C in my script, just didn't included in OP

[Guillaume]

cellfun indeed does not provide any performance advantage, if anything it may be slower due to the cost of the anonymous function call. Arguably, the main advantage is that it makes it clear that whatever you're doing is transforming a sequence of something into another sequence of something. You don't have to worry about the size and shape of the input, it'll work regardless (on the other hand your loop won't work properly if A is 2d) and you don't have to worry about preallocation.

a is just an arbitrary name I chose for the input variable of the anonymous function. This will receive in turn each element of the cell array A.

[Yi-xiao Liu]

Can you explain more on the example? I find myself having hard time understanding it, though it does work

[Guillaume]

cellfun(fun, A) applies the function fun to each element of A. Here, fun is the anonymous function:

@(a) nnz(contains(B, a)) == 7

which written as normal function would be equivalent to:

function out = anonymous_function(a)
    %unlike normal functions, anonymous functions can capture variables in the enclosing function
    %so B is in scope in the anonymous function
    out = nnz(contains(B, a)) == 7;
end

which is basically the code you had originally.