Opérateurs booléens && et ||

Selon la définition du langage R , la différence entre &et &&(en conséquence |et ||) est que le premier est vectorisé alors que le second ne l'est pas.

Selon le texte d'aide , j'ai lu la différence semblable à la différence entre un "Et" et "AndAlso" (correspondant "Ou" et "OrElse") ... Signification: Ce ne sont pas toutes les évaluations si elles ne doivent pas être (c'est-à-dire que A ou B ou C est toujours vrai si A est vrai, alors arrêtez d'évaluer si A est vrai)

Quelqu'un pourrait-il faire la lumière ici? Y a-t-il également un AndAlso et un OrElse dans R?

Les plus courts sont vectorisés, ce qui signifie qu'ils peuvent renvoyer un vecteur, comme ceci:

((-2:2) >= 0) & ((-2:2) <= 0)
# [1] FALSE FALSE  TRUE FALSE FALSE

Le formulaire plus long évalue de gauche à droite en examinant uniquement le premier élément de chaque vecteur, donc ce qui précède donne

((-2:2) >= 0) && ((-2:2) <= 0)
# [1] FALSE

Comme l'indique la page d'aide, cela rend le formulaire plus long "approprié pour la programmation du flux de contrôle et [est] généralement préféré dans les clauses if".

Vous souhaitez donc utiliser les formes longues uniquement lorsque vous êtes certain que les vecteurs sont de longueur un.

Vous devez être absolument certain que vos vecteurs ne sont que de longueur 1, comme dans le cas où ce sont des fonctions qui ne renvoient que des booléens de longueur 1. Vous souhaitez utiliser les formes courtes si les vecteurs sont de longueur éventuellement> 1. Donc, si vous n'êtes pas absolument sûr, vous devez d'abord vérifier, ou utiliser le formulaire court, puis utiliser allet anypour le réduire à une longueur pour une utilisation dans les instructions de flux de contrôle, comme if.

Les fonctions allet anysont souvent utilisées sur le résultat d'une comparaison vectorisée pour voir si toutes ou certaines des comparaisons sont vraies, respectivement. Les résultats de ces fonctions sont sûrs de longueur 1, ils peuvent donc être utilisés dans les clauses if, tandis que les résultats de la comparaison vectorisée ne le sont pas. (Bien que ces résultats puissent être utilisés dans ifelse.

Une dernière différence: le &&et ||n'évalue que le nombre de termes nécessaires (ce qui semble être ce que l'on entend par court-circuit). Par exemple, voici une comparaison utilisant une valeur non définie a; s'il ne court-circuitait pas, comme &et |pas, cela donnerait une erreur.

a
# Error: object 'a' not found
TRUE || a
# [1] TRUE
FALSE && a
# [1] FALSE
TRUE | a
# Error: object 'a' not found
FALSE & a
# Error: object 'a' not found

Enfin, voir la section 8.2.17 dans The R Inferno , intitulée "and and and and".

La réponse au sujet du "court-circuit" est potentiellement trompeuse, mais a une certaine vérité (voir ci-dessous). Dans le langage R / S, &&et ||n'évaluez que le premier élément du premier argument. Tous les autres éléments d'un vecteur ou d'une liste sont ignorés, quelle que soit la première valeur. Ces opérateurs sont conçus pour fonctionner avec la if (cond) {} else{}construction et au contrôle des programmes directs plutôt que de construire de nouveaux vecteurs .. Les &et les |opérateurs sont conçus pour fonctionner sur des vecteurs, donc ils seront appliqués « en parallèle », pour ainsi dire, sur toute la longueur l'argument le plus long. Les deux vecteurs doivent être évalués avant d'effectuer les comparaisons. Si les vecteurs n'ont pas la même longueur, le recyclage de l'argument le plus court est alors effectué.

Lorsque les arguments vers &&ou ||sont évalués, il y a un "court-circuit" en ce sens que si l'une des valeurs successives de gauche à droite est déterminante, les évaluations cessent et la valeur finale est renvoyée.

> if( print(1) ) {print(2)} else {print(3)}
[1] 1
[1] 2
> if(FALSE && print(1) ) {print(2)} else {print(3)} # `print(1)` not evaluated
[1] 3
> if(TRUE && print(1) ) {print(2)} else {print(3)}
[1] 1
[1] 2
> if(TRUE && !print(1) ) {print(2)} else {print(3)}
[1] 1
[1] 3
> if(FALSE && !print(1) ) {print(2)} else {print(3)}
[1] 3

L'avantage du court-circuit n'apparaîtra que lorsque les arguments mettent longtemps à être évalués. Cela se produit généralement lorsque les arguments sont des fonctions qui traitent des objets plus gros ou ont des opérations mathématiques plus complexes.

&&et ||sont ce qu'on appelle des "courts-circuits". Cela signifie qu'ils n'évalueront pas le deuxième opérande si le premier opérande est suffisant pour déterminer la valeur de l'expression.

Par exemple, si le premier opérande &&est faux, il n'y a aucun intérêt à évaluer le second opérande, car il ne peut pas changer la valeur de l'expression ( false && trueet false && falsesont tous deux faux). Il en va de même ||lorsque le premier opérande est vrai.

Vous pouvez en savoir plus à ce sujet ici: http://en.wikipedia.org/wiki/Short-circuit_evaluation Dans le tableau de cette page, vous pouvez voir que cela &&équivaut à AndAlsoVB.NET, auquel je suppose que vous faites référence.