Cours 1

I- Généralités sur R
II- Les fonctions de R et autres objets
III-Les vecteurs
IV-Les facteurs
 I-1 Généralités sur R

R (1995, AT&T Bell Laboratories) est un logiciel d ’analyse

statistique et graphique, clone de S-PLUS, écrit essentiellement en
C.

R est un logiciel gratuit, distribué librement sous les termes de la

« GNU Public Licence » de la « Free Software Foundation » . Le
développement et la distribution sont assurés par plusieurs
statisticiens ( le « R Development Core Team ». Il est compatible
avec toutes les plate-formes.

Les fichiers et instructions d’installation de R, didacticiels et mises à

jour sont disponibles à partir du site du C R AN (The
Comprehensive R Archive Network) à http://cran.r-project.org/.
 I-1 Généralités ….

Le noyau de R est un langage

 Interprété : Les fonctions disponibles se trouvent dans une

bibliothèque ("R_HOME/library"), organisée en packages
contenant les fonctions et opérateurs et des jeux de données.

 Orienté-objet : Les variables, données, fonctions, résultats

intervenant dans une session R sont stockés sous forme
d’objets en mémoire dans le workspace (espace de travail,
attribué par défaut/désigné par l’utilisateur par la commande
setwd(" chemin") ). La commande getwd() permet de connaître
son emplacement.
 Rgui
I-2 Aides au démarrage

R pour démarrer une session sous LINUX (Rgui sous windows)

q() pour quitter

touche Esc pour interrompre

Flèche ↑ et ↓ pour rappeler les anciennes commandes, ← et → pour
se déplacer sur la ligne de commande

plusieurs commandes sur la même ligne séparées par des; si ligne de
commande trop longue, + pour continuer

mots réservés: NA, letters, LETTERS, T, F, TRUE,FALSE.

Il faut respecter la casse: n ≠N

Save workspace image? = y pour sauver les objets créés dans la
session dans le workspace.

Créer un Script: progR.txt (fichier texte); exécution :
source( "chemin/progR.txt ") ; affichage résultat : print();
commentaire #
 Rgui
I- 2 Aide….

L’essentiel des commandes consiste à créer des objets (tout est objet)

Pour créer un objet, on utilise :

 un opérateur d’assignation: <- ou =
 des opérateurs, des fonctions ou des objets précédemment créés

Exemples: n=5 ; M=matrix(1:10, 2, 5); N<-c(1,2,3); h=n+N

On peut créer plusieurs objets sur la même ligne en les séparant par ;

pour voir la valeur d ’un objet, taper son nom.

Pour voir l’ensemble des objets créés (stockés dans le workspace) ou en
éliminer:
objects(),ls() voir tous les objets
ls(pat= " n ") voir objets dont le nom commence par la lettre n
rm() remove() élimine des objets
 Rgui
II- 1 Les fonctions (et opérateurs)

Les fonctions et opérateurs sont des objets particuliers qui agissent

sur d’autres objets. Ces objets sont stockés dans des packages.
Certains sont automatiquement chargés, d’autres doivent l’être.

Parmi les packages automatiquement chargés, le package base ("R-

HOME/library /base") contient les fonctions et opérateurs de base
pour la lecture et la manipulation des données, des fonctions
graphiques et statistiques standard.

search() : liste les packages chargés

library() : liste les packages disponibles
library("nom package") : charge un package (ex: library(" survival " ))
help (package="nom package") : Liste les fonction du package
(ex: help(package=" survival " ))
 II-2 Aide sur les fonctions Rgui

La fonction help.start() permet d’accéder à l’aide de R

au format html

Les fonctions help() ou ? permettent d’obtenir de l’aide

sur n’importe quelle fonction ou opérateur d’un package
chargé (avec ou sans " " pour les fonctions, avec pour les
opérateur).

Ex: ? "* " ; help("* " ); help(log); help("log "); ?sum

 Rgui
II- 3 Les autres objets

Les principaux types d’objets sont: vector, factor, matrix, arrays,

time-series, list, data.frame.

Un objet est caractérisé par son nom, son contenu, mais aussi ses
deux attributs intrinsèques:
 mode: 4 principaux = numérique, caractère, complexe, logique
mode()
 longueur: nombre d’éléments de l’objet length()

Une valeur manquante est représentée par NA, quel que soit le mode

Une valeur de mode caractère est représentée entre guillemets
doubles

Ex: u=1:3; v=letters[1:3]; w=c("a","b",NA); x=c(T,F)

m=matrix(1:10,2,5); mode(u);mode(v); mode(x);length(w);
 Rgui
III- 1 Les vecteurs (vector)

Un vecteur est une séquence ordonnée formée

d’éléments de même mode (numérique, logiques ou
caractère).

>u=1:5 >c("a","b")
>u [1] "a" "b"
[1] 1 2 3 4 5 >mode(c("a","b"))
> mode(u) [1] "character"
[1] "numeric«
> length(u)
[1] 5
 Rgui
III-2 Génération de vecteurs

 En saisissant les valeurs séparées par des virgules avec c() :

>u=c(1,2,3)
>u
[1] 1 2 3

>v=c(T,F)
>v
[1] TRUE FALSE

> w=c("a","b","c")
>w
[1] "a" "b" "c"
 III-2 Génération de vecteurs

 En générant des suites numériques par:

 « : » > x=1:10
>x
[1] 1 2 3 4 5 6 7 8 9 10

 seq() génère des suites régulières:

> y=seq(0,10, length=11) > z=seq(0,2, by=0.5)
>y >z
[1] 0 1 2 3 4 5 6 7 8 9 10 [1] 0.0 0.5 1.0 1.5 2.0

 rep() duplique une suite:

>t=rep(1:4,2) > r=rep(1:4, each=2)
>t >r
[1] 1 2 3 4 1 2 3 4 [1] 1 1 2 2 3 3 4 4

 sample() génère des vecteurs aléatoires (cf III-3)

 III-2 Génération de vecteurs

 En générant des suites de lettres par letters[], LETTERS[]

> u=letters;u
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
[20] "t" "u" "v" "w" "x" "y" "z "

> letters[3]
[1] "c "

> LETTERS[c(1,2,4)]
[1] " A" " B" "D"
 III-3 Génération de vecteurs aléatoires

 Avec la fonction sample(): tire des échantillons aléatoires, avec ou sans

remise, uniformes ou suivant une autre loi discrète.
Exemples:

> u=sample(1:10) ;u # permutation de{1,2,..,10}
[1] 7 3 4 5 8 2 1 6 10 9

> v=sample(1:10,3); v # tirage uniforme (par défaut) sans remise (par défaut ) de
[1] 1 5 3 #3 éléments parmi 10

>w=sample(1:2,5,replace=T);w #tirage uniforme avec remise de 5 valeurs

[1] 2 2 2 2 1 #1 ou 2

>x=sample(c(1,2,4,5),3, prob=c(0.1,0.2,0.6,0.1));x #tirage non uniforme sans remise

# suivant
[1] 1 4 2 #la loi P=(0.1,0.2,0.6,0.1)
 III-3 Génération…..

 Tirage d’échantillons suivant des lois de probas

spécifiques: fonctions r “dist”()

Exemples:

u=rnorm(100): génère 100 observations issues de la loi
normale de paramètres 0 et 1 (par défaut)

v=rnorm(100, 2, 3): génère 100 observations issues de
la loi normale de paramètres 2 et 3

w=rpois(10, 3): génère 10 observations issues de la loi
de Poisson de paramètres 3
 III- 4 Opérations sur les vecteurs

Opérateurs élément par élément (! s’appliquent même si les longueurs diffèrent)
- numériques : + ,- ,* , / , ^ (numérique/logique->numérique)
- comparaison : >,<,>=,<=,==,!=
(numérique/logique/caractère->logique)
- logiques : &,I,! (logique->logique)

Exemples: v1=1:2; v1 [1] 1 2

v2=c(T,F); v2 [1] TRUE FALSE
v3=letters[c(1,2)]; v3 [1] "a" "b"
v4=rep(1:2,2); v4 [1] 1 2 1 2
v5=v1+v2; v5 [1] 2 2
v6=v1+v4;v6 [1] 2 4 2 4
v7=v1/v3; v7 Error in v1/v3 : non-numeric argument to binary operator
v8=v1<v2; v8 [1] FALSE FALSE
v9=v1^2; v9 [1] 1 4
v10=v1==v2 ; v10 [1] TRUE FALSE
v11=!v10 ; v11 [1] FALSE TRUE
 III- 4 Opérations sur les vecteurs

opérateurs globaux : identical() , all.equal()

> w=identical(v1,v2); #sur des vecteurs de tout mode
> w
[1] FALSE

>x=all.equal(v1,v2) #sur des vecteurs de mode numeriques

>x
[1] "target is numeric, current is logical«
>v2=as.numeric(v2)
>all.equal(v1,v2)
[1] "Mean relative difference: 1"

paste( ): colle des vecteurs terme à terme après transformation en

chaine de caractères: v=paste(0:2,c("a", "b", "c")) ; v
[1] "0 a" "1 b" "2 c"
III- 5 Sélection d’éléments dans un vecteur

Deux modes de sélection dans un vecteur v:

 Utiliser les indices de position des éléments de v entre []
> v= -3:2; v
[1] -3 -2 -1 0 1 2
> v[3]
[1] –1
> v[c(4,6)]
[1] 0 2
>a=c(4,6); v[a] #même résultat
 Utiliser un vecteur booléen l de même longueur que v, valant TRUE
aux indices de positions des éléments à sélectionner (v(l))
> l=c(F, F, F,F,T,T); v[l]
[1] 1 2
> l=v>0; v[l] ; l=which(v>0); v[l] #mêmes résultats
 which() donne les positions où l’indicateur logique vaut TRUE.
 Utilisation d’indices négatifs pour dé-selectionner : >w=v[-4] ;w
[1] -3 -2 -1 1 2
 III- 6 Compléments sur les vecteurs

Remarque sur opérations arithmétiques/ comparaisons : si les deux

vecteurs ne sont pas de même longueur, donne un vecteur de la longueur du
plus grand, en dupliquant le plus court

> v=1:2;w=1:4; v+w

[1] 2 4 4 6

On peut tester le mode d’un vecteur : avec les fonctions

is.numeric(), is.logical(), is.character() (donne un booléen TRUE ou
FALSE)
> is.logical(v); is.numeric(v)
[1] FALSE
[1] TRUE

On peut changer le mode d’un vecteur :

as.numeric() : impose le mode numérique
as.logical(), as.character()
 III-6 Compléments….

 Conversion en numérique (as.numeric())

Logique : FALSE->0 / TRUE ->1

Caractère : “ 1 ”, “ 2 ”,..->1,2,../“ A ”->NA
> u=c("1","d","T");as.numeric(u) > f=c(T,F); as.numeric(f)
[1] 1 NA NA [1] 1 0

 Conversion en logique (as.logical() )

Numérique : 0->FALSE / autres nombres ->TRUE

Caractère : “ FALSE”->FALSE/“ TRUE” ->TRUE/ autres->NA
> v=0:2; as.logical(v) >as.logical(u)
[1] FALSE TRUE TRUE [1] NA NA TRUE

 Conversion en caractère (as.character())

Numérique : 1,2,…-> “ 1 ”, “ 2 ”

Logique : FALSE- > “ FALSE ” /TRUE -> “ TRUE ”
 IV- 1 Les Facteurs (factor)

Un facteur est une variable catégorielle, constituée de deux lignes,

l’une représentant ses valeurs (vecteur), l’autre ses niveaux (valeurs
possibles). Un facteur doit contenir des éléments de même mode.

>factor(1:4) [1] 1 2 3 4
Levels: 1 2 3 4

> factor(letters[c(1,3,4)], levels=c("a","b","c","d"))

[1] a c d
Levels: a b c d

> factor(letters[c(1,3,4)], levels=c("a","b","c"))

[1] a c <NA>
Levels: a b c
 IV- 2 Génération de facteurs (factor)

 On crée un facteur avec la fonction factor()

>factor(1:3); factor(1:3, levels=1:5)
[1] 1 2 3
Levels: 1 2 3
[1] 1 2 3
Levels: 1 2 3 4 5
>factor(1:3, exclude=2); factor(1:3, labels=c("a", "b", "c"))
[1] 1 <NA> 3
Levels: 1 3
[1] a b c
Levels: a b c

 Les fonctions is.factor(), as.factor()…

> x=1:3; is.factor(x); as.factor(x)
[1] FALSE
[1] 1 2 3
Levels: 1 2 3
 IV- 2 Génération de facteurs (factor)

 Fonction cut(): divise l’étendue de v, numérique, en n classes

(breaks=n ou breaks=c(x0,…,xn)) et code les valeurs de v en
fonction de l’intervalle dans lequel elles tombent. L’objet résultant
est un facteur.

> v=1:10; cut(v, breaks=2);

[1] (0.991,5.5] (0.991,5.5] (0.991,5.5] (0.991,5.5] (0.991,5.5] (5.5,10]
[7] (5.5,10] (5.5,10] (5.5,10] (5.5,10]
Levels: (0.991,5.5] (5.5,10]

>cut(v, breaks=c(1,5.5,10));
[1] <NA> (1,5.5] (1,5.5] (1,5.5] (1,5.5] (5.5,10] (5.5,10] (5.5,10]
[9] (5.5,10] (5.5,10]
Levels: (1,5.5] (5.5,10]
 Logiciels libres

La FSF maintient une définition du logiciel libre basée sur

quatre libertés:
1. La liberté d'exécuter le programme, pour tous les
usages.
2. La liberté d'étudier le fonctionnement du programme
(ceci suppose l'accès au code source).
3. La liberté de redistribuer des copies (ceci comprend la
liberté de vendre des copies).
4. La liberté d'améliorer le programme et de publier ses
améliorations. (Ceci encourage la création d'une
communauté de développeurs améliorant le logiciel).