Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Scilab 6.0.2
Change language to: Français - Português - 日本語 - Русский

# unique

extracts (and sorts) distinct elements, rows or columns of a matrix

### Syntax

```N = unique(M)
N = unique(M, orient)
[N, k] = unique(..)```

### Arguments

M

vector, matrix, or hypermatrix of numbers or strings.

orient

flag with possible values : 1 or "r", 2 or "c". It can't be used if `M` is an hypermatrix.

N

• If `orient` is not used: Vector of extracted `M` components sorted in ascending order.
• If `orient` is used: Matrix of extracted `M` rows or columns, sorted in lexicographic ascending order.

k

Vector of indices of first encountered occurences, such that `N(i) = M(k(i))` or `N(i,:) = M(k(i),:)` or `N(:,i) = M(:,k(i))`.

### Description

`unique(M)` returns a vector which retains the unique entries of `M` in ascending order.

`unique(M,"r")` or `unique(M,1)` removes all duplicates of `M` rows and returns unique rows in lexicographic ascending order.

`unique(M,"c")` or `unique(M,2)` removes all duplicates of `M` columns and returns unique columns in lexicographic ascending order. Extracted components, rows or columns can be resorted in their initial order by sorting `k`. See the first example.

### Examples

With some numbers:

```M = int8([2  0  2  2  1  1  1  2  1  1  0  1  1  0  1  1
0  1  2  0  1  2  2  0  1  1  2  0  1  0  0  0
])
[u, k] = unique(M)
[uc, kc] = unique(M, "c")

// Get unduplicated columns in initial order:
M(:, gsort(kc,"g","i"))```
```--> M
M =
2  0  2  2  1  1  1  2  1  1  0  1  1  0  1  1
0  1  2  0  1  2  2  0  1  1  2  0  1  0  0  0

--> [u, k] = unique(M)
u  =
0
1
2

k  =
2.
4.
1.

--> [uc, kc] = unique(M, "c")
uc  =
0  0  0  1  1  1  2  2
0  1  2  0  1  2  0  2

kc  =
14.   2.   11.   12.   5.   6.   1.   3.

--> // Get unduplicated columns in initial order:
--> M(:, gsort(kc,"g","i"))
ans  =
2  0  2  1  1  0  1  0
0  1  2  1  2  2  0  0
```

With complex numbers:

```i = %i;
c = [1+i, 1-i, -i, i, -i, 1+i]
[u, k] = unique(c)
[uc, kc] = unique(c, "c")```
```--> c = [1+i, 1-i, -i, i, -i, 1+i]
c  =
1. + i     1. - i  -i    i   -i    1. + i

--> [u, k] = unique(c)
u  =
-i    i    1. - i   1. + i

k  =
3.   4.   2.   1.
```

With some texts:

```t = ["AB" "BA" "BA" "BA" "AB" "BA" "AB" "AB" "BB" "AA" "AB" "BA" "BA" "BA" "AA"
"AA" "AA" "AB" "AA" "BB" "BB" "BB" "BA" "AB" "AB" "BB" "BB" "AB" "AB" "AA"
]
[u, k] = unique(t)
[uc, kc] = unique(t, "c")```
``` t  =
!AB  BA  BA  BA  AB  BA  AB  AB  BB  AA  AB  BA  BA  BA  AA  !
!AA  AA  AB  AA  BB  BB  BB  BA  AB  AB  BB  BB  AB  AB  AA  !

--> [u, k] = unique(t);
u  =
!AA  !
!AB  !
!BA  !
!BB  !

k  =
2.
1.
3.
10.

--> [uc, kc] = unique(t, "c")
uc  =
!AA  AA  AB  AB  AB  BA  BA  BA  BB  !
!AA  AB  AA  BA  BB  AA  AB  BB  AB  !

kc  =
15.   10.   1.   8.   5.   2.   3.   6.   9.
```

• members — count (and locate) in an array each element or row or column of another array
• gsort — sorting by quick sort algorithm
• vectorfind — finds in a matrix rows or columns matching a vector
• grep — find matches of a string in a vector of strings
• union — extract union components of a vector
• intersect — returns the unduplicated elements or rows or columns met in both input arrays

### History

 Version Description 6.0.2 unique() can now be used to unduplicate complex numbers.