2.10 Quelques fonctions utiles
Dans ce dernier chapitre de la premiére partie de ce cours, nous n'allons pas apprendre de nouveau concept. Nous allons plutôt découvrir un certain nombre de fonctions utilitaires qui existent déjà en R. Pour l'instant, nous ne conaissons que quelques fonctions : typeof() , print() ainsi que is.na() que vous avons croisé au chapitre des manipulations de vecteurs, ainsi que les fonctions de conversion de type comme as.logical() .
Heureusement pour nous, R dispose de base d'un grand ensemble de fonctions existantes, que nous pouvons utiliser pour réaliser différents objectifs. Ce chapitre se compose plus comme une liste ordonée de diverses fonctions que comme quelque chose de réellement structuré. Le but n'est pas de de vous faire tenir toutes les fonctions, mais simplement de vous signaler leur existance. A l'usage, il vous arrivera peut être de venir réguliérement consulter ce chapitre pour y trouver une fonction appropriée.
Les fonctions builtin :
La plupart des fonctions utilitaires donc nous allons parler font directement partie du coeur du langage R. Pour les différencier des fonctions "normales" que nous pourions coder nous même, les créateurs de R ont décidés que ces fonctions auraient le type builtin au lieu du type classique closure que nous connaissons.
Si on demande le type de la fonction is.na , on voit bien que la console nous affiche builtin ou lieu du closure habituel.
typeof(is.na) #builtin
Ce type builtin est là uniquement pour indiquer que la fonction est incorpée avec R, et qu'elle vient des créateurs du langage. La seule différence avec une fonction closure est que vous ne pourrez jamais créer vous même une fonction qui aura ce type builtin . Seul les créateurs du langage peuvent le faire, et il vous faudrait alors modifier directement le code source du langage R pour y ajouter votre propre fonction de type builtin .
Un héritage poussiéreux ?
Néanmoins, cette différence de type de fonction n'est pas utile. Pire, elle est même assez incohérente et difficile à comprendre. Il est impossible de savoir à l'avance si une fonction sera considée comme de type builtin ou closure . Par exemple, la fonction typeof est ainsi considée elle même comme une closure , alors qu'il semble difficile de trouver une fonction plus au coeur du langage que celle-ci non ? De même, la fonction abs() qui donne la valeur absolue est considérée elle comme une builtin , alors que la fonction mean() qui donne la moyenne d'un vecteur est une closure ! Pourtant, les deux fonctions sont des fonctions statistiques "de base", pourquoi une telle différence de traitement ?
Ce manque de cohérence vient probablement de l'évolution du langage : personne n'a pris le temps de véritablement établir une liste cohérente des fonctions considées comme des builtins, en précisant des critéres spécifiques. Aussi, impossible de savoir si une fonction est considérée comme une closure ou une builtin autrement qu'en testant son type...
Nous avons fait ce petit point de vocabulaire uniquement pour que vous ne soyez par surpris en testant un jour le type de ces fonctions et de voir apparaitre le terme builtin au lieu de closure . En pratique, cela ne fait aucune différence, une builtin est une fonction comme une autre ! D'ailleurs non parlerons toujours de fonctions par abus de langage, et jamais de closure ou de builtin .
Les fonctions mathémétiques en R :
Comme R est un langage pour les mathématiques et les statistiques, nous allons commencer par présenter quelques fonctions mathématiques. Toutes ces fonctions marchent avec des vecteurs de nombres.
Calculer une valeur absolue :
vect = c(1,2,3,4,5)
m = abs(vect)
Calculer un arrondi à l'entier supérieur :
vect = c(1,2,3,4,5)
ar = ceiling(vect)
Calculer un arrondi à l'entier inférieur :
vect = c(1,2,3,4,5)
ar = floor(vect)
Arrondir à n chiffres aprés la virgule :
vect = c(1,2,3,4,5)
ar = round(vect, digits = n)
Fonctions trigonométriques :
vect = c(1,2,3,4,5)
cos_vect = cos(vect)
sin_vect = sin(vect)
tan_vect = tan(vect)
acos_vect = acos(vect)
asin_vect = asin(vect)
atan_vect = atan(vect)
Fonctions exp, log et log en base 10 :
vect = c(1,2,3,4,5)
ex = exp(vect)
ln = log(vect)
ln10 = log10(vect)
Sommer les éléments d'un vecteur :
vect = c(1,2,3,4,5)
s = sum(vect)
Faire le produit des éléments d'un vecteur :
vect = c(1,2,3,4,5)
p = prod(vect)
Calculer la factoriel d'un nombre :
factorial(n)
Les fonctions statistiques de base de R :
R étant un langage conçu pour le calcul statistique, il dispose également de nombreuses fonctions dédiées. Nous allons en voir quelques unes ici :
Calculer une moyenne :
vect = c(1,2,3,4,5)
m = mean(vect)
Calculer une médiane :
vect = c(1,2,3,4,5)
med = median(vect)
Calculer une variance :
vect = c(1,2,3,4,5)
var = var(vect)
Calculer un ecart-type :
vect = c(1,2,3,4,5)
ecart_type = sd(vect)
Trouver le maximum et minimum :
vect = c(1,2,3,4,5)
max = max(vect)
mon = min(vect)
Calculer un quantile :
vect = c(1,2,3,4,5)
q = quantile(x = vect, probs = 0.10) #calcule le 1 er quantil
Générer un vecteur aléatoire :
Tirer un échantillon aléatoire dans un vecteur :
#tire sans remplacement un echantillon de taille n dans le vecteur x
echantillon = sample(x, size = n, replace = FALSE)
Tirer n élément d'une distribution normale :
echantillon = rnorm(n) #tire d'une loi normale centrée réduite
echantillon = rnorm(n, mean = 1, sd = 2) #tire d'une loi normale de moyenne 1 et sd = 2
Autres lois de probabilités, densités et quantilles :
R dispose de fonctions permettant de tirer des échantillons et d'estimer des densités ainsi que des quantile pour la plupart des lois de probabilités usuelles : loi normale, de poisson, binomiale, de Cauchy etc. Vous pouvez retrouvez à cette adresse un tableau complet des fonctions associée à chaque loi ainsi que les paramétres de chaque fonction. Toutes les lister ici serait bien trop long !
Générer des séquences :
Il est courant que l'on souhaite générer des vecteurs de nombres. Il existe différentes méthodes en R pour cela, en particulier pour générer des vecteurs selon des lois de probabilités usuelles. Voyons quelques fonctions intéressantes :
Générer une séquence par pas :
x = seq(1, 100, by = 2) #géner les nombres impaires entre 1 et 100
Générer un vecteur uniforme de taille n :
n = 100
x = rep(1,n) #génére un vecteur de taille 100 contenant uniquemen le nombre 1
x = rep(1/n, n) #vecteur uniforme normalisé (somme = 1)
Tester le type d'un objet
Il existe en R toute une famille de fonctions qui nous permet de savoir si un objet est bien d'un type donné ou non. Ces fonctions renvoient un booléen (TRUE ou FALSE ) selon le type de l'objet en question.
Tester un integer :
is.integer(10L) #TRUE
is.integer("Washington") #FALSE
Tester un double :
is.double(3.14) #TRUE
is.double("Washington") #FALSE
Tester un complex :
is.complex(3 + 2i) #TRUE
is.complex("Washington") #FALSE
Tester un logical :
is.logical(TRUE) #TRUE
is.logical("Washington") #FALSE
Tester un character :
is.character("Washington") #TRUE
is.character(12) #FALSE
Tester un numeric (double ou integer) :
is.numeric(3L) #TRUE
is.numeric(3.14) #TRUE
is.numeric(3 +4i) #FALSE
Tester certaines valeurs :
En plus du type atomique d'un objet, il est possible de tester si certaines valeurs sont présentes dans un vecteur. Les fonctions en question prennent un vecteur en entrée, et renvois un vecteur de booléen indiquant pour chaque élément si oui ou non il prend bien la valeur recherchée.
Tester la présence de Inf et -Inf :
v = c(2, Inf, NA, -Inf)
is.infinite(v) # FALSE TRUE FALSE TRUE
Tester la présence de NA :
v = c(2, Inf, NA, -Inf)
is.NA(v) #FALSE FLASE TRUE FALSE
Interagir avec l'utilsateur :
A l'aide de la fonction readline on peut récupérer ce que l'utilisateur écrit dans la console et le stocker dans une variable. Cette fonction prend en paramétre une chaine qui sera affichée dans la console pour demander à l'utilisateur sa saisie. Elle renvoit toujours une chaine de carctére.
saisie = readline("Quel âge avez-vous ?")
saisie = as.numeric(saisie) #On converti la chaine récupérée en nombre
C'est une fonction trés pratique pour réaliser des programmes qui intéragissent avec l'utilisateur !
A retenir :
- Il existe de nombreuses fonctions utilitaires en R, en particulier pour la génération de vecteurs aléatoires, la génération de séquences de nombres, les opérations mathématiques, ainsi que tester le type des objets.
- Certaines de ces fonctions ont le type
builtinau lieu declosure, pour indiquer qu'elles font partie directement du coeur du langage. Nénanmoins cette disctinction est assez arbitraire, et en pratique les deux types de fonctions se comportement exactement de la même façon...