Structure de la programmation R

R est un langage structuré en bloc comme C, C ++, Python, Perl, etc. Comme vous l'avez fait déjà vu, les blocs sont délimités par des accolades, bien que les accolades sont facultatives si le bloc se compose d'une simple déclaration. Les déclarations sont séparées par des caractères de nouvelle ligne ou, éventuellement, par des points-virgules.
Dans cette partie, nous allons couvrir les structures de base de R en tant que langage de programmation. Nous allons passer en revue quelques détails supplémentaires sur les boucles, puis continuer tout droit dans le sujet des fonctions, qui occuperont la majeure partie de cette partie.
Comme pour beaucoup langages de script, vous ne "déclarez" pas les variables dans R.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation R

Les fonctions R sont des objets de première classe (de la classe "fonction", bien sûr), ce qui signifie qu'ils peuvent être utilisés pour la plupart comme d'autres objets. Cela se voit dans la syntaxe de la création de fonctions:

  1. > g <- function(x) {
  2. + return(x+1)
  3. +}
Source code

Ici, function () est une fonction R intégrée dont le travail est de créer des fonctions! Sur le côté droit, il y a vraiment deux arguments pour function (): La première est la liste des arguments formels pour la fonction que nous créons - ici, seulement x - et la seconde est le corps de cette fonction - ici, juste le retour d'état unique (x + 1). Ce second argument doit être de classe "expression". Donc, le fait est que le membre de droite crée un objet de fonction, qui est ensuite assigné à g.
Par ailleurs, même le "{" est une fonction, comme vous pouvez le vérifier en tapant ceci:

  1. > ?"{"
Source code
Son travail est de faire une seule unité de ce qui pourrait être plusieurs déclarations.
Ces deux arguments pour function () peuvent ensuite être accédés via les fonctions R formals () et body (), comme suit:

  1. > formals(g)
  2. $x
  3. > body(g)
  4. {
  5. return(x + 1)
  6. }
Source code
Rappelez-vous que lorsque vous utilisez R en mode interactif, il suffit de taper le nom d'un objet pour imprimer cet objet à l'écran. Les fonctions ne font pas exception, puisqu'elles sont des objets comme n'importe quoi d'autre.

  1. >g
  3. return(x+1)
  4. }
Source code
C'est utile si vous utilisez une fonction que vous avez écrite mais dont vous avez oublié les détails. L'impression d'une fonction est également utile si vous n'êtes pas sûr de ce que fait une fonction de bibliothèque R. En regardant le code, vous pouvez le comprendre mieux. Par exemple, si vous n'êtes pas sûr du comportement exact de la fonction graphique abline (), vous pouvez parcourir son code pour mieux comprendre comment l'utiliser.

  2. function (a = NULL, b = NULL, h = NULL, v = NULL, reg = NULL,
  3. coef = NULL, untf = FALSE, ...)
  4. {
  5. ...
  6. ...
  7. int_abline <- function(a, b, h, v, untf, col = par("col"),
  8. lty = par("lty"), lwd = par("lwd"), ...) .Internal(abline(a,
  9. b, h, v, untf, col, lty, lwd, ...))
  10. if (!is.null(reg)) {
  11. if (!is.null(a))
  12. }
  13. warning("'a' is overridden by 'reg'")
  14. a<-reg
  15. if (is.object(a) || is.list(a)) {
  16. p <- length(coefa <- as.vector(coef(a)))
Source code
Si vous souhaitez afficher une longue fonction de cette manière, lancez-la à travers la page ():

Source code
Une alternative est de le modifier en utilisant la fonction edit (), dont nous parlerons dans la section 7.11.2.
Notez cependant que certaines des fonctions intégrées les plus fondamentales de R sont écrites directement dans C et ne sont donc pas visibles de cette manière. Voici un exemple:

  1. > sum
  2. function (..., na.rm = FALSE) .Primitive("sum")
Source code
Les fonctions étant des objets, vous pouvez également les assigner, les utiliser comme arguments pour d'autres fonctions, etc.

  1. > f1 <- function(a,b) return(a+b)
  2. > f2 <- function(a,b) return(a-b)
  3. >f<-f1
  4. > f(3,2)
  5. [1] 5
  6. >f<-f2
  7. > f(3,2)
  8. [1] 1
  9. > g <- function(h,a,b) h(a,b)
  10. > g(f1,3,2)
  11. [1] 5
  12. > g(f2,3,2)
  13. [1] 1
Source code
Et comme les fonctions sont des objets, vous pouvez parcourir une liste composée de plusieurs fonctions. Cela serait utile, par exemple, si vous souhaitiez écrire une boucle pour tracer un certain nombre de fonctions sur le même graphe, comme suit:

  1. > g1 <- function(x) return(sin(x))
  2. > g2 <- function(x) return(sqrt(x^2+1))
  3. > g3 <- function(x) return(2
  4. *
  5. x-1)
  6. > plot(c(0,1),c(-1,1.5)) # prepare the graph, specifying X and Y ranges
  7. > for (f in c(g1,g2,g3)) plot(f,0,1,add=T) # add plot to existing graph
Source code
Les fonctions formals () et body () peuvent même être utilisées comme fonctions de remplacement. Nous discuterons des fonctions de remplacement dans la Section 7.10, mais pour l'instant, réfléchissez à la façon dont vous pourriez modifier le corps d'une fonction par affectation:

  1. > g <- function(h,a,b) h(a,b)
  2. > body(g) <- quote(2
  3. >g
  5. 2
  6. *
  7. x+3
  8. > g(3)
  9. [1] 9
  10. *
  11. x+3)
Source code
La raison pour laquelle quote () était nécessaire est que techniquement, le corps d'une fonction a la classe "call", qui est la classe produite par quote (). Sans l'appel à citer (), R essaierait d'évaluer la quantité 2 * x + 3. Donc, si x avait été défini et égal à 3, par exemple, nous assignerions 9 au corps de g (), certainement pas ce que nous voulons. D'ailleurs, puisque * et + sont des fonctions (comme décrit dans la section 2.4.1), en tant qu'objet de langage, 2 * x + 3 est en effet un appel entrant, c'est un appel de fonction imbriqué dans un autre.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation R

Dans la section 5.1.2, nous lisons dans un ensemble de données à partir d'un fichier appelé examens:

  1. > testscores <- read.table("exams",header=TRUE)
Source code
L'argument header = TRUE indique à R que nous avons une ligne d'en-tête, donc R ne devrait pas compter cette première ligne dans le fichier en tant que donnée.
Ceci est un exemple d'utilisation d'arguments nommés. Voici les premières lignes de la fonction:

  2. function (file, header = FALSE, sep = "", quote = "\"'", dec = ".",
  3. row.names, col.names, as.is = !stringsAsFactors, na.strings = "NA",
  4. colClasses = NA, nrows = -1, skip = 0, check.names = TRUE,
  5. fill = !blank.lines.skip, strip.white = FALSE, blank.lines.skip = TRUE,
  6. comment.char = "#", allowEscapes = FALSE, flush = FALSE,
  7. stringsAsFactors = default.stringsAsFactors(), encoding = "unknown")
  8. {
  10. ...
  11. ...
  12. file <- file(file, "r")
Source code
Le deuxième argument formel est nommé en-tête. Le champ = FALSE signifie que cet argument est optionnel, et si nous ne le spécifions pas, la valeur par défaut sera FALSE. Si nous ne voulons pas la valeur par défaut, nous devons nommer l'argument dans notre appel:

  1. > testscores <- read.table("exams",header=TRUE)
Source code
D'où la terminologie nommée argument.
Notez cependant que parce que R utilise l'évaluation paresseuse, il n'évalue pas une expression tant que l'argument nommé ne peut pas être utilisé.

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation R

 

Le tableau 7-1 répertorie les opérateurs de base.
Tableau 7-Ì: Opérateurs R de base
Description d'opération
x + y Addition
x - y Soustraction
x * y Multiplication
Division x / y
x n y Exponentiation
x %% y Arithmétique modulaire
x% /% y Division entière
x == y Test d'égalité
x <= y Test inférieur ou égal à
x> = y Test supérieur ou égal à
x y Booléen ET pour les scalaires
x Il y Booléen OU pour les scalaires
x S y Boolean ET pour les vecteurs (vecteur x, y, résultat)
x I y Booléen OU pour les vecteurs (vecteur x, y, résultat)
! x négation booléenne

Bien que R ostensiblement n'a pas de types scalaires, les scalaires étant traités comme des vecteurs à un élément, nous voyons l'exception dans le Tableau 7-1: Il existe différents opérateurs booléens pour les cas scalaires et vectoriels. Cela peut sembler étrange, mais un simple exemple démontrera la nécessité d'une telle distinction.

  1. >x
  2. [1] TRUE FALSE TRUE
  3. >y
  4. [1] TRUE TRUE FALSE
  5. >x&amp;y
  6. [1] TRUE FALSE FALSE
  7. > x[1] &amp;&amp; y[1]
  8. [1] TRUE
  9. > x &amp;&amp; y # looks at just the first elements of each vector
  10. [1] TRUE
  11. > if (x[1] &amp;&amp; y[1]) print("both TRUE")
  12. [1] "both TRUE"
  13. > if (x &amp; y) print("both TRUE")
  14. [1] "both TRUE"
  15. Warning message:
  16. In if (x &amp; y) print("both TRUE") :
  17. the condition has length > 1 and only the first element will be used
Source code

Le point central est qu'en évaluant un if, nous avons besoin d'un seul booléen, pas d'un vecteur de booléens, d'où l'avertissement vu dans l'exemple précédent, ainsi que la nécessité d'avoir à la fois les opérateurs & et &&.
Les valeurs booléennes VRAI et FAUX peuvent être abrégées en tant que T et F (les deux doivent être en majuscules). Ces valeurs changent à 1 et 0 dans les expressions arithmétiques:

  1. >1<2
  2. [1] TRUE
  3. >(1<2)
  4. [1] 1
  5. >(1<2)
  6. *
  7. (3<4)
  8. *
  9. (3<4)
  10. [1] 0
  11. > (1 < 2) == TRUE
  12. [1] TRUE
  13. >(1<2)==1
  14. [1] TRUE
  15. *
  16. (5<1)
Source code
Dans le deuxième calcul, par exemple, la comparaison 1 <2 renvoie TRUE, et 3 <4 donne VRAI aussi. Les deux valeurs sont traitées comme 1 valeurs, donc le produit est 1.
En surface, les fonctions R ressemblent à celles de C, Java, etc. Cependant, ils ont beaucoup plus d'une saveur de programmation fonctionnelle, ce qui a des implications directes pour le programmeur R.

 

Détails
Catégorie parente: Logiciel R
Catégorie : Structure de la programmation R

Les instructions de contrôle dans R ressemblent beaucoup à celles des langages de la famille descendante ALGOL mentionnés ci-dessus. Ici, nous examinerons les boucles et les instructions if-else.


1 Boucles
Dans la section 1.3, nous avons défini la fonction oddcount (). Dans cette fonction, la ligne suivante aurait dû être immédiatement reconnue par les programmeurs Python:

  1. for (n in x) {
Source code
Cela signifie qu'il y aura une itération de la boucle pour chaque composante du vecteur x, avec n prenant les valeurs de ces composantes dans la première itération, n = x [1]; dans la deuxième itération, n = x [2]; etc. Par exemple, le code suivant utilise cette structure pour sortir le carré de chaque élément d'un vecteur:

  1. > x <- c(5,12,13)
  2. > for (n in x) print(n^2)
  3. [1] 25
  4. [1] 144
  5. [1] 169
Source code
La boucle de style C avec while et repeat est également disponible, avec break, une instruction qui fait que le contrôle quitte la boucle. Voici un exemple qui utilise tous les trois:

  1. > i <- 1
  2. > while (i <= 10) i <- i+4
  3. > i
  4. [1] 13
  5. >
  6. > i <- 1
  7. > while(TRUE) { # similar loop to above
  8. + i <- i+4
  9. + if (i > 10) break
  10. + }
  11. > i
  12. [1] 13
  13. >
  14. > i <- 1
  15. > repeat { # again similar
  16. + i <- i+4
  17. + if (i > 10) break
  18. + }
  19. > i
  20. [1] 13
Source code

Dans le premier fragment de code, la variable i a pris les valeurs 1, 5, 9 et 13 comme la boucle a traversé ses itérations. Dans ce dernier cas, la condition i <= 10 a échoué, alors la pause s'est installée et nous avons quitté la boucle.
Ce code montre trois façons différentes d'accomplir la même chose, la pause jouant un rôle clé dans les deuxième et troisième façons.
Notez que repeat n'a pas de condition de sortie booléenne. Vous devez utiliser break (ou quelque chose comme return ()). Bien sûr, break peut aussi être utilisé avec les boucles for.
Une autre instruction utile est la suivante, qui demande à l'interpréteur de passer le reste de l'itération en cours de la boucle et de passer directement au suivant. Cela permet d'éviter d'utiliser des constructions if-then-else complexes, ce qui peut rendre le code déroutant. Jetons un oeil à un exemple qui utilise ensuite. Le code suivant provient d'un examen étendu du chapitre 8:

  1. 1 sim <- function(nreps) {
  2. 2 commdata <- list()
  3. 3 commdata$countabsamecomm <- 0
  4. 4 for (rep in 1:nreps) {
  5. 5 commdata$whosleft <- 1:20
  6. 6 commdata$numabchosen <- 0
  7. 7 commdata <- choosecomm(commdata,5)
  8. 8 if (commdata$numabchosen > 0) next
  9. 9 commdata <- choosecomm(commdata,4)
  10. 10 if (commdata$numabchosen > 0) next
  11. 11 commdata <- choosecomm(commdata,3)
  12. 12 }
  13. 13 print(commdata$countabsamecomm/nreps)
  14. 14 }
Source code
Il y a les prochaines déclarations aux lignes 8 et 10. Voyons comment ils fonctionnent et comment ils améliorent les alternatives. Les deux instructions suivantes se trouvent dans la boucle qui commence à la ligne 4. Ainsi, lorsque la condition if se trouve à la ligne 8, les lignes 9 à 11 seront ignorées et le contrôle sera transféré à la ligne 4. La situation de la ligne 10 est similaire.
Sans utiliser ensuite, nous aurions besoin de recourir à des instructions imbriquées if, quelque chose comme ceci:

  1. 1 sim <- function(nreps) {
  2. 2 commdata <- list()
  3. 3 commdata$countabsamecomm <- 0
  4. 4 for (rep in 1:nreps) {
  5. 5 commdata$whosleft <- 1:20
  6. 6 commdata$numabchosen <- 0
  7. 7 commdata <- choosecomm(commdata,5)
  8. 8 if (commdata$numabchosen == 0) {
  9. 9 commdata <- choosecomm(commdata,4)
  10. 10 if (commdata$numabchosen == 0)
  11. 11 commdata <- choosecomm(commdata,3)
  12. 12 }
  13. 13 }
  14. 14 print(commdata$countabsamecomm/nreps)
  15. 15 }
Source code
Parce que cet exemple simple n'a que deux niveaux, ce n'est pas trop mal. Cependant, les instructions imbriquées peuvent devenir déroutantes lorsque vous avez plus de niveaux.
La construction for fonctionne sur n'importe quel vecteur, quel que soit le mode. Vous pouvez faire une boucle sur un vecteur de noms de fichiers, par exemple. Disons que nous avons un fichier nommé file 1 avec le contenu suivant:
1
2
3
4
5
6
Nous avons aussi un fichier nommé file 2 avec ces contenus:
5
12
13
La boucle suivante lit et imprime chacun de ces fichiers. Nous utilisons ici la fonction scan () pour lire dans un fichier de nombres et stocker ces valeurs dans un vecteur. Nous parlerons plus en détail de scan () au chapitre 10.

  1. > for (fn in c("file1","file2")) print(scan(fn))
  2. Read 6 items
  3. [1]123456
  4. Read 3 items
  5. [1] 51213
Source code
Donc, fn est d'abord réglé sur filel, et le fichier de ce nom est lu et imprimé. Ensuite, la même chose se produit pour file2.


2 Bouclage sur des ensembles non-vecteurs
R ne supporte pas directement l'itération sur les ensembles non-vecteurs, mais il existe quelques moyens indirects mais faciles à réaliser:
• Utilisez lapply (), en supposant que les itérations de la boucle sont indépendantes les unes des autres, ce qui permet de les exécuter dans n'importe quel ordre.

 

• Utilisez get (). Comme son nom l'indique, cette fonction prend comme argument une chaîne de caractères représentant le nom d'un objet et renvoie l'objet de ce nom. Cela semble simple, mais get () est une fonction très puissante.
Regardons un exemple d'utilisation de get (). Supposons que nous ayons deux matrices, u et v, contenant des données statistiques, et nous souhaitons appliquer à chacun d'eux la fonction de régression linéaire lm ().

  1. >u
  2. [,1] [,2]
  3. [1,] 1 1
  4. [2,] 2 2
  5. [3,] 3 4
  6. >v
  7. [,1] [,2]
  8. [1,] 8 15
  9. [2,] 12 10
  10. [3,] 20 2
  11. > for (m in c("u","v")) {
  12. + z <- get(m)
  13. + print(lm(z[,2] ~ z[,1]))
  14. +}
  15. Call:
  16. lm(formula = z[, 2] ~ z[, 1])
  17. Coefficients:
  18. (Intercept) z[, 1]
  19. -0.6667 1.5000
  20. Call:
  21. lm(formula = z[, 2] ~ z[, 1])
  22. Coefficients:
  23. (Intercept) z[, 1]
  24. 23.286 -1.071
Source code
Ici, m a été mis pour la première fois. Alors ces lignes assignent la matrice u à z, ce qui permet l'appel à lm () sur u:

  1. z <- get(m)
  2. print(lm(z[,2] ~ z[,1]))
Source code
La même chose se produit alors avec v.


3 if-else
La syntaxe de if-else ressemble à ceci:

  1. if (r == 4) {
  2. x<-1
  3. } else {
  4. x<-3
  5. y<-4
  6. }
Source code
Cela semble simple, mais il y a ici une subtilité importante. La section if se compose d'une seule déclaration:
  1. x <- 1
Source code
Donc, vous pourriez deviner que les accolades autour de cette déclaration ne sont pas nécessaires. Cependant, ils sont en effet nécessaires.
L'accolade droite avant le else est utilisée par l'analyseur R pour déduire qu'il s'agit d'un if-else plutôt que d'un if. En mode interactif, sans accolades, l'analyseur pense par erreur à ce dernier et agit en conséquence, ce qui n'est pas ce que nous voulons.
Une instruction if-else fonctionne comme un appel de fonction et, à ce titre, renvoie la dernière valeur attribuée.

  1. v <- if (cond) expression1 else expression2
Source code
Cela mettra v au résultat de l'expression! ou expression2, selon que la condition est vraie. Vous pouvez utiliser ce fait pour compacter votre code. Voici un exemple simple:

  1. >x<-2
  2. > y <- if(x == 2) x else x+1
  3. >y
  4. [1] 2
  5. >x<-3
  6. > y <- if(x == 2) x else x+1
  7. >y
  8. [1] 4
Source code

Sans prendre ce point, le code 

  1. y <- if(x == 2) x else x+1
Source code
consisterait plutôt en un peu plus encombré

  1. if(x == 2) y <- x else y <- x+1
Source code
Dans des exemples plus complexes, expression! et / ou expression2 pourraient être des appels de fonction. D'un autre côté, vous ne devriez probablement pas laisser la compacité prendre le pas sur la clarté.
Lorsque vous travaillez avec des vecteurs, utilisez la fonction ifelse (), comme indiqué au chapitre 2, car elle produira probablement un code plus rapide.