intersect элементы, либо строки либо столбцы, имеющиеся в обоих входных массивах, без повторов

## Синтаксис

                M = intersect(a, b)
                M = intersect(a, b, orient)
                [M, ka] = intersect(..)
                [M, ka, kb] = intersect(..)

## Аргументы

a, b
  векторы, матрицы или гиперматрицы логических значений, кодированных целых чисел, вещественных или комплексных чисел, или текста. `a` и `b` должны иметь одинаковый тип данных. Для текстовых входных данных принимаются символы UTF. Принимаются разреженные числовые или логические матрицы: либо `a` либо `b` либо как `a`, так и `b` могут быть разрежёнными.

orient
  флаг с возможными значениями: 1 или "r", 2 или "c". Не может использоваться, если `a` или/и `b` являются гиперматрицами.

M

  матрица того же типа данных, что и `a` и `b`.

  - Без `orient`: `M` является вектором-строкой.
  - С `orient="r"|1`: `M` является матрицей, накапливающей общие строки `a` и `b`.
  - С `orient="c"|2`: `M` является матрицей, накапливающей общие столбцы `a` и `b`.

  `M` является разрежённой, если либо `a` или `b` являются разрежёнными и ни одна не является пустой.

ka
  Плотный вектор-строка индексов в `a`.

kb
  Плотный вектор-строка индексов в `b`.

## Описание

`intersect(a,b)` возвращает вектор-строку уникальных значений, присутствующих как в массиве `a` так и в массиве `b`. Значения отсортированы в порядке возрастания

- для комплексных чисел: сначала в порядке возрастания амплитуды, затем в порядке возрастания фазы;
- для текстов: в алфавитном порядке.

Два элемента `NaN` всегда считаются разными. Так, `NaN` или строки или столбцы, имеющие `NaN`, никогда не окажутся в результирующей `M`.

`[M, ka, kb] = intersect(a,b)` дополнительно возвращает векторы индексов `ka` и `kb` в `a` и в `b` выбранных компонентов, первых попавшихся так, что `M=a(ka)` и `M=b(kb)`.

### Общие строки или столбцы

Когда указан аргумент `orient`, сравнение выполняется между строками `a` и `b` -- каждая из которых рассматривается как целое --, или между их столбцами.

`intersect(a,b,"r")` или `intersect(a,b,1)` будет возвращать матрицу накопленных неповторяющихся строк, встреченных как в `a`, так и в `b`, сортированных в лексикографическом порядке возрастания. Если `a` и `b` не имеют одинаковое количество столбцов, то будет возвращено `[]` без сравнения величин.

`[M,ka,kb] = intersect(a,b,"r")` дополнительно возвращает векторы `ka` и `kb` минимальных индексов общих строк, соответственно в `a` и `b`, так что `M=a(ka,:)` и `M=b(kb,:)`.

`intersect(a,b,"c")` или `intersect(a,b,2)` делает то же самое, но для столбцов.

## Примеры

    A = grand(3, 3, "uin", 0, 9)
    B = grand(2, 4, "uin", 0, 9)
    intersect(A, B)
    [N, ka, kb] = intersect(A,B);
    ka, kb

    --> A = grand(3, 3, "uin", 0, 9)
     A  =
       0.   6.   4.
       6.   6.   6.
       2.   7.   9.

    --> B = grand(2, 4, "uin", 0, 9)
     B  =
       1.   8.   0.   2.
       6.   2.   2.   1.

    --> intersect(A, B)
     ans  =
       0.   2.   6.

    --> [N, ka, kb] = intersect(A,B);
    --> ka, kb
     ka  =
       1.   3.   2.
     kb  =
       5.   4.   2.

В вышеприведённом примере обратите внимание, что 6 встречена четыре раза в `A` с индексами [2 4 5 8]. Только минимальный индекс 2 возвращается в `ka`. Та же ситуация для 2 в `B`.

Значения `NaN` никогда не могут быть в результате:

    %nan == %nan
    intersect([1 -2 %nan 3 6], [%nan 1:3])

    --> %nan == %nan
     ans  =
      F

    --> intersect([1 -2 %nan 3 6], [%nan 1:3])
     ans  =
       1.   3.

`intersect()` может также обрабатывать некоторые символы или тексты. Поскольку Scilab превосходно работает с символами UTF, то здесь пример с некоторым арабским содержимым, получающим символы, присутствующими в обоих предложениях:

    A = strsplit("هو برنامج علمي كبير ""Scilab""")'
    B = strsplit("فهو حر ومفتوح")'
    intersect(A,B)

    --> A = strsplit("هو برنامج علمي كبير ""Scilab""")'
     A  =
    !ه  و     ب  ر  ن  ا  م  ج     ع  ل  م  ي     ك  ب  ي  ر     "  S  c  i  l  a  b  "  !

    --> B = strsplit("فهو حر ومفتوح")'
     B  =
    !ف  ه  و     ح  ر     و  م  ف  ت  و  ح  !

    --> intersect(A,B)
     ans  =
    !   ر  م  ه  و  !

Постолбцовая или построковая обработка двух матриц: здесь мы обрабатываем 2 матрицы знаковых 1-битных целых и получаем общие столбцы:

    A = int8(grand(3,5,"uin",0,1))
    B = int8(grand(3,9,"uin",0,1))
    [M,ka,kb] = intersect(A, B, "c");
    M, ka, kb

    --> A = int8(grand(3,5,"uin",0,1))
     A  =
      0  0  1  1  1
      0  0  1  1  0
      0  0  0  0  1

    --> B = int8(grand(3,9,"uin",0,1))
     B  =
      1  0  1  1  1  0  1  1  1
      1  0  0  1  1  1  0  0  0
      1  0  1  0  1  1  1  0  0

    --> [M,ka,kb] = intersect(A, B, "c");
    --> M, ka, kb
     M  =
      0  1  1
      0  0  1
      0  1  0

     ka  =
       1.   5.   3.

     kb  =
       2.   3.   4.

`intersect()` для логических значений главным образом полезны с опцией `"r"` или `"c"`. Здесь пример с разрежённой матрицей логических значений:

    [F, T] = (%f, %t);
    A = [F F T F T F ; T F F T T T ; T T F T F F]
    B = [F T F T F F ; T F F F T F ; F T F F T F]
    [M,ka,kb] = intersect(A, sparse(B), "c");
    issparse(M), full(M), ka, kb

    --> A = [F F T F T F ; T F F T T T ; T T F T F F]
     A  =
      F F T F T F
      T F F T T T
      T T F T F F

    --> B = [F T F T F F ; T F F F T F ; F T F F T F]
     B  =
      F T F T F F
      T F F F T F
      F T F F T F

    --> [M,ka,kb] = intersect(A, sparse(B), "c");
    --> issparse(M), full(M), ka, kb
     ans  =
      T

     ans  =
      F F T
      T T F
      F T F

     ka  =
       6.   1.   3.

     kb  =
       1.   5.   4.

## Смотрите также

- members
- unique
- gsort
- union

## История

6.1.0 Теперь принимаются комплексные числа.
6.1.1 Теперь принимаются разрежённые матрицы (числовые или логические значения).