LANGUAGE R

GUID

Réalisé par :
• Jawaher CHENNAK
• Tasnim MOUNIR
• Karima KACI
• Torayya ENNAJAR
• Youssra ROCHDI
Encadré par :
• Soukaina FALOUHI
• M.MORCHADI Radouan
Introduction :
R est un langage de programmation et un logiciel libre dédié aux
statistiques et à la science des données soutenu par la R
Foundation for Statistical Computing. R fait partie de la liste des
paquets GNU et est écrit en C (langage), Fortran et R. Le système R
connaît depuis plus d’une décennie une progression remarquable
dans ses fonctionnalités, dans la variété de ses domaines
d’application ou, plus simplement, dans le nombre de ses
utilisateurs. La documentation disponible suit la même tangente :
plusieurs maisons d’édition proposent dans leur catalogue des
ouvrages dédiés spécifiquement aux utilisations que l’on fait de R
en sciences naturelles, en sciences sociales, en finance, etc.
Néanmoins, peu d’ouvrages se concentrent sur l’apprentissage de
R en tant que langage de programmation sous-jacent aux
fonctionnalités statistiques. C’est la niche que nous tâ chons
d’occuper.
Plan :
I. Les données avec R
II. Les graphiques avec R
III. Les analyses statistiques avec R
IV. Programmer avec R en pratique

I-Les données avec R :

I-1- Créer, lister et effacer les objets en mémoire :
De nombreuses fonctions sont déjà stockées dans une bibliothèque localisée
sur le disque dans le répertoire R_HOME/library .
Le package base constitue le cœur du logiciel et contient les fonctions de
base, et si l’on souhaite trouver les fonctions qui composent un package
défini, il suffit de se rendre dans le répertoire afférent. Par exemple, pour le

package R, il suffit de visiter le fichier R_HOME/library/base/R/base.

Le symbole “>” qui apparaît en début de ligne montre que R est prêt à être
utilisé.
Une des commandes les plus simples consiste à afficher le contenu d’un
objet en tapant tout simplement son nom. Par exemple
 n <- 15
>n
[1] 15
 > 5 -> n
>n
[1] 5
 > n <- 3 + rnorm(1)
>n
[1] 2.208807
La fonction rnorm(1) génère une variable aléatoire. On peut
simplement taper une expression sans assigner sa valeur a un
objet, le résultat est alors afficher a l’écran mais n’est pas stocké
en mémoire.
 (10 + 2) * 5
[1] 60
 Créer une liste :
> name <- "Carmen"; n1 <- 10; n2 <- 100; m <- 0.5
 La fonction ls permet d’afficher une liste simple des objets en
mémoire,
c’est-`a-dire que seuls les noms des objets sont affichés:
> ls()
[1] "m" "n1" "n2" "name“
 Si l’on veut lister uniquement les objets qui contiennent un
caractère donné dans leur nom, on utilisera alors l’option pattern
 (qui peut s’abréger avec pat) :
> ls(pat = "m")
[1] "m" "name" 
 Pour restreindre la liste aux objets dont le nom commence par le
caractère en question :
> ls(pat = "^m")
[1] "m"
 La fonction ls.str affiche des détails sur les objets en mémoire :
> ls.str()
m : num 0.5
n1 : num 10
n2 : num 100
name : chr "Carmen" 
 Une autre option utile de ls.str est max.level qui spécifie le
niveau de détails de l’affichage des objets composites. Par défaut,
ls.str affiche les détails de tous
les objets contenus en mémoire, ce qui peut faire un affichage très
long. On évite d’afficher tous les détails avec l’option max.level =
-1 :
 > M <- data frame(n1, n2, m)
> ls.str(pat = "M")
M : ‘data frame’: 1 obs. of 3 variables:
$ n1: num 10
$ n2: num 10
$ m : num 0.5
> ls.str(pat="M", max.level=-1)
M : ‘data frame’ : 1 obs. of 3 variables:
 Pour effacer des objets de la mémoire, on utilise la fonction rm :
rm(x) pour effacer l’objet x,
rm(x, y) pour effacer les objets x et y,
rm(list=ls()) pour effacer tous les objets en mémoire;
on pourra ensuite utiliser les mêmes options citées pour ls() pour
effacer sélectivement certains objets: rm(list=ls(pat = "^m")).

I-2- Des instructions sur les objets :

 > x <- 1
>mode(x)
 [1] ‘‘numeric’’
> length(x)
[1] 1
 Les valeurs manquantes sont toujours représentées par la chaîne
de caractères NA.
D’autre part, R représente correctement les valeurs infinies (Inf et
-Inf) et celles qui ne sont pas des nombres (NaN), par exemple:
> x <- 5/0
>x
[1] Inf
> exp(x)
[1] Inf
> exp(-x)
[1] 0

I-3- Lecture et enregistrement de données :

Il est possible de créer des données directement dans R, mais il est aussi
possible d’en importer comme d’en exporter.
La commande getwd() permet de savoir le répertoire où l’on se trouve. S’il
s’avère nécessaire d’en changer, setwd peut nous y aider par exemple :
setwd(home/christinet/R) : permet d’accéder au répertoire R du dossier
« christinet ».

a) Lecture de données :

Les fonctions read.table, scan et read.fwf permettent d’accéder à des

données stockées dans des fichiers de type ASCII.
La fonction read.table permet de lire très facilement un fichier de donner.
Par exemple :
> messonnees<- read.table(‘‘mesdonnees.txt’’)
crée un tableau de données nommé “mesdonnees” et les variables sont, par
défaut, nommées V1, V2, . . .. Pour accéder à ces dernières, il suffit de taper
mesdonnees$V1 ou mesdonnees[“V1”] ou encore mesdonnees[,1].
En ce qui concerne la fonction scan, elle offre un peu plus de flexibilité
puisqu’elle permet, entre autre, de spécifier le mode des variables.
Elle permet également de créer différents objets grâ ce à l’option what.
Par exemple :
> mesdonnees2 <-scan(‘‘mesdonnees.txt’’,what=list(‘‘ ’’,0,0))
b) Enregistrement de données :

La façon la plus simple d’écrire des données créées dans R dans un fichier
consiste à utiliser la fonction write. La syntaxe par défaut :
write(x,file=“donnees.txt”) permet de stocker l’objet x (un vecteur, une
matrice ou un tableau) dans le fichier donnees.txt.

 Pour enregistrer les données correctement, utiliser l’option ncol.

 utiliser la commande save pour enregistrement d’objets
 Il est préférable d’utiliser le format d’enregistrement ASCII en
utilisant
option ascii=TRUE
 pour charger les données, on pourra taper ultérieurement
load(nomdufichier).

I-4- Création de données :

Pour créer une séquence de données régulières à partir de la valeur a et par
pas de 1 à b :
> a:b
Si le pas diffère de 1, la commande à utiliser est seq dont la syntaxe :
> seq(a,b,p)
où a est la valeur de départ, b la valeur maximale et p le pas. Il se peut que
la valeur b ne soit jamais atteinte. Ou on peut écrire simplement
> c(n_1,n_2,n_3)
D’autres fonctions sont également disponibles telles :
• rep qui permet de répéter un objet un certain nombre de fois ;
• sequence qui crée une suie de séquences de nombres entiers se
terminant chacune par les valeurs spécifiées en argument ;
• gl(k,n) qui génère une série régulière dans un facteur comprenant k
niveaux et n répétitions.
I-5- Les données aléatoires:
En statistique, pour pouvoir générer des données aléatoires, il suffit
d’utiliser les fonctions : rfunc(n,p1,p2, . . .) où func désigne la loi de
probabilité, n le nombre de données à générer et p1, p2, . . ., les paramètres
de la loi.
Voici un tableau qui fait apparaître la dénomination et les paramètres de

certaines lois :

Afin d’obtenir la densité de probabilité, on utilise dfunc en lieu et place de

rfunc. En ce qui concerne la densité de probabilité cumulée, ce sera pfunc et
qfunc pour la valeur du quantile.
I-6- Manipulation des objets :

Vecteur :
La commande vector, qui comprend deux arguments (mode et length), crée
un vecteur composé de 0 si le vecteur est numérique, FALSE s’il est logique
et “ ” s’il s’agit d’un caractère.
Facteur :
Le codage d’une variable catégorielle fait appel à la commande factor qui
inclue les valeurs de la variables mais aussi toutes les modalités possibles.

> factor(1:7)
[1] 1 2 3 4 5 6 7
Levels 1 2 3 4 5 6 7
> factor(1:7;levels=1:10)
[1] 1 2 3 4 5 6 7
Levels 1 2 3 4 5 6 7 8 9 10
> factor(1:4;levels=c(‘‘A’’,‘‘B’’,‘‘F’’,‘‘G’’)
[1] A B F G
Levels A B F G
La commende levels permet d’indiquer les modalités d’une variable dans le
cas présent.

Matrice :
Pour les matrices la “longueur” associée à une matrice comprend deux
informations, celle relative au nombre de lignes et la seconde au nombre de
colonnes. Cette information est alors donnée à R sous la forme :
> matrix(data=NA,nrow=l;ncol=j)

x <- 1:10
> matrix(data=x, ncol=5,nrow=2,byrow=TRUE)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 2 3 4 5
[2,] 6 7 8 9 10
> matrix(data=x, ncol=5,nrow=2,byrow=FALSE)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 3 5 7 9
[2,] 2 4 6 8 10
Data frame :
Un data.frame est un objet implicitement crée lors du recours à la
commande read.table.
On peut fabriquer un tel objet de manière explicite au moyen de read.table
comme ci-suit :
> x <- 1:

> y <- 1:3

> z <- c(1,7)
> t <- 3

> data.frame(x,t) > data.frame(x,z)

[x] [t] [x] [z]
1 1 3 1 1 1
2 2 3 2 2 7
3 3 3 3 3 1
4 4 3 4 4 7

Liste :
Une liste permet de regrouper dans un même objet des éléments différents,
sans aucune contrainte liée à la taille ou au mode de ces derniers. Par
exemple:
> L1 <- list(x,y)
> L1
[[1]]
[1] 1 2 3 4
[[2]]
[1] 1 2 3

Expression :
Ce dernier mode consiste en une suite de caractère qui peut être
interprétable par le logiciel et évaluer par la suite au moyen de la
commande eval. Par exemple :

> x <- 1; y <- 2; z <- 3

> exp1 <- expression(x/(y+z))
> exp1
expression(x/(y+z))
 > eval(exp1)
[1] 0.2

I-7- Operations élémentaires:

a) Opérateurs usuels:

Voici une liste des principaux opérateurs qui sont regroupés en trois
grandes classe :

Une autre fonction de comparaison existe, il s’agit de identical et sa sœur

all.equal.
a) Indexation:
Que l’on soit en présence d’un vecteur ou d’une matrice, on peut vouloir
extraire un élément ou une suite d’éléments. Une façon d’opérer consiste à
recourir à la syntaxe suivante :
> x<-c(1,5,7,2)
> x[3]
[1] 7
On a ainsi extrait le 3ème élément du vecteur x. Ceci peut également
permettre de modifier une des composantes du vecteur.
 > x[3]<-2
>x
[1] 1 5 2 2
Cependant, on peut également extraire un ensemble d’éléments par :
> x[c(1,4)]
[1] 1 2
Dans le cas où x est une matrice, on peut faire la même chose comme
l’illustre les séquences suivantes:
> x<-matrix(1:6,2,3)
>x
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> x[,3]
[1] 5 6
> x[,3]<-c(1,1)
[,1] [,2] [,3]
[1,] 1 3 1
[2,] 2 4 1
> x[,-2]
[,1] [,2]
[1,] 1 1
[2,] 2 1
Le logiciel offre des facilités dans la manipulation des matrices. Ainsi, les
commandes cbind et rbind permettent de juxtaposer des matrices en
conservant les lignes ou les commandes.
> x<-matrix(1,ncol=2,nrow=2)
> y<-matrix(2,ncol=2,nrow=2)
> rbind(x,y) > cbind(x,y)
[,1] [,2] [,1] [,2] [,3] [,4]
[1,] 1 1 [1,] 1 1 2 2
[2,] 1 1 [2,] 1 1 2 2
[3,] 2 2
[4,] 2 2
Un autre opérateur très utile est l’opérateur de multiplication matriciel qui
s’écrit & ∗ &.
D’autres fonctions notables existent telles diag, solve, qr, eigen ou svd..

II-Les graphiques avec R:

II-1- Fenêtre graphique:
Afin d’ouvrir une fenêtre graphique, on peut utiliser les commandes X11() ,
postscript() ou pdf() selon que l’on souhaite un simple affichage ou un
enregistrement. Mais, la fenêtre graphique active, est la dernière
appelée.
Afin de connaître les fenêtres ou device ouverts on utilise dev.list() qui
nous donne le numéro associé à chacune des fenêtres. Ce numéro sera très
utile pour modifier la fenêtre graphique au moyen de dev.set(numéro).
Enfin, la commande dev.off() permet de fermer la fenêtre active.
Après avoir ouvert un device, on peut vouloir le diviser en plusieurs sous
fenêtres. Plusieurs options sont possibles, mais nous n’en évoquerons
simplement deux.
Une première méthode consiste à utiliser split.screen de la façon suivante :
> split.screen(c(1,2))
qui permet de diviser la fenêtre en deux parties qui seront appelées par
screen(1) et screen(2).

Une solution équivalent consiste à recourir à la fonction par :

• par(mfrow=c(2,2) permet de scinder la fenêtre en quatre sous-fenêtres
(2 lignes et 2 colonnes). Le mode de remplissage s’effectue par ligne.
• par(mcol=c(2,2) permet de scinder la fenêtre en quatre sous-fenêtres (2
lignes et 2 colonnes). Le mode de remplissage s’effectue par colonne.

Une autre fonction utile est layout qui peut conduire à des partitions assez
complexes.
II-2- fonctions graphiques:
Certaines de ces options sont identiques pour plusieurs fonctions
graphiques, voici les principales:

add : FALSE si TRUE superpose le graphe au graphe existant

axes : TRUE si FALSE ne trace pas les axes ni le cadre
type : "p" le type de graphe qui sera dessiné:
xlim= , ylim= : fixe les limites inferieures et supérieures des axes
xlab=, ylab= : annotations des axes, doivent être des variables de mode
caractère.
Main : titre principal, doit être une variable de mode caractère
sub : sous-titre ( écrit dans une police plus petite)

II-3- fonctions graphiques secondaire:

III-Les analyses statistiques avec R:
III-1- Les formules:
• 1 y~x-1 : force la régression `a passer par l’origine (idem pour y~x+0
ou 0+y~x)
• 1 y~1 : ajuste un modèle sans effets (juste l’« intercept »)
• offset(...) : ajoute un effet au modèle sans estimer de paramètre (par
ex. offset(3*x))
On voit que les operateurs arithmétiques de R ont dans une formule un
sens diffèrent de celui qu’ils ont dans une expression classique. Par
exemple, la formule y~x1+x2 définira le modèle y = β1x1 + β2x2 + α, et
non pas (si l’operateur + avait sa fonction habituelle) y = β(x1 + x2) + α.
Pour inclure des opérations arithmétiques dans une formule, on utilisera la
fonction I : la formule y~I(x1+x2) définira alors le modèle y = β(x1 + x2)
+α. De même, pour définir le modèle y = β1x + β2x2 + α on utilisera la
formule y~poly(x,2) (et non pas y ~ x + x^2).
Pour les analyses de variance, aov() accepte une syntaxe particulière pour
spécifier les effets aléatoires. Par exemple, y ~ a + Error(b) signifie effets
additifs d’un terme fixe (a) et d’un terme aléatoire (b).

III-2- Les fonctions génériques:

On se souvient que les fonctions de R agissent en fonction des attributs des
objets éventuellement passes en arguments. La classe est un attribut qui
mérite une certaine attention ici. Il est très fréquent que les fonctions
statistiques de R retournent un objet de classe emprunt ́e au nom de la
fonction (par exemple; aov retourne un objet de classe "aov", lm retourne
un de classe "lm"). Ces fonctions sont dites génériques.
L’usage typique de ces fonctions étant :
> mod <- lm(y ~ x)
> df.residual(mod)

[1] 8
Une fonction comme aov ou lm produit donc une liste dont les différents
éléments correspondent aux résultats de l’analyse. Si l’on reprend l’exemple
de l’analyse de variance sur les données InsectSprays, on peut regarder la
structure de l’objet crée par aov :
> str(aov.spray, max.level = -1)
List of 13
- attr(*, "class")= chr [1:2] "aov" "lm" 
Une autre façon de regarder cette structure est d’afficher les noms des
éléments de l’objet :

Les éléments peuvent ensuite être extraits comme vu précédemment :

summary() crée également une liste, qui dans le cas d’aov() se limite à un
tableau de tests :

Les fonctions génériques n’agissent généralement pas sur les objets: elles
appellent la fonction appropriée en fonction de la classe de l’argument. Une
fonction appelée par une générique est une méthode (method) dans le
jargon de R. De façon schématique, une méthode est construite selon
generic.cls , où cls désigne la classe de l’objet. Dans le cas de summary, on
peut afficher les méthodes correspondantes :

On peut
visualiser les particularités de cette générique dans le cas de la
régression linéaire comparée `a l’analyse de variance avec un petit exemple
simulé :
Le tableau suivant indique certaines fonctions génériques qui font des
analyses supplémentaires á partir d’un objet qui résulte d’une analyse faite
au préalable, l’argument principale tant cet objet, mais dans certains cas un
argument supplémentaire est nécessaire comme pour predict ou update.

Il y a également diverses fonctions utilitaires qui extraient des informations

d’un objet modèle ou d’une formule, comme alias qui trouve les termes
linéairement dépendants dans un modèle linéaire spécifié par une formule.
III-3- Les packages:
Le tableau suivant liste les packages standards distribués avec une
installation de base de R.( vous pouvez consulter tous packages en utilisant
la commende help) :
MAINTENANT QUE NOUS AVONS FAIT UN TOUR D’ENSEMBLE DES
FONCTIONNALITE DE R, REVENONS AU LANGAGE ET A LA
PROGRAMMATION. NOUS ALLONS VOIR DES IDEES SIMPLES
SUSCEPTIBLES D’ETRE MISES EN PRATIQUE.
IV-Programmer avec R:
IV-1- Boucles et vectorisation:
a) Les boucles avec while() :
Répéter une instruction tant qu'une condition d'arrêt n'est pas honorée ;
nombre de répétitions inconnu a priori.
WHILE(CONDITION) INSTRUCTION
Condition doit être un logique ;
Instruction peut contenir plusieurs instructions, si entoure par des
accolades.
> x <- 100
while(x/3 > 1){
x <- x/3
}
x/3 > 1
## [1] FALSE
X
## [1] 1.234568
Remarque : Attention à bien s'assurer d'avoir une condition qui pourra être
honorée ; R éprouve des difficultés à arrêter le calcul d'une boucle infinie..

b) Les boucles avec for() :

Répéter une instruction un nombre de fois défini a priori

FOR(VARIABLE IN VECTOR) INSTRUCTION

Variable : nom de variable locale à la fonction for, qui prendra une valeur
différente à chaque itération ;
Vector : le vecteur contenant les valeurs que va prendre variable ;
instruction: l'instruction à répéter à chaque itération (si entre accolades,
permet d'évaluer plusieurs instructions).

Les boucles avec for() sont pratiques pour remplir les éléments d'une liste
ou d'un vecteur. La création a priori de l'objet à remplir, à la taille souhaitée
est recommandée ;
En effet, l'allocation en mémoire est plus efficace de la sorte, plutô t que de
laisser R créer un objet plus long à chaque itération.

# Manière peu efficace

>resultat <- NULL
for(i in seq_len(3)) {
resultat[i] <- i
}
resultat

## [1] 1 2 3

# Manière plus économique

resultat <- rep(NA, 3)
for(i in seq_len(3)) {
resultat[i] <- i
} resultat

## [1] 1 2 3

IV-2- Les conditions:

Les conditions sont primordiales en programmation ; elles permettent
d'exécuter du code, ou de retourner des objets, à condition de remplir
certains critères.

a) Instruction if... Else:

Les instructions if et else fournissent un moyen d'exécuter du code si une
condition est respectée ou non.
Deux syntaxes possibles :
# Première forme (pas de code si condition == FALSE)
if (condition) instruction
# Seconde forme
if (condition) instruction si vrai else instruction si faux
Condition : un logique ;
Instruction : du code à évaluer en fonction de la condition.
Exemple avec des instructions dans le cas contraire :
>if(x == 2) print("Hello") else print("x est différent de 2")
## [1] "x est différent de 2"
if(x == 2){
print("Hello")
} else {# x != 2
x <- x-1
print(paste0("La nouvelle valeur de x : ", x))
}
## [1] "La nouvelle valeur de x : 2"

b) La fonction switch():

La fonction switch() permet d'éxecuter du code en fonction d'une valeur

prise par une variable :

switch(valeur_test,
cas_1 = {
instruction_cas_1
},
cas_2 = {
instruction_cas_2
},
Valeur_test : nombre ou chaîne de caractère ;
Si valeur_test vaut cas_1, évaluer instruction_cas_1 ;
Si valeur_test vaut cas_2, évaluer instruction_cas_2 ;
 >centre <- function(x, type) {
switch(type,
mean = mean(x),
median = median(x))
}
>x <- rcauchy(10)
centre(x, "mean")
## [1] -1.082508
centre(x, "median")
## [1] -0.1342556

c) L'intstruction repeat... break :

repeat... break permet de répéter une expression ;

La présence d'un test d'arrêt est nécessaire, à l'aide de l'instruction break.

>i<- 1
repeat {
i <- i + 1
if(i == 3) break
}
>i
## [1] 3

IV-3- La vectorisation:
Les boucles sont lentes en R ;
De nombreux cas où elles peuvent être évitées ;
Emploi des calculs vectoriels.
Voici un exemple d'un calcul en boucle que l'on peut vectoriser :
# Somme des logarithmes des 10 premiers entiers
>somme_log <- 0
for(i in seq_len(10)){
somme_log <- somme_log + log(i)
}
>somme_log
## [1] 15.10441
À chaque itération, on modifie la valeur de somme_log pour lui ajouter la
valeur du logarithme d'un entier i. La même chose en vectorisant le calcul
# En vectorisant le calcul
>sum(log(seq_len(10)))
## [1] 15.10441
La fonction log() est appliquée à tous les éléments de seq_len(10) ;
Puis la fonction sum() se charge d'additionner tous les éléments entre eux.
Nous allons considérer des fonctions qui prennent une fonction en input, et
retournent un vecteur en output ;
Deux sources :
Les fonctions issues du package plyr,
certains équivalents présents dans le package base.

a) Les fonctions du package plyr:

Charger le package : library(plyr) ;

Des noms faciles à retenir :
Première lettre : format d'entrée des données ;
Seconde lettre : format de sortie souhaité ;
Suffixe ply.

Type Array Data.fram List

array aaply() adply() alply()
data.frame daply() ddply() alply()
list laply() ldply() llply()

Les fonctions du package plyr : data.frame en input :

Format très fréquent en entrée ;
daply(), ddply(), dlply() ;
Application d'une fonction à chaque partie d'un tableau ;
Puis rassemblement des résultats obtenus dans un array, un data.frame ou
une list ;
Les paramètres principaux sont :
.Data : les données d'input,
.Variables : la ou les variables servant à découper le tableau pour faire des
sous-tableaux,
>chomage <- data.frame(region = rep(c(rep("Bretagne", 4),
rep("Corse", 2)), 2),departement = rep(c("Cotes-d'Armor",
"Finistere", "Ille-et- Vilaine", "Morbihan","Corse-du-Sud", "Haute-
Corse"), 2),annee =rep(c(2011, 2010), each = 6),ouvriers =
c(8738, 12701,11390, 10228, 975, 1297,8113, 12258, 10897,
9617, 936, 1220), ingenieurs = c(1420, 2530, 3986, 2025, 259,
254,1334, 2401, 3776, 1979, 253, 241))
Les fonctions du package plyr : list en input :
Format très fréquent en entrée ;
laply(), ldply(), llply() ;
Application d'une fonction à chaque élément d'une liste ;
Puis rassemblement des résultats obtenus dans un array, un data.frame ou
une list ;
Les paramètres principaux sont :
Pas de paramétrage à effectuer pour le découpage !
.data : les données d'input,
.fun : la fonction à appliquer à chaque portion du tableau.
>dply(liste, length)
## .id V1
## 1 normale 10
## 2 logiques 3
## 3 x 3
>llply(liste, length)
## $normale
## [1] 10
##
## $logiques
b) Les fonctions de la famille apply dupackage base:

Il existe des fonctions du même type que celles du package plyr, dans le
package base ;
Elles sont cependant moins uniformisées dans leur syntaxe ;

FONCTION INPUT OUTPUT

apply() Matrice ou tableau Vecteur ou tableau

ou liste
Lpply() Liste ou vecteu Liste
Spply() Liste ou vecteu Vecteur ou matrice
ou list
Vpply() Liste ou vecteu Vecteur ou matrice
ou list
Tpply() Tableau et facteurs Tableau ou liste
Mpply() Listes et/ou vecteurs Vecteur ou matrice
ou liste

c) La fonction Vectorize():

Vectorize() permet de convertir une fonction scalaire en une fonction

vectorielle. N'améliore cependant pas la rapidité d'exécution du code...
mais son utilisation permet d'éviter des lignes de codes !

FUN : fonction à appliquer à chaque élément ;

vectorize.args : vecteur de paramètres (de type character) qui devaient
être vectorisés (par défaut, tous les paramètres de FUN) ;
SIMPLIFY : même usage que pour sapply() ;
USE.NAMES : même usage que pour sapply().

Vectorize(FUN, vectorize.args, SIMPLIFY, USE.NAMES)

> f <- function(x = 1:3, y) c(x, y)

>vf <- Vectorize(f, SIMPLIFY = FALSE)

 f(1:3, 1:3)
## [1] 1 2 3 1 2 3
vf(1:3, 1:3)
## [[1]]
## [1] 1 1
##
## [[2]]
## [1] 2 2
##
## [[3]]
## [1] 3 3
Conclusion:
R est un langage riche présentant de nombreux avantages. Gratuit et open
source, il permet une rapide intégration de toutes les nouvelles méthodes
statistiques modernes en permettant aux utilisateurs d'eux-mêmes enrichir
le langage. Le nombre de packages disponibles ne cesse d'augmenter.
Pratiquement toutes les méthodes statistiques de pointe sont disponibles
sous R. La communauté ne cesse de grandir.

Malheureusement, le langage R présente un certain nombre

d'inconvénients et de limites. Comme beaucoup de langages, R n'a pas été
conçu pour gérer le parallélisme ou la concurrence. De même, la taille
maximale des bases de données exploitables est de l'ordre de la dizaine de
giga alors que les spécialistes des grandes dimensions travaillent d'ores et
déjà avec des dizaines voire des centaines de terra. Enfin, R n'est pas
compilable, ce qui entraine un manque à gagner important en termes de
performance.