Set exclusive OR of two arrays

collapse all in page

## Syntax

`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')`

## Description

example

`C = setxor(A,B)`

returns the data of `A`

and `B`

that are not in their intersection (the symmetric difference), with no repetitions. That is, `setxor`

returns the data that occurs in `A`

or `B`

, but not both. `C`

is in sorted order.

If

`A`

and`B`

are tables or timetables, then`setxor`

returns the rows that occur in one or the other of the two tables, but not both. For timetables,`setxor`

takes row times into account to determine equality, and sorts the output timetable`C`

by row times.

example

`C = setxor(A,B,setOrder)`

returns `C`

in a specific order. `setOrder`

can be `'sorted'`

or `'stable'`

.

`C = setxor(A,B,___,'rows')`

and

treat each row of `C`

= setxor(`A,B`

,'rows',___)`A`

and each row of `B`

as single entities and returns the rows of `A`

and `B`

that are not in their intersection, with no repetitions. You must specify `A`

and `B`

and optionally can specify `setOrder`

.

The `'rows'`

option does not support cell arrays, unless one of the inputs is either a categorical array or a datetime array.

example

`[C,ia,ib]= setxor(___)`

also returns index vectors `ia`

and `ib`

using any of the previous syntaxes.

Generally, the values in

`C`

are a sorted combination of the elements of`A(ia)`

and`B(ib)`

.If the

`'rows'`

option is specified, then`C`

is a sorted combination of the rows of`A(ia,:)`

and`B(ib,:)`

.If

`A`

and`B`

are tables or timetables, then`C`

is a sorted combination of the rows of`A(ia,:)`

and`B(ib,:)`

.

example

`[C,ia,ib]= setxor(A,B,'legacy')`

and `[`

preserve the behavior of the `C`

,`ia`

,`ib`

]= setxor(`A,B`

,'rows','legacy')`setxor`

function from R2012b and prior releases.

The `'legacy'`

option does not support categoricalarrays, datetime arrays, duration arrays, tables, or timetables.

## Examples

collapse all

### Symmetric Difference of Two Vectors

Open Live Script

Define two vectors with a value in common.

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

Find the values of `A`

and `B`

that are not in their intersection.

C = setxor(A,B)

`C = `*1×4* 2 3 4 5

### Symmetric Difference of Two Tables

Open Live Script

Define two tables with rows in common.

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

Find the rows of `A`

and `B`

that are not in their intersection.

C = setxor(A,B)

`C=`*4×3 table* Var1 Var2 Var3 ____ ____ _____ 2 B true 4 D true 7 G false 9 I false

### Symmetric Difference of Two Vectors and Indices to Different Values

Open Live Script

Define two vectors with a value in common.

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

Find the values of `A`

and `B`

that are not in their intersection as well as the index vectors `ia`

and `ib`

.

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

`C = `*1×4* 2 3 4 5

`ia = `*2×1* 3 1

`C`

is a sorted combination of the elements `A(ia)`

and `B(ib)`

.

### Symmetric Difference of Two Tables and Indices to Different Rows

Open Live Script

Define a table, `A`

, of gender, age, and height for five people.

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

Define a table, `B`

, with the same variables as `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

Find the rows of `A`

and `B`

that are not in their intersection, as well as the index vectors `ia`

and `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`

is a sorted combination of the elements `A(ia,:)`

and `B(ib,:)`

.

### Symmetric Difference of Rows in Two Matrices

Open Live Script

Define two matrices with rows in common.

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];

Find the rows of `A`

and `B`

that are not in their intersection as well as the index vectors `ia`

and `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`

is a sorted combination of the rows of `A(ia,:)`

and `B(ib,:)`

.

### Symmetric Difference of Two Vectors in Specified Order

Open Live Script

Use the `setOrder`

argument to specify the ordering of the values in `C`

.

Specify `'stable'`

if you want the values in `C`

to have the same order as `A`

and `B`

.

`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

Alternatively, you can specify `'sorted'`

order.

`[C,ia,ib] = setxor(A,B,'sorted')`

`C = `*1×4* 2 3 4 5

`ia = `*2×1* 3 1

`ib = `*2×1* 3 1

### Symmetric Difference of Vectors Containing NaNs

Open Live Script

Define two vectors containing `NaN`

.

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

Find the symmetric difference of vectors `A`

and `B`

.

C = setxor(A,B)

`C = `*1×4* NaN NaN NaN NaN

The `setxor`

function treats `NaN`

values as distinct.

### Cell Array of Character Vectors with Trailing White Space

Open Live Script

Create a cell array of character vectors, `A`

.

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

Create a cell array of character vectors, `B`

, where some of the vectors have trailing white space.

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

Find the character vectors that are not in the intersection of `A`

and `B`

.

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

`C = `*1x4 cell* {'dog'} {'dog '} {'fish'} {'fish '}

`ia = `*2×1* 1 3

`ib = `*2×1* 1 3

`setxor`

treats trailing white space in cell arrays of character vectors as distinct characters.

### Symmetric Difference of Vectors of Different Classes and Shapes

Open Live Script

Create a column vector character array.

A = ['A';'B';'C'], class(A)

`A = `*3x1 char array* 'A' 'B' 'C'

ans = 'char'

Create a row vector containing elements of numeric type `double`

.

B = [66 67 68], class(B)

`B = `*1×3* 66 67 68

ans = 'double'

Find the symmetric difference of `A`

and `B`

.

C = setxor(A,B)

`C = `*2x1 char array* 'A' 'D'

The result is a column vector character array.

class(C)

ans = 'char'

### Symmetric Difference of Char and Cell Array of Character Vectors

Open Live Script

Create a character vector, `A`

.

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

ans = 'char'

Create a cell array of character vectors, `B`

.

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

ans = 'cell'

Find the character vectors that are not in the intersection of `A`

and `B`

.

C = setxor(A,B)

`C = `*4x1 cell* {'fish' } {'fox' } {'horse'} {'pig' }

The result, `C`

, is a cell array of character vectors.

class(C)

ans = 'cell'

### Preserve Legacy Behavior of setxor

Open Live Script

Use the `'legacy'`

flag to preserve the behavior of `setxor`

from R2012b and prior releases in your code.

Find the symmetric difference of `A`

and `B`

with the current behavior.

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

Find the symmetric difference and preserve the legacy behavior.

`[C2,ia2,ib2] = setxor(A,B,'legacy')`

`C2 = `*1×4* 2 3 4 5

`ia2 = `*1×2* 5 1

`ib2 = `*1×2* 4 1

## Input Arguments

collapse all

`setOrder`

— Order flag

`'sorted'`

(default) | `'stable'`

Order flag, specified as `'sorted'`

or `'stable'`

, indicates the order of the values (or rows) in `C`

.

Flag | Description |
---|---|

`'sorted'` | The values (or rows) in
`C = setxor([5 1 3],[4 1 2],'sorted')` C = 2 3 4 5 |

`'stable'` | The values (or rows) in
`C = setxor([5 1 3],[4 1 2],'stable')` C = 5 3 4 2 |

**Data Types: **`char`

| `string`

## Output Arguments

collapse all

`C`

— Symmetric difference array

vector | matrix | table | timetable

Symmetric difference array, returned as a vector, matrix, table, or timetable. If the inputs `A`

and `B`

are tables or timetables, then the order of the variables in `C`

is the same as the order of the variables in `A`

.

The following describes the shape of `C`

when the inputs are vectors 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, in which case`C`

is a row vector. For example,`setxor([],[1 2])`

returns a column 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 empty.

The class of the inputs `A`

and `B`

determinesthe class of `C`

:

If the class of

`A`

and`B`

arethe same, then`C`

is the same class.If you combine a

`char`

or nondoublenumeric class with`double`

, then`C`

isthe same class as the nondouble input.If you combine a

`logical`

classwith`double`

, then`C`

is`double`

.If you combine a cell array of character vectors with

`char`

,then`C`

is a cell array of character vectors.If you combine a categorical array with a charactervector, cell array of character vectors, or string, then

`C`

isa categorical array.If you combine a datetime array with a cell arrayof date character vectors or single date character vector, then

`C`

isa datetime array.If you combine a string array with a character vectoror cell array of character vectors, then

`C`

is astring array.

`ia`

— Index to `A`

column vector

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).

`ib`

— Index to `B`

column vector

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).

## Tips

To find the symmetric difference with respect to a subset of variables from a table or timetable, you can use column subscripting. For example, you can use

`setxor(A(:,`

, where),B(:,`vars`

))`vars`

is a positive integer, a vector of positive integers, a variable name, a cell array of variable names, or a logical vector. Alternatively, you can use vartype to create a subscript that selects variables of a specified type.`vars`

## Extended Capabilities

### Tall Arrays

Calculate with arrays that have more rows than fit in memory.

Usage notes and limitations:

The

`'stable'`

and`'legacy'`

options are not supported.Inputs of type

`'char'`

are not supported.Ordinal categorical arrays are not supported.

For more information, see Tall Arrays.

### C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

Code generation does not support cell arrays for the first or second arguments.

Code generation does not support

`setxor`

between a variable-size rows and columns.`A`

and`B`

must be variable-size vector inputs with the same orientation.When you do not specify the

`'rows'`

option:Inputs

`A`

and`B`

must be vectors with the same orientation. If you specify the`'legacy'`

option, then inputs`A`

and`B`

must be row vectors.The first dimension of a variable-size row vector must have fixed length 1. The second dimension of a variable-size column vector must have fixed length 1.

The input

`[]`

is not supported. Use a 1-by-0 or 0-by-1 input, for example ,`zeros(1,0)`

, to represent the empty set.If you specify the

`'legacy'`

option, then empty outputs are row vectors, 1-by-0, never 0-by-0.

When you specify both the

`'legacy'`

option and the`'rows'`

option, the outputs`ia`

and`ib`

are column vectors. If these outputs are empty, then they are 0-by-1. They are never 0-by-0, even if the output`C`

is 0-by-0.When the

`setOrder`

is not`'stable'`

or when you specify the`'legacy'`

flag, the inputs must already be sorted in ascending order. The first output,`C`

, is sorted in ascending order.Complex inputs must be

`single`

or`double`

.When one input is complex and the other input is real, do one of the following:

Set

`setOrder`

to`'stable'`

.Sort the real input in complex ascending order (by absolute value). Suppose the real input is

`x`

. Use`sort(complex(x))`

or`sortrows(complex(x))`

.

See Code Generation for Complex Data with Zero-Valued Imaginary Parts (MATLAB Coder).

### Thread-Based Environment

Run code in the background using MATLAB® `backgroundPool`

or accelerate code with Parallel Computing Toolbox™ `ThreadPool`

.

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

### GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Usage notes and limitations:

The

`'legacy'`

flag is not supported.64-bit integers are not supported.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

### Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

Usage notes and limitations:

The

`'legacy'`

flag is not supported.Table, timetable, categorical, datetime and duration inputs are not supported.

Inputs of type

`char`

and`string`

are not supported when`A`

or`B`

is a cell array of character vectors. Convert cell arrays of character vectors input arguments to string arrays instead.

For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

## Version History

**Introduced before R2006a**

## See Also

unique | intersect | ismember | issorted | setdiff | union | sort

### Topics

- Combine Categorical Arrays

## MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

### Americas

- América Latina (Español)
- Canada (English)
- United States (English)

### Europe

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- Deutsch
- English
- Français

- United Kingdom (English)

Contact your local office