Performance 为什么对存储在单元格中的数据的访问时间比存储在矩阵中的短？

我在matlab中处理非常大的数据，并用于将这些数据存储在矩阵中。我过去习惯于按行存储数据，但由于Matlab按列存储数据，我知道重新调整矩阵的形状以便按列索引可以加快处理速度。这里有一个例子来说明我的意思：

---

一般参数

nbr_channels = 20;
nbr_samples_per_channel = 3200000;
fake_data = randn(1, nbr_samples_per_channel);
ROI = 1200000 : 2800000;

按行分配数据

data = nan(nbr_channels, nbr_samples_per_channel);
tic; 
for j = 1 : nbr_channels
    data(j, 1:nbr_samples_per_channel) = fake_data; 
end; 
toc;

% Elapsed time is 1.476525 seconds.

从行矩阵返回数据

tic; 
for j = 1 : nbr_channels
    bla = data(j, ROI); 
end; 
toc;

% Elapsed time is 0.572162 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(j, :); 
end; 
toc;

% Elapsed time is 0.589489 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(ROI, j); 
end; 
toc;

% Elapsed time is 0.260824 seconds.

tic; 
f    or j = 1 : nbr_channels
    bla = data(:, j); 
end; 
toc;

% Elapsed time is 0.092983 seconds.

返回行矩阵中的所有数据

tic; 
for j = 1 : nbr_channels
    bla = data(j, ROI); 
end; 
toc;

% Elapsed time is 0.572162 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(j, :); 
end; 
toc;

% Elapsed time is 0.589489 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(ROI, j); 
end; 
toc;

% Elapsed time is 0.260824 seconds.

tic; 
f    or j = 1 : nbr_channels
    bla = data(:, j); 
end; 
toc;

% Elapsed time is 0.092983 seconds.

按列分配数据

data = nan(nbr_samples_per_channel, nbr_channels);
tic; 
for j = 1 : nbr_channels
    data(1:nbr_samples_per_channel, j) = fake_data; 
end; 
toc;

% Elapsed time is 0.299682 seconds.

从列矩阵返回数据

tic; 
for j = 1 : nbr_channels
    bla = data(j, ROI); 
end; 
toc;

% Elapsed time is 0.572162 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(j, :); 
end; 
toc;

% Elapsed time is 0.589489 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(ROI, j); 
end; 
toc;

% Elapsed time is 0.260824 seconds.

tic; 
f    or j = 1 : nbr_channels
    bla = data(:, j); 
end; 
toc;

% Elapsed time is 0.092983 seconds.

返回列矩阵中的所有数据

tic; 
for j = 1 : nbr_channels
    bla = data(j, ROI); 
end; 
toc;

% Elapsed time is 0.572162 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(j, :); 
end; 
toc;

% Elapsed time is 0.589489 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data(ROI, j); 
end; 
toc;

% Elapsed time is 0.260824 seconds.

tic; 
f    or j = 1 : nbr_channels
    bla = data(:, j); 
end; 
toc;

% Elapsed time is 0.092983 seconds.

---

摘要第1部分：

正如我们所看到的，按列访问数据将处理时间至少减少了两倍

但我不明白为什么细胞更有效！看看这个例子：

按单元格分配数据

data = cell(1, nbr_samples_per_channel);
tic; 
for j = 1 : nbr_channels
    data{j} = fake_data; 
end; 
toc;

% Elapsed time is 0.000013 seconds.

从单元格数组返回数据

tic; 
for j = 1 : nbr_channels
    bla = data{j}(ROI); 
end; 
toc;

% Elapsed time is 0.260294 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data{j}; 
end; 
toc;

% Elapsed time is 0.000022 seconds.

%%

返回单元格数组中的所有数据

tic; 
for j = 1 : nbr_channels
    bla = data{j}(ROI); 
end; 
toc;

% Elapsed time is 0.260294 seconds.

tic; 
for j = 1 : nbr_channels
    bla = data{j}; 
end; 
toc;

% Elapsed time is 0.000022 seconds.

%%

---

摘要第2部分：

这比我在第1部分中展示的要快几个数量级

问题1

为什么对存储在单元格中的数据的访问时间比存储在矩阵中的短

问题2

使用矩阵通常比使用单元格更容易，因为使用矩阵就可以了

my_矩阵（100:20000，1:3）

---

但就我所知，用细胞我做不到这一点。关于如何同时从多个单元格返回特定元素，还有其他选择吗？

您看到的是不同的时间，因为您没有做相同的事情。要比较您的两个案例：

按单元格分配数据

data = cell(1, nbr_samples_per_channel);
tic; 
for j = 1 : nbr_channels
    data{j} = fake_data; 
end; 
toc;

% Elapsed time is 0.000013 seconds.

• 您正在创建一个单元格数组行向量，并向每个单元格填充一个长的双向量

• 每次循环迭代都会将一个向量分配到单元数组中的一个插槽中

• 正在完成的分配数为“每个频道的nbr\U样本数”

按列分配数据

data = nan(nbr_samples_per_channel, nbr_channels);
tic; 
for j = 1 : nbr_channels
    data(1:nbr_samples_per_channel, j) = fake_data; 
end; 
toc;

% Elapsed time is 0.299682 seconds.

• 您将遍历矩阵的列，并为每列中的每个元素指定一个向量

• 每个循环迭代，不管您使用的缩写冒号：表示法是什么，都会分解为许多赋值。数据（1:nbr\U每个通道的样本数，j）表示每次迭代的“nbr\U每个通道的样本数”分配

• 总体而言，您正在执行“每个频道的nbr\U样本”*“nbr\U频道”总分配

for j = 1 : nbr_channels    

    n = length(fake_data)

    data(1,     j) = fake_data(1); 
    data(2,     j) = fake_data(1); 

    ... etc ...

    data(n - 1, j) = fake_data(n-1); 
    data(n,     j) = fake_data(n); 

end

为了说明我的观点，只需在不使用冒号操作符的情况下重新编写循环，以可视化所有赋值

for j = 1 : nbr_channels    

    n = length(fake_data)

    data(1,     j) = fake_data(1); 
    data(2,     j) = fake_data(1); 

    ... etc ...

    data(n - 1, j) = fake_data(n-1); 
    data(n,     j) = fake_data(n); 

end

总之，你在比较两个不同的东西，所以你不能说一个比另一个快，因为它们是不相等的

如果您只是循环一个双数组和一个单元格数组，并执行常规赋值

%% Setup samples and pre-allocate
numberOfSamples = 100000;

doubleData = nan(numberOfSamples, 1);
cellData = cell(numberOfSamples, 1);

randomValues = rand(numberOfSamples, 1);

%% Assign N number of values to a double array
tic; 
for idx = 1 : numberOfSamples
    data(numberOfSamples) = randomValues(idx);
end
doubleTime = toc;

%% Assign N number of values to a cell array
tic; 
for idx = 1 : numberOfSamples
    cellData{numberOfSamples} = randomValues(idx);
end
cellTime = toc;

disp(sprintf('Double Array: %f seconds', doubleTime));
disp(sprintf('Cell   Array: %f seconds', cellTime));

你最终会得到：

Double Array: 0.006073 seconds
Cell   Array: 0.032966 seconds

---

关于你的第二个问题，这就是你想要做的吗

>> bigCell = {1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16}

bigCell = 

    [ 1]    [ 2]    [ 3]    [ 4]
    [ 5]    [ 6]    [ 7]    [ 8]
    [ 9]    [10]    [11]    [12]
    [13]    [14]    [15]    [16]

>> subCell = bigCell(1:2, 3:4)

subCell = 

    [3]    [4]
    [7]    [8]

---

请注意，子单元仍然是一个单元。通过使用（）而不是{}来访问单元格，可以将其保留为一个单元格。

只是一个小注释：赋值时，这样做更快：

对于j=1:nbr\u通道数据（j，：）=fake\u数据；结束（
1.962057秒。
）大于
对于j=1:nbr\u通道数据（j，1:nbr\u每个通道的样本）=伪数据；结束（
2.608001秒。
）