# unique

Unique values in array

## Syntax

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

## 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.If `A` is a categorical array, then the sort order is determined by the order of the categories. ```

example

````C = unique(A,setOrder)` returns the unique values of `A` in a specific order. `setOrder` can be `'sorted'` (default) or `'stable'`.```
````C = unique(A,occurrence)` specifies which indices to return in case of repeated values. `occurrence` can be `'first'` (default) or `'last'`.```

example

````C = unique(A,___,'rows')` and `C = unique(A,'rows',___)` treat each row of `A` as a single entity and return the unique rows of `A` in sorted order. You must specify `A` and optionally can specify `setOrder` or `occurrence`.The `'rows'` option does not support cell arrays.```
````[C,ia,ic] = unique(___)` also returns index vectors `ia` and `ic` using any of the previous syntaxes. 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 the `'rows'` option is specified, then `C = A(ia,:)` and ```A = C(ic,:)```.If `A` is a table or a timetable, then `C = A(ia,:)` and ```A = C(ic,:)```. ```

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, calendarDuration 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 = 1×3 2 5 9 ```

Create a table with some 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=5×3 table 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`. `unique` returns the rows of `A` in sorted order by the first variable `Age` and then by the second variable `Height`.

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

Find the table rows with unique values in the first variable `Age`. If you only want one table variable to contain unique values, you can use the indices returned by `unique` to extract those rows from the table.

```[C,ia] = unique(A.Age); B = A(ia,:)```
```B=3×3 table Age Height Weight ___ ______ ______ Fred 38 71 176 George 40 67 185 Betty 43 69 163 ```

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 = 1×3 2 5 9 ```
```ia = 3×1 2 4 1 ```
```ic = 4×1 3 1 3 2 ```

Create a 10-by-3 matrix with some repeated rows.

`A = randi(3,10,3)`
```A = 10×3 3 1 2 3 3 1 1 3 3 3 2 3 2 3 3 1 1 3 1 2 3 2 3 2 3 3 2 3 3 1 ```

Find the unique rows of `A` based on the data in the first two columns. Specify three outputs to return the index vectors `ia` and `ic`.

`[C,ia,ic] = unique(A(:,1:2),'rows')`
```C = 7×2 1 1 1 2 1 3 2 3 3 1 3 2 3 3 ```
```ia = 7×1 6 7 3 5 1 4 2 ```
```ic = 10×1 5 7 3 6 4 1 2 4 7 7 ```

Use `ia` to index into `A` and retrieve the rows that have unique combinations of elements in the first two columns.

`uA = A(ia,:)`
```uA = 7×3 1 1 3 1 2 3 1 3 3 2 3 3 3 1 2 3 2 3 3 3 1 ```

Find the unique elements in a vector and then use `accumarray` to count the number of times each unique element appears.

Create a vector of random integers from 1 through 5.

`a = randi([1 5],200,1);`

Find the unique elements in the vector. Return the index vectors `ia` and `ic`.

`[C,ia,ic] = unique(a);`

Count the number of times each element in `C` appears in `a`. Specify `ic` as the first input to `accumarray` and `1` as the second input so that the function counts repeated subscripts in `ic`. Summarize the results.

```a_counts = accumarray(ic,1); value_counts = [C, a_counts]```
```value_counts = 5×2 1 46 2 36 3 38 4 39 5 41 ```

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 = 1×3 9 2 5 ```
```ia = 3×1 1 2 4 ```
```ic = 4×1 1 2 1 3 ```

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

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

Define a vector containing `NaN`.

`A = [5 5 NaN NaN];`

Find the unique values of `A`.

`C = unique(A)`
```C = 1×3 5 NaN NaN ```

`unique` treats `NaN` values as distinct.

Create a vector `x`. Obtain a second vector `y` by transforming and untransforming `x`. This transformation introduces round-off differences in `y`.

```x = (1:6)'*pi; y = 10.^log10(x);```

Verify that `x` and `y` are not identical by taking the difference.

`x-y`
```ans = 6×1 10-14 × 0.0444 0 0 0 0 -0.3553 ```

Use `unique` to find the unique elements in the concatenated vector `[x;y]`. The `unique` function performs exact comparisons and determines that some values in `x` are not exactly equal to values in `y`. These are the same elements that have a nonzero difference in `x-y`. Thus, `c` contains values that appear to be duplicates.

`c = unique([x;y])`
```c = 8×1 3.1416 3.1416 6.2832 9.4248 12.5664 15.7080 18.8496 18.8496 ```

Use `uniquetol` to perform the comparison using a small tolerance. `uniquetol` treats elements that are within tolerance as equal.

`C = uniquetol([x;y])`
```C = 6×1 3.1416 6.2832 9.4248 12.5664 15.7080 18.8496 ```

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 = 1x4 cell {'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 = 1x6 cell {'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 = 1×3 2 5 9 ```
```ia1 = 3×1 2 4 1 ```
```ic1 = 4×1 3 1 3 2 ```

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

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

## Input Arguments

collapse all

Input array.

• If `A` is a table, then `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, then `unique` takes row times into account. Two rows that have the same values, but different times, are not considered equal.

• If `A` is a categorical array, then the sort order is determined by the order of the categories. To see the sort order of a categorical array, use the `categories` function.

`A` can also 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`.

FlagDescription

`'sorted'`

The values (or rows) in `C` return in sorted order as returned by `sort`.

Example

`C = unique([5 5 3 4],'sorted')`
```C = 3 4 5```

`'stable'`

The values (or rows) in `C` return in the same order as in `A`.

Example

`C = unique([5 5 3 4],'stable')`
```C = 5 3 4```

Data Types: `char` | `string`

Occurrence flag, 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```. This is the default behavior when the `'legacy'` flag is specified.
`'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')``` returns `ia = 1`. This is the default behavior.

Data Types: `char` | `string`

## Output Arguments

collapse all

Unique data of `A`, returned as an array. The class of `C` is the same as the class of the input `A`. The shape of `C` depends on whether the input 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`.

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,:)```.

## Tips

• Use `uniquetol` to find unique floating-point numbers using a tolerance.

• To find unique rows in tables or timetables 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.

## Version History

Introduced before R2006a