MATLAB加速技巧

1. 向量化

目的：减少for循环的使用

`
%nonVecl.m
clear all;
tic

A=0:0.000001:10;
B=0:0.000001:10;

Z=zeros(size(A));
y=0;
for i=1:10000001
    Z(i)=sin(0.5*A(i))*exp(B(i)^2);
    y=y+Z(i);
end
toc
y
`

nonVecl.m文件使用的是for循环求和。
下面是具有相同功能的Vecl.m文件：

%Vecl.m

clear all;
tic

A=0:0.000001:10;
B=0:0.000001:10;

Z=zeros(size(A));
y=0;

y=sin(0.5*A)*exp(B.^2)';

toc
y

2.上下边界提取

当对每个元素设定上下边界时，用min和max代替if和elseif ，防止向量化被破坏。

% ifExample.m

clear all;
tic;

A=0:0.000001:10;
B=0:0.000001:10;

Z=zeros(size(A));
y=0;

for i=1:10000001

    if(A(i)<0.1) A(i)=0.1;
    elseif (A(i)>0.9) A(i)=0.9;
    end

    Z(i)=sin(0.5*A(i))*exp(B(i)^2);
    y=y+Z(i);    
end
toc
y

用min和max代替if（A<0.1）和if(A>0.9)

%nonifExample.m

clear all;
tic

A=0:0.000001:10;
B=0:0.000001:10;

Z=zeros(size(A));
y=0;

A=max(A,0.1);
%max(A,LowerBound)
%A>=LowerBound

A=min(A,0.9);
%min(A,UpperBound)
%A>=UpperBound

y=sin(0.5*A)*exp(B.^2)';

toc
y

加速结果如下：

用find代替if（A==0.5）:

if(A(i)==0.5) A(i)=0;
end

find加速：

A（find（A==0.5））=0;

3.内存预分配

调整数组大小都涉及到内存的释放或分配、数值的复制，极浪费时间。可以通过预分配内存获得加速。

%preAlloc.m
%Resizing Array

tic

x=8;
x(2)=10;
x(3)=11;
x(4)=20;

toc

%pre-allocation
tic

y=zeros(4,1);
y(1)=8;
x(2)=10;
x(3)=11;
x(4)=20;

toc

实验结果：

4.列循环嵌套

不可避免的for-loop循环，优先用列循环嵌套
行读取：

%row_first.m

clear all;

A=rand(300,300,40,40);
B=zeros(300,300,40,40);

tic
for i=1:300
    for j=1:300
        B(i,j,:,:)=2.5*A(i,j,:,:);
    end
end
toc

列读取：

%col_first.m

clear all;

A=rand(300,300,40,40);
B=zeros(300,300,40,40);

tic
for j=1:300
    for i=1:300
        B(i,j,:,:)=2.5*A(i,j,:,:);
    end
end
toc

结果：

分析：可能跟列存储机制有关，同列数据在相邻的地址。

5.稀疏矩阵

对于数据稀疏的矩阵，矩阵类型转化为稀疏矩阵，矩阵越稀疏效率越高。密集矩阵转化为稀疏矩阵运算需要花费更多的时间。
密集矩阵：

%DenseSparse.m
%Dense matrix
A=rand(5000,2000);
b=rand(5000,1);

tic
x=A\b;
toc

%Convert to sparse form in MATLAB
sp_denseA=sparse(A);

tic 
x=sp_denseA\b;
toc

稀疏矩阵：

%RealSparse.m
%Sparse matrix
sp_A2=sprand(5000,2000,0.2);
b2=rand(5000,1);

%Convert sparse matrix to full matrix
full_A2=full(sp_A2);

tic
y=full_A2\b2;
toc

tic
y=sp_A2\b2;
toc

运算结果：

对于密集的矩阵，用密集矩阵运算更快，用稀疏矩阵反而慢；对于稀疏的矩阵，用稀疏矩阵运算更快。

6.减少文件读写、设置路径和改变变量类型

文件读写、设置路径、改变变量类型需要花费大量的时间，在循环中，最好放在循环之外