Valid XHTML     Valid CSS2    

Mathématiques Finances Economie : Logiciels statistiques

Cours 2

gilles.hunault "at" univ-angers.fr

 

Table des matières cliquable

  1. Manipulation de données en R

  2. Fonctions statistiques élémentaires en R

  3. Fonctions graphiques élémentaires en R

  4. Les packages de R et les interfaces

  5. Programmation élémentaire avec R

  6. Utilisation élémentaire de statgh.r

1. Manipulation de données en R

Pour créer une variable, on utilise l'affectation avec les caractères < et -. R est typé mais il n'y a pas de déclaration explicite de typage : on peut mettre 2 dans x puis TRUE puis "kilo" sans aucune difficulté. Pour créer un vecteur, on utilise la fonction c() et la fonction matrix() pour créer une matrice ; la création d'une liste se fait avec list(). Le nombre d'éléments d'un vecteur ou d'une liste s'obtient par length(). Pour une matrice, on dispose des fonctions dim(), nrow(), ncol(), colnames() et row.names(). Les fonctions seq() (dont la version élémentaire est implémentée via la symbole : ) et rep() permettent de remplir les variables, les lignes et les colonnes d'un vecteur. La virgule à l'intérieur des crochets dans une matrice permet de spécifier un élément, une ligne, une colonne alors que le symbole $ permet d'accéder aux élements par nom. Pour connaitre les premiers ou les derniers éléments, on peut utiliser les fonctions head() et tail(). Les fonctions print() et cat() permettent d'afficher texte et données. La fonction sprintf() sert à gérer les formats d'affichage. 


      x  <- 2
      x  <- TRUE
      x  <- "kilo"
      y  <- c(1,10,5)
      z  <- list(poids=y,unite=x)
      a1 <- 1:10
      ( a2 <- rep(0,8) ) # affichage au passage !
      poids <- round( runif(30,min=50,max=100) ) # tirage aléatoire uniforme
      poids
      head(poids)
      head(poids,n=10)
      tail(poids)
      cat(" le poids est de ",z$poids[2]," (",z$unite,")\n\n")
      a <- 1.7861234
      cat(" en gros, a = ",sprintf("%5.2f",a),"\n" )
     
      m <- matrix(nrow=3,ncol=2)
      colnames(m)  <- c("Mars","Avril")
      row.names(m) <- c("Angers","Nantes","Paris")
      dim(m)
      nrow(m)
      ncol(m)
      m[1,]  <- c(10,20)
      m[,2]  <- a1[1:3]
      m[1,1] <- 5
      m[3,]  <- a2[1:2]

R fonctionne en mode «vectoriel» c'est-à-dire que de nombreuses opérations et fonctions s'appliquent terme à terme en R. Les tests logiques avec <, >, ==, !, &, | et peuvent renvoyer des vecteurs logiques qu'on peut réutiliser comme indices. De plus FALSE vaut 0 et TRUE vaut 1, ce qui permet des comptages rapides dans les conditions. Les fonctions sort() et order() permettent respectivement de trier et de fournir l'ordre de tri des éléments. Avec attach() les colonnes d'un data frame sont accessibles via leur nom. Quand on n'en a plus besoin, on utilise detach(). 


      x <- runif(5)
      x+1
      x*2
      x**3
      sqrt(x)
      x>0.5
      x[ x>0.5 ]
     
     (va <- rbinom(n=30,size=8,prob=0.6))
     sum(va==max(va))            # nombre d'occurences du maximum
     (1:length(va))[va==min(va)] # positions du minimum
     
     
      m <- matrix(1:25,nrow=5,ncol=5)
      m <- matrix(rep(runif(10),25),nrow=5,ncol=5)
      sort(m[,1])
      order(m[,1])
      m[ order(m[,1]) , ]
     
      source("http://www.info.univ-angers.fr/~gh/statgh.r",encoding="latin1")
      elf <- lit.dar("http://www.info.univ-angers.fr/~gh/Datasets/elf.dar")
      attach(elf)
      head(AGE)
      head(SEXE)
      head(AGE[SEXE==1]) # début de l'age des femmes
      detach(elf)

2. Fonctions statistiques élémentaires en R

Les fonctions statistiques élémentaires pour QT s'appliquent à des vecteurs. Il faut utiliser apply() avec FUN pour spécifier une fonction et l'appliquer aux lignes (MARGIN=1) ou aux colonnes (MARGIN=2) d'une matrice. Les noms des fonctions sont basés sur les mots anglais : min, max, sum, mean, var, sd, median, stem. Les fonctions cbind et rbind permettent de concaténer respectivement en colonne et en ligne des structures Pour les QL, la fonction table() comptabilise les valeurs alors que unique() renvoie les valeurs distinctes. Pour les pourcentages, on peut utiliser la fonction round() afin d'arrondir. 


       x <- 1:10
       min(x)
       max(x)
       sum(x)
       mean(x)
       var(x)
       sd(x)
       median(x)
       stem(x)
     
       m
       mean(x)
       moylig <- apply(m,FUN=mean,MARGIN=1)
       moycol <- apply(m,FUN=mean,MARGIN=2)
       cbind( m, moylig)
       rbind( m, moycol)
     
       source("http://www.info.univ-angers.fr/~gh/statgh.r",encoding="latin1")
       elf <- lit.dar("http://www.info.univ-angers.fr/~gh/Datasets/elf.dar")
       attach(elf)
       sexe         <- as.factor(SEXE)
       levels(sexe) <- c("homme","femme") # fallait le savoir que HOMME=0 !
       table(sexe)
       100*table(sexe)/length(sexe)
       round( 100*table(sexe)/length(sexe) )
       detach(elf)

Attention aux données manquantes ! La fonction is.na() permet de tester si une valeur est définie ou non (NA = not available). Certaines fonctions savent calculer en tenant compte de ces NA, d'autres non. Donc prudence...

3. Fonctions graphiques élémentaires en R

Le tracé d'une QT peut se faire avec plot() et son histogramme de classes par hist() alors que sa boite à moustache est fournie par boxplot() mais les options graphiques sont nombreuses (voir celles de plot dans le cours1). Pour une QL, on peut utiliser barplot(table()). Avec par(mfrow...) on peut spécifer plusieurs zones de tracés pour un même graphique. points(), lines() et abline() permettent d'enrichir les graphiques alors que text() et legend() permettent de l'annoter. Si on veut sauvegarder un graphique, des fonctions comme png() et postscript() créent les fichiers correspondants. Voici quelques exemples élémentaires : 


     apt <- read.table("http://www.info.univ-angers.fr/~gh/Datasets/appart.dar",header=TRUE,row.names=1)
     # à la fac :
     # apt <- read.table("K:/stat_ad/appart.dar",header=TRUE,row.names=1)
     
     plot(apt$SURF)
     plot(apt$SURF,main="SURFACES",pch=21,col="black",bg="red")
     
     titreApt <- "PRIX en fonction de la SURFACE"
     plot(apt$SURF,apt$PRIX,main=titreApt,pch=21,col="black",bg="red")
     
     attach(apt)
     limx <- c(0,300)
     limy <- c(0,10**4)
     
     png(filename="appart.png",width=800,height=600)
     plot(PRIX~SURF,main=titreApt,pch=23,col="blue",bg="yellow",xlim=limx,ylim=limy)
     moy_x <- mean(SURF)
     moy_y <- mean(PRIX)
     points(moy_x,moy_y,cex=1.5,pch=19)
     abline(h=moy_y,col="green")
     dev.off() # pour fermer le fichier graphique .png
     
     par(mfrow=c(1,2))
     hist(PRIX,main="Histogramme des classes de PRIX",col="lightgreen")
     boxplot(SURF,main="Boite à moustaches des SURFACES",col="pink")
     
     par(mfrow=c(1,1))
     
     elf <- read.table("http://www.info.univ-angers.fr/~gh/Datasets/elf.dar",header=TRUE,row.names=1)
     sexe <- as.factor(elf$SEXE)
     levels(sexe) <- c("Homme","Femme")
     barplot(table(sexe),col="yellow",main="Remarquer la séparation entre les \"barres\"")
     
     detach(apt)

4. Les packages de R et les interfaces

Le logiciel R comporte plusieurs milliers de fonctions, certaines disponibles dès le chargement de R, d'autres accessibles seulement après avoir chargé un «package» c'est-à-dire un ensemble de de données et de fonctions. Certains packages sont installés automatiquement, d'autres doivent être téléchargés avant d'être installés. La longue liste des packages est ici.

Les 3 packages fondamentaux sont nommés base, stats et graphics. Il n'y a pas besoin de les charger. Pour les autres, il faut utiliser library() pour charger le package s'il est installé. install.packages() sert à installer les packages.

Voici quelques-unes des fonctions que nous utiliserons dans ces packages :

Package Fonctions     
     base      attach, c, cat, cbind, colnames, detach, dim, factor, function, length, list, matrix, mean, print...
     stats           anova, binomial, chisq.test, cor, cor.test, dbinom, lm, median, rnorm, shapiro.test, t.test...
     graphics           abline, barplot, boxplot, legend, lines, pairs, par, plot, points, text, title,

Certains de nos exercices utilisent le package beanplot pour tracer des courbes «en violon» (ou «haricot»), et nous conseillons le package gdata pour lire les fichiers Excel.

Au lieu de la simple ligne de commandes, il est possible d'utiliser des interfaces pour R. Voir par exemple la question 10 de notre cours numéro 5 en EDA1 et sa solution.

Parmi toutes ces interfaces, nous conseillons d'utiliser Rstudio.

5. Programmation élémentaire avec R

On utilise function() pour définir une fonction. Par défaut, le dernier calcul est renvoyé. Les blocs d'instructions sont délimités par des accolades. La structure conditionnelle est bien sûr nommée if et la boucle pour se nomme for. Voici quelques exemples très simples de fonctions : 


     carre <- function(x) { x*x }
     cat(" le carré de 3 est ",carre(3),"\n")
     
     # une meilleure définition
     
     carré <- function(x) {
       # calcule le carré d'un nombre ou d'une structure
       return( x*x )
     } # fin de fonction carré
     
     cat(" le carré de 3 est ",carré(3),"\n")
     
     # la fonction racine en français, un peu inutile
     # à cause de la fonction primitive sqrt
     
     racine <- function(x) {
       # calcule la racine carrée
       if (x<0) {
         cat("impossible de calculer la racine d'un nombre négatif.\n")
         return(NaN)
       } else {
         return( sqrt(x) )
       } # fin de si
     } # fin de fonction racine
     
     cat(" la racine carrée de 3 est ",racine(3),"\n")
     cat(" la racine carrée de -1 est ",racine(-1),"\n")
     
     # un tracé avec des options et des valeurs par défaut
     
     traceXY <- function(x,y,couleur="blue",moy_x=TRUE,moy_y=TRUE) {
       plot(x,y,col=couleur)
       if (moy_x) {
         mean_x <- mean(x)
         abline(v=mean_x,col="green")
       } # fin de si
       if (moy_y) {
         mean_y <- mean(y)
         abline(h=mean_y,col="red")
       } # fin de si
     } # fin de fonction traceXY
     
     traceXY(apt$SURF,apt$PRIX)
     traceXY(apt$SURF,apt$PRIX,couleur="black",moy_x=FALSE)
     
     nbv <- 10
     pdv <- 1:nbv
     for (idv in pdv) {
       cat(" x= ", sprintf("%3d",idv)," racine(x) = ",racine(idv),"\n")
     } # fin de pour
     
     cat("Avec une meilleure gestion des décimales : \n\n")
     
     for (idv in pdv) {
       f_racidv <- sprintf("%9.5f",sqrt(idv))
       cat(" x= ", sprintf("%3d",idv)," racine(x) = ",f_racidv,"\n")
     } # fin de pour

On trouvera à l'adresse statghfns.php une interface pour les fonctions de statgh.r qui montre des exemples d'utilisation et le détail du code-source des fonctions.

6. Utilisation élémentaire de statgh.r

Comme indiqué au paragraphe précédent, le fichier statgh.r contient de nombreuses fonctions pour simplifier les analyses statistiques.

Voici quelques exemples d'utilisation de ces fonctions : 


     apt <- lit.dar("http://www.info.univ-angers.fr/~gh/Datasets/appart.dar")
     lesColonnes(apt)
     
     decritQT("SURFACE",apt$SURF," mètres carré")
     
     datagh("elf")
     decritQL("SEXE",sexe,m_sexe,TRUE)
     
     cat("l'écart-type de l'age est ",ect(age)," ans.\n")
     boxplotQT("SURFACE",apt$SURF)
     
     allQTdf(apt,c("FRANCS","mètres carré") )
     
     decritQT("SURFACE",apt$SURF,"mètres carré",TRUE)
     decritQT("SURFACE",apt$SURF,"mètres carré",TRUE,"surface.png")

 

retour au plan de cours

 

 

retour gH    Retour à la page principale de   (gH)