@Michelle – thank you for the update.

Please note the extra tip here, in case the developers missed it, since it was not included in the main post body.

Also, please consider adding corresponding vectorized functions for maxdrawup/emaxdrawup – Whereas draw-ups are used less frequently than draw-downs, they too are widely used. If you wish, I’ll be happy to send you my version of maxdrawup to serve as a baseline for your developers.

Thanks for bringing the issue to our attention.

Thanks Yair–I wasn’t trying to say “look you could have sped this up!”, I was instead asking if there was a better way of performing the loop I made in the second example, using vectorization instead of a for loop, which is the un-Matlab way to do it. I was mainly disappointed that Matlab wasn’t optimizing away vectorization of X==9 in conjunction with find(X==9,1).

@Marshal – I accept that additional speedup is possible for the line you noted, in cases involving 1e9 data elements (as in your example). As I noted in my post, the new function is ~40 times faster than Matlab’s built-in function, to the point where additional speedups might not have been very cost-effective, especially since my use-case involved up to a few million (not billions of) data elements. In such cases, shaving off a few dozen millisecs did not seem to be worth the extra coding time and risk.

If you are interested in extra speedup, an additional tip would be to enclose the entire section that computes MaxIndex1, MaxIndex2 and MaxDDIndex with a check that the MaxDDIndex output arg is in fact requested – in many use cases it is not, and in such cases there is no need to compute these indexes:

if nargout > 1
   MaxIndex2 = find(MaxDD==DD,1,'last');
   MaxIndex1 = MaxIndexes(find(MaxIndexes<=MaxIndex2,1,'last'));
   MaxDDIndex(1,:) = MaxIndex1;
   MaxDDIndex(2,:) = MaxIndex2;
end

One of the lines in your code

MaxIndex2 = find(MaxDD==DD,1,'last');

is one that is incredibly common but is undoubtedly inefficient because the == compares every element, despite the fact that our call to find requests that we stop. As an example, the following two are roughly comparable in time:

% compare using vectorization
X = zeros(1e9,1); X(5e8) = 9;
tic; find(X==9,1); t_vec = toc;

% compare using a for-loop
tic;
for i = 1:length(X)
    if(X(i)==9), break; end
end
t_iter = toc;

fprintf('Vectorized: %2.2f\n',t_vec);
fprintf('Iterative: %2.2f\n',t_iter);

Vectorized: 3.94
Iterative: 3.58

However, in the following scenario, the issue becomes obvious:

X = zeros(1e9,1); X(1) = 9;
tic; find(X==9,1); t_vec = toc;

% compare using a for-loop
tic;
for i = 1:length(X)
    if(X(i)==9), break; end
end
t_iter = toc;

fprintf('Vectorized: %2.2f\n',t_vec);
fprintf('Iterative: %2.2f\n',t_iter);

Vectorized: 2.19
Iterative: 0.00

From this we can deduce that the call to find() in the first example takes about 2 seconds, with the other 2 seconds due to the comparison X==9. However, in the second example, the entirety of X is still compared to 9 before the find is called

A smart compiler would optimize away the common code pattern of find(X==y), but it appears Matlab’s JIT doesn’t. Is there a more obvious idiomatic Matlab method of avoiding performing a full comparison when it’s not necessary?

Yair, thanks for the quick reply and explanation

@John – the reason is that MaxIndexes is compared to another indices array, MaxIndex2, below. For this comparison we need numeric indices, not a logical array.

just wondering if the find function is really required
for example is: MaxIndexes = MaxData==Data; equivalent to MaxIndexes = find(MaxData==Data);

best regards