@Andrew – you may indeed be correct, but when we use a.B=c notation, the setB(a,c) function is still getting invoked if you declare it, which seems to indicate that the opposite is the case. But then it would not explain why a.B would be faster than calling setB() directly. I don’t have a good answer to explain the apparent contradiction.

This is not really the case of two different ways of invoking a method. We’re setting or getting a property. Properties can either be directly specified/obtained using set/get methods (allowing for things like validation) or via “dot” notation. The latter is much simpler and probably why this is faster. Indeed, trying to get nonexistent properties using the various methods shows that they return different error messages. When setting nonexistent properties, the set method returns an error, but the “dot” notation methods obviously do not. This additional overhead of validation may be what is slowing down get/set over repeated calls.

… the blog apparently ate my n-dash and the rest of my post. In any case, similarly, I wonder which method would be fastest for getting/setting multiple properties of the same handle when using cell arrays, i.e., as in this StackOverflow/Matlab answer of mine.

Interesting

%Setup many axes in one figure
tmp = figure;
Fig = zeros(1,10000);
for idx=1:10000
    Fig(idx) = axes('parent',tmp);
end

% Using standard set() function
tic, for idx=1:10000, set(Fig(idx),'tag','testing'); end, toc % Elapsed time is 0.163880 seconds

% Using the HG handle() wrapper within the loop
tic, for idx=1:10000, hFig = handle(Fig(idx)); set(hFig,'tag','testing'); end, toc % Elapsed time is 0.375456 seconds

% Using the HG handle() wrapper outside of the loop
tic
hFig = handle(Fig);
for idx=1:10000, set(hFig(idx),'tag','testing'); end, 
toc % Elapsed time is 0.241068 seconds

% Using dot notation with handle() wrapper within the loop
tic
for idx=1:10000, hFig = handle(Fig(idx)); hFig.tag = 'testing'; end
toc % Elapsed time is 0.290306 seconds

% Using dot notation with handle() wrapper outside of the loop
tic
hFig = handle(Fig);
for idx=1:10000, hFig(idx).tag = 'testing'; end
toc % Elapsed time is 3.585026 seconds

@Xiaohu – I do not understand why this is, but it appears to be consistent. If anyone has an explanation, I’d be happy to learn.

PPS. Adding the code to a script file and using run allows the compiled code to be used each time. Then we see

>> GShell.load('/Users/ML/blogtest.groovy')  % Load and compile once
ans =
     1

>> tic;GShell.run();toc
Elapsed time is 0.060009 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.019712 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.003378 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.003129 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.003126 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.003531 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.003365 seconds.
>> tic;GShell.run();toc
Elapsed time is 0.003394 seconds.

The performance improvements are down to HotSpot I guess.

As this is a JButton, the code should really be run on the EDT.
Using GShell.runEDT – which uses invokeAndWait – performance returns to ~0.03s.
Using GShell.runLater – which uses invokeLater – performance improves another 10x (the MATLAB thread is not blocked as control returns as soon as the code is posted to the EDT).

invokeAndWait cannot be called if already on the EDT (e.g. if javaObjectEDT has been used on the button). GShell solves that with GShell.runQuery which uses GShell.runEDT if it can, and GShell.runLater otherwise.

Note that GShell is independent of the rest of the Waterloo code – in fact it’s wrapped in an RStudio project folder and can be used from MATLAB, R, Python, SciLab, JRuby etc. It can be used to run any Java/Groovy code and control threading e.g. to create a background SwingWorker thread or work on the JavaFX platform thread.

GShell contains little or no novel code – it’s just giving easy access to a Groovy shell instance from other scripting environments.

tic;
GShell.setVariable('button', jhb);
GShell.eval('for (def idx=0; idx < 10000; idx++) { button.setText("testing")'); 
toc;

Elapsed time is 0.019272 seconds.

A ~10x improvement on the best of the above on my machine (after GShell warm up).

Further info at http://waterloo.sourceforge.net/groovy/GShell.html

Horses-for-courses: expect JVM languages to outperform MATLAB on JVM operations ; and MATLAB to (substantially) outperform the JVM when working with natives.

function SpeedTests
   fig = figure;
   for i = 1:4
      hObj(i) = subplot(2,2,i);
      handleObj{i} = handle(hObj(i));
      handleObjs2(i) = handle(hObj(i));
   end
   for itest = 1:1000
      subfun(handleObj,hObj,handleObjs2);
   end
   return
end

function subfun(handleObj,hObj,handleObjs2)
   for i = 1:4
      pos0 = handleObjs2(i).Position;
      pos1 = handleObj{i}.Position;
      pos2 = get(hObj(i),'Position');
      pos3 = handleObj{i}.Position;
      XLIMS = handleObj{i}.XLim;
   end
end

Any thoughts?