and

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) — Binary AND between integers. Logical AND over/between booleans and numbers
• or — OU logique entre éléments d'un tableau booléen ou numérique
• ~ not — négation logique