matlab sum（XY）vs sum（X） - sum（Y）

Question

If we have two matrices X and Y , both two-dimensional, now mathematically we can say: sum(XY)=sum(X)-sum(Y) .

Which is more efficient in Matlab? Which is faster?

Answer 1

On my machine, sum(xy) is slightly faster for small arrays, but sum(x)-sum(y) is quite a lot faster for larger arrays. To benchmark, I'm using MATLAB R2015a on a Windows 7 machine with 32GB memory.

n = ceil(logspace(0,4,25));

for i = 1:numel(n)
    x = rand(n(i));
    y = rand(n(i));
    t1(i) = timeit(@()sum(x-y));
    t2(i) = timeit(@()sum(x)-sum(y));
    clear x y
end

figure; hold on
plot(n, t1)
plot(n, t2)
legend({'sum(x-y)', 'sum(x)-sum(y)'})
xlabel('n'); ylabel('time')
set(gca, 'XScale', 'log', 'YScale', 'log')

Answer 2

You got me all curious and I decided to run some benchmark. By the time I was done it seems knedlsepp had it right as for larger matrices sum(XY) become quite slower.

The crossover seems to happen around 10^3 elements.

%% // Benchmark code

nElem = (1:9).'*(10.^(1:6)) ; nElem = nElem(:) ;    %'//damn pretifier
nIter = numel(nElem) ;

res = zeros(nIter,2) ;
for ii=1:nIter
    X = rand(nElem(ii) ,1) ;
    Y = rand(nElem(ii) ,1) ;

    f1 = @() sum(X-Y) ;
    f2 = @() sum(X)-sum(Y) ;

    res(ii,1) = timeit( f1 ) ;
    res(ii,2) = timeit( f2 ) ;
    clear f1 f2 X Y
end

loglog(nElem,res,'DisplayName','nElem')

I ran that a few times and the results are quite consistent on my machine. I blew my memory trying to go above 10^7 elements. Feel free to extend the test but I don't think the relationship is going to change much.

---

Specs: Windows 8.1 Pro / Matlab R2013a on:

Answer 3

Assuming that both x and y have N x M = K elements, then For sum(x)-sum(y) you have:

K memory access to read x, K memory access to read y, one memory access to write the result --> 2K + 1 memory access (Assuming that the intermediate sum inside the sum function will be held in a CPU register).

2K sum operations + 1 subtraction --> 2k + 1 CPU operations.

For sum(x - y): Matlab will calculate x - y and store the output then calculate the sum, so we have K memory access to read x, K memory access to read y, K memory access to write the result of the subtraction, K memory access to read the subtraction result again for the sum function then 1 memory access to write the sum result --> 4K + 1 memory operations.

k subtractions + k summations --> 2K operations.

As we can see sum(x - y) consumes many memory access, so in large number of elements it may consume higher time but I don't have an explanation why it's faster for small number of elements.