union

extrai componentes da união de um vetor

# Seqüência de Chamamento

                [v, ka, kb] = union(a, b)
                [v, ka, kb] = union(a, b, orient)

## Parâmetros

a, b

- matrizes de booleanos, números ou texto. Matrizes booleanas ou numéricas esparsas são aceitos. Os tipos de `a` et de `b` podem ser distintos, mas compatíveis para concatenação.

orient

- orientação do processamento :
  - 1 ou "r": a união é realizada nas linhas.
  - 2 or "c": a união é realizada nas colunas.

v

- vetor linha, ou matriz. O tipo de dados de `v` é o tipo de resultado `[a(:) ; b(:)]`.

ka

- vetor linha de inteiros: Índices em `a` de elementos / linhas / colunas de `v` vindos de `a`.

kb

- vetor linha de inteiros: Índices em `b` dos elementos / linhas / colunas restantes de `v` vindos de `b`.

## Descrição

`union(a,b)` retorna um vetor linha ordenado que retém as entradas únicas de `[a(:);b(:)]`.

`union(a,b,"r")` ou `union(a,b,1)`retorna a matriz formada pela união das linhas únicas de `a` e `b` em ordem lexicográfica ascendente. Neste caso, as matrizes `a` e `b` devem ter o mesmo número de colunas.

`union(a,b,"c")` ou `union(a,b,2)`retorna a matriz formada pela união das colunas únicas de `a` e `b` em ordem lexicográfica ascendente. Neste caso, as matrizes `a` e `b` devem ter o mesmo número de colunas.

`[v,ka,kb]=union(a,b)` também retorna vetores de índices `ka` e `kb` tais que `v` é uma combinação ordenada das entradas `a(ka)` e `b(kb)`.

## Exemplos

    A = [6  7  6 ; 5  8  3 ];
    B = [1  7  1  0  6 ];

    union(A, B)
    [u, ka, kb] = union(A, B)

    --> union(A, B)
     ans  =
       0.   1.   3.   5.   6.   7.   8.

    --> [u, ka, kb] = union(A, B)
     u  =
       0.   1.   3.   5.   6.   7.   8.
     ka  =
       6.   2.   1.   3.   4.
     kb  =
       4.   1.

    A = ["a" "b" "a" "c" "c" "b"
         "b" "c" "a" "b" "c" "c" ];
    B = ["b" "a" "c" "c" "b" "a"
         "a" "c" "b" "b" "b" "b" ];

    [U, ka, kb] = union(A, B, "c")

    --> [U, ka, kb] = union(A, B, "c")
     U  =
      "a"  "a"  "a"  "b"  "b"  "b"  "c"  "c"
      "a"  "b"  "c"  "a"  "b"  "c"  "b"  "c"

     ka  =
       3.   1.   2.   4.   5.

     kb  =
       2.   1.   5.

    [F, T] = (%f, %t);
    A = sparse([T T F T F T ; F F F F T T ; T F F F F T ]); full(A)
    B = sparse([F F T T F F ; T T T T T T ; T F T T T F ]); full(B)

    [U, ka, kb] = union(A, B, "c");
    issparse(U)
    full(U), ka, kb

    --> A = sparse([T T F T F T ; F F F F T T ; T F F F F T ]); full(A)
     ans  =
      T T F T F T
      F F F F T T
      T F F F F T

    --> B = sparse([F F T T F F ; T T T T T T ; T F T T T F ]); full(B)
     ans  =
      F F T T F F
      T T T T T T
      T F T T T F

    --> [U, ka, kb] = union(A, B, "c");
    --> issparse(U)
     ans  =
      T

    --> full(U), ka, kb
     ans  =
      F F F T T T
      F T T F F T
      F F T F T T

     ka  =
       3.   5.   2.   1.   6.
     kb  =
       1.

## Ver Também

- brackets
- unique

## Histórico