union Set of all elements, rows, or columns of two arrays, without duplicates

## Syntax

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

## Arguments

a, b
  arrays of booleans, numbers, or text. Sparse boolean or numerical matrices are accepted. The types of `a` and of `b` can be distinct but compatible for concatenation.

orient
  orientation of the processing:
  - 1 or "r": the union is performed over the rows.
  - 2 or "c": the union is performed over the columns.

v
  row vector, or matrix. `v`'s data type is the type of `[a(:) ; b(:)]`'s result.

ka
  row vector of integers: Indices in `a` of `v` elements/rows/columns coming from `a`.

kb
  row vector of integers: Indices in `b` of `v` remaining elements/rows/columns coming from `b`.

## Description

`union(a,b)` returns a sorted row vector which retains the unique entries of `[a(:) ; b(:)]`.

`union(a,b,"r")` or `union(a,b,1)`returns the matrix formed by the union of the unique rows of `a` and `b` sorted in lexicographic ascending order. In this case matrices `a` and `b` must have the same number of columns.

`union(a,b,"c")` or `union(a,b,2)`returns the matrix formed by the union of the unique columns of `a` and `b` sorted in lexicographic ascending order. In this case matrices `a` and `b` must have the same number of rows.

`[v,ka,kb]=union(a,b)` also returns index vectors `ka` and `kb` such that `v` is a sorted combination of the entries `a(ka)` and `b(kb)`.

## Examples

    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.

## See also

- brackets
- unique

## History

6.1.0 Extension to boolean matrices.
6.1.1 Extension to sparse boolean, sparse real, and sparse complex matrices.