What separates Matlab from many other programming languages is the ability to vectorize code.  Vectorization allows a programmer to write code that is more intuitive, more concise, and often faster than using standard for, while and if statements.  If you have to do a large data processing task or need to create real-time application that does a large number of mathematical operations, vectorization is often a good option.  However, vectorization is not always the faster alternative for time-sensitive tasks.   I created tests for six tasks and compared the amount of time needed to run the vectorized and non-vectorized code.  The results were mixed, showing a decrease in running time for vectorized code on some tasks and a increase in running time on other tasks.  Tests involving mathematical operations ran faster using vectorized code, while tests involving conditional operators and vector creation ran faster for non-vectorized code.

[table id=13 /]

For each task, I created a non-vectorized and a vectorized version of code.  I always preallocated arrays for the non-vectorized code, to make the comparisons fair.  Preallocation decreases running time by a tremendous amount and is necessary for any tasks that are remotely time-sensitive .  I also used Monte Carlo simulations with 1000 iterations to obtain more precise values for the ratios between the two versions of the code.  For tests that used random numbers, I set the random number generator to the same state so that the two versions of code use the same random numbers.

I created six tests that represent common tasks in Matlab.  The first test was named the “Polynomial Test” and involved adding the first through fourth powers of a list of random numbers.  The second test was named the “Logarithm Test” and computed the natural logarithm of a 2-D array of random numbers.  The “Exponent Test” takes the number 3 to the power of an array of random numbers and saves the results in a new array.  The “Multiplication Test” computes the product of two numbers, each selected from a different array of random numbers.  The “Vector Creation Test” creates a horizontal vector using two different methods.  The last test is the “Conditional Test”, which finds indices where values of two arrays of random numbers are greater than a threshold.  If statements are used in the non-vectorized version of the last test, while the find function is used in the vectorized version.

The results from the tests are in the table above, in order of the tests that showed the greatest to smallest decrease in run time using vectorization.  The second column shows the results of the tests, which are expressed as the ratio between the time needed to run the vectorized code and the time needed to run the non-vectorized code.  A number below 1.0 indicates that vectorization was faster, while a number above 1.0 indicates the opposite.  The tests that used mathematical operations on a single vector decreased their run time the most using vectorization.  Multiplication of two different arrays also performed slightly faster when vectorized.  However, vector creation was slower using vectorization, which seems strange considering that this task is so often vectorized.  The Conditional Test was by far the slowest task when vectorized.  This is also surprising, since examples with conditional statements are often utilized to show the advantages of vectorization, but when preallocation and trimming are used, non-vectorized code using for and if statements actually runs faster.

These results were quite surprising to me, as they go against my previous beliefs about vectorization and my general coding practices.  In general, mathematical operations should be vectorized, although there is sometimes a limited benefit from doing so for some operations, such as exponents and multiplication of two arrays.  However, vector creation is performed slightly faster by non-vectorized code, and non-vectorized code performs conditional statements much more quickly.  When writing time-sensitive applications, programmers should take these results into account, as a 5% decrease in run time can result in a savings of hours for large data processing jobs.  However, for applications that are not time-sensitive, programmers should consider readability and ease of programming, as well.  Some code is quite difficult to write in a vectorized form, and there may be only a limited benefit in run time.  Additionally, some code is more difficult and time-consuming to write in non-vectorized form, especially for experienced Matlab programmers.  For instance, vector creation is 5% slower when vectorized, but is more readable and concise than the non-vectorized version.  Conditional tasks are significantly slower when vectorized, but for tasks that will not take long to process, the vectorized code may be the better choice in terms of readability and ease of coding.  What these tests show is that vectorization is not always desirable, and programmers should not worry too much about whether to vectorize or not vectorize code for tasks that are not time-sensitive.  In the end, the programmer should consider the trade-offs for each project and write code that is most suitable for his or her current task.

Vectorization Comparison Tests

Polynomial Test

N = 1000;
nv = zeros(N,1);
v = zeros(N,1);
ratio = zeros(N,1);

rand('state', 0)

for n = 1:N
    x = rand(100000,1);
    tic
    e = zeros(1,length(x));
    for k = 1:length(x)
         e(k) = x(k)^4 + x(k)^3 + x(k)^2 + x(k);
    end
    nv(n) = toc;
    clear e
end

rand('state', 0)

for n = 1:N
    x = rand(100000,1);
    tic
    s = x.^4 + x.^3 + x.^2 + x;
    v(n) = toc;
    clear s
end

ratio = v./nv;

disp('Poly Test')
disp(['Mean Ratio = ' num2str(mean(ratio))])

Logarithm Test

N = 1000;
nv = zeros(N,1);
v = zeros(N,1);
ratio = zeros(N,1);

rand('state', 0)

for n = 1:N
    x = rand(500,500);
    tic
    e = zeros(size(x));
    for k = 1:size(x,1)
        for j = 1:size(x,2)
            e(k,j) = log(x(k,j));
        end
    end
    nv(n) = toc;
    clear e
end

rand('state', 0)

for n = 1:N
    x = rand(500,500);
    tic
    s = log(x);
    v(n) = toc;
    clear s
end

ratio = v./nv;

disp('Log Test')
disp(['Mean Ratio = ' num2str(mean(ratio))])

Exponent Test

N = 1000;
nv = zeros(N,1);
v = zeros(N,1);
ratio = zeros(N,1);

rand('state', 0)

for n = 1:N
    x = rand(100000,1);
    tic
    e = zeros(1,length(x));
    for k = 1:length(x)
         e(k) = 3^x(k);
    end
    nv(n) = toc;
    clear e
end

rand('state', 0)

for n = 1:N
    x = rand(100000,1);
    tic
    s = 3.^x;
    v(n) = toc;
    clear e
end

ratio = v./nv;

disp('Expo Test')
disp(['Mean Ratio = ' num2str(mean(ratio))])

Multiplication Test

N = 1000;
nv = zeros(N,1);
v = zeros(N,1);
ratio = zeros(N,1);

rand('state', 0)

for n = 1:N
    x = rand(1000000,1);
    y = rand(1000000,1);

    tic
    e = zeros(1,length(x));
    for k = 1:length(x)
         e(k) = x(k)*y(k);
    end
    nv(n) = toc;
    clear e
end

rand('state', 0)

for n = 1:N
    x = rand(1000000,1);
    y = rand(1000000,1);

    tic
    s = x.*y;
    v(n) = toc;
    clear s
end

ratio = v./nv;

disp('Mult Test')
disp(['Mean Ratio = ' num2str(mean(ratio))])

Vector Creation Test

N = 1000;
nv = zeros(N,1);
v = zeros(N,1);
ratio = zeros(N,1);

for n = 1:N
    tic
    g = zeros(1000000,1);
    for m = 1:1000000
         g(m) = 3*m;
    end
    nv(n) = toc;
    clear g
end

for n = 1:N
    tic
    h = 3:3:3000000;
    v(n) = toc;
    clear h
end

ratio = v./nv;

disp('Create Vector Test')
disp(['Mean Ratio = ' num2str(mean(ratio))])

Conditional Test

N = 1000;
nv = zeros(N,1);
v = zeros(N,1);
ratio = zeros(N,1);

rand('state', 0)

for n = 1:N

    X = randn(1000000,1);
    Y = randn(1000000,1);

    tic
    A = zeros(size(X));
    c = 1;
    for k = 1:length(X)
        if (Y(k) > 0.3) & (X(k) > 0.3)
            A(c) = k;
            c = c + 1;
        end
    end
    A = A(1:c-1);
    nv(n) = toc;
    clear A
end

rand('state', 0)

for n = 1:N
    X = randn(1000000,1);
    Y = randn(1000000,1);

    tic
    B = find((Y > 0.3) & (X > 0.3));
    v(n) = toc;
    clear B
end

ratio = v./nv;

disp('If Test')
disp(['Mean Ratio = ' num2str(mean(ratio))])