setxor

两个数据集的异或集

全页折叠

语法

C = setxor(A,B)
C = setxor(A,B,setOrder)
C = setxor(A,B,___,'rows')
C = setxor(A,B,'rows',___)
[C,ia,ib] = setxor(___)
[C,ia,ib] = setxor(A,B,'legacy')
[C,ia,ib] = setxor(A,B,'rows','legacy')

说明

C = setxor(A,B) 返回不在 A 和 B 的交集中的数据（对称差集），不包括重复项。即，setxor 返回出现在 A 或 B 中，但不是同时出现在二者中的数据。C 是有序的。

  • 如果 A 和 B 是表或时间表，则 setxor 返回出现在其中一个表而不是两个表中都出现的行。对于时间表，setxor 在确定相等性时会考虑行时间，并按行时间对输出时间表 C 进行排序。

示例

C = setxor(A,B,setOrder) 以特定顺序返回 C。setOrder 可以是 'sorted' 或 'stable'。

示例

C = setxor(A,B,___,'rows') 和 C = setxor(A,B,'rows',___) 将 A 和 B 的每一行都视为单个实体，并返回在 A 和 B 中但不在二者交集中的行，不包括重复项。必须指定 A 和 B，setOrder 是可选的。

'rows' 选项不支持元胞数组，除非其中一个输入项为分类数组或日期时间数组。

[C,ia,ib] = setxor(___) 支持任何上述语法，且可返回索引向量 ia 和 ib。

  • 一般情况下，C 中的值是 A(ia) 和 B(ib) 的元素的有序并集。

  • 如果指定了 'rows' 选项，则 C 是 A(ia,:) 和 B(ib,:) 的行的有序并集。

  • 如果 A 和 B 是表或时间表，则 C 是 A(ia,:) 和 B(ib,:) 的行的有序并集。

示例

[C,ia,ib] = setxor(A,B,'legacy') 和 [C,ia,ib] = setxor(A,B,'rows','legacy') 保留 R2012b 和早期版本中 setxor 函数的行为。

'legacy' 选项不支持分类数组、日期时间数组、持续时间数组、表或时间表。

示例

示例

全部折叠

打开实时脚本

定义都包含某个值的两个向量。 

A = [5 1 3 3 3]; B = [4 1 2];

求出不在 A 和 B 的交集中的值。 

C = setxor(A,B)
C = 1×4

     2     3     4     5
打开实时脚本

定义都包含某些行的两个表。 

A = table([1:5]',['A';'B';'C';'D';'E'],logical([0;1;0;1;0]))
A=5×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1       A      false
     2       B      true 
     3       C      false
     4       D      true 
     5       E      false


B = table([1:2:10]',['A';'C';'E';'G';'I'],logical(zeros(5,1)))
B=5×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     1       A      false
     3       C      false
     5       E      false
     7       G      false
     9       I      false

求出 A 和 B 的不在其交集中的行。 

C = setxor(A,B)
C=4×3 table
    Var1    Var2    Var3 
    ____    ____    _____

     2       B      true 
     4       D      true 
     7       G      false
     9       I      false
打开实时脚本

定义都包含某个值的两个向量。 

A = [5 1 3 3 3]; B = [4 1 2];

求出不在 A 和 B 的交集中的值以及索引向量 ia 和 ib。 

[C,ia,ib] = setxor(A,B)
C = 1×4

     2     3     4     5


ia = 2×1

     3
     1


ib = 2×1

     3
     1

C 是元素 A(ia) 和 B(ib) 的排序组合。

打开实时脚本

定义表 A，其中包含五个人的性别、年龄和身高。 

A = table(['M';'M';'F'],[27;52;31],[74;68;64],...
'VariableNames',{'Gender' 'Age' 'Height'},...
'RowNames',{'Ted' 'Fred' 'Betty'})
A=3×3 table
             Gender    Age    Height
             ______    ___    ______

    Ted        M       27       74  
    Fred       M       52       68  
    Betty      F       31       64

定义一个表 B，其中包含与 A 相同的变量。 

B = table(['F';'M'],[64;68],[31;47],...
'VariableNames',{'Gender' 'Height' 'Age'},...
'RowNames',{'Meg' 'Joe'})
B=2×3 table
           Gender    Height    Age
           ______    ______    ___

    Meg      F         64      31 
    Joe      M         68      47

求出 A 和 B 的不在其交集中的行以及索引向量 ia 和 ib。 

[C,ia,ib] = setxor(A,B)
C=3×3 table
            Gender    Age    Height
            ______    ___    ______

    Ted       M       27       74  
    Joe       M       47       68  
    Fred      M       52       68  


ia = 2×1

     1
     2


ib = 
2

C 是元素 A(ia,:) 和 B(ib,:) 的排序组合。

打开实时脚本

定义都包含某些行的两个矩阵。 

A = [7 8 9; 7 7 1; 7 7 1; 1 2 3; 4 5 6];
B = [1 2 3; 4 5 6; 7 7 2];

求出 A 和 B 的不在其交集中的行以及索引向量 ia 和 ib。 

[C,ia,ib] = setxor(A,B,'rows')
C = 3×3

     7     7     1
     7     7     2
     7     8     9


ia = 2×1

     2
     1


ib = 
3

C 是行 A(ia,:) 和 B(ib,:) 的排序组合。

打开实时脚本

使用 setOrder 参量指定 C 中值的排序方式。

如果您想要 C 中的值与 A 和 B 中的值顺序相同，请指定 'stable'。 

A = [5 1 3 3 3]; B = [4 1 2];
[C,ia,ib] = setxor(A,B,'stable')
C = 1×4

     5     3     4     2


ia = 2×1

     1
     3


ib = 2×1

     1
     3

此外，还可以指定 'sorted' 顺序。 

[C,ia,ib] = setxor(A,B,'sorted')
C = 1×4

     2     3     4     5


ia = 2×1

     3
     1


ib = 2×1

     3
     1
打开实时脚本

定义两个包含 NaN 的向量。 

A = [5 NaN NaN]; B = [5 NaN NaN];

计算向量 A 和 B 的对称差集。 

C = setxor(A,B)
C = 1×4

   NaN   NaN   NaN   NaN

setxor 函数将 NaN 值视为不同的值。

打开实时脚本

创建字符向量元胞数组 A。 

A = {'dog','cat','fish','horse'};

创建字符向量元胞数组 B，其中某些向量带有尾随空白。

B = {'dog ','cat','fish ','horse'};

求出不在 A 和 B 的交集中的字符向量。

[C,ia,ib] = setxor(A,B)
C = 1×4 cell
    {'dog'}    {'dog '}    {'fish'}    {'fish '}


ia = 2×1

     1
     3


ib = 2×1

     1
     3

setxor 将字符向量元胞数组中的尾随空白视为不同的字符。

打开实时脚本

创建一个列向量字符数组。 

A = ['A';'B';'C'], class(A)
A = 3×1 char array
    'A'
    'B'
    'C'


ans = 
'char'

创建一个包含数值类型 double 的元素的行向量。 

B = [66 67 68], class(B)
B = 1×3

    66    67    68


ans = 
'double'

计算 A 和 B 的对称差集。 

C = setxor(A,B)
C = 2×1 char array
    'A'
    'D'

结果是一个列向量字符数组。 

class(C)
ans = 
'char'
打开实时脚本

创建字符向量 A。 

A = ['cat';'dog';'fox';'pig'];
class(A)
ans = 
'char'

创建字符向量元胞数组 B。 

B={'dog','cat','fish','horse'};
class(B)
ans = 
'cell'

求出不在 A 和 B 的交集中的字符向量。

C = setxor(A,B)
C = 4×1 cell
    {'fish' }
    {'fox'  }
    {'horse'}
    {'pig'  }

结果 C 是字符向量元胞数组。 

class(C)
ans = 
'cell'
打开实时脚本

在代码中使用 'legacy' 标志以保留 R2012b 和早期版本中 setxor 的行为。

计算 A 和 B 的对称差集并保留当前行为。 

A = [5 1 3 3 3]; B = [4 1 2 2];
[C1,ia1,ib1] = setxor(A,B)
C1 = 1×4

     2     3     4     5


ia1 = 2×1

     3
     1


ib1 = 2×1

     3
     1

计算对称差集并保留旧版行为。 

[C2,ia2,ib2] = setxor(A,B,'legacy')
C2 = 1×4

     2     3     4     5


ia2 = 1×2

     5     1


ib2 = 1×2

     4     1

输入参数

全部折叠

输入数组。如果指定 'rows' 选项，则 A 和 B 的列数必须相同。

A 和 B 必须属于同一类，以下情况例外：

  • logical、char 和所有数值类可以与 double 数组合并。

  • 字符串数组可以与字符向量和字符向量元胞数组合并。

  • 分类数组可以与字符串标量和字符向量结合使用。

  • 日期和时间和持续时间数组可以与格式化为表示日期和时间的字符串标量和字符向量结合使用。

根据数据类型，对 A 和 B 还有其他要求：

  • 如果 A 和 B 均为有序分类数组，则必须具有相同的类别集（包括其顺序）。如果 A 和 B 都不是有序分类数组，则不必具有相同的类别集，因此可使用类别名称对两者进行比较。在这种情况下，C 的类别中前面是 A 的类别，后面跟有不在 A 中的 B 的类别。类别的顺序与在 A 和 B 中的顺序相同，将使用类别顺序对 C 进行排序。

  • 如果 A 和 B 是表或时间表，则必须具有相同的变量名称（顺序除外）。对于表，将忽略行名称，所以值相同而名称不同的两行将被视为相等。对于时间表，将考虑行时间，所以值相同而时间不同的两行将被视为不相等。

  • 如果 A 和 B 是日期时间数组，则这两个数组必须或者都指定时区，或者都未设置时区。

A 和 B 还可以是具有以下类方法的对象：

  • sort（或 'rows' 选项的 sortrows）

  • eq

  • ne

对象类方法彼此之间必须一致。这些对象包括从相同根类导出的异构数组。例如，A 和 B 可以是图形对象的句柄数组。

顺序标志以 'sorted' 或 'stable' 指定，指示 C 中值（或行）的顺序。

标志描述
'sorted'

按 sort 返回的排序顺序返回 C 中的值（或行）。

示例

C = setxor([5 1 3],[4 1 2],'sorted')
C =

     2     3     4     5

'stable'

C 中的值（或行）按它们在 A 中的显示顺序返回，然后按它们在 B 中的显示顺序返回。

示例

C = setxor([5 1 3],[4 1 2],'stable')
C =

     5     3     4     2

数据类型: char | string

输出参量

全部折叠

对称差集合数组，以向量、矩阵、表或时间表的形式返回。如果输入 A 和 B 是表或时间表，则 C 中的变量顺序与 A 中的变量顺序相同。

下面介绍了当输入为向量或矩阵并且未指定 'legacy' 标志时 C 的形状：

  • 如果未指定 'rows' 标志，则 C 为列向量，除非 A 和 B 都是行向量，在这种情况下，C 为行向量。例如，setxor([],[1 2]) 返回一个列向量。

  • 如果指定了 'rows' 标志，则 C 是一个包含 A 和 B 的不在交集中的行的矩阵。

  • 如果 A 的所有值（或行）也在 B 中，则 C 为空。

输入 A 和 B 的类确定 C 的类：

  • 如果 A 和 B 的类相同，则 C 为相同类。

  • 如果将 char 或非双精度数值类与 double 合并，则 C 是与非双精度输入相同的类。

  • 如果将 logical 类与 double 合并，则 C 是 double。

  • 如果将字符向量元胞数组与 char 合并，则 C 是字符向量元胞数组。

  • 如果将分类数组与字符向量、字符向量元胞数组或字符串合并，则 C 是分类数组。

  • 如果将日期时间数组与日期字符向量元胞数组或单个日期字符向量合并，则 C 是日期时间数组。

  • 如果将字符串数组与字符向量或字符向量元胞数组合并，则 C 是字符串数组。

A 的索引，当未指定 'legacy' 标志时以列向量的形式返回。ia 标识 A 中合入对称差集中的值（或行）。如果有仅在 A 中重复出现的值（或行），则 ia 包含该值（或行）第一次出现位置的索引。

B 的索引，当未指定 'legacy' 标志时以列向量的形式返回。ib 标识 B 中合入对称差集中的值（或行）。如果有仅在 B 中重复出现的值（或行），则 ib 包含该值（或行）第一次出现位置的索引。

提示

  • 要求出与表或时间表中的变量子集相关的对称差集，可使用列下标。例如，可以使用 setxor(A(:,vars),B(:,vars))，其中 vars 为正整数、正整数向量、变量名称、变量名称元胞数组或逻辑向量。您也可以使用 vartype 创建一个下标，以选择指定类型的变量。

扩展功能

全部展开

版本历史记录

在 R2006a 之前推出

另请参阅

| | | | | |

主题