雅可比方法的两种算法:为什么时间会发生变化?

时间:2014-08-31 07:04:44

标签: algorithm matlab

我已经实现了Jacobi算法,以两种方式迭代求解线性系统。它们都是先检查一下是否可以应用该方法,然后明确地构造迭代矩阵P和迭代'添加了向量c,而另一个使用每个迭代的子函数逐个组件地计算新的向量。这是第一个:

function [x,nit,t,invt] = jacobi(A,b,tol,x0,NMAX)
%Perfetto equivalente di jacobsparse.m che lavora con A in formato full e
%restituisce sia il tempo impiegato a risolvere il sistema sia quello
%impiegato per invertire la matrice D che serve a calcolare la matrice di
%iterazione.
if nargin < 5
    NMAX=100;
    %Se il max di iterazioni non ? dato, viene automaticamente impostato a
    %100.
    if nargin < 4
        x0=zeros(1,length(A));
        %Se l'innesco non ? dato, viene automaticamente impostato al
        %vettore nullo.
        if nargin < 3
            error('Mi devi dare almeno la matrice, il termine noto e la tolleranza')
            %Se manca anche la tolleranza, non volendo dare un valore di
            %default che non sapevo come sceglierlo, gli faccio dare
            %errore.
        end
    end
end
matsize=size(A);
if matsize(1)~=length(b)
    error('Le dimensioni di matrice e termine noto non concordano')
    %Se b non ? A per un vettore, allora non posso risolvere il sistema.
end
if matsize(2)~=length(x0)
    error('Le dimensioni di matrice e vettore d''innesco non concordano')
    %Se A*x0 non ? definito, l'innesco non ha la dimensione giusta per
    %poter risolvere il sistema.
end
if matsize(1)~=matsize(2)
    error('Non posso applicare il metodo a matrici rettangolari.')
    %Il metodo di Jacobi non si pu? applicare a matrici rettangolari perch?
    %le componenti delle iterate si ricavano in corrispondenza con quelle
    %del termine noto, e se i numeri di componenti di b e di x sono diversi
    %non riesco a risolvere il problema.
end
for i=1:min(size(A))
    if A(i,i)==0
        error('Non posso applicare il metodo causa elemento diagonale (%.0f,%.0f) nullo.',i,i)
        %Il metodo richiede di dividere almeno una volta per ogni elemento
        %diagonale, quindi se un elemento ? nullo ci fermiamo subito, prima
        %che capiti "Division by zero", che poi su MATLAB manco d? errore,
        %d? Inf.
    end
end
nit=0;
incr=tol;
xold=x0;
%Inizializzo queste variabili in modo da poterle usare subito. nit ?
%ovviamente 0, poi viene incrementato; incr lo metto a tol cos? entra nel
%ciclo; xold parte da x0.
diagon=diag(A,0);
D=diag(diagon);
LU=A-D;
tic
Dinv=inv(D);
invt=toc;
P=Dinv*LU;
c=Dinv*b;
tic
while nit < NMAX && incr >= tol
    nit = nit + 1;
    %Incremento il numero di iterazioni.
    xnew = P*xold+c;
    %Ricavo con la subfunction il vettore xnew dell'iterata corrente.
    x = xnew;
    %Metto xnew in x, cos? se si esce x ? gi? sistemato.
    incr = norm(xnew-xold);
    %Salvo la norma dell'incremento.
    xold=xnew;
    %Metto xnew in xold, cosicch? la prossima iterata usi xnew come xold e
    %ricavi il corrispondente xnew.
end
t=toc;
end

这是第二个:

function [x,nit,t] = jacobsparse(A,b,tol,x0,NMAX)
%Restituisce la soluzione x del sistema con matrice A e b in ingresso,
%ottenuta col metodo di Jacobi con tolleranza tol in ingresso, innesco x0
%in ingresso o automaticamente nullo, e massimo di iterazioni NMAX in
%ingresso o automaticamente 100. Se non ha abbastanza input, d? errore.
%Lavora con A in formato sparse. L'equivalente in formato full ? jacobi.m.
%Restituisce anche il numero di iterazioni effettivamente compiute nit e il
%tempo impiegato t. Si serve di jac_iter.m per le singole iterazioni del
%metodo.
if nargin < 5
    NMAX=100;
    %Se il max di iterazioni non ? dato, viene automaticamente impostato a
    %100.
    if nargin < 4
        x0=zeros(length(A),1);
        %Se l'innesco non ? dato, viene automaticamente impostato al
        %vettore nullo.
        if nargin < 3
            error('Mi devi dare almeno la matrice, il termine noto e la tolleranza')
            %Se manca anche la tolleranza, non volendo dare un valore di
            %default che non sapevo come sceglierlo, gli faccio dare
            %errore.
        end
    end
end
matsize=size(A);
if matsize(1)~=length(b)
    error('Le dimensioni di matrice e termine noto non concordano')
    %Se b non ? A per un vettore, allora non posso risolvere il sistema.
end
if matsize(2)~=length(x0)
    error('Le dimensioni di matrice e vettore d''innesco non concordano')
    %Se A*x0 non ? definito, l'innesco non ha la dimensione giusta per
    %poter risolvere il sistema.
end
if matsize(1)~=matsize(2)
    error('Non posso applicare il metodo a matrici rettangolari.')
    %Il metodo di Jacobi non si pu? applicare a matrici rettangolari perch?
    %le componenti delle iterate si ricavano in corrispondenza con quelle
    %del termine noto, e se i numeri di componenti di b e di x sono diversi
    %non riesco a risolvere il problema.
end
for i=1:min(size(A))
    if A(i,i)==0
        error('Non posso applicare il metodo causa elemento diagonale (%.0f,%.0f) nullo.',i,i)
        %Il metodo richiede di dividere almeno una volta per ogni elemento
        %diagonale, quindi se un elemento ? nullo ci fermiamo subito, prima
        %che capiti "Division by zero", che poi su MATLAB manco d? errore,
        %d? Inf.
    end
end
nit=0;
incr=tol;
xold=x0;
%Inizializzo queste variabili in modo da poterle usare subito. nit ?
%ovviamente 0, poi viene incrementato; incr lo metto a tol cos? entra nel
%ciclo; xold parte da x0.
tic
while nit < NMAX && incr >= tol
    nit = nit + 1;
    %Incremento il numero di iterazioni.
    xnew = jac_iter(A,xold,b);
    %Ricavo con la subfunction il vettore xnew dell'iterata corrente.
    x = xnew;
    %Metto xnew in x, cos? se si esce x ? gi? sistemato.
    incr = norm(xnew-xold);
    %Salvo la norma dell'incremento.
    xold=xnew;
    %Metto xnew in xold, cosicch? la prossima iterata usi xnew come xold e
    %ricavi il corrispondente xnew.
end
t=toc;
end

具有以下子功能:

function xnew = jac_iter(A,xold,b)
xnew=zeros(length(xold),1);
for i=1:length(xold)
    xnew(i)=b(i);
    %Comincio a mettere b(i) in xnew(i).
    for j=1:i-1
        xnew(i) = xnew(i)-A(i,j)*xold(j);
        %Poi ci sottraggo la somma per j<i di A(i,j)*xold(j).
    end
    for j=i+1:length(xold)
        xnew(i) = xnew(i)-A(i,j)*xold(j);
        %Poi ci sottraggo la somma per j>i.
    end
    xnew(i)=xnew(i)/A(i,i);
    %Infine divido il tutto per A(i,i), cos? divido solo una volta. Il
    %ciclo naturalmente va da 1 a size(xold)=size(xnew).
end
end

对于意大利语中的评论感到抱歉,但是我用意大利语写了这些评论,因为这将被放入&#34;报告&#34;在意大利语和英语评论似乎不合适。我想谷歌不应该对这些做得太糟糕。如果您希望我翻译它们,请告诉我。无论如何,我的问题是:为什么第一个,在2000×2000的全格式稀疏矩阵中,需要大约5.4e-1秒来反转对角矩阵和1.8e-1秒来解决系统只有最多200次迭代91次,而200次迭代后的第二次迭代结束其工作耗时1e4秒?这意味着,假设一次迭代的时间是恒定的,那么数字2将花费大约5e3秒来执行数字1在~2s中所做的相同事情!然而,他们应该以不同的顺序或多或少地做同样的操作!为什么1号收敛而2号不收?我在这里错过了什么吗?最后,我被告知要实现两个不同的函数来将这个算法应用于完整和稀疏格式的矩阵,并且我找不到任何明智的理由。有什么想法吗? PS如果你觉得我应该分开问这个问题,请告诉我,我会。

更新 按照迈克尔的建议,我写了下面的代码:

clear all
clc
for i=1:200
    [A,A1]=sparsa2(10*i);
    tic
    xnew=jac_iter(A,zeros(10*i,1),ones(10*i,1));
    times(1,i)=toc;
    toc
    tic
    xnew=jac_iter(A1,zeros(10*i,1),ones(10*i,1));
    times(2,i)=toc;
    toc
    tic
    diagmat=diag(diag(A1,0));
    Dinv=inv(diagmat);
    LU=A1-diagmat;
    P=Dinv*LU;
    c=Dinv*ones(10*i,1);
    times(3,i)=toc;
    toc
    tic
    xnew2=P*zeros(10*i,1)+c;
    times(4,i)=toc;
    toc
end

这使用以下功能:

function [A,A1]=sparsa2(n,dens)
%Crea una matrice n-per-n sparsa con densit? dens tramite sprand; la
%densit? si pu? lasciare automaticamente impostata a 20. La function si
%sincera anche che la diagonale non contenga zeri.
if nargin == 0
    error('Almeno la dimensione me la devi dare, se no come ti faccio la matrice sparsa?')
    %Se non viene data la dimensione, errore.
elseif nargin == 1
    dens = 20;
    %Se non viene data la densit?, si imposta automaticamente a 20.
end
A=rand(n);
%Si crea la matrice.
tol=dens/100;
%Si salva la densit? in formato decimale.
for i=1:n
    for j=1:n
        if A(i,i)<tol && i~=j
            A(i,i)=0;
            %Si impone una sparsit? con densit? di non zeri dens azzerando
            %tutto quello che nella matrice sta sotto a dens/100;
            %ovviamente questo si basa sull'euristica che la probabilit? di
            %ottenere con rand un numero qualunque sia sempre la stessa e
            %evita di azzerare entrate diagonali.
        end
    end
end
for i=1:n
    if A(i,i)==0
        A(i,i)=rand;
    end
    %Visto che questa function devo usarla per fornire matrici a Jacobi, mi
    %sincero che sulla diagonale non ci siano zeri, altrimenti Jacobi non
    %si pu? applicare. Per ottimizzare i tempi non sostituisco con rand
    %tutte le entrate diagonali di A, ma solo quelle nulle, che vengono
    %individuate con un condizionale.
end
A1=A;
A=sparse(A);
%Memorizzo in A1 il formato full, che per ora ? quello di A, e poi metto
%in A il formato sparse.

与意大利语中的评论相同。我使用rand然后归零一些术语因为sprand,除了没有观察非零的密度要求(第三个参数是非零的密度,而不是零的密度,对吧? ),需要aaaaaages产生一个矩阵,然后它仍然必须非对角线,否则Jacobi算法不能应用。我在运行该代码的过程中受到了厌倦,并在大约i=185停了下来,获得了以下times'

    0.0067    0.0033    0.0029    0.0003
    0.0075    0.0001    0.0003    0.0001
    0.0156    0.0001    0.0552    0.0000
    0.0201    0.0001    0.0003    0.0000
    0.0409    0.0001    0.0003    0.0000
    0.0613    0.0002    0.0004    0.0000
    0.0720    0.0003    0.0006    0.0001
    0.1075    0.0003    0.0007    0.0001
    0.1186    0.0003    0.0009    0.0001
    0.1515    0.0004    0.0008    0.0001
    0.1915    0.0004    0.0010    0.0001
    0.2400    0.0005    0.0015    0.0001
    0.2494    0.0006    0.0025    0.0001
    0.2902    0.0007    0.0026    0.0001
    0.3299    0.0008    0.0026    0.0001
    0.3408    0.0008    0.0029    0.0002
    0.3995    0.0012    0.0038    0.0002
    0.4324    0.0012    0.0039    0.0001
    0.4687    0.0014    0.0062    0.0003
    0.5365    0.0015    0.0061    0.0003
    0.5922    0.0017    0.0072    0.0001
    0.6417    0.0019    0.0070    0.0001
    0.6970    0.0020    0.0076    0.0001
    0.7088    0.0022    0.0082    0.0001
    0.8002    0.0027    0.0087    0.0002
    0.8338    0.0025    0.0117    0.0004
    0.9091    0.0026    0.0105    0.0003
    0.9981    0.0033    0.0110    0.0001
    1.0528    0.0034    0.0121    0.0001
    1.1499    0.0038    0.0117    0.0002
    1.1778    0.0038    0.0143    0.0001
    1.2721    0.0042    0.0156    0.0002
    1.3673    0.0046    0.0182    0.0002
    1.4727    0.0045    0.0183    0.0002
    1.5056    0.0049    0.0211    0.0003
    1.6287    0.0052    0.0214    0.0003
    1.6792    0.0057    0.0163    0.0002
    1.7923    0.0061    0.0226    0.0002
    1.8907    0.0062    0.0220    0.0002
    2.0210    0.0067    0.0227    0.0002
    2.0612    0.0071    0.0281    0.0003
    2.1789    0.0076    0.0290    0.0003
    2.3028    0.0076    0.0274    0.0002
    2.3854    0.0079    0.0253    0.0002
    2.5192    0.0088    0.0326    0.0003
    2.6105    0.0089    0.0314    0.0003
    2.7601    0.0093    0.0375    0.0012
    2.9112    0.0094    0.0340    0.0002
    3.0224    0.0106    0.0350    0.0002
    3.1576    0.0108    0.0420    0.0003
    3.2817    0.0107    0.0357    0.0004
    3.4132    0.0112    0.0392    0.0003
    3.5205    0.0118    0.0505    0.0004
    3.6826    0.0122    0.0432    0.0003
    3.8778    0.0134    0.0581    0.0005
    4.0303    0.0135    0.0499    0.0003
    4.1311    0.0147    0.0496    0.0003
    4.2592    0.0148    0.0583    0.0004
    4.4248    0.0149    0.0625    0.0004
    4.6334    0.0154    0.0580    0.0004
    4.7406    0.0164    0.0566    0.0004
    4.9101    0.0166    0.0676    0.0004
    5.0624    0.0171    0.0616    0.0004
    5.2709    0.0188    0.0762    0.0004
    5.4508    0.0180    0.0739    0.0004
    5.6180    0.0189    0.0724    0.0004
    5.8853    0.0192    0.0825    0.0004
    6.0036    0.0199    0.0798    0.0004
    6.1707    0.0219    0.0968    0.0005
    6.3741    0.0206    0.0880    0.0005
    6.5337    0.0215    0.0915    0.0004
    6.8124    0.0211    0.1028    0.0005
    6.9312    0.0222    0.1058    0.0004
    7.1312    0.0227    0.1030    0.0005
    8.2538    0.0266    0.1238    0.0005
    8.5937    0.0243    0.1033    0.0006
    7.7826    0.0248    0.1040    0.0004
    8.1156    0.0272    0.1137    0.0005
    8.3723    0.0261    0.1245    0.0006
    8.5101    0.0262    0.1351    0.0006
    8.6796    0.0272    0.1374    0.0006
    8.9729    0.0279    0.1339    0.0006
    9.2011    0.0285    0.1350    0.0006
    9.6675    0.0288    0.1466    0.0005
    9.8925    0.0304    0.1452    0.0006
   10.0381    0.0328    0.1553    0.0008
   10.4903    0.0315    0.1671    0.0007
   10.5815    0.0308    0.1627    0.0006
   10.8701    0.0327    0.1761    0.0006
   11.1378    0.0331    0.1651    0.0007
   11.2975    0.0342    0.1768    0.0006
   11.4691    0.0352    0.1916    0.0006
   11.7784    0.0370    0.1795    0.0007
   12.1960    0.0357    0.1776    0.0006
   12.4342    0.0374    0.1897    0.0007
   12.6972    0.0415    0.2034    0.0006
   13.0002    0.0380    0.2269    0.0007
   13.2209    0.0394    0.2218    0.0006
   13.5231    0.0410    0.2234    0.0008
   13.7816    0.0403    0.2123    0.0007
   14.1996    0.0415    0.2354    0.0009
   14.6795    0.0426    0.2491    0.0007
   14.8138    0.0436    0.2456    0.0009
   14.9901    0.0425    0.2394    0.0007
   15.5859    0.0455    0.2608    0.0008
   15.9803    0.0457    0.2673    0.0008
   16.0887    0.0475    0.2418    0.0008
   16.3703    0.0487    0.2887    0.0008
   16.9425    0.0492    0.3165    0.0008
   18.7806    0.0584    0.3333    0.0010
   21.7533    0.0506    0.3116    0.0008
   20.3409    0.0545    0.2927    0.0008
   18.5046    0.0538    0.3411    0.0008
   18.6049    0.0529    0.3154    0.0011
   19.3019    0.0533    0.3359    0.0010
   19.6578    0.0544    0.3567    0.0010
   19.9678    0.0555    0.3432    0.0009
   20.2023    0.0569    0.3234    0.0012
   20.8636    0.0581    0.3588    0.0010
   20.8515    0.0568    0.3348    0.0009
   21.5589    0.0593    0.4119    0.0010
   21.6361    0.0614    0.3526    0.0012
   21.9093    0.0618    0.3932    0.0011
   22.3367    0.0622    0.3873    0.0010
   22.5436    0.0633    0.4033    0.0010
   23.1500    0.0642    0.4152    0.0011
   23.8644    0.0657    0.4237    0.0010
   24.4362    0.0986    0.4828    0.0012
   24.5771    0.0704    0.4227    0.0012
   24.6004    0.0675    0.4672    0.0010
   25.1526    0.0709    0.4508    0.0012
   25.4833    0.0720    0.4298    0.0012
   25.8981    0.0719    0.4657    0.0013
   26.3997    0.0720    0.4826    0.0013
   26.7230    0.0740    0.5216    0.0013
   27.2369    0.0739    0.4747    0.0012
   27.6131    0.0763    0.5270    0.0012
   29.5497    0.0804    0.5495    0.0014
   29.7541    0.0804    0.5224    0.0013
   29.4014    0.0794    0.5366    0.0014
   30.3006    0.0811    0.5419    0.0013
   30.7948    0.0825    0.5798    0.0018
   31.0410    0.0842    0.5704    0.0012
   31.4454    0.0921    0.5945    0.0013
   32.7923    0.0839    0.5688    0.0015
   33.2333    0.0862    0.5950    0.0015
   34.1797    0.0872    0.5905    0.0021
   35.1448    0.0925    0.5921    0.0017
   35.4237    0.0951    0.6729    0.0016
   36.1466    0.0934    0.6738    0.0018
   36.6392    0.0945    0.6435    0.0016
   37.1361    0.0981    0.6345    0.0014
   37.5505    0.0964    0.6789    0.0015
   37.9392    0.0975    0.7185    0.0016
   38.6308    0.0996    1.5555    0.0020
   39.1776    0.0997    0.7734    0.0018
   39.7029    0.1030    0.6917    0.0016
   40.2277    0.1021    0.6831    0.0015
   40.5795    0.1064    0.7645    0.0018
   41.5639    0.1138    0.8422    0.0023
   41.3331    0.1155    0.7962    0.0019
   42.5029    0.1116    0.8032    0.0016
   42.6863    0.1089    0.7750    0.0020
   43.2784    0.1730    2.2928    0.0019
   44.0860    0.1119    0.8629    0.0017
   44.9578    0.1144    0.8481    0.0019
   45.4306    0.1186    1.0030    0.0020
   45.9325    0.1208    0.8851    0.0017
   46.9734    0.1220    0.8957    0.0021
   47.8684    0.1191    0.9411    0.0022
   47.7906    0.1251    0.9779    0.0017
   48.5830    0.1206    0.9621    0.0022
   49.0313    0.1229    0.9828    0.0022
   49.6555    0.1255    0.9881    0.0023
   50.4140    0.1258    0.9727    0.0023
   51.0908    0.1365    0.9776    0.0023
   51.9044    0.1459    1.0970    0.0023
   52.7301    0.1314    1.0280    0.0022
   53.6985    0.1329    1.3397    0.0017
   53.6170    0.1329    1.0780    0.0020
   54.6879    0.1364    1.1436    0.0024
   55.1210    0.1402    1.1096    0.0020
   57.6322    0.1428    1.1453    0.0020
   57.0160    0.1417    1.2097    0.0021

我已经准备好运行缺失位的脚本,但我认为可能没有必要。观察以sparse格式提供矩阵的方式如何增加jac_iter所需时间的50倍,前者分别为前两列,sparsefull。第三列是算法1用完整矩阵计算 P 的时间,最后一列是算法1的迭代。如您所见,如果我们计算结构,算法1需要更长的时间 P ,否则相反,并且在任何情况下sparse矩阵需要更长时间。显然,从sparse矩阵中检索条目也比从full矩阵中检索相同条目要长得多。在F=sprand(4,7,20)之后,我跑了:

tic
F(1,2);
tt(1)=toc;
toc
tic
F1(1,2);
tt(2)=toc;
toc

两次,得到了:

   1.0e-03 *

   0.612686000000000   0.001495000000000


   1.0e-04 *

   0.547670000000000   0.020670000000000

在左侧,检索F(1,2)sparse格式的时间;在右边,相同的条目,但来自F1=full(F)。无论如何,稀疏矩阵的数量超过10倍。这是为什么?如何优化稀疏矩阵的Jacobi算法?

1 个答案:

答案 0 :(得分:0)

我不是matlab的专家,但我认为你的问题是普遍的问题。在第一个算法中,您进行的计算少于第二个算法。更准确地说,在第一种情况下,一些计算只执行一次,而在第二种情况下,它们会在while循环的每次迭代中重复。

如果我正确理解您的代码,请使用第一个算法中的以下片段:

diagon=diag(A,0);
D=diag(diagon);
LU=A-D;
tic
Dinv=inv(D);
invt=toc;
P=Dinv*LU;
c=Dinv*b;

是第二种算法中 jac_iter 函数的等价物。不同之处在于,当 jac_iter 函数在 while 循环中多次执行时,此片段仅在 循环之前执行一次,并且它是一个优化的地方。

<强>更新

在我看来,如果您的数据不是非常稀疏的,即当它们包含很多非零值时,您不应该使用稀疏矩阵。在上一个示例中,您使用了以下代码 F = sprand(4,7,20) sprand 函数的最后一个参数取0到1的值。通过指定20作为第三个参数,您创建了一个不包含零的稀疏矩阵。

以下代码显示了稀疏矩阵和完整矩阵的行为,具体取决于矩阵中的零个数。我测量了乘法和读取矩阵中所有单元的时间:

density = [0.01, 0.02, 0.05, 0.1, 0.25, 0.5, 0.75, 0.95];
N = 1000
for x=1:length(density)
    A = sprand(N,N,density(x));
    elapsed(x,1) = density(x);

    tic;
    Z = A*A;
    elapsed(x,2)=toc;

    tic;
    sum = 0;
    for i=1:N
        for j=1:N
            sum = sum + A(i,j);
        end
    end
    elapsed(x,3)=toc;

    B = full(A);

    tic;
    Y = B*B;
    elapsed(x,4)=toc;

    tic;
    sum2 = 0;
    for i=1:N
        for j=1:N
            sum2 = sum2 +  B(i,j);
        end
    end
    elapsed(x,5)=toc;
end

N = 100的结果是:

Density   Sparse    Sparse    Full      Full
          multip.   retrieval multip.   retrieval 
0.0100    0.0001    0.0795    0.0030    0.0002
0.0200    0.0001    0.0996    0.0153    0.0002
0.0500    0.0002    0.0959    0.0031    0.0002
0.1000    0.0006    0.1651    0.0007    0.0002
0.2500    0.0013    0.1110    0.0080    0.0002
0.5000    0.0019    0.0898    0.0006    0.0002
0.7500    0.0012    0.0861    0.0052    0.0002
0.9500    0.0025    0.0823    0.0161    0.0002

N = 1000的结果是:

Density   Sparse    Sparse    Full      Full
          multip.   retrieval multip.   retrieval 
0.0100    0.0088    7.5884    0.1216    0.1047
0.0200    0.0464    7.3136    0.1149    0.0521
0.0500    0.0827    7.0464    0.1733    0.0811
0.1000    0.1265    7.3251    0.0739    0.0563
0.2500    0.2088    7.5518    0.1392    0.0702
0.5000    0.5299    8.1214    0.0895    0.0579
0.7500    0.9524    9.0760    0.0836    0.1023
0.9500    1.3971    9.1553    0.1006    0.1208

结论很简单。如果矩阵中有很多零,则稀疏格式很好。此外,如果要逐个访问单元格,则不应使用稀疏矩阵。当然,对于较小的矩阵,差异并不那么重要。