Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Please login or create an account
Change language to: English - Português - 日本語 - Русский
Aide de Scilab >> Fonctions Elémentaires > Opérations matricielles > and

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 rangées de A. Si A est une matrice, b est alors une rangée, 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
Scilab Enterprises
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors
Last updated:
Mon Feb 12 19:15:26 CET 2018