# Documentation

### This is machine translation

Translated by
Mouse over text to see original. Click the button below to return to the English verison of the page.

# unique

Unique values in array

## Syntax

• ``C = unique(A)``
example
• ``C = unique(A,'rows')``
example
• ``````[C,ia,ic] = unique(A)``````
• ``````[C,ia,ic] = unique(A,'rows')``````
• ``````[C,ia,ic] = unique(A,setOrder)``````
example
• ``````[C,ia,ic] = unique(A,'rows',setOrder)``````
example
• ``````[C,ia,ic] = unique(A,'legacy')``````
example
• ``````[C,ia,ic] = unique(A,'rows','legacy')``````
example
• ``````[C,ia,ic] = unique(A,occurrence,'legacy')``````
example
• ``````[C,ia,ic] = unique(A,'rows',occurrence,'legacy')``````
example

## Description

example

````C = unique(A)` returns the same data as in `A`, but with no repetitions. `C` is in sorted order.If `A` is a table or timetable, then `unique` returns the unique rows in `A` in sorted order. For timetables, `unique` takes row times and row values into account when determining whether rows are unique, and sorts the output timetable `C` by row times.```

example

````C = unique(A,'rows')` treats each row of `A` as a single entity and returns the unique rows of `A` in sorted order.The `'rows'` option does not support cell arrays.```
``````[C,ia,ic] = unique(A)``` also returns index vectors `ia` and `ic`.If `A` is a vector, then ```C = A(ia)``` and `A = C(ic)`.If `A` is a matrix or array, then ```C = A(ia)``` and `A(:) = C(ic)`.If `A` is a table or a timetable, then `C = A(ia,:)` and `A = C(ic,:)`.```
``````[C,ia,ic] = unique(A,'rows')``` also returns index vectors `ia` and `ic`, such that `C = A(ia,:)` and `A = C(ic,:)`.```

example

``````[C,ia,ic] = unique(A,setOrder)``` and ```[C,ia,ic] = unique(A,'rows',setOrder)``` return `C` in a specific order. `setOrder` can be `'sorted'` or `'stable'`:`'sorted'` — `C` is in sorted order. This is the default.`'stable'` — `C` is in the same order as `A`.```

example

``````[C,ia,ic] = unique(A,'legacy')```, ```[C,ia,ic] = unique(A,'rows','legacy')```, ```[C,ia,ic] = unique(A,occurrence,'legacy')```,and ```[C,ia,ic] = unique(A,'rows',occurrence,'legacy')``` preserve the behavior of the `unique` function from R2012b and prior releases.The `'legacy'` option does not support categorical arrays, datetime arrays, duration arrays, tables, or timetables.```

## Examples

collapse all

Define a vector with a repeated value.

```A = [9 2 9 5]; ```

Find the unique values of `A`.

```C = unique(A) ```
```C = 2 5 9 ```

Define a table with repeated data.

```Name = {'Fred';'Betty';'Bob';'George';'Jane'}; Age = [38;43;38;40;38]; Height = [71;69;64;67;64]; Weight = [176;163;131;185;131]; A = table(Age,Height,Weight,'RowNames',Name) ```
```A = Age Height Weight ___ ______ ______ Fred 38 71 176 Betty 43 69 163 Bob 38 64 131 George 40 67 185 Jane 38 64 131 ```

Find the unique rows of `A`.

```C = unique(A) ```
```C = Age Height Weight ___ ______ ______ Bob 38 64 131 Fred 38 71 176 George 40 67 185 Betty 43 69 163 ```

`unique` returns the rows of `A` in sorted order by the first variable, `Age` and then by the second variable, `Height`.

Define a vector with a repeated value.

```A = [9 2 9 5]; ```

Find the unique values of `A` and the index vectors `ia` and `ic`, such that `C = A(ia)` and `A = C(ic)`.

```[C, ia, ic] = unique(A) ```
```C = 2 5 9 ia = 2 4 1 ic = 3 1 3 2 ```

Define a matrix with a repeated row.

```A = [9 2 9 5; 9 2 9 0; 9 2 9 5]; ```

Find the unique rows of `A` and the index vectors `ia` and `ic`, such that `C = A(ia,:)` and `A = C(ic,:)`.

```[C, ia, ic] = unique(A,'rows') ```
```C = 9 2 9 0 9 2 9 5 ia = 2 1 ic = 2 1 2 ```

Notice that the second row in `A` is identified as unique even though the elements `9`, `2`, and `9` are repeated in the other rows.

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 in `A`.

```A = [9 2 9 5]; [C, ia, ic] = unique(A,'stable') ```
```C = 9 2 5 ia = 1 2 4 ic = 1 2 1 3 ```

Alternatively, you can specify `'sorted'` order.

```[C, ia, ic] = unique(A,'sorted') ```
```C = 2 5 9 ia = 2 4 1 ic = 3 1 3 2 ```

Define a vector containing `NaN`.

```A = [5 5 NaN NaN]; ```

Find the unique values of `A`.

```C = unique(A) ```
```C = 5 NaN NaN ```

`unique` treats `NaN` values as distinct.

Create a cell array of character vectors.

```A = {'one','two','twenty-two','One','two'}; ```

Find the unique character vectors contained in `A`.

```C = unique(A) ```
```C = 1×4 cell array 'One' 'one' 'twenty-two' 'two' ```

Create a cell array of character vectors, `A`, where some of the vectors have trailing white space.

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

Find the unique character vectors contained in `A`.

```C = unique(A) ```
```C = 1×6 cell array 'cat' 'dog' 'dog ' 'fish' 'fish ' 'horse' ```

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

Use the `'legacy'` flag to preserve the behavior of `unique` from R2012b and prior releases in your code.

Find the unique elements of `A` with the current behavior.

```A = [9 2 9 5]; [C1, ia1, ic1] = unique(A) ```
```C1 = 2 5 9 ia1 = 2 4 1 ic1 = 3 1 3 2 ```

Find the unique elements of `A`, and preserve the legacy behavior.

```[C2, ia2, ic2] = unique(A, 'legacy') ```
```C2 = 2 5 9 ia2 = 2 4 3 ic2 = 3 1 3 2 ```

## Input Arguments

collapse all

Input array, specified as a numeric array, logical array, character array, categorical array, datetime array, duration array, string array, cell array of character vectors, table, or timetable.

• If `A` is a table, `unique` does not take row names into account. Two rows that have the same values, but different names, are considered equal.

• If `A` is a timetable, `unique` takes row times into account. Two rows that have the same values, but different times, are not considered equal.

`A` also can be an object with the following class methods:

• `sort` (or `sortrows` for the `'rows'` option)

• `ne`

The object class methods must be consistent with each other. These objects include heterogeneous arrays derived from the same root class. For example, `A` can be an array of handles to graphics objects.

Order flag, specified as `'sorted'` or `'stable'`, indicates the order of the values (or rows) in `C`.

Order FlagMeaning
`'sorted'`The values (or rows) in `C` return in sorted order. For example: ```C = unique([5 5 3 4],'sorted')``` returns ```C = [3 4 5]```.
`'stable'`The values (or rows) in `C` return in the same order as in `A`. For example: ```C = unique([5 5 3 4],'stable')``` returns `C = [5 3 4]`.

Occurrence flag for legacy behavior, specified as `'first'` or `'last'`, indicates whether `ia` should contain the first or last indices to repeated values found in `A`.

Occurrence FlagMeaning
`'last'`If there are repeated values (or rows) in `A`, then `ia` contains the index to the last occurrence of the repeated value. For example: ```[C,ia,ic] = unique([9 9 9],'last','legacy')``` returns `ia = 3`.
`'first'`If there are repeated values (or rows) in `A`, then `ia` contains the index to the first occurrence of the repeated value. For example: ```[C,ia,ic] = unique([9 9 9],'first','legacy')``` returns `ia = 1`.

## Output Arguments

collapse all

Unique data of `A`, returned as a vector, matrix, table, or timetable. The following describes the shape of `C` when the input, `A`, is a vector or a matrix:

• If the `'rows'` flag is not specified and `A` is a row vector, then `C` is a row vector.

• If the `'rows'` flag is not specified and `A` is not a row vector, then `C` is a column vector.

• If the `'rows'` flag is specified, then `C` is a matrix containing the unique rows of `A`.

The class of `C` is the same as the class of the input `A`.

Index to `A`, returned as a column vector of indices to the first occurrence of repeated elements. When the `'legacy'` flag is specified, `ia` is a row vector that contains indices to the last occurrence of repeated elements.

The indices generally satisfy `C = A(ia)`. If `A` is a table, or if the `'rows'` option is specified, then `C = A(ia,:)`.

Index to `C`, returned as a column vector when the `'legacy'` flag is not specified. `ic` contains indices that satisfy the following properties.

• If `A` is a vector, then ```A = C(ic)```.

• If `A` is a matrix or array, then ```A(:) = C(ic)```.

• If `A` is a table, or if the `'rows'` option is specified, then `A = C(ic,:)`.

collapse all

### Tall Array Support

This function supports tall arrays with the limitations:

• Use the syntax `C = unique(A)` for tall vectors and tall tables, or `C = unique(A,'rows')` for tall matrices.

• Multiple outputs are not supported.

### Tips

• To find unique rows in table or timetable `A` with respect to a subset of variables, you can use column subscripting. For example, you can use `unique(A(:,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. Alternatively, you can use `vartype` to create a subscript that selects variables of a specified type.