and ET logique entre éléments d'un tableau booléen ou numérique

## Syntaxe

                b = and(A)
                b = and(A, 'r')
                b = and(A, 'c')
                b = and(A, n)

## Paramètres

A

  vecteur, matrice ou hypermatrice de booléens, d'entiers encodés (de type entier inttype quelconque), de décimaux, ou de nombres complexes. `A` peut être encodée creuse (sparse).

  Un nombre est identifié à `%F` (faux) s'il vaut 0 ou 0+0i. Sinon (%nan inclus), il est identifé à `%T` (vrai).

  Valeurs particulières de `A` :
  - `and([])` vaut `%T`.
  - `and(%nan)` vaut `%T`.
b

  Booléen simple si `and(A)` est utilisée sans option `"r", "c", n`. `b` vaut alors

  - %F, si au moins un des éléments de `A` est %F ou zéro.
  - %T, sinon : tous les éléments de `A` sont %T ou non nuls ou %nan.

  Sinon : vecteur ligne, colonne, matrice ou hypermatrice. Voir la description de `n` ci-dessous.

  Lorsque `A` est encodée creuse, `b` l'est également.

n

  N° <= ndims(A) de la dimension selon laquelle `and()` est appliqué / projeté. Par défaut, `and()` est appliqué entre tous les éléments de `A`. Sinon :

  - n = 1 | "r" : `and()` est appliqué entre les lignes de `A`. Si `A` est une matrice, `b` est alors une ligne, avec `b(j) = and(A(:,j))`
  - n = 2 | "c" : `and()` est appliqué entre les colonnes de `A`. Si `A` est une matrice, `b` est alors une colonne, avec `b(i) = and(A(i,:))`.
  - n > 2 : Si `A` est une hypermatrice `and()` est appliqué selon sa nème dimension.

    Exemple: Si `ndims(A)==3` et `n=3`, `b` sera une matrice booléenne de tailles `size(A)([1 2])`, avec `b(i,j) = and(A(i,j,:))`.

## Description

`and()` applique un "ET" logique entre les éléments de l'opérande unique `A`, et en calcule le résultat.

Pour appliquer un ET logique entre éléments respectifs de 2 tableaux `C` et `D` de mêmes tailles, utiliser l'opérateur dédié `&`.

Pourquoi `and([])` vaut-il `%T` ? Quels que soient les tableaux compatibles `B` et `C`, `and([B C]) == ( and(B) & and(C) )`. Or, pour `B = []`, `and([B C])==and(C)`. Pour avoir toujours `(and([]) & and(C)) == and(C)`, `and([])` doit être `%T`.

## Exemples

    and([])
    and(0)
    and(0+0*%i)
    and(%eps)
    and(%i)
    and(%nan)

    // Projection à travers une dimension / selon une direction :
    A = rand(2,5)<0.5
    and(A)
    and(A, "r")   // and(A, 1) est équivalent
    and(A, "c")   // and(A, 2) est équivalent

    // Utilisation entre entiers encodés :
    A = int16(grand(3,5,"uin",-10,10));
    A(abs(A)<3) = 0
    and(A)
    and(A,1)

    // Avec une hypermatrice de nombres décimaux :
    A = rand(3,4,2);
    A(A<0.2) = 0
    and(A,3)

    // Avec une matrice encodée creuse :
    A = sprand(70,100, 0.001)
    and(A, "r")
    and(A, "c")

    --> and([])
     ans  =
      T

    --> and(0)
     ans  =
      F

    --> and(0+0*%i)
     ans  =
      F

    --> and(%eps)
     ans  =
      T

    --> and(%i)
     ans  =
      T

    --> and(%nan)
     ans  =
      T

    --> // Projection à travers une dimension / selon une direction :
    --> A = rand(2,5)<0.5
     A  =
      T T F F F
      F T F F T

    --> and(A)
     ans  =
      F

    --> and(A, "r")   // and(A, 1) est équivalent
     ans  =
      F T F F F

    --> and(A, "c")   // and(A, 2) est équivalent
     ans  =
      F
      F

    --> // Utilisation entre entiers encodés :
    --> A = int16(grand(3,5,"uin",-10,10));
    --> A(abs(A)<3) = 0
     A  =
       0  0  -8  -6    8
     -10  6  -5   3  -10
       0  3 -10   7   10

    --> and(A)
     ans  =
      F

    --> and(A,1)
     ans  =
      F F T T T

    --> // Avec une hypermatrice de nombres décimaux :
    --> A = rand(3,4,2);
    --> A(A<0.2) = 0
     A  =
    (:,:,1)
       0.4052   0.4819   0.2806   0.2119
       0.9185   0.264    0.       0.
       0.       0.4148   0.7783   0.6857
    (:,:,2)
       0.       0.4062   0.       0.5896
       0.6971   0.4095   0.       0.6854
       0.8416   0.8784   0.5619   0.8906

    --> and(A,3)
     ans  =
      F T F T
      T T F F
      F T T T

    --> // Avec une matrice encodée creuse :
    --> A = sprand(70,100, 0.001)
     A  =
    (  70,  100) sparse matrix

    (  4,  87)    0.6463
    (  5,  39)    0.4898
    (  7,  92)    0.7094
    (  29,  87)   0.794
    (  33,   1)   0.4087
    (  36,  79)   0.4876
    (  54,  65)   0.4456
    (  67,  45)   0.458

    --> and(A, "r")
     ans  =
    (  1,  100)False sparse matrix

    --> and(A, "c")
     ans  =
    (  70,  1)False sparse matrix

## Voir aussi

- & (distributif)
- or
- ~ not

## Historique

6.0.0 Les nombres complexes sont désormais acceptés.