Cours complet pour débutants pour apprendre la programmation en R

On définit une nouvelle fonction avec la syntaxe suivante :

fun <- function(arguments) expression

où

• fun est le nom de la fonction (les règles pour les noms de fonctions étant les mêmes que celles présentées à la section 2.2Conventions pour les noms d'objets pour tout autre objet) ;
• arguments est la liste des arguments, séparés par des virgules ;
• expression constitue le corps de la fonction, soit une expression ou un groupe d'expressions réunies par des accolades.

La plupart des fonctions sont écrites dans le but de retourner un résultat. Or, les règles d'interprétation d'un groupe d'expressions présentées à la section 2.1Commandes R s'appliquent ici au corps de la fonction.

• Une fonction retourne tout simplement le résultat de la dernière expression du corps de la fonction.
• On évitera donc que la dernière expression soit une affectation, car la fonction ne retournera alors rien et on ne pourra utiliser une construction de la forme x <- f() pour affecter le résultat de la fonction à une variable.
• Si on doit retourner un résultat sans être à la dernière ligne de la fonction (à l'intérieur d'un bloc conditionnel, par exemple), on utilise la fonction return. L'utilisation de return à la toute fin d'une fonction est tout à fait inutile et considérée comme du mauvais style en R.
• Lorsqu'une fonction doit retourner plusieurs résultats, il est en général préférable d'avoir recours à une liste nommée.

Comme la majorité des langages de programmation, R comporte des concepts de variable locale et de variable globale.

• Toute variable définie dans une fonction est locale à cette fonction, c'est-à-dire qu'elle :

  • n'apparaît pas dans l'espace de travail ;
  • n'écrase pas une variable du même nom dans l'espace de travail.
• Il est possible de définir une variable dans l'espace de travail depuis une fonction avec l'opérateur d'affectation <<-. Il est très rare — et généralement non recommandé — de devoir recourir à de telles variables globales.
• On peut définir une fonction à l'intérieur d'une autre fonction. Cette fonction sera locale à la fonction dans laquelle elle est définie.

Le lecteur intéressé à en savoir plus pourra consulter les sections de la documentation de R portant sur la portée lexicale (lexical scoping). C'est un sujet important et intéressant, mais malheureusement trop avancé pour ce document d'introduction à la programmation en R.

Le code développé pour l'exemple de point fixe de la section 4.4Algorithme du point fixe peut être intégré dans une fonction ; voir la figure 5.1.

• Le nom de la fonction est fp.
• La fonction compte quatre arguments : k, n, start et TOL.
• Les deux derniers arguments ont respectivement des valeurs par défaut de 0.05 et 10⁻¹⁰.
• La fonction retourne la valeur de la variable i puisque l'on évalue celle-ci à la dernière ligne (ou expression) de la fonction.

fp <- function(k, n, start = 0.05, TOL = 1E-10)
{
    ## Fonction pour trouver par la méthode du point
    ## fixe le taux d'intérêt pour lequel une série de
    ## 'n' paiements vaut 'k'.
    ##
    ## ARGUMENTS
    ##
    ##     k: la valeur présente des paiements
    ##     n: le nombre de paiements
    ## start: point de départ des itérations
    ##   TOL: niveau de précision souhaité
    ##
    ## RETOURNE
    ##
    ## Le taux d'intérêt

    i <- start
    repeat
    {
        it <- i
        i <- (1 - (1 + it)^(-n))/k
        if (abs(i - it)/it < TOL)
        break
    }
    i
}

Il est parfois utile de définir une fonction sans lui attribuer un nom — d'où la notion de fonction anonyme. Il s'agira en général de fonctions courtes utilisées dans une autre fonction. Par exemple, pour calculer la valeur de xy² pour toutes les combinaisons de x et y stockées dans des vecteurs du même nom, on pourrait utiliser la fonction outer ainsi :

> x <- 1:3; y <- 4:6
> f <- function(x, y) x * y^2
> outer(x, y, f)
     [,1] [,2] [,3]
[1,]   16   25   36
[2,]   32   50   72
[3,]   48   75  108

Cependant, si la fonction f ne sert à rien ultérieurement, on peut se contenter de passer l'objet fonction à outer sans jamais lui attribuer un nom :

> outer(x, y, function(x, y) x * y^2)
     [,1] [,2] [,3]
[1,]   16   25   36
[2,]   32   50   72
[3,]   48   75  108

On a alors utilisé dans outer une fonction anonyme.

Il est assez rare d'arriver à écrire un bout de code sans bogue du premier coup. Par conséquent, qui dit programmation dit séances de débogage.

Les techniques de débogage les plus simples et naïves sont parfois les plus efficaces et certainement les plus faciles à apprendre. Loin d'un traité sur le débogage de code R, nous offrons seulement ici quelques trucs que nous utilisons régulièrement.

• Les erreurs de syntaxe sont les plus fréquentes (en particulier l'oubli de virgules). Lors de la définition d'une fonction, une vérification de la syntaxe est effectuée par l'interprète R. Attention, cependant : une erreur peut prendre sa source plusieurs lignes avant celle que l'interprète pointe comme causant problème.

• Les messages d'erreur de l'interprète ne sont pas toujours d'un grand secours… tant que l'on n'a pas appris à les reconnaître. Un exemple de message d'erreur fréquemment rencontré :

  • valeur manquante là où TRUE / FALSE est requis

    Cette erreur provient généralement d'une commande if dont l'argument vaut NA plutôt que TRUE ou FALSE. La raison : des valeurs manquantes se sont faufilées dans les calculs à notre insu jusqu'à l'instruction if, faisant en sorte que l'argument de if vaut NA alors qu'il ne peut être que booléen.

• Lorsqu'une fonction ne retourne pas le résultat attendu, placer des commandes print à l'intérieur de la fonction, de façon à pouvoir suivre les valeurs prises par les différentes variables.

  Par exemple, la modification suivante à la boucle de la fonction fp permet d'afficher les valeurs successives de la variable i et de détecter, par exemple, une procédure itérative divergente :

   

  Sélectionnez

  1.
  2.
  3.
  4.
  5.
  6.
  7.
  8.
  

  repeat
  {
      it <- i
      i <- (1 - (1 + it)^(-n))/k
      print(i)
      if (abs((i - it)/it < TOL))
          break
  }
  

• Quand ce qui précède ne fonctionne pas, ne reste souvent qu'à exécuter manuellement la fonction. Pour ce faire, définir dans l'espace de travail tous les arguments de la fonction, puis exécuter le corps de la fonction ligne par ligne. La vérification du résultat de chaque ligne permet généralement de retrouver la ou les expressions qui causent problème.

Si tous conviennent que l'adoption d'un style propre et uniforme favorise le développement et la lecture de code, il existe plusieurs chapelles dans le monde des programmeurs quant à la « bonne façon » de présenter et, surtout, d'indenter le code informatique.

Par exemple, Emacs reconnaît et supporte les styles de codage suivants, entre autres :

for (i in 1:10)
{
    expression
}

for (i in 1:10){
    expression
}

for (i in 1:10)
    {
    expression
    }

for (i in 1:10)
  {
    expression
  }

• Pour des raisons générales de lisibilité et de popularité, le style C++, avec les accolades sur leurs propres lignes et une indentation de quatre (4) espaces est considéré comme standard pour la programmation en R.
• Consulter la documentation de votre éditeur de texte pour savoir s'il est possible de configurer le niveau d'indentation. La plupart des bons éditeurs pour programmeurs le permettent.
• Surtout, éviter de ne pas du tout indenter le code.

valeurs <- function(x, start = 100)
{
    ## Création d'un vecteur pour les résultats. La valeur
    ## de départ est placée au début du vecteur pour faire
    ## la boucle. Elle sera supprimée à la fin.
    res <- c(start, numeric(nrow(x)))

    ## Conversion des étiquettes ("hausse", "nul", "baisse")
    ## de la première colonne des données en
    ## valeurs numériques (1, 0, -1).
    d <- (x[, 1] == "hausse") - (x[, 1] == "baisse")

    ## Calcul des valeurs successives du titre.
    for(i in seq(length(res) - 1))
        res[i + 1] <- res[i] + d[i] * x[i, 2]

    ## Résultats sans la valeur de départ
    res[-1]
}

5.1 (solution) La fonction var calcule l'estimateur sans biais de la variance d'une population à partir de l'échantillon donné en argument. Écrire une fonction variance qui calculera l'estimateur biaisé ou sans biais selon que l'argument biased sera TRUE ou FALSE, respectivement. Le comportement par défaut de variance devrait être le même que celui de var. L'estimateur sans biais de la variance à partir d'un échantillon kitxmlcodeinlinelatexdvpX_1,\dots,X_nfinkitxmlcodeinlinelatexdvp est

alors que l'estimateur biaisé est

où kitxmlcodeinlinelatexdvp\hat{X} = n^{-1}(X_1+\cdots+X_n)finkitxmlcodeinlinelatexdvp.

5.2 (solution) Écrire une fonction matrix2 qui, contrairement à la fonction matrix, remplira par défaut la matrice par ligne. La fonction ne doit pas utiliser matrix. Les arguments de la fonction matrix2 seront les mêmes que ceux de matrix, sauf que l'argument byrow sera remplacé par bycol.

5.3 (solution) Écrire une fonction phi servant à calculer la fonction de densité de probabilité d'une loi normale centrée réduite, soit

La fonction devrait prendre en argument un vecteur de valeurs de x.Comparer les résultats avec ceux de la fonction dnorm.

5.4 (solution) Écrire une fonction Phi servant à calculer la fonction de répartition d'une loi normale centrée réduite, soit

Supposer, pour le moment, que kitxmlcodeinlinelatexdvpx\ge0finkitxmlcodeinlinelatexdvp. L'évaluation numérique de l'intégrale ci-dessus peut se faire avec l'identité

Utiliser la fonction phi de l'exercice 5.3 et tronquer la somme infinie à une grande valeur, 50 par exemple. La fonction ne doit pas utiliser de boucles, mais peut ne prendre qu'une seule valeur de x à la fois. Comparer les résultats avec ceux de la fonction pnorm.

5.5 (solution) Modifier la fonction Phi de l'exercice 5.4 afin qu'elle admette des valeurs négatives. Lorsque kitxmlcodeinlinelatexdvpx<0,\ \Phi(x) = 1 - \Phi(-x)finkitxmlcodeinlinelatexdvp. La solution simple consiste à utiliser une structure de contrôle if ... else, mais les curieux chercheront à s'en passer.

5.6 (solution) Généraliser maintenant la fonction de l'exercice 5.5 pour qu'elle prenne en argument un vecteur de valeurs de kitxmlcodeinlinelatexdvpxfinkitxmlcodeinlinelatexdvp. Ne pas utiliser de boucle. Comparer les résultats avec ceux de la fonction pnorm.

5.7 (solution) Sans utiliser l'opérateur %*%, écrire une fonctionprod.mat qui effectuera le produit matriciel de deux matrices seulement si les dimensions de celles-ci le permettent. Cette fonction aura deux arguments (mat1 et mat2) et devra tout d'abord vérifier si le produit matriciel est possible. Si celui-ci est impossible, la fonction retourne un message d'erreur.

1. Utiliser une structure de contrôle if ... else et deux boucles.
2. Utiliser une structure de contrôle if ... else et une seule boucle.

Dans chaque cas, comparer le résultat avec l'opérateur %*%.

5.8 (solution) Vous devez calculer la note finale d'un groupe d'étudiants à partir de deux informations : 1) une matrice contenant la note sur 100 des étudiants à chacune des évaluations, et 2) un vecteur contenant la pondération des évaluations. Un de vos collègues a composé la fonction notes.finales ci-dessous afin de faire le calcul de la note finale pour chacun de ses étudiants. Votre collègue vous mentionne toutefois que sa fonction est plutôt lente et inefficace pour de grands groupes d'étudiants. Modifiez la fonction afin d'en réduire le nombre d'opérations et faire en sorte qu'elle n'utilise aucune boucle.

notes.finales <- function(notes, p)
{
    netud <- nrow(notes)
    neval <- ncol(notes)
    final <- (1:netud) * 0
    for(i in 1:netud)
    {
        for(j in 1:neval)
        {
            final[i] <- final[i] + notes[i, j] * p[j]
        }
    }
    final
}

5.9 (solution) Trouver les erreurs qui empêchent la définition de la fonction ci-dessous.

AnnuiteFinPeriode <- function(n, i)
{{
    v <- 1/1 + i)
    ValPresChaquePmt <- v^(1:n)
    sum(ValPresChaquepmt)
}

5.10 (solution) La fonction ci-dessous calcule la valeur des paramètres d'une loi normale, gamma ou Pareto à partir de la moyenne et de la variance, qui sont connues par l'utilisateur.

param <- function(moyenne, variance, loi)
{
    loi <- tolower(loi) {
    if (loi == "normale")
        param1 <- moyenne
        param2 <- sqrt(variance)
        return(list(mean = param1, sd = param2))
    }
    if (loi == "gamma") {
        param2 <- moyenne/variance
        param1 <- moyenne * param2
        return(list(shape = param1, scale = param2))
    }
    if (loi == "pareto") {
        cte <- variance/moyenne^2
        param1 <- 2 * cte/(cte-1)
        param2 <- moyenne * (param1 - 1)
        return(list(alpha = param1, lambda = param2))
    }
    stop("La loi doit être une de \"normale\", \"gamma\" ou \"pareto\"")
}

L'utilisation de la fonction pour diverses lois donne les résultats suivants :

> param(2, 4, "normale")
$mean
[1] 2
$sd
[1] 2
> param(50, 7500, "gamma")
Erreur dans param(50, 7500, "gamma") : Objet "param1" introuvable
> param(50, 7500, "pareto")
Erreur dans param(50, 7500, "pareto") : Objet "param1" introuvable

1. Expliquer pour quelle raison la fonction se comporte ainsi.
2. Appliquer les correctifs nécessaires à la fonction pour que celle-ci puisse calculer les bonnes valeurs. (Les erreurs ne se trouvent pas dans les mathématiques de la fonction.) Astuce : tirer profit du moteur d'indentation de votre éditeur de texte pour programmeur.