Présentation de R

R en quelques mots

Il s'agit d'un logiciel libre de statistique, comprenant des fonctions pour effectuer des traitements statistiques non triviaux.

C'est, comme python, un langage interprété (on peut programmer avec.) Si l'on a beaucoup de données à traiter, le côté interprêté de R ralentit l'affaire, d'autant plus que R charge toutes les données qu'il manipule en mémoire.

Enfin, s'il permet de créer des graphiques honnêtes, ça n'est pas pour autant un logiciel de présentation de données : on peut trouver mieux.

Installation de R et python-rpy

Explications préparatoires

Elle se fait en deux étapes : l'installation de R à proprement parlé, suivi de l'installation du module rpy (R pour python).

À vrai dire, R seul nous suffirait pour le cours de statistiques, mais pouvoir l'intégrer à python nous donnera accès aux multiples possibilités de ce langage (et de ses bibliothèques).

Si besoin est, se reporter au site de rpy : http://rpy.sourceforge.net/.

Installer R

Site de R : http://www.r-project.org/

Sur ce site, on peut télécharger un exécutable ("binaire") de R (pour linux, Mac ou Windows)...mais, pour pouvoir utiliser R et python, il faut récupérer le fichier source : http://cran.cict.fr/src/base/R-2/R-2.5.0.tar.gz (à adapter aux éventuelles nouvelles versions de R).

On le décompresse :

  $  tar zxvf R-2.5.0.tar.gz

Puis, on rentre dans le répertoire décompressé, et l'on fait :

  $ make distclean
  $ ./configure --enable-R-shlib
  $ make
  $ make install

ce qui a pour effet de compiler R comme une bibliothèque partagée.

Installer python-rpy

Comment installer python R ?

• Sous une debian (ubuntu), dans un terminal :

  $ sudo apt-get install python-rpy python-rpy-doc

Puis on édite le fichier /etc/ld.so.conf :

  $ sudo gedit etc/ld.so.conf

et on ajoute /usr/local/lib/R/bin à la fin de ce fichier (à adapter, éventuellement, en fonction de l'emplacement de R)

Il ne reste plus qu'à lancer ldconfig en superutilisateur :

  $ sudo ldconfig

...et le tour est joué !}

Vérifications

Dans un terminal, on peut le lancer ainsi (tout simplement) :

  $ R

On lance ensuite python, et l'on tape :

  >>> from rpy import *

La base

Commençons par importer le module python-rpy

  >>> from rpy import *

Des fonctions élémentaires

r.sqrt(x)

Racine carree de x.

r.log(x)

Logarithme népérien de x.

r.exp(x)

Exponentielle de x.

r.abs(x)

Valeur absolue de x.

r.gamma(x)

Fonction gamma de x. Si x est entier, r.gamma(x) est égal à (x-1)!

r.choose(n,k)

$C_n^k$ : k parmi n.

Les vecteurs

Création de vecteurs

On conserve la création habituelle de vecteurs de python :

  >>> 2:5
  >>> [1, 3, 2, 45] 
  >>> [2: *5

A cela s'ajoute la création d'un vecteur de n données aléatoires normales centrées réduites, comme par exemple :

  >>> r.rnorm(10)

Opérations sur les vecteurs

On peut appliquer une fonction à chaque terme d'un vecteur, comme par exemple :

  >>> r.exp(r.rnorm(10))

Autres fonctions utilisables sur les vecteurs :

r.max(x)

Maximum de x

r.min(x)

Minimum de x

r.round(x,n)

Arrondis les éléments de x avec n chiffres après la virgule

r.length(x)

Nombre d'éléments de x

r.sum(x)

Somme d'éléments de x

r.prod(x)

Produit des éléments de x

r.sort(x)

Classe les éléments de x par ordre croissant

r.rank(x)

Rangs des éléments de c.

Les matrices

Création de matrices

r.matrix(x,ncol=c)

Matrice de c colonnes déployant le vecteur x. On peut remplacer ncol par nrow.

r.cbind(x,y)

Matrice combinant par colonnes les éléments des vecteurs x et y.

r.rbind(x,y)

Comme ci-dessus, mais par lignes.

r.c(M)

Transforme la matrice M en un vecteur.

M[r,

: Vecteur de la ligne r de M.

M[,c

: Vecteur de la colonne c de M.

M[i,j

: Elément de la ligne i et de la colonne j de M.

Opérations sur les matrices

r.t(M)

Transposée de la matrice M.

r.dim(M)

Taille (nombre de lignes et de colonnes) de la matrice M

r.solve(M)

Calcule l'inverse de la matrice M, si elle est inversible.

Les graphiques

Sauvegarde d'un graphique

Pour sauvegarder un graphique dans un fichier postscript, on procède ainsi :

  >>> r.postscript("fichier.eps", horizontal=False, onefile=False, height=5, width=6, pointsize=10)
  >>> ???
  >>> dev.off()

• La première commande ouvre le fichier fichier.eps, en mode portrait, en fixant la taille du cadre extérieur,
• ???
• La dernière ferme le fichier postscript.

Probabilités

Lois classiques

Loi binomiale

r.dbinom(x,n,p)

Probabilité de x succès en n expériences de Bernoulli (p est la probabilité de succès à chaque expérience)

r.pbinom(x,n,p)

Probabilité d'au plus x succès

r.qbinom(q,n,p)

Nombre de succès pour avoir une probabilité d'au moins q

r.rbinom(m,n,p)

m observations aléatoires de la binomiale (n,p)

Loi de Poisson

r.dpois(x,$\lambda$)

probabilité de x succès en n expériences de Poisson

r.ppois(x,$\lambda$)

Probabilité d'au plus x succès

r.qpois(q,$\lambda$)

Nombre de succès pour avoir une probabilité d'au moins q

r.rpois(m,$\lambda$)

m observations aléatoires de la Poisson ($\lambda$)

Loi hypergéométrique

r.dhyper(x,N1,N2,n)

Probabilité de x succès dans un échantillon de taille n (tiré d'une population avec N1 succès et N2 échecs)

r.phyper(x,N1,N2,n)

Probabilité d'au plus x succès

r.qhyper(x,N1,N2,n)

Nombre de succès pour avoir une probabilité d'au moins q

r.rhyper(x,N1,N2,n)

m observations aléatoires de la binomiale (n,p)

Loi uniforme

r.punif(x,a,b)

$Pr(X \leqslant x)$ dans une uniforme [a,b:

r.qunif(q,a,b)

Valeur x telle que $Pr(X \leqslant x) = q$

r.runif(m,a,b)

m observations aléatoires d'une uniforme [a,b:

Loi exponentielle

r.pexp(x,$\lambda$)

$Pr(X \leqslant x)$ dans une exponentielle de paramètre $\lambda$

r.qexp(q,$\lambda$)

Valeur x telle que $Pr(X \leqslant x)= q$

r.rexp(m,$\lambda$)

m observations aléatoires d'une exponentielle ($\lambda$)

Loi normale

r.pnorm(z)

$Pr(X \leqslant x)$ dans une normale centrée et réduite.

r.pnorm(x,$\mu$,$\sigma$)

$Pr(X \leqslant x)$ dans une normale ($\mu$,$\sigma$)

r.qnorm(q,$\mu$,$\sigma$)

Nombre de succès pour avoir une probabilité d'au moins q:r.rnorm(m,$\mu$,$\sigma$): m observations aléatoires de la normale ($\mu$,$\sigma$)

Statistiques

Statistiques descriptives

Création de l'échantillon

r.mean(x)

Moyenne du vecteur x.

r.var(x)

Variance du vecteur x.

r.sd(x)

Ecart-type du vecteur x.

r.median(x)

Médiane du vecteur x.

r.quantile(x)

Médiane, maximum, $Q_1$, $Q_3$, minimum. (r.quantile(y,[0.33, 0.8: ), par exemple, pour avoir la séparation au niveau de 33\%, puis de 80\%).

Graphiques

r.barplot(x)

Diagramme en tuyaux d'orgue de x.

r.stem(x)

Diagramme en tiges et feuilles (r.stem(x,2) double le

nombre de feuilles, quand r.stem(x,0.5) le divise par 2).

r.boxplot(x)

Diagramme en boîte.

r.plot(x,y)

Graphique des points de coordonnées (x,y)

Echantillonage

Loi de Student

r.pt(t,r)

$Pr(T \leqslant y)$ dans une loi de Student avec r degrès de liberté.

r.qt(q,r)

Valeur r telle que $Pr(T \leqslant y)= q$.

Loi de khi-deux

r.pchisq(u,r)

$Pr(U \leqslant u)$ dans une loi de khi-deux avec r degrés de liberté.

r.qschisq(q,r)

Valeur u telle que $Pr(U \leqslant u)= q$.

Loi F de Fisher

r.pf(f,r1,r2)

$Pr(F \leqslant f)$ dans une loi F avec r1 et r2 degrés de liberté.

r.qf(q,,r1,r2)

Valeur f telle que $Pr(F \leqslant f)= q$.

Tirage aléatoire d'un échantillon

r.sample(x,n)

Echantillon de taille n tiré sans remise de x.

r.qschisq(q,r)

Echantillon de taille n tiré avec remise de x.