Comments on: Zero-testing performance

By: Jan Simon

Jan Simon — Wed, 05 Oct 2016 14:58:57 +0000

I’ve published a C-Mex function to check if two array have any equal numbers:
http://www.mathworks.com/matlabcentral/fileexchange/26867-anyeq
This avoids the creation of the temporary logical array and returns early if any element is found.

a = rand(1e4)+1;
tic, b = any(a(:)==0); toc
% Elapsed time is 0.490473 seconds.
tic, b = ~all(a); toc
% Elapsed time is 0.255272 seconds.
tic, b = anyEq(a, 0); toc
% Elapsed time is 0.214196 seconds.

This is faster for finding NaNs and INFs also:

tic, b = any(isnan(a(:))); toc
% Elapsed time is 0.489283 seconds.
tic, b = anyEq(a, NaN); toc
% Elapsed time is 0.192315 seconds.

By: Yair Altman

Yair Altman — Tue, 06 Sep 2016 16:08:15 +0000

In reply to Daniel E. Shub. @Daniel - the fiery death that you reported is due to an internal Matlab bug (reported). Oddly, the crash only happens with the anonymous-function variant (@(a,b)and(a,b)) and not with the standard function-handle variant (@and).

By: ly

ly — Fri, 02 Sep 2016 16:46:29 +0000

test this:

tic, a = zeros(1e4); toc
tic, b = any(a(:)); toc
tic, c = repelem(0,1e4,1e4); toc
tic, d = any(c(:)); toc

It seems that ZEROS does not initialize an array (to 0) immediately.

By: Daniel E. Shub

Daniel E. Shub — Thu, 01 Sep 2016 14:01:11 +0000

You need to be careful with using nans in "logical" tests. While one might expect that since all(nan) is true, that and(nan, nan) would also be true. While the behavior varies with MATLAB version, and possibly OS, with R2015b on Linux:

>> and(nan, nan)
NaN's cannot be converted to logicals.

and you can cause MATLAB (again R2015b on Linux) to die a fiery death with:

bsxfun(@(a,b)and(a, b), true(10, 1), [true(10, 1), nan(10, 1)])

By: Andy Stamps

Andy Stamps — Wed, 31 Aug 2016 19:46:11 +0000

Regarding your comment about the runtime benefit from bypassing the logical array construction, I have to say that I do see the improvement on my machine (0.02-0.03 second). Given the behavior of the JIT-compiler, I think it also makes sense to perform repeated runs and average the results, particularly for these tests that take relatively little time. The 'timeit' function simplifies this process. I will also suggest that there is overhead in constructing the intermediate array a(:). In my quick testing on my computer the following seemed to perform better for all zeros or few (i.e. 1) nonzeros.

a = zeros(1e4);
f = @()all(all(a));
timeit(f)

For the case with many nonzeros described in the post, the all(all(a)) construction was noticeably slower than all(a(:)) form, but still considerably faster than the pathological cases. As with many performance tuning problems, the appropriate choice really depends on what the typical argument looks like and whether you are trying to improve average performance or the worst-case bound. Finally, I will note that the all(all(a)) formulation is only appropriate for 2-D arrays, whereas all(a(:)) is generic enough to be used on N-D arrays of any size.