Structures de données

À savoir pour commencer

R est un logiciel statistique, ou plus exactement un langage. C'est un logiciel libre, développé et maintenu par la communauté des participants au sein du projet R et proposé pour les trois systèmes d'exploitation : Unix/Linux, Windows et MacOS. C'est enfin un logiciel modulaire : de nombreux packages complémentaires offrent une grande variété de procédures mathématiques ou statistiques, incluant des méthodes de représentations graphiques complexes, le traitement des séries chronologiques, l'analyse des données, etc. On ne présente ici que quelques éléments de base permettant de comprendre le fonctionnement du langage.

À partir du site http://www.r-project.org/, du projet R, atteindre l'un des sites d'archives (CRAN pour Comprehensive R Archive Network), puis télécharger le fichier d'installation de la dernière version de R. Le logiciel s'installe par défaut dans la même langue que Windows, ce qui détermine les intitulés des menus et sous-menus, mais pas toutes les commandes et réponses du système qui resteront en anglais. Les modules complémentaires désirés seront directement installés à partir de R via une liaison internet.

L'application R se présente par une interface utilisateur simple. Elle est structurée autour d'une barre de menu et de diverses fenêtres. Les menus sont peu développés. Leur objectif est de fournir un raccourci vers certaines commandes parmi les plus utilisées, mais leur usage n'est pas exclusif, ces mêmes commandes pouvant être exécutées depuis la console.

Le menu File contient les outils nécessaires à la gestion de son espace de travail, tels que la sélection du répertoire par défaut, le chargement de fichiers sources externes, la sauvegarde et le chargement d'historiques de commandes, etc. Il est recommandé d'utiliser un répertoire différent pour chaque projet d'analyse, ce afin d'éviter la confusion dans les données et les programmes au fur et à mesure de l'accumulation des projets successifs.

Le menu Edit contient les habituelles commandes de copier-coller, ainsi que la boîte de dialogue autorisant la personnalisation de l'apparence de l'interface, tandis que le menu Misc traite de la gestion des objets en mémoire et permet d'arrêter une procédure en cours de traitement.

Le menu Packages automatise la gestion et le suivi des librairies de fonctions, permettant leur installation et leur mise à jour de manière transparente au départ du site du CRAN ou de toute autre source locale.

Enfin, les menus Windows et Help assument des fonctions similaires à celles qu'ils occupent dans les autres applications Windows, à savoir la définition spatiale des fenêtres et l'accès à l'aide en ligne et aux manuels de références de R.

Parmi les fenêtres, on distingue la console, fenêtre principale où sont réalisées par défaut les entrées de commandes et les sorties de résultats en mode texte. À celle-ci peuvent s'ajouter un certain nombre de fenêtres facultatives, telles que les fenêtres graphiques et les fenêtres d'information (historique des commandes, aide, visualisation de fichier, etc.), toutes appelées par des commandes spécifiques via la console.

Lorsque l'on lance R, la console s'ouvre et affiche quelques informations de démarrage puis l'invite de commande indiquée par > qui attend l'entrée d'une commande. On tapera les commandes nécessaires pour une tâche particulière après cette invite. Par exemple, tapez 1+1, puis $\fbox{Entr\'ee}$ . Le résultat est calculé instantanément et affiché sous la forme : [1] 2.

Pour démarrer, et pour une utilisation «légère», vous rentrerez ainsi des commandes ligne par ligne. Un «retour-chariot» $\fbox{Entr\'ee}$ exécute la ligne. Dans une ligne de commande, tout ce qui suit # est ignoré, ce qui est utile pour les commentaires. Les commandes que nous proposons sur des lignes successives sont supposées être séparées par des retour-chariot. Ajouter un point virgule en fin d'une commande et poursuivre une autre commande sur la même ligne équivaut à exécuter les deux commandes ligne par ligne. Si votre commande est trop longue pour la taille de la fenêtre ou si elle est incomplète un signe + indique la continuité de l'invite.
Souvent des commandes doivent être répétées, ou légèrement modifiées. On peut naviguer dans les commandes précédentes avec les touches $\fbox{$\uparrow$}$ et $\fbox{$\downarrow$}$ . Une fois rappelée une commande, elle peut être modifiée en se déplaçant dans la ligne : $\fbox{$\leftarrow$}$ ou $\fbox{$\rightarrow$}$ . L'aide en ligne est appelée par la fonction help, ou un simple point d'interrogation. La commande help() avec pour argument le nom de la fonction sur laquelle on désire une aide, génère une rubrique d'aide avec l'information désirée. Quand on ignore le nom exact d'une fonction mais que l'on pense le connaître en partie, on pourra chercher son nom en utilisant la fonction help.search() ou un double point d'interrogation.

help(plot)
help.search("table")
??table
?table
?c

On ouvre l'aide en ligne de toutes les fonctions installées par help.start(), ou bien par l'item Aide de la barre des menus de R. Pour quitter, taper q() ou utiliser l'item Quitter du menu Fichier.
Toutes les variables (scalaires, vecteurs, matrices, ...) créées dans R sont appelées des objets. Dans R, on affecte des valeurs aux variables en utilisant une flèche <- : taper les signes «inférieur» et « moins». Par exemple on affectera le résultat du calcul $2\times 3$ à la variable

en utilisant la commande x <- 2*3. Pour examiner le contenu d'un objet quelconque de R il suffit de taper son nom. Ainsi par exemple pour voir le contenu de

on tapera x et on observera après avoir validé la commande avec un retour chariot : [1] 6. Vecteurs et listesIl existe différents types d'objets dans R, comprenant entre autres des scalaires, des matrices, des tableaux, des « data frame »(tableaux, similaires à des matrices, mais dans lesquels les colonnes ne sont pas nécessairement de même type), des tables et des listes. Dans R, la structure élémentaire d'objet est le vecteur. Une variable scalaire telle que x ci-dessus peut être assimilée à un vecteur qui ne possède qu'une seule composante, un vecteur plus général est décrit par plusieurs composantes. Tous les éléments d'un vecteur doivent être du même type (par exemple numérique ou alphanumérique (caractère) ou logique), alors que les listes peuvent être composées d'éléments de types différents. Les nombres décimaux doivent être encodés avec un point décimal, les chaînes de caractères entourées de guillemets doubles " ", et les valeurs logiques codées par les valeurs TRUE et FALSE ou leurs abréviations T et F respectivement. Les données manquantes sont codées par défaut par la chaîne de caractères NA. Pour créer un vecteur on peut utiliser la commande c() de concaténation. Par exemple pour créer un vecteur appelé monvecteur de composantes 8, 6, 9, 10, et 5, on tape :
monvecteur <- c(8,6,9,10,5)
Pour examiner le contenu de la variable monvecteur il suffit de taper son nom

monvecteur
[1]  8  6 9 10 5

Le [1] est l'indice du premier élément du vecteur (les coordonnées sont numérotées à partir de

dans tous les objets : vecteurs, listes, matrices...). L'extraction d'éléments d'un vecteur est rendue possible par l'utilisation d'un vecteur d'indices, placé entre crochets à la suite du nom du vecteur. R possède une grande souplesse concernant cette indexation, ce qui rend les opérations d'extraction et de modification des éléments de vecteurs très aisées. On peut accéder à n'importe quelle composante du vecteur et tapant le nom du vecteur avec l'indice de la composante entre crochets. Par exemple pour obtenir la valeur de la troisième et quatrième composante du vecteur monvecteur, on tapera :

> monvecteur[c(3,4)]
[1]  9 10

Il existe plusieurs autres manières de définir un vecteur dans R. Une façon fréquente est d'utiliser des commandes d'itération : elle permettent de construire des vecteurs de nombres séparés par des pas positifs ou négatifs.

La syntaxe de base, seq(deb,fin, by=pas), retourne un vecteur de valeurs allant de deb à fin par valeurs séparées par des multiples de pas. Les crochets sont facultatifs. Par défaut, pas vaut . Selon que fin-deb est ou non un multiple entier de pas, le vecteur se terminera ou non par fin.

Si l'on souhaite un vecteur commençant par deb et se terminant par fin avec n coordonnées régulièrement espacées, il est préférable d'utiliser seq(deb,fin,length=n). La commande rep permet de dupliquer les éléments d'un vecteur. Par exemple, rep(5,6) duplique le nombre 5 six fois.

v <- 0:10
v <- seq(0:10)
v <- seq(0,1,by=0.1)
v <- seq(0,.99,by=0.1)
v <- seq(0,1,by=0.15)
v <- seq(1,0,by=-0.15)
v <- rep(5,6)

Vecteurs
`x:y`	nombres de `x` à `y` par pas de 1
`seq(x,y,by=p)`	nombres de `x` à `y` par pas de `p`
`seq(x,y,length=n)`	`n` nombres entre `x` et `y`
`v[i]`	`i`-ième coordonnée de `v`
`v[i1:i2]`	coordonnées `i1` à `i2` de `v`
`v[-(i1:i2)]`	supprimer les coordonnées `i1` à `i2` de `v`

À côté des vecteurs coexiste un second type d'objets très utilisé dans le langage R, la liste. À l'opposé d'un vecteur, une liste peut contenir des composantes de types différents, par exemple, aussi bien numériques qu'alphanumériques. Une liste peut également avoir pour composante un vecteur. On utilisera la fonction list() pour créer une liste dans R. On pourrait par exemple créer la liste maliste en tapant :

 maliste <- list(nom="Fred", epouse="Marie", monvecteur)

On peut alors afficher le contenu de la liste maliste en tapant son nom :

 maliste 
 $nom
 [1] "Fred"
 $epouse
 [1]  "Marie"
 [[3]]
 [1] 8 6 9 10 5

Les composantes d'une liste sont numérotées et on peut y accéder en utilisant des indices. On peut donc extraire le contenu d'une composante d'un élément d'une liste en tapant le nom de la liste avec l'indice de la composante à extraire entre double crochets :

 maliste[[2]]
 [1] "Marie" 
 maliste [[3]]
 [1] 8 6 9 10 5

Les composantes d'une liste peuvent être également nommées, et dans ce cas on peut accéder à leur contenu en tapant le nom de la liste suivi d'un $, suivi du nom de la composante. Par exemple maliste$nom est identique à maliste[[1]]. On peut retrouver les noms attribués aux champs d'une liste avec la fonction attributes(). Ainsi par exemple :

attributes(maliste)
$names
[1] "nom"  "epouse" ""

Il est possible de concaténer plusieurs listes en une seule au moyen de la fonction c(liste1, liste2, ...), comme pour les vecteurs.

Les tableaux de données (data.frame) constituent une classe particulière de listes, consacrée spécifiquement au stockage des données destinées à l'analyse. Chaque composant (le plus souvent un vecteur) de la liste forme alors l'équivalent d'une colonne ou variable, tandis que les différents éléments de ces composants correspondent aux lignes ou individus. À cette classe d'objets sont associées une série de méthodes spécifiques dérivées des fonctions de base et destinées à faciliter la visualisation et l'analyse de leur contenu (plot(), summary(), ...). Nous verrons plus tard comment réaliser un tableau de données dans R.

Un autre type d'objet que vous rencontrerez avec R est une variable de type table. Ainsi par exemple, si l'on crée un vecteur mesnoms contenant les prénoms des élèves d'une classe, on pourra utiliser la fonction table() pour construire une table contenant le nombre d'élèves par prénom possible :

mesnoms<- c("Marie", "Jean", "Anne", "Jean", "Simon", "Jean", "Simon")
table(mesnoms)
mesnoms
  Marie Jean Anne  Simon  
   1     3     1      2

Dans les noms de variables, les majuscules sont distinctes des minuscules. Toutes les variables d'une session sont globales et conservées en mémoire. Des erreurs proviennent souvent de confusions avec des noms de variables déjà affectés. Il faut penser à ne pas toujours utiliser les mêmes noms ou à libérer les variables par rm(). Vos variables sont listées par ls().

 
a<-c(1,2); A<-c("b","c")  # affecte a et A
ls()                      # vos variables
rm(a)
ls()                      # a disparaît

Faites attention à ne pas utiliser des noms de fonctions prédéfinies. Les fonctions de R utilisent généralement des arguments, qui sont des variables d'entrée (des objets) sur lesquelles les calculs programmés dans la fonction sont effectués. Par exemple en utilisant log10() sur une entrée numérique x, le logarithme de base 10 de est calculé :

 
x<-100     # affecte 100 à x
log10(x)   # appelle le log10 avec pour entrée le contenu de x
2          # le réesultat

Construire des matricesEn R, la structure de base est le vecteur. À partir de cette classe élémentaire sont définies un grand nombre d'autres classes plus spécifiques, chacune caractérisée par des attributs et des méthodes propres. Ainsi les matrices (arrays) sont constituées par un vecteur auquel on adjoint un attribut de dimension.

Il y a plusieurs solutions pour frabriquer des matrices à partir de vecteurs. L'une consiste à écrire ses vecteurs ligne ou colonne, puis à les relier horizontalement ou verticalement par rbind ou cbind. L'autre consiste à écrire tous les coefficients en un seul vecteur, redimensionné ensuite par la fonction matrix. Par défaut matrix structure le vecteur des coefficients verticalement colonne par colonne. Si on désire un arrangement ligne par ligne il faut appeler la fonction matrix() avec l'argument byrow=TRUE.

a <- c(1,2,3); b <- c(4,5,6)
rbind(a,b)
cbind(a,b)
c(a,b)
matrix(c(a,b),2,3)
matrix(c(a,b),2,3,byrow=T)
matrix(c(a,b),3,2)
matrix(c(a,b),3,2,byrow=T)

La transposée est réalisée par la commande t. Elle permet en particulier de changer un vecteur colonne de dimension

en un vecteur ligne (matrice $1 \times n$ ) et réciproquement.

x <- c(1,2,3)
x
t(x)
A <- matrix(c(1,2,3,4,5,6,7,8,9), nrow=3); A
t(A)

On a souvent besoin de connaître les dimensions d'une matrice (par exemple pour vérifier si un objet est un vecteur ligne). On utilise pour cela la fonction dim. Lorsque la fonction dim est appliquée sur un vecteur le résultat est NULL : un vecteur n'est pas une matrice, sa longueur est donnée par length. Par contre dim appliquée à toute matrice de taille $n \times p$ retourne un vecteur dont la première composante est et la seconde est . Les fonction nrow ou ncol désignent le nombre de lignes (rows) ou de colonnes (columns).

La fonction dim
`dim(A)`	nombre de lignes et de colonnes
`nrow(A)` ou `dim(A)[1]`	nombre de lignes
`ncol(A)` ou `dim(A)[2]`	nombre de colonnes
`length(A)`	nombre total d'éléments

help(dim)
A <- matrix(c(1,2,3,4,5,6), nrow=2, byrow=T)
dim(A)
dim(t(A))
dim(A)[1]
dim(A)[2]
length(A)

L'élément de la i-ième ligne, j-ième colonne de la matrice A est A[i,j]. Si v et w sont deux vecteurs d'entiers, A[v,w] désigne la sous-matrice extraite de A en conservant les éléments dont l'indice de ligne est dans v et l'indice de colonne dans w. A[v,] (respectivement : A[,w]) désigne la sous-matrice formée des lignes (resp. : des colonnes) indicées par les coordonnées de v (resp. : w).

A <- matrix(c(1,2,3,4,5,6), nrow=2, byrow=T)
A[2,2]
A[,2]
A[,c(1,3)]
A[1,]
A[,2]

On peut modifier un élément, une ligne, une colonne, pourvu que le résultat reste une matrice. Pour supprimer des éléments, on donne un signe négatif à leurs indices.

A <- matrix(c(1,2,3,4,5,6), nrow=2, byrow=T); A
A[1,3] <- 30; A
A[,c(1,3)] <- c(10,20,30)    # erreur
A[,c(1,3)] <- rbind(c(10,30),c(40,60)); A
A[,-c(1,3)]; A               # supprime les colonnes 1 et 3

Faire appel à un élément dont un des indices dépasse le nombre de lignes ou de colonnes de la matrice provoque un message d'erreur (subscript out of bounds).

Matrices
`A[i,j]`	coefficient d'ordre `i,j` de `A`
`A[i1:i2,]`	lignes `i1` à `i2` de `A`
`A[dim(A)[1],]`	dernière ligne de `A`
`A[-(i1:i2),]=`	supprimer les lignes `i1` à `i2` de `A`
`A[,j1:j2]`	colonnes `j1` à `j2` de `A`
`A[,dim(A)[2]]`	dernière colonne de `A`
`A[,-(j1:j2)]]`	supprimer les colonnes `j1` à `j2` de `A`
`diag(A)`	coefficients diagonaux de `A`

Si A, B, C, D sont 4 matrices, les commandes cbind(A,B), rbind(A,B),
rbind(cbind(A,B), cbind(C,D)) retourneront des matrices construites par blocs, pourvu que les dimensions coïncident. Si v et w sont deux vecteurs , c(v,w) les concaténera, cbind(v,w) les juxtaposera (en colonnes), rbind(v,w) les empilera (en lignes).

A <- matrix(c(1,2,3,4,5,6), nrow=2, byrow=T)
cbind(A,A)
rbind(A,A)
cbind(A,t(A))               # erreur
rbind(A,c(0,20,30))

Des fonctions prédéfinies permettent de construire certaines matrices particulières.

Matrices particulières
`matrix(x,m,n)`	matrice constante de taille `m,n`
`diag(rep(1,n))`	matrice identité de taille `n`)
`diag(v)`	matrice diagonale dont la diagonale est le vecteur `v`
`diag(A)`	extrait la diagonale de la matrice `A`
`toeplitz`	matrices à diagonales constantes

matrix(3,2,3)
d <- 1:6
D <- diag(d)
A <- matrix(c(1,2,3,4,5,6), nrow=2, byrow=T)
d <- diag(A)
help(toeplitz)
M <- toeplitz(1:5)

v <- 1:6
help(matrix)
A <- matrix(v,2,2)    
A <- matrix(v,3,3)    
A <- t(matrix(v,2,3))
w <- as.vector(A)
A <- t(A); w <- t(as.vector(A))

Un peu d'algèbre permet souvent de construire des matrices particulières à peu de frais, en utilisant le produit matriciel, noté %*%, et la transposée t().

A <- matrix(rep(1,4),4,1)%*%c(1,5)
A <- (1:4) %*% matrix(rep(1,5),1,5)
B <- matrix(c(1,2,3,4), byrow=T, nrow=2)
B*B
B*diag(rep(1,dim(B)[1]))
diag(rep(1,dim(B)[1]))*B

Opérations sur vecteurs et matrices Les opérations numériques s'effectuent en suivant les ordres de priorité classiques (puissance avant multiplication, et multiplication avant addition). Pour éviter les doutes il est toujours prudent de mettre des parenthèses.

2+3*4
(2+3)*4
2^3*4
2^(3*4) 
2^3^4
(2^3)^4
7%/%2     # division entière
7%%2      # modulo

Les vecteurs peuvent être utilisés tels quels dans des expressions arithmétiques classiques. Les opérations sont alors effectuées élément par élément. Les différents vecteurs intervenant dans l'expression ne doivent pas nécessairement présenter la même longueur. Si ce n'est pas le cas, le résultat est un vecteur possédant une longueur identique à celle du plus long vecteur de l'expression. Les valeurs des vecteurs plus courts sont alors recyclées, éventuellement partiellement, de manière à atteindre cette longueur.

x <- c(3,4,5); x
y <- matrix(c(1,2,3,4,5,6), ncol=2); y
z <- c(2,2); z
x*y
y*x
y*z
y^x
y/x
y-x
x*z # erreur

De la même manière, les vecteurs peuvent être utilisés dans des expressions logiques, renvoyant alors un vecteur logique correspondant au résultat de l'expression appliquée sur chaque élément du vecteur de départ.

x <- c(1, 2, 3, 4, 5)
x>3

Les opérations +, -,%*% sont matricielles. Tenter une opération entre matrices de tailles non compatibles retournera en général un message d'erreur.

Quelques fonctions simples s'appliquant sur des objets de type matrices sont résumées dans le tableau suivant :

Fonctions matricielles
`dim`	dimension d'une matrice
`as.matrix`	transforme son argument en matrice
`%*%`	produit matriciel
`t`	transposition
`det`	déterminant d'une matrice carrée
`solve`	inverse d'une matrice carrée
`eigen`	valeurs propres et vecteurs propres

En voici quelques exemples :

a <- c(1,2,3,4,5,6,7,8,9,10)
A <- matrix(a,nrow=5,ncol=2)  
B <- matrix(a, nrow = 5, ncol = 2, byrow = TRUE)  
C <- matrix(a, nrow = 2, ncol = 5, byrow = TRUE)
t(C)
B%*%C
D <- C%*%B
det(D)
solve(D)

Fonctions Les fonctions forment l'unité de base de la programmation sous R. Elles sont stockées en mémoire sous forme d'objets élémentaires de mode function et peuvent contenir une suite d'instructions R, y compris des appels à d'autres fonctions. C'est sur ce principe pyramidal de fonctions construites sur la base d'autres fonctions que repose une grande part de la puissance et de la concision du langage. La grande majorité des fonctions internes sont construites sur ce mode directement en langage R, la base de cette pyramide étant formée d'un petit nombre de fonctions basiques externes. La syntaxe d'appel d'une fonction est simple et intuitive :
nom_fonction(argument1 = valeur1, argument2 = valeur2, ...).
Les arguments peuvent être spécifiés sous forme d'une liste nommée, la reconnaissance s'effectuant sur base du nom de l'argument, d'une liste ordonnée, basée alors sur la position de l'argument dans la liste (l'emplacement des arguments manquants étant malgré tout réservé au moyen des virgules de séparation), ou d'un mélange des deux.

Exemple :

 
plot(x=hauteur, y=poids, type="p")

Cet appel de plot(), fonction graphique présentant ici trois arguments

et type, est équivalent à

 
plot(hauteur, poids, , ,"p")

les arguments x, y et type intervenant respectivement en première, deuxième et cinquième position dans la définition de la fonction, ou encore à :

 
plot(hauteur, poids, type="p")

les deux premiers arguments étant à leur position nominale et l'argument type nommé. En outre la plupart des fonctions sont définies avec une liste d'arguments par défaut, consultable via l'aide associée. Les arguments possédant une valeur par défaut peuvent être omis lors de l'appel de la fonction et sont alors remplacés par cette valeur lors de l'interprétation du code. Cette propriété permet la définition de fonctions présentant un nombre important d'arguments et donc une grande souplesse d'exécution, tout en conservant la facilité d'emploi et la concision du code.
Étant donné le nombre important de fonctions disponibles sous l'environnement R et dans les librairies associées, un effort particulier a été consenti pour leur documentation. Outre une aide concise concernant la syntaxe, les arguments et les principes sous-jacents à l'utilisation de chaque fonction, accessible par la commande help(nom_fonction), l'utilisateur peut bénéficier d'une démonstration par l'exemple de l'emploi des différentes fonctions, grâce à example(nom_fonction).

x<-1:10
y<-sin(x)
y<-x*sin(x)      
y<-sin(x)/x
A<-matrix(c(4,4,4,4),ncol=2)
sqrt(A)
A^(1/2)

Les fonctions vectorielles s'appliquent à l'ensemble d'un vecteur, d'une matrice ou d'un dataframe, et retournent un scalaire. Pour appliquer une telle fonction sur une matrice, colonne par colonne ou ligne par ligne, il faut utiliser la fonction apply avec l'argument MARGIN=1 ou MARGIN=2. Il faut se souvenir qu'avec l'option MARGIN=1 , la fonction retournera un vecteur avec autant de composantes que de lignes, et donc s'appliquera aux lignes. Par exemple, apply(A,MARGIN=1,sum) retourne un vecteur qui est formé des sommes des coefficients dans chaque ligne.

Fonctions vectorielles
`max`	maximum
`min`	minimum
`sort`	tri par ordre croissant
`sum`	somme
`prod`	produit
`cumsum`	sommes cumulées
`cumprod`	produits cumulés
`mean`	moyenne
`median`	médiane
`sd`	écart-type

A <- matrix(c(1,2,3,4,5,6), ncol=3, byrow=T)
sum(A)
apply(A,MARGIN=1,sum)
apply(A,MARGIN=2,sum)
apply(A,MARGIN=1,cumsum)
cumsum(A)
mean(A[1,])
apply(A,MARGIN=1,mean)

Librairies externes Le langage R est structuré en librairies de fonctions (packages ou libraries). Les fonctions élémentaires sont regroupées dans la librairie base, chargée en mémoire au démarrage. Une sélection d'autres librairies, recommandées par le groupe de coordination du projet R, est également installée par défaut en même temps que le programme principal. Afin de pouvoir utiliser une fonction externe appartenant à une librairie, il est nécessaire de charger cette librairie au préalable dans l'espace de travail courant. Cette opération peut être réalisée via la menu Packages ou par la commande library(nom_librairie). Une communauté importante d'utilisateurs a pu contribuer à l'extension des fonctionnalités de R. Un large choix de librairies additionnelles est ainsi disponible sur le site du CRAN, couvrant des domaines très variés de l'analyse statistique au sens large (analyse multivariée, géostatistique, séries chronologiques, modèles non linéaires, ...). Leur installation est facilitée par les commandes du menu Packages, de même que leur mise à jour automatique.

Enfin, signalons que des interfaces vers des procédures externes d'autres langages courants, notamment vers le C et le Fortran sont également disponibles. Types de données

R est un langage faiblement typé. Les variables ne sont pas déclarées, et la même lettre peut désigner un réel, un entier, un polynôme, ou une fonction. Les types existent cependant et l'attribut d'un objet devient important quand on manipule des objets. Tous les objets ont deux attributs: leur type et leur longueur. La fonction mode() peut être utilisée pour obtenir le type d'un objet alors que length retourne sa longueur. Il y a quatre types principaux de données dans R: numérique, caractère, logique et complexe. Par défaut, les nombres sont traités comme des réels en double précision. Les calculs ne sont donc pas «exacts». La précision machine est de l'ordre de $10^{-16}$ . Cela ne signifie pas que les nombres inférieurs à $10^{-16}$ ou supérieurs à $10^{16}$ sont inaccessibles, mais R ne peut distinguer deux réels que à $10^{-16}$ près. Les objets NULL sont des objets vides sans type particulier et de longueur 0.

val <- 605           # numérique
mode(val)
length(val)
cha <- "Hello World" # caractère
mode(cha)
length(cha)
2<4 #logique
mode(2<4)
lcn<-2+3i            # complexe
mode(cn)
length(cn)
mode(sin)            # fonction
names(val)           # NULL

Souvent certains éléments dans un ensemble de données sont inconnus ou manquants et on leur attribue une valeur manquante. Le code pour une valeur manquante dans R est NA. Ce code indique que la valeur ou la composante de l'objet est inconnue. Toute opération avec un NA rend un NA. La fonction is.na() peut être utilisée pour contrôler l'existence de valeurs manquantes.

val <- c(3,6,23,NA)
is.na(val)           # indique les valeurs manquantes
any(is.na(val))      # y a-t-il une valeur manquante ?
na.omit(val)         # supprime les valeurs manquantes

Les valeurs non définies et infinies (NaN, Inf, -Inf) peuvent être testées à l'aide des fonctions is.finite, is.infinite, is.nan et is.number de façon similaire à is.na(). ces valeurs résultent souvent d'une division par zéro ou de l'application d'un logarithme sur une entrée négative ou nulle.

À part les réels, les entrées d'une matrice peuvent être des booléens, des complexes, ou des chaînes de caractères. Les booléens sont TRUE (true) et FALSE (false) pour les saisies ou encore T et F. L'égalité logique est notée == pour la distinguer de l'affectation de paramètres.

a <- 2==3 
b <- 2<3
c <- T
a|(b&c)

Opérateurs logiques
`==`	égalité	`!`	non
`<`		`>`
`<=`	$\leqslant$	`>=`	$\geqslant$
`&`	et	`\|`	ou

Les matrices booléennes sont le résultat d'opérations logiques matricielles (toujours terme à terme). Par exemple, si A et B sont deux matrices (réelles) de même taille, A<B est la matrice des booléens A[i,j]<B[i,j]. Les opérateurs and et or peuvent s'appliquer à l'ensemble des éléments d'une matrice booléenne, à ses lignes ou à ses colonnes selon l'option choisie. Si A est une matrice et B est une matrice de booléens, la commande A[B] extrait de A les coordonnées correspondant aux indices pour lesquels B est à vrai.

Les complexes sont définis à l'aide de la constante 1i ( $\sqrt{-1}$ ).Les fonctions classiques appliquées à un complexe donnent toujours un résultat unique, même si mathématiquement elles ne sont pas définies de façon unique (racine carrée, logarithme, puissances).

help(complex)
A<-matrix(c(1,2,3,4),2,2)+1i*matrix(c(0,1,2,3),2,2)
Re(A)
Im(A)
Conj(A)
t(A)
Mod(A)
Arg(A)
A^3

Complexes
`Re`	partie réelle
`Im`	partie imaginaire
`Conj`	conjugué
`Mod`	module
`Arg`	argument (en radians)

Les chaînes de caractères, encadrées par des cotes ou double cotes, ("..." ou '...') servent d'intermédiaire pour des échanges de données avec des fichiers.