Logical

Je vous préviens : je suis un fan absolu des vecteurs logiques. Ces choses-là sont absolument extraordinaires.

Vous pouvez en créer un à la main :

> x <- c(TRUE, FALSE, TRUE)
> class(x)
[1] "logical"

Ou, comme nous l’avions fait avec logic :

logic <- value > median(value)

Puisque :

> median(value)
[1] 392

L’expression value > median(value) créé un vecteur logique composé de TRUE là où les éléments de value sont strictement inférieurs à 392 et de FALSE dans les autres cas (là où les éléments de value sont supérieurs ou égaux à 350).

Ce qui nous donne :

> logic
 [1]  TRUE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE FALSE FALSE
[13] FALSE FALSE  TRUE

Ce qui, comme nous l’avons déjà vu, permet d’indexer value pour ne récupérer que les valeurs supérieures à 392 :

> value[logic]
[1]  735  524  450 1459  465  600  870

Une des grandes applications des vecteurs logical ce sont les structures de type : si(condition) {alors} sinon {alors}. Un exemple valant mieux qu’un long discours, soit :

> x <- 99
> test <- x > 100
> test
[1] FALSE
> class(test)
[1] "logical"
> ifelse(test, 1, 0)
[1] 0

En revanche :

> x <- 101
> test <- x > 100
> test
[1] TRUE
> ifelse(test, 1, 0)
[1] 1

Dans certain cas, vous aurez besoin d’une forme plus développée. Par exemple, imaginez que vous vouliez créer un petit script qui calcule l’aire d’un disque quand aire = TRUE ou sa circonférence quand aire = FALSE :

rayon <- 10
aire <- TRUE
if(aire) {
 resultat <- pi*rayon^2
} else {
 resultat <- pi*2*rayon
}

Avec aire <- TRUE, vous obtenez :

> resultat
[1] 314.1593

Avec aire <- FALSE, vous aurez :

> resultat
[1] 62.83185

Une autre manière de coder la même chose eut été :

resultat <- pi * if(aire) rayon^2 else 2*rayon

Vous pouvez aussi utiliser des if sans else :

> x <- 99
> if(x >= 100) x <- 0
> x
[1] 99

Et :

> x <- 100
> if(x >= 100) x <- 0
> x
[1] 0

La classe logical permet d’utiliser les opérateurs logiques de base que sont and (&), or (|), not (!) et xor (la fonction xor). Là encore, quelques exemples :

Avec :

vrai <- TRUE

Vous pouvez créer :

> faux <- ! vrai
> faux
[1] FALSE

Dès lors, avec l’opérateur and (&) :

> vrai & faux
[1] FALSE
> vrai & vrai
[1] TRUE
> faux & faux
[1] FALSE
> vrai & !faux
[1] TRUE

Avec l’opérateur or (|) :

> vrai | faux
[1] TRUE
> vrai | vrai
[1] TRUE
> faux | faux
[1] FALSE
> vrai | !faux
[1] TRUE

Et enfin, avec xor (le or exclusif) :

> xor(vrai, faux)
[1] TRUE
> xor(vrai, vrai)
[1] FALSE
> xor(faux, faux)
[1] FALSE
> xor(vrai, !faux)
[1] FALSE

(Si vous n’êtes pas habitué à ce type de logiques, passez-y quelques minutes pour bien comprendre.)

Sur des vecteurs de longueur supérieure à 1 :

> logic | rep(FALSE, length(logic))
 [1]  TRUE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE FALSE FALSE
[13] FALSE FALSE  TRUE

Et le recyclage fonctionne aussi :

> logic & TRUE
 [1]  TRUE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE FALSE FALSE
[13] FALSE FALSE  TRUE

Ce qui vous permet d’écrire très synthétiquement des choses assez complexes :

> xor(logic, ! rev(logic))
 [1]  TRUE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE FALSE  TRUE
[13]  TRUE  TRUE  TRUE

Très pratiquement, si vous souhaitez récupérer les éléments de value qui sont inférieurs à 350 ou supérieurs à 850 :

> value[value < 350 | value > 850]
[1]  320  325 1459  135  330  336  280  315  870

Avec les vecteurs logiques viennent quelques fonctions très utiles :

> test <- value >= 800
> any(test)
[1] TRUE
> all(test)
[1] FALSE
> which(test)
[1]  7 15

Autre propriété amusante :

> as.numeric(TRUE)
[1] 1
> as.numeric(FALSE)
[1] 0

Ce qui fait que :

> TRUE + TRUE
[1] 2

Ça a l’air d’un détail mais vous verrez que ça peut s’avérer extrêmement pratique dans bien des cas. Par exemple :

> z <- 1:10 > 5
> sum(z)
[1] 5

Ce qui nous permet de déduire que 5 éléments du vecteur 1:10 sont supérieurs à 5.

Vous pouvez abréger TRUE et FALSE avec T et F :

> T == !F
[1] TRUE

Aucun commentaire:

Enregistrer un commentaire