C = setxor(A,B) returns
the data of A and B that are
not in their intersection (the symmetric difference).

If A and B are
numeric arrays, logical arrays, character arrays, categorical arrays,
or cell arrays of strings, then setxor returns
the values that occur in A or B,
but not both. The values of C are in sorted order.

If A and B are
tables, then setxor returns the rows that occur
in one or the other of the two tables, but not both. The rows of table C are
in sorted order.

C = setxor(A,B,'rows') treats
each row of A and each row of B as
single entities and returns the rows of matrices A and B that
are not in their intersection. The rows of C are
in sorted order.

[C,ia,ib]
= setxor(A,B) also returns index vectors ia and ib.

If A and B are
numeric arrays, logical arrays, character arrays, categorical arrays,
or cell arrays of strings, then C is a sorted combination
of the elements A(ia) and B(ib).

If A and B are
tables, then C is a sorted combination of the rows
of A(ia,:) and B(ib,:).

[C,ia,ib]
= setxor(___,setOrder) returns C in
a specific order using any of the input arguments in the previous
syntaxes. setOrder='sorted' returns the values
(or rows) of C in sorted order. setOrder='stable' returns
the values (or rows) of C in the same order as A and B.
If no value is specified, the default is 'sorted'.

[C,ia,ib]
= setxor(A,B,'legacy') and [C,ia,ib]
= setxor(A,B,'rows','legacy') preserve
the behavior of the setxor function from R2012b
and prior releases.

The 'legacy' option does not support categorical
arrays or tables.

A = table([1:5]',['A';'B';'C';'D';'E'],logical([0;1;0;1;0]))
B = table([1:2:10]',['A';'C';'E';'G';'I'],logical(zeros(5,1)))

A =
Var1 Var2 Var3
---- ---- -----
1 A false
2 B true
3 C false
4 D true
5 E false
B =
Var1 Var2 Var3
---- ---- -----
1 A false
3 C false
5 E false
7 G false
9 I false

Find the rows of A and B that
are not in their intersection.

C = setxor(A,B)

C =
Var1 Var2 Var3
---- ---- -----
2 B true
4 D true
7 G false
9 I false

Input arrays, specified as numeric arrays, logical arrays, character
arrays, categorical arrays, cell arrays of strings, or tables.

A and B must belong to
the same class with the following exceptions:

logical, char,
and all numeric classes can combine with double arrays.

Cell arrays of strings can combine with char arrays.

Categorical arrays can combine with cell arrays of
strings or single strings.

If A and B are both ordinal
categorical arrays, they must have the same sets of categories, including
their order. If neither A nor B are
ordinal, they need not have the same sets of categories, and the comparison
is performed using the category names. In this case, the categories
of C are the sorted union of the categories from A and B.

If you specify the 'rows' option, A and B must
have the same number of columns.

If A and B are tables,
they must have the same variable names. Conversely, the row names
do not matter. Two rows that have the same values, but different names,
are considered equal.

Furthermore, A and B can
be objects with the following class methods:

sort (or sortrows for
the 'rows' option)

eq

ne

The object class methods must be consistent with each
other. These objects include heterogeneous arrays derived from the
same root class.

Symmetric difference array, returned as a vector, matrix, or
table. If the inputs A and B are
tables, the order of the variables in the resulting table, C,
is the same as the order of the variables in A.

The following describes the shape of C when
the inputs are vector or matrices and when the 'legacy' flag
is not specified:

If the 'rows' flag is not specified,
then C is a column vector unless both A and B are
row vectors.

If the 'rows' flag is not specified
and both A and B are row vectors,
then C is a row vector.

If the'rows' flag is specified,
then C is a matrix containing the rows of A and B that
are not in the intersection.

If all the values (or rows) of A are
also in B, then C is an empty
matrix.

The class of the inputs A and B determines
the class of C:

If the class of A and B are
the same, then C is the same class.

If you combine a char or nondouble
numeric class with double, then C is
the same class as the nondouble input.

If you combine a logical class
with double, then C is double.

If you combine a cell array of strings with char,
then C is a cell array of strings.

If you combine a categorical array with a cell array
of strings or single string, then C is a categorical
array.

Index to A, returned as a column vector when
the 'legacy' flag is not specified. ia identifies
the values (or rows) in A that contribute to the
symmetric difference. If there is a repeated value (or row) appearing
exclusively in A, then ia contains
the index to the first occurrence of the value (or row).

Index to B, returned as a column vector when
the 'legacy' flag is not specified. ib identifies
the values (or rows) in B that contribute to the
symmetric difference. If there is a repeated value (or row) appearing
exclusively in B, then ib contains
the index to the first occurrence of the value (or row).

To find the symmetric difference with respect to a
subset of variables from a table, you can use column subscripting.
For example, you can use setxor(A(:,vars),B(:,vars)),
where vars is a positive integer, a vector
of positive integers, a variable name, a cell array of variable names,
or a logical vector.