intersect éléments, lignes, ou colonnes communs aux 2 tableaux d'entrée, sans doublon

## Syntaxe

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

## Arguments

a, b
  vecteurs, matrices ou hypermatrices de booléens, d'entiers encodés, de nombres réels ou complexes, ou de texte. `a` et `b` doivent être du même type de données, mais ont des tailles indépendantes. Pour les données texte, les caractères UTF sont admis. Les matrices creuses booléennes ou numériques sont acceptées : `a` ou `b` ou les deux peuvent être creuses.

orient
  indicateur de traitement par colonnes ou lignes. Valeurs possibles : 1 ou "r", 2 ou "c". Ne peut pas être utilisé lorsque `a` ou/et `b` est une hypermatrice.

M

  Matrice du type de `a` et `b`.

  - Sans `orient`: `M` est un vecteur ligne.
  - Avec `orient="r"|1`: `M` est une matrice empilant les lignes communes à `a` et `b`.
  - Avec `orient="c"|2`: `M` est une matrice concaténant les colonnes communes à `a` et `b`.

  `M` est creuse dés que `a` ou `b` est creuse et aucune n'est vide.

ka
  Vecteur ligne dense d'indices dans `a`.

kb
  Vecteur ligne dense d'indices dans `b`.

## Description

`intersect(a,b)` produit un vecteur ligne des éléments dédoublonnés présents à la fois dans les tableaux `a` et `b`, triés en ordre croissant

- pour les nombres complexes : par modules croissants, puis par phases croissantes.
- pour le texte : par ordre alphabétique.

Deux éléments NaN étant toujours considérés comme différents, NaN ou les lignes ou colonnes en contenant ne seront jamais présents dans le résultat `M`.

`[M, ka, kb] = intersect(a,b)` fournit en outre les vecteurs lignes `ka` et `kb` des indices dans `a` et `b` des éléments communs rencontrés à leur première position, tels que `M=a(ka)` and `M=b(kb)`.

### Lignes ou colonnes en commun

Lorsque l'option `orient` est utilisée, la comparaison entre `a` et `b` est réalisée en considérant leurs lignes ou leurs colonnes dans leur entier.

`intersect(a,b,"r")` ou `intersect(a,b,1)` fournira la matrice des lignes (sans doublons) présentes à la fois dans `a` et dans `b`, triées en ordre lexicographique croissant. Lorsque `a` et `b` n'ont pas le même nombre de colonnes, [] est retourné sans comparer aucun élément.

`[M,ka,kb]=intersect(a,b,"r")` fournit en outre les vecteurs `ka` et `kb` des indices minimaux des lignes communes, indices respectivement dans `a` dans `b`. On a alors `M=a(ka,:)` et `M=b(kb,:)`.

`intersect(a,b,"c")` ou `intersect(a,b,2)` réalise la même chose sur les colonnes.

## Exemples

    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.

Dans l'exemple ci-dessus, on notera que 6 est présent quatre fois dans A, aux indices [2 4 5 8]. Seule la position d'indice minimal 2 est donnée dans ka. Même situation pour 2 dans B.

La valeur NaN (Not-a-Number) ne peut jamais figurer dans le résultat :

    %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() peut aussi traiter des caractères ou du texte. Scilab sait traiter les textes encodés en UTF. Voici un exemple avec du texte en arabe, afin d'obtenir les caractères arabes communs à deux phrases :

    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  =
    !   ر  م  ه  و  !

Lignes ou colonnes communes à deux matrices : l'exemple suivant extrait les colonnes communes à deux matrices d'entiers signés encodés sur un octet :

    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.

Pour des booléens, `intersect()` est utile essentiellement avec l'option "r" ou "c". Voici un exemple avec une matrice booléenne creuse :

    [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.

## Voir aussi

- members
- unique
- gsort
- union

## Historique

6.1.0 Nombres complexes désormais acceptés.
6.1.1 Matrices creuses numériques ou booléennes désormais acceptées.