本页对应的英文页面已更新,但尚未翻译。 若要查看最新内容,请点击此处访问英文页面。

accumarray

使用累加构造数组

说明

示例

A = accumarray(subs,val) 通过使用下标 subs 累积向量 val 的元素来返回数组 A。如果 subs 为列向量,则每个元素在输出中定义一个相应的下标,下标也是一个列向量。accumarray 函数收集 val 的在 subs 中具有相同下标的所有元素,并将这些元素之和存储在 A 中对应于该下标的位置(对于索引 iA(i)=sum(val(subs(:)==i)))。若 A 的某些元素的下标未出现在 subs 中,则这些元素等于 0。

对于 m×n 矩阵 subs,其中每一行的值都表示输出 A 的一个 n 维下标。subs 的第 i 行对应于向量 val 中的第 i 个元素。

示例

A = accumarray(subs,val,sz) 返回大小为 sz 的数组 A。将 sz 指定为正整数向量以定义输出的大小,或指定为 [] 以便由 subs 中的下标确定输出的大小。如果 subs 未引用您希望出现在输出中的结尾行、列或维度,请使用 sz

示例

A = accumarray(subs,val,sz,fun) 将函数 fun 应用于在 subs 中具有相同下标的 val 中的每个元素子集。使用 @ 符号(例如 @mean)指定 fun,或者指定为 [] 以使用默认函数 @sum

示例

A = accumarray(subs,val,sz,fun,fillval) 使用标量值 fillval 填充未被 subs 中的任何下标引用的 A 的所有元素。fillval 输入必须具有与 fun 返回的值相同的类。将 fillval 指定为 [] 以使用默认值 0

示例

A = accumarray(subs,val,sz,fun,fillval,issparse) 返回稀疏数组 A(如果标量 issparsetrue1),或者返回完全数组(如果 issparsefalse0)。默认情况下,输出 A 为完全数组。

示例

全部折叠

创建一个由下标构成的向量 subs

subs = [1; 2; 4; 2; 4]
subs = 5×1

     1
     2
     4
     2
     4

accumarrayval = 1 结合使用可计算 subs 中相同下标的数目。

A = accumarray(subs,1)
A = 4×1

     1
     2
     0
     2

结果为一个 bin 计数向量。使用 histcounts(subs,'BinMethod','integers') 可以获取相同答案。但是,accumarray 也可以计算更高维度网格上的 bin 计数。

创建一个数据向量 val 和一个具有相同长度的下标值向量 subs

val = 101:105';
subs = [1; 3; 4; 3; 4]
subs = 5×1

     1
     3
     4
     3
     4

使用 accumarray 对在 subs 中具有相同下标的 val 中的值求和。

A = accumarray(subs,val)
A = 4×1

   101
     0
   206
   208

结果为一个累加值向量。由于 subs 的第二个和第四个元素等于 3,则 A(3)val 的第二个和第四个元素之和,即 A(3) = 102 + 104 = 206。此外,A(2) = 0,原因是 subs 不包含值 2。由于 subs 为向量,则输出 A 也为向量。A 的长度为 max(subs,[],1)

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = 101:106';
subs = [1 1; 2 2; 3 2; 1 1; 2 2; 4 1]
subs = 6×2

     1     1
     2     2
     3     2
     1     1
     2     2
     4     1

subs 中的下标为输出定义一个 4×2 矩阵。

使用 accumarray 对在 subs 中具有相同下标的 val 中的值求和。

A = accumarray(subs,val)
A = 4×2

   205     0
     0   207
     0   103
   106     0

结果为一个由累加值构成的 4×2 矩阵。

使用 accumarraysz 输入返回 4×4 矩阵。可以指定一个大小并且每个维度等于或大于默认大小,在此例中为 4×2,但维度不小于该大小。

A = accumarray(subs,val,[4 4])
A = 4×4

   205     0     0     0
     0   207     0     0
     0   103     0     0
   106     0     0     0

结果为一个由累加值构成的 4×4 矩阵。

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = [100.1 101.2 103.4 102.8 100.9 101.5]';
subs = [1 1; 1 1; 2 2; 3 2; 2 2; 3 2]
subs = 6×2

     1     1
     1     1
     2     2
     3     2
     2     2
     3     2

subs 中的下标为输出定义一个 3×2 矩阵。

使用 accumarrayfun 输入计算在 subs 中具有相同下标的 val 中数据的组内方差。将 fun 指定为 @var

A1 = accumarray(subs,val,[],@var)
A1 = 3×2

    0.6050         0
         0    3.1250
         0    0.8450

结果为一个由方差值构成的 3×2 矩阵。

您也可以将 fun 指定为匿名函数,只要它接受向量输入并返回标量。使用此方法较为有用的一种常见情况是向函数传递其他参数。在这种情况下,请使用带归一化参数的 var 函数。

A2 = accumarray(subs,val,[],@(x) var(x,1))
A2 = 3×2

    0.3025         0
         0    1.5625
         0    0.4225

结果为一个由归一化方差值构成的 3×2 矩阵。

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = int8(10:15);
subs = [1 1 1; 1 1 1; 1 1 2; 1 1 2; 2 3 1; 2 3 2]
subs = 6×3

     1     1     1
     1     1     1
     1     1     2
     1     1     2
     2     3     1
     2     3     2

subs 中的下标为输出定义一个 2×3×2 多维数组。

使用 accumarray 对在 subs 中具有相同下标的 val 中的数据值求和。通过使用 sum 函数的 'native' 选项,可以使用函数句柄以其本身的 int8 整数类求值的和。

A = accumarray(subs,val,[],@(x) sum(x,'native'))
A = 2x3x2 int8 array
A(:,:,1) =

   21    0    0
    0    0   14


A(:,:,2) =

   25    0    0
    0    0   15

结果为一个 int8 类的 2×3×2 多维数组。

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = 1:10;
subs = [1 1;1 1;1 1;1 1;2 1;2 1;2 1;2 1;2 1;2 2]
subs = 10×2

     1     1
     1     1
     1     1
     1     1
     2     1
     2     1
     2     1
     2     1
     2     1
     2     2

subs 中的下标为输出定义一个 2×2 矩阵。

使用 accumarrayval 的元素分组到元胞数组。

A = accumarray(subs,val,[],@(x) {x})
A=2×2 cell
    {4x1 double}    {0x0 double}
    {5x1 double}    {[      10]}

结果为 2×2 元胞数组。

验证向量元素的顺序是否与 val 中出现的顺序相同。

A{2,1}
ans = 5×1

     5
     6
     7
     8
     9

由于 subs 中的下标已排序,则元胞数组中数值向量的元素的顺序与其显示于 val 中的顺序相同。

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = 1:5;
subs = [1 2; 1 1; 1 2; 1 1; 2 3]
subs =

     1     2
     1     1
     1     2
     1     1
     2     3

subs 中的下标为输出定义一个 2×3 矩阵,但未根据输出 A 中的线性索引进行排序。

通过指定 fun = @(x) {x}val 中的值分组到一个元胞数组中。

A = accumarray(subs,val,[],@(x) {x})
A =

  2×3 cell array

    [2×1 double]    [2×1 double]     []
              []              []    [5]

结果为 2×3 元胞数组。

检查 A{1,2} 中的向量。

A{1,2}
ans =

     3
     1

A{1,2} 向量的元素必须与 val 中的元素具有不同的顺序。向量的第一个元素为 3 而不是 1。如果未根据线性索引对 subs 中的下标排序,则 accumarray 在将 val 中的数据传递给 fun 时可能不会始终保持这些数据的顺序。在特殊情况下,fun 要求其输入值的顺序与 val 中出现的顺序相同,根据输出的线性索引对 subs 中的索引排序。

在此情况下,使用带有两个输入项和两个输出项的 sortrows 函数,针对输出的线性索引同时对 subsval 重新排序。

[S,I] = sortrows(subs,[2,1]);
A = accumarray(S,val(I),[],@(x) {x});
A{1,2}
ans =

     1
     3

A{1,2} 向量的元素现在处于重排后的顺序。

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = 101:106';
subs = [1 1; 2 2; 3 3; 1 1; 2 2; 4 4]
subs = 6×2

     1     1
     2     2
     3     3
     1     1
     2     2
     4     4

subs 中的下标为输出定义一个 4×4 矩阵,但仅引用 16 个元素中的 4 个。默认情况下,输出中的其他 12 个元素为 0

使用 accumarrayfillval 输入以使用 NaN 值填充额外的输出元素。

A = accumarray(subs,val,[],[],NaN)
A = 4×4

   205   NaN   NaN   NaN
   NaN   207   NaN   NaN
   NaN   NaN   103   NaN
   NaN   NaN   NaN   106

结果为一个使用 NaN 值填充的 4×4 矩阵。

创建一个数据向量 val 和一个由下标构成的矩阵 subs

val = [34 22 19 85 53 77 99 6];
subs = [1 1; 400 400; 80 80; 1 1; 400 400; 400 400; 80 80; 1 1]
subs = 8×2

     1     1
   400   400
    80    80
     1     1
   400   400
   400   400
    80    80
     1     1

subs 中的下标为输出定义一个 400×400 矩阵,但仅引用 160,000 个元素中的 3 个。如果使用 accumarray 的运算结果导致生成一个含低密度非零元素的大型输出数组,则可以通过将输出存储为稀疏矩阵来节省存储空间。

使用 accumarrayissparse 输入返回稀疏矩阵。

A = accumarray(subs,val,[],[],[],true)
A = 
   (1,1)      125
  (80,80)     118
 (400,400)    152

结果为稀疏矩阵。使用 sparse(subs(:,1),subs(:,2),val) 可以获取相同答案。

输入参数

全部折叠

下标矩阵,指定为索引向量、索引矩阵或索引向量元胞数组。索引必须为正整数:

  • m×n 矩阵 subs 的每一行中的值指定输出 A 中的 n 维索引。例如,如果 subs 为一个 3×2 矩阵,则它包含三个二维下标。subs 也可以是一个包含索引的列向量,这种情况下输出 A 也是一个列向量。

  • subs 中的第 i 行对应于 val 中的第 i 个数据值。

  • 如果 subs 为空,则 accumarray 函数将会报错。

因此,subs 确定要对 val 中的哪些数据分组以及这些数据在输出中的最终目标。如果 subs 为由索引向量构成的元胞数组,则每个向量的长度必须相同,函数会将这些向量视为一个下标矩阵的列。

数据,指定为一个向量或标量:

  • 如果 val 为向量,它的长度必须与 subs 中的行数相同。

  • 如果 val 是一个标量,则它是一个扩展标量。

在这两种情况下,subs 的每一行中的下标和 val 中的数据值之间存在一对一的配对关系。

数据类型: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char
复数支持:

输出数组的大小,指定为正整数向量或 [](默认值)。当指定 [] 以使用默认值时,subs 中的值将确定输出数组 A 的大小。

当将 sz 指定为正整数向量时,它必须满足这些属性:

  • 如果 subs 为一个包含 n > 1 列的非空 m×n 矩阵,则 sz 必须具有 n 个元素并且传递逻辑测试 all(sz >= max(subs,[],1))

  • 如果 subs 是一个非空列向量,则 sz 必须是 [m 1],其中 m >= max(subs)

示例: sz = [3 3]

函数,指定为函数句柄或 [](默认值)。默认函数为 @sumfun 函数必须接受列向量并返回数值、logicalchar 标量或标量 cell。如果未根据线性索引对 subs 中的下标排序,则 fun 不应依赖于输入数据中值的顺序。有关函数句柄的详细信息,请参阅创建函数句柄

示例: fun = @max

数据类型: function_handle

填充值,指定为标量或 [](默认值)。fillval 的默认值是 0。如果 subs 未引用输出中的每个元素,则 accumarray 将使用 fillval 指定的值填充输出。fillval 的类必须与 fun 返回的值相同。

输出稀疏性,指定为数值或逻辑值 1 (true) 或 0 (false)。如果希望输出数组为稀疏数组,请指定 true1。如果 issparsetrue1

  • fillval 必须是 0[]

  • val 中的值和 fun 的输出值都必须为 double 类型。

输出参数

全部折叠

输出数组,以向量、矩阵或多维数组的形式返回。Afun 返回的值具有相同的类。

如果未指定 sz,则 A 的大小取决于输入 subs

  • 如果 subs 是一个包含 n > 1 列的非空矩阵,则 A 是一个大小为 max(subs,[],1)n 维数组。

  • 如果 subs 是一个包含 n > 1 列的空矩阵,则 A 是一个 n 维空数组并且大小为 0×0×...×0。

  • 如果 subs 是一个非空列向量,则 A 是长度为 max(subs,[],1) 的列向量。当 subs 为空时,A 的长度为 0

详细信息

全部折叠

累加元素

下图描述了 accumarray 作用于在 12 个月的时间段中获取的温度数据向量的行为。为了得出每个月的最大温度读数,accumarraymax 函数应用于在 month 中具有相同下标的 temperature 中的每组值。

month 中的值都不指向输出的 5、6、7 或 10 位置。默认情况下,这些元素在输出中为 0,但可以使用 fillval 指定用于填充的值。

提示

  • accumarray 的行为与 histcounts 函数的行为类似。两个函数都将数据分组置入 bin 中。

    • histcounts 使用 bin 边界将连续值分组置入某个一维范围中。accumarray 使用 n 维下标对数据进行分组。

    • histcounts 返回区 bin 计数和/或 bin 位置。而 accumarray 则可以将任何函数应用于分 bin 数据。

    您可以将 accumarrayval = 1 结合使用来模拟 histcounts 的行为。

  • sparse 函数也具有与 accumarray 类似的累积行为。

    • sparse 使用二维下标将数据分组置入 bin 中,而 accumarray 使用 n 维下标将数据分组置入 bin 中。

    • 对于具有相同下标的元素,sparse 会将这些元素之和分配给输出。accumarray 默认情况下执行相同的操作,但也可以选择将任何函数应用于 bin。

扩展功能

另请参阅

| | |

在 R2006a 之前推出