Always lots of interest when there’s a quickie to try out! I will only make 2 general comments so far.

1) why the math is faster than & may have to do with the JIT and/or multi-threading - but I am not sure.
2) Solutions using find may be able to be sped up using just the logical expression instead as a logical index. It’s being computed in the find expression already, and doesn’t have to translate to locations and then index back in.

–Loren

ismember is your friend here:

>> [aa,ind] = ismember(Array2,Array1)
aa =
     1     1     1     1     1     1     1
ind =
     1     2     1     4     4     3     2

–Loren

a = [ 1  4  9  0 25  0 49  0];
b = [ 1  0  3  0  0  6  7  8];
anyzero = unique([find(a == 0), find(b == 0)]);
a(anyzero) = []
b(anyzero) = []

As with most of my code, it may not work, but it seems to match your answer. It also calls find twice, which may be costly. Finally, I am not sure if unique is better/worse than any.

I = (a == 0 | b == 0);
a(I) = [];
b(I) = [];

love your blog because of such inspiring and challenging comments to such ’small’ programming questions. My quick & dirty approach which did the job for me:

a(find(a~=0 & b~=0))
b(find(a~=0 & b~=0))

a_z = a~=0;
b_z = b~=0;
Two logical arrays, which need less memory than temporarily combining a and b
Third logical
ind = a_z|b_z;
or
ind = a_z&b_z;
depending on whether you want any or all zeros.
New variables
na = a(ind); nb = = b(ind);
This avoids combining the a and b as in the first example. And also the multiplication that was used in the second.
If you want to overwrite the original values, just negate the logical operators used here and assign
a(ind) = [];
The variables will still be moved to a new location in memory, right? As their size will change we can’t use the (1:end) index trick to keep them in the same location.

Of course, to allow NaNs (counting them as non-zero):

mask = (a~=0) & (b~=0);

The mask says “a and b should be non-zero”.

If, on reflection, NaNs should veto inclusion as well as zeros, that’s easy too:

mask = ~((a==0) | isnan(a) | (b==0) | isnan(b));

 
y = a&b;
x = a(y);
y = b(y);
 

But I was surprised to find that the second solution you posted was faster, even with the multiplication and then logical comparison all happening twice! Why is that?
I thought maybe it was because the memory for the index wasn’t specifically stored, but this is even slower (as I would have expected):

 
x2 = a(a&b);
y2 = b(a&b);
 

So how can a simple & be slower than element by element multiplication then a logical comparison?
I used a = round(rand(10000,1)*3); and similar for b.