Which way of programming is more efficient and faster?

Dear friends,

I would like to know whether there is a difference between following cases. Your responses are appreciated.

Case 1
X = 1;
Y = X + 4;
Z = X + Y;

Case 2
X = 1; Y = X + 4; Z = X + Y;

Other cases that I want to compare are as follows:

Case 3
v1 = k1{t};
nVar = size(v1, 2);
CP = randsample(nVar-1, 2);

Case 4
CP = randsample(size(k1{t}, 2)-1, 2);

[Shameer Parmar]

Hello Amir,

The output of Case 1 and Case2 are same, but Case 2 is faster than Case1.

The output of Case 3 and Case4 are same, but Case 4 is faster than Case3.

[Alex Mcaulley]

In my understanding Case 1 and case 2 are exactly the same. By the way, you can see it using timeit function

[Guillaume]

"but Case 2 is faster than Case1"

I would like to see some justification for that statement. The only difference between the two cases is that two carriage returns have been changed to a space. That should have no impact on the parser and certainly none on the JIT compiler.

"but Case 4 is faster than Case3"

Again, I'd like to see justification for this. There could be an undetectable gain in speed as the 2nd case doesn't have to have to register actual variable names, but it still need to allocate the memory for the temporary variables.

[Shameer Parmar]

Guillaume,

Here is the justifications.. Case 1 takes time 0.0292 sec while Case 2 take 0.0173 Sec,

So Case 2 is faster tha Csae 1 and it is optimized way of writing the code.. Any further doubt ?

% Case 1
tic
X = 1;
Y = X + 4;
Z = X + Y;
toc
Elapsed time is 0.029206 seconds.
-------------------------------------------------------------
% Case 2
tic
X = 1; Y = X + 4; Z = X + Y;
toc
Elapsed time is 0.017372 seconds.

[Alex Mcaulley]

tic-toc is not a good idea to calculate the time (it is just 1 execution). If you take into account more executions the time spent tends to be the same.

[Guillaume]

Attached, a proper test code. It repeats each test a 10000 times (otherwise timeit warns you that the timing uncertainty is too big, and test the timing 5 times. Here is the output on my machine:

>> testtiming
Code on multiple lines: 3.99263e-05
Code on a single line:  4.61002e-05

Code on multiple lines: 9.43913e-06
Code on a single line:  8.98619e-06

Code on multiple lines: 8.91961e-06
Code on a single line:  8.437e-06

Code on multiple lines: 8.50375e-06
Code on a single line:  1.23205e-05

Code on multiple lines: 1.23055e-05
Code on a single line:  9.3873e-06

I'd say it's a tie as expected.

Note that because of the JIT compiler these timings can't be relied on for real world use case anyway.

"and it is optimized way of writing the code"

Certainly not. As I answered the optimisation you should focus on is clarity, not speed. Focusing on speed before you've proven that speed is a problem is not a good way to write code. In any case, even if there were differences, they would be so minutes as to be completely undetectable by the user.

[Stephen23]

"Which way of programming is more efficient and faster?"

Case 1 is faster than Case 2: not in runtime, but definitely in reading time, understanding time, debugging time, and maintenance time.

"I would like to know whether there is a difference between following cases"

Yes, there is a major difference: Case 1 is much clearer, which in turn leads to fewer bugs and makes code easier to understand and debug.

Answer 1

[Guillaume]

No, there is no difference between the cases. More importantly, even if there was, you shouldn't care until you've proven that the operations are a bottleneck.

If you haven't proven that the operations are a bottle neck (by using the profiler), then you should care about clarity, and for that reason, you should prefer case 1 over case 2. As for the other two cases, unless nVar and v1 are going to be reused later on, I'd prefer case 4 as there's little point in creating temporary variables that are only used once.

But again, considerations about speed shouldn't even be on your radar at this point.

Answer 2

[Jan]

%Case 1
X = 1;
Y = X + 4;
Z = X + Y;

%Case 2
X = 1; Y = X + 4; Z = X + Y;

The documentation of Matlab stated, that the JIT acceleration works only, if you write one statement per line, because it needs the power to re-order the commands. In your case there is no difference, but in general 1 statement per line is preferred and, by the way, easier to read.

The JIT is not fully documented and subject to changes between Matlab versions. But I can imagine, that this feature is still valid.

% Case 3
v1 = k1{t};
nVar = size(v1, 2);
CP = randsample(nVar-1, 2);

% Case 4
CP = randsample(size(k1{t}, 2)-1, 2);

This is a question of taste. While the runtime is identical, another point gets important: The total time for solviong a problem is built by:

T_total = T_planning + T_programming + T_documentation + T_debugging + T_runtime

Optimizing such tiny pieces of code for the runtime can increase the timings for debugging and documenting. So if the code runs a microsecond faster and is called 1 million times, you save a full second. If you have a typo, which is concealed in the dense code of Case 4, but would be found directly in Case 3, you might save 1 hour of debug time.

"Premature optimization" is a bad programming practice. You loose more than you win. See https://en.wikipedia.org/wiki/Anti-pattern