I didn t go through your code, but the JIT compiler in recent versions of Matlab has improved to the point where the situation you re facing is quite common - loops can be faster than vectorized code. It is difficult to know in advance which will be faster, so the best approach is to write the code in the most natural fashion, profile it and then if there is a bottleneck, try switching from loops to vectorized (or the other way).

MATLAB s just in time compiler (JIT) has been improved significantly over the last couple years. And even though you are right that one should generally vectorize code, from my experience this is only true for certain operations and functions and also depends on how much data your functions are handling.

The best way for you to find out what works best, is to profile your MATLAB code with and without vectorization.

Maybe a matrix of a few elements is not a good test for vectorization efficiency. In the end it depends on the application on what works well.

Also, usually vectorized code looks better (more true to underlying model), but it many cases it does not and it ends up hurting the implementation. What you did is great as now you know what works best for you.

我不会说这种病媒化。

你似乎正在采取某种过滤行动。 这种过滤器的真正病媒化版本是原始数据,乘以过滤矩阵(即代表整个流体的矩阵)。

与这些矩阵有关的问题是,这些矩阵是太少的(只有少数非零元素环绕着寺院),很难有效地使用这些结构。 页: 1 即便如此,通知的用意可能不足以证明需要额外记忆。

Matlab在 lo路上很坏,因为即使是 lo门柜等也仍然被视为复杂的tric子,因此,所有对tric子的检查都经过了评估。 我的猜测是,在你申请过滤系数时,所有这些检查都始终进行。

Perhaps the matlab functions filter and filter2 are useful here? You may also ant to read this post: Improving MATLAB Matrix Construction Code : Or, code Vectorization for begginers

One possible explanation is startup overhead. If a temporary matrix is created behind the scene, be prepared for memory allocations. Also, I guess MATLAB cannot deduce that your matrix is small so there will be loop overhead. So your vectorized version may end up in code like

double* tmp=(double*)malloc(n*sizeof(double));
for(size_t k=0;k<N;++k)
    {
//  Do stuff with elements
    }
free(tmp);

Compare this to a known number of operations:

double temp[2];
temp[0]=...;
temp[1]=...;

So JIT may be faster when the malloc-loopcounter-free time is long compared to the workload for each computation.