Catégorie : Tuto R

Les structures décisionnelles exigent que le programmeur spécifie une ou plusieurs conditions devant être évaluées ou testées par le programme, ainsi qu’une ou plusieurs instructions à exécuter si la condition est déterminée comme étant vraie et éventuellement d’autres instructions à exécuter si la condition est déterminé comme étant fausse.

Voici la forme générale d’une structure décisionnelle typique trouvée dans la plupart des langages de programmation.

R fournit les types de décisions suivants. Cliquez sur les liens suivants pour vérifier leur détail.

if

Une instruction if est constituée d’une expression booléenne suivie d’une ou plusieurs instructions.

La syntaxe de base pour créer une instruction if dans R est :

If (boolean_expression) {
    // instruction (s) s’exécutera si l’expression booléenne est vraie.
}

Si l’expression booléenne s’avère vraie, le bloc de code à l’intérieur de l’instruction if sera exécuté. Si l’expression booléenne s’avère fausse, le premier ensemble de code après la fin de l’instruction if (après l’accolade fermante) sera exécuté.

x <- 30L
if(is.integer(x)) {
   print(« X est un entier »)
}

 

if …else

Une instruction if peut être suivie d’une instruction optionnelle else qui s’exécute lorsque l’expression booléenne est false.
Syntaxe

La syntaxe de base pour créer une instruction if … else dans R est :

If (boolean_expression) {
    // instruction (s) s’exécutera si l’expression booléenne est vraie.
} else {
    // instruction (s) s’exécutera si l’expression booléenne est false.
}

Si l’expression booléenne est évaluée comme étant vraie, alors le bloc de code if sera exécuté, sinon le bloc de code sera exécuté.

x <- c(« Que », »faire », »demain »)

if(« demain » %in% x) {
   print(« demain est présent »)
} else {
   print(« demain n’est pas présent »)
}

L’instruction if … else if … else

Une instruction if peut être suivie d’une instruction if else , qui est très utile pour tester diverses conditions en utilisant l’instruction if else if.

Syntaxe

La syntaxe de base pour créer une instruction if … else if … else dans R est

If (boolean_expression 1) {
    // Exécute lorsque l’expression booléenne 1 est vraie.
} Else if (expression_booléenne 2) {
    // Exécute quand l’expression booléenne 2 est vraie.
} Else if (expression_booléenne 3) {
    // Exécute lorsque l’expression booléenne 3 est vraie.
} else {
    // s’exécute lorsque aucune des conditions ci-dessus n’est vraie.
}

x <- c(« que », »faire », »demain »)

if(« demain » %in% x) {
   print(« demain est présent »)
} else if (« faire » %in% x) {
   print(« faire est présent »)
} else {
   print(« Ni faire, ni demain sont présents »)
}

switch

Une instruction switch permet à une variable d’être testée pour l’égalité par rapport à une liste de valeurs. Chaque valeur est appelée case, et la variable à activer est vérifiée pour chaque cas.
Syntaxe

La syntaxe de base pour créer une instruction switch dans R est

switch (expression, case1, case2, case3 ….)

Les règles suivantes s’appliquent à une instruction switch :

Si la valeur d’expression n’est pas une chaîne de caractères, elle est contrainte à l’entier.

Vous pouvez avoir n’importe quel nombre de déclarations de cas dans un commutateur. Chaque cas est suivi de la valeur à comparer et un :.

Si la valeur de l’entier est comprise entre 1 et nargs () – 1 (le nombre maximum d’arguments), l’élément correspondant de la condition de cas est évalué et le résultat renvoyé.

Si expression est évaluée à une chaîne de caractères, cette chaîne correspond exactement aux noms des éléments.

S’il y a plus d’une correspondance, le premier élément correspondant est renvoyé.

Aucun argument par défaut est disponible.

Dans le cas d’aucune correspondance, s’il y a un élément sans nom de … sa valeur est renvoyée. (S’il y a plusieurs arguments, une erreur est retournée.)

x <- switch(
   3,
   « first »,
   « second »,
   « third »,
   « fourth »
)

 

 

Un opérateur est un symbole qui indique au compilateur d’effectuer des manipulations mathématiques ou logiques spécifiques. R est riche en opérateurs intégrés et fournit les types suivants d’opérateurs.
Types d’opérateurs

Nous avons les types d’opérateurs suivants dans la programmation R –

–  Opérateurs arithmétiques
– Opérateurs relationnels
–  Opérateurs logiques
–  Opérateurs d’affectation
–  Opérateurs divers

Opérateurs arithmétiques

Le tableau suivant montre les opérateurs arithmétiques supportés par le langage R. Les opérateurs agissent sur chaque élément du vecteur.

+ additionne deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v+t))

[1] 10.0  8.5 10.0

 

– soustrait deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v-t)

[1] -6.0  2.5  2.0

* multiplier deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v*t)

[1] 16.0 16.5 24.0

/ Diviser deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v/t)

[1] 0.250000 1.833333 1.500000

%% Donner le reste du premier vecteur avec le second
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%%t)

%/% Donner le reste de la division du premier vecteur par le second (quotient)
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%/%t)

[1] 2.0 2.5 2.0

^  Le premier vecteur élevé à l’exposant du second vecteur
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v^t)

[1]  256.000  166.375 1296.000

Opérateurs relationnels

Le tableau suivant montre les opérateurs relationnels supportés par le langage R. Chaque élément du premier vecteur est comparé à l’élément correspondant du second vecteur. Le résultat de la comparaison est une valeur booléenne.

> Vérifie si chaque élément du premier vecteur est supérieur à l’élément correspondant du second vecteur.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>t)

[1] FALSE  TRUE FALSE FALSE

< Vérifie si chaque élément du premier vecteur est inférieur à l’élément correspondant du second vecteur.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<t)

[1]  TRUE FALSE  TRUE FALSE

== Vérifie si chaque élément du premier vecteur est égal à l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v == t)

[1] FALSE FALSE FALSE  TRUE

<= Vérifie si chaque élément du premier vecteur est inférieur ou égal à l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<=t)

[1]  TRUE FALSE  TRUE  TRUE

 

>= Vérifie si chaque élément du premier vecteur est supérieur ou égal à l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>=t)

[1] FALSE  TRUE FALSE  TRUE

 

!= Vérifie si chaque élément du premier vecteur est différent de l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v!=t)

[1]  TRUE  TRUE  TRUE FALSE

Opérateurs logiques

Le tableau suivant montre les opérateurs logiques pris en charge par le langage R. Il ne s’applique qu’aux vecteurs de type logique, numérique ou complexe. Tous les nombres supérieurs à 1 sont considérés comme valeur logique TRUE.

Chaque élément du premier vecteur est comparé à l’élément correspondant du second vecteur. Le résultat de la comparaison est une valeur booléenne.

& Elle est appelée opérateur logique ET élémentaire. Il combine chaque élément du premier vecteur avec l’élément correspondant du second vecteur et donne une sortie TRUE si les deux éléments sont TRUE.

v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

[1]  TRUE  TRUE FALSE  TRUE

| Il est appelé Opérateur logique élémentaire OU. Il combine chaque élément du premier vecteur avec l’élément correspondant du second vecteur et donne une sortie TRUE si l’un des éléments est TRUE.

v <- c(3,0,TRUE,2+2i)
t <- c(4,0,FALSE,2+3i)
print(v|t)

[1]  TRUE FALSE  TRUE  TRUE

! Il est appelé opérateur logique NOT. Prend chaque élément du vecteur et donne la valeur logique opposée.
v <- c(3,0,TRUE,2+2i)
print(!v)

[1] FALSE  TRUE FALSE FALSE

L’opérateur logique && et || Ne considère que le premier élément des vecteurs et donne un vecteur d’élément unique comme sortie.

&& Appelé Opérateur ET logique. Prend le premier élément des deux vecteurs et donne VRAI seulement si les deux sont VRAI.

v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

[1] TRUE

|| Appelé Opérateur OU logique. Prend le premier élément des deux vecteurs et donne VRAI si l’un d’eux est VRAI.
v <- c(0,0,TRUE,2+2i)
t <- c(0,3,TRUE,2+3i)
print(v||t)

[1] FALSE

Opérateurs d’affectation

Ces opérateurs sont utilisés pour attribuer des valeurs aux vecteurs.

<− ou = ou <<−  assignation à gauche
v1 <- c(3,1,TRUE,2+3i)
v2 <<- c(3,1,TRUE,2+3i)
v3 = c(3,1,TRUE,2+3i)
print(v1)
print(v2)
print(v3)

> print(v1)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v2)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v3)
[1] 3+0i 1+0i 1+0i 2+3i

−> ou −>>  assignation à droite
c(3,1,TRUE,2+3i) -> v1
c(3,1,TRUE,2+3i) ->> v2
print(v1)
print(v2)

> print(v1)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v2)
[1] 3+0i 1+0i 1+0i 2+3i

Opérateurs divers

Ces opérateurs sont utilisés pour des fins spécifiques et non pour des calculs mathématiques ou logiques généraux.

: Il crée la série de nombres en séquence pour un vecteur.
v <- 2:8
print(v)

[1] 2 3 4 5 6 7 8

%in% Cet opérateur permet d’identifier si un élément appartient à un vecteur.

v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t)
print(v2 %in% t)

> print(v1 %in% t)
[1] TRUE
> print(v2 %in% t)
[1] FALSE

%*% Cet opérateur est utilisé pour multiplier une matrice par sa transposition.
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

     [,1] [,2]
[1,]   65   82
[2,]   82  117