2

我有一个结构数组，包含三个字段——一个数组、数组的长度和一个数字。

N = 5;
data = struct;
for i=1:N
    n = ceil(rand * 3);
    data(i).len = n;
    data(i).array = rand(1,n);
    data(i).number = i;
end

数据如下所示：

data = 
1x5 struct array with fields:
    len    = [ 1 3 3 1 1 ]
    array  = [[0.8]; [0.7 0.9 0.4]; [0.7 0 0.3]; [0.1]; [0.3]]
    number = [ 1 2 3 4 5 ]

我可以通过多种方式将数组作为 1x9 数组返回：

>>> [data.array] 
>>> cat(2,data.array)
[0.8 | 0.7 0.9 0.4 | 0.7 0 0.3 | 0.1 | 0.3]     %  | shows array separation

我想重复数字 ( data.number)len次，以生成与串联数组相同长度的数组。

我目前正在这样arrayfun做cell2mat：

>> x = arrayfun(@(x) repmat(x.number, 1, x.len), data, 'UniformOutput', false)
x = 
    [1]    [1x3 double]    [1x3 double]    [4]    [5]
>> cell2mat(x)
[ 1 2 2 2 3 3 3 4 5]

这使得数字与数组对齐。

arrays =  [ 0.8 | 0.7 0.9 0.4 | 0.7 0 0.3 | 0.1 | 0.3 ] 
numbers = [ 1   | 2   2   2   | 3   3   3 | 4   | 5   ]

这背后的想法是将数据提供给 GPU 进行处理 - 但重新排列数据所需的时间比实际处理时间长几个数量级。

Arrayfun当 N=100,000 时需要约 5 秒，而 for 循环调用repmat需要约 4 秒。

有没有更快的方法将结构中不均匀数组中的数据重新排列成匹配长度的一维数组？我愿意使用不同的数据结构。

测试向量化方法：

data = struct;
data(1).len = 1;
data(1).array = [1 2 3];
data(1).number = 11;
data(2).len = 0;
data(2).array = [];
data(2).number = 12;
data(3).len = 2;
data(3).array = [4 5 6; 7 8 9];
data(3).number = 13;

list_of_array = cat(1,data.array)

idx = zeros(1,size(list_of_array,1));
% Set start of each array to 1
len = cumsum([data.len])
idx(len) = 1
% Flat indices
idx = cumsum([1 idx(1:end-1)])

nf = [data.number]
repeated_num_faces = nf(idx)

给出输出：

list_of_array =
     1     2     3
     4     5     6
     7     8     9
len =
     1     1     3    % Cumulative lengths
idx =
     1     0     1    % Ones at start
idx =
     1     2     2    % Flat indexes - should be [1 3 3]
nf =
    11    12    13    % Numbers expanded
repeated_num_faces =
    11    12    12    % Wrong .numbers - should be [11 13 13]
4

1 回答 1

2

好吧，struct这里不是最容易处理的。当然，你不应该使用repmat. 而不是这样，预分配data_number数组并执行for循环：

tic;
data_array  = [data(:).array];
data_number = zeros(size(data_array));
start = 1;
for i=1:N
    nel = data(i).len;
    data_number(start:start+nel-1) = data(i).number;
    start = start+nel;
end
toc;

这是另一个“矢量化”解决方案，cumsum用于标记“平面”矢量中的索引

tic;
data_array  = [data.array];
data_number = zeros(size(data_array));

% cumulative sum of number of elements in every array
len = cumsum([data.len]);

% mark the end of every array in a 'flat' vector
data_number(len) = 1;

% compute 'flat' indices for every data(i).array
data_number = cumsum([1 data_number(1:end-1)]);

% extract the data.number field
data_num = [data.number];
data_number = data_num(data_number);
toc;

对于一个数据集N=1e5的时间是：

Elapsed time is 0.153539 seconds.
Elapsed time is 0.110694 seconds.
于 2012-10-18T08:03:02.300 回答