cal2-intro-R.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<a href=\"http://www.insa-toulouse.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/logo-insa.jpg\" style=\"float:left; max-width: 120px; display: inline\" alt=\"INSA\"/></a> \n",
    "\n",
    "<a href=\"http://wikistat.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/wikistat.jpg\" style=\"max-width: 250px; display: inline\"  alt=\"Wikistat\"/></a>\n",
    "\n",
    "<a href=\"http://www.math.univ-toulouse.fr/\" ><img src=\"http://www.math.univ-toulouse.fr/~besse/Wikistat/Images/logo_imt.jpg\" style=\"float:right; max-width: 250px; display: inline\" alt=\"IMT\"/> </a>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a href=\"https://cran.r-project.org/\"><img src=\"https://cran.r-project.org/Rlogo.svg\" style=\"max-width: 40px; display: inline\" alt=\"R\"/></a> [pour Statistique et Science des Données](https://github.com/wikistat/Intro-Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction à <a href=\"https://cran.r-project.org/\"><img src=\"https://cran.r-project.org/Rlogo.svg\" style=\"max-width: 40px; display: inline\" alt=\"R\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Résumé** Tutoriel d'initiation qui précise l'environnement de travail (packages, répertoire courant). Il propose de manipuler les différents types d'objets  existants dans R et décrit quelques outils d'importation/exportation de données. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Environnement\n",
    "Quelques compléments pour une utilisation facile concernant le chargement de librairies complémentaires et le répertoire de travail.\n",
    "### 1.1 Librairies\n",
    "La liste complète des *packages* ou librairies disponibles est consultable sur le site du [CRAN](http://cran.cict.fr/web/packages/index.html).  L'installation d'un package supplémentaire peut se faire via le menu de Rstudio `Packages>Installer le(s) package(s)` et en choisissant un site miroir du CRAN ou directement avec la fonction `install.packages(\"nomPackage\")`. Celui-ci est installé dans un répertoire de l'utilisateur qui n'a donc pas besoin de dorits d'administration de la machine.\n",
    "### 1.2 Répertoire courant\n",
    "Pour pouvoir récupérer des données, il est utile de connaître le répertoire de travail, c'est-à-dire le répertoire sous lequel les divers résultats seront sauvegardés par défaut. Ce dernier s'obtient à l'aide la commande:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "getwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tandis que la commande \n",
    "\n",
    "`setwd(\"C:/User/Mes documents/CoursR\")`\n",
    "\n",
    "change de répertoire courant. C'est également possible à partir du menu de RStudio (`Set Sorking Directory`).\n",
    "\n",
    "## 2 Structures de données\n",
    "Sous R, les éléments de base sont des objets : vecteurs, matrices, listes..., sur lesquels sont appliquées des fonctions qui fournissent des résultats numériques et graphiques. Ces objets se différencient par leur *mode* décrivant leur contenu, et leur *classe* décrivant leur structure. Les objets atomiques sont de mode *homogène* et les objets récursifs (listes) sont de mode *hétérogène*. \n",
    "\n",
    "Les différents modes sont `null` (objet vide), `logical, numeric, complex, character`. Les classes d'objets les plus courantes sont : `vector, matrix, array, factor, data.frame, list`. \n",
    "\n",
    "On peut avoir des vecteurs, matrices, tableaux, ... de mode `null` (objet vide), `logical` (`TRUE, FALSE, NA`), `numeric, complex`, character tandis que les listes et les *data frame* peuvent être composés d'éléments hétérogènes.\n",
    "\n",
    "**Attention** Une confusion entre classes d'objets dans l'appel d'une fonction est la source d'erreur largement la plus fréquente. \n",
    "### 2.1 Opérations sur les scalaires\n",
    "Entrer les commandes en identifiant  les différents types de données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = log(2)\n",
    "b <- cos(10) #  \"<-\" est équivalent à \"=\"\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2==3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 2<3 ; b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls()  # variables de l'environnement de travail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rm(a) # effacer une ou plusieurs variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=\"texte\"\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Type caractère\n",
    "Manipulation de Chaînes de caractères."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=\"ABCdef\";nchar(c);c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is.character(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "substr(c,1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# changer la casse\n",
    "tolower(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "toupper(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# coller\n",
    "paste(\"alpha\",c,sep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Type booléen et opérateurs logiques\n",
    "Les variables booléennes prennent les valeurs `TRUE` ou `FALSE` ; les opérateurs de comparaison  `<,> <=, >=, !=, ==` retournent ces valeurs tandis  que `&, |, !` sont les opérateurs logiques \"et\", \"ou\", \"non\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3 ; b = 6\n",
    "a<=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a!=b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(b - 3 == a) & ( b>= a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(b  == a) | (b>=a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Les vecteurs (`vector`)\n",
    "Un vecteur regroupe des éléments de même mode. La création d'un vecteur peut se faire par la commande `c(e1,e2,...)`. On peut également générer une séquence avec la commande `seq(a,b,t)` débutant par `a` inférieure ou égale à `b` et de pas `t` ; `rep(x,n)` est un vecteur répétant *n* fois l'élément `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = c(2,3,5,8,4,6); d\n",
    "is.vector(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c(2,5,\"texte\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Séquences et répétitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1:10 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq(from=1,to=20,by=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq(1,20,by=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq(1,20,length=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rep(5,times=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rep(c(1,2),3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rep(c(1,2),each=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = rep(1,10); e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extraction dans un vecteur par `[]` et valeurs manquantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[2];d[2:3];d[-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# attention aux indices :\n",
    "d[-1:2];d[-(1:2)] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NA (Not Available) signale une donnée manquante\n",
    "d[3]=NA;d;summary(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is.na(d);help(NA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fonctions \"any\" et \"all\"\n",
    "any(is.na(d));all(is.na(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Labels et opérations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = c(a=12,b=26,c=32,d=41);f\n",
    "names(f);f[\"a\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names(f)=c(\"a1\",\"a2\",\"a3\",\"a4\")\n",
    "f>30;f[f>30]  # noter les différences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "which(f>30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f[2] = 22;f+100;f+d  # un problème ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cos(f);length(f);sum(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t(f) # transposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=rep(2,4); 2*e; 2+e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e+f ; e*f # opérations terme à terme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t(f)%*%e # produit scalaire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a<-c(3,-1,5,2,-7,3,9)\n",
    "abs(a);sort(a);order(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.5 Facteurs\n",
    "Un facteur est un vecteur avec une liste prédéfinie de valeurs, les niveaux (\\emph{levels}). Cela correspond typiquement à une variable qualitative nominale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect=c(\"a\",\"b\",\"c\",\"b\",\"b\",\"a\")\n",
    "vect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect.f=as.factor(vect)\n",
    "vect.f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "as.integer(vect.f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "as.character(vect.f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6 Les matrices (`matrix`)\n",
    "Comme les vecteurs, les matrices sont de mode quelconque mais ne\n",
    "contiennent que des éléments de même nature. Pour créer une matrice, on utilise\n",
    "la commande `matrix(vec,nrow=n,ncol=p)` où `vec` est le vecteur\n",
    "contenant les éléments de la matrice de taille *n* par *p*, qui seront rangés en\n",
    "colonne sauf si l'option `byrow=T` est utilisée."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = matrix(1:15,ncol=5);A\n",
    "B = matrix(1:15,nc=5,byrow=T)\n",
    "B2=B;B2[1,1]=\"toto\";B2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cbind(A,B);rbind(A,B) # concaténations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1,3];A[,2];B[2,] # composants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1:3,2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Opérations sur les matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = seq(0,1,length=20)\n",
    "C = matrix(g,nrow=4)\n",
    "dim(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C[C[,1]>0.1,]  # * voir question ci-dessous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ranunif : tirage aléatoire uniforme\n",
    "D = matrix(runif(16),ncol=4)\n",
    "D>0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D[D[,1]>0.5,2]=0   # ** voir question ci-dessous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A+B;A*B  #  opérations terme à terme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cos(A); cos(A[1:2,1:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# inversion\n",
    "solve(A);solve(A[1:2,1:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# produit matriciel\n",
    "t(A) %*% B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1:2,1:2] %*% B[1:2,1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t(B); diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apply(A,2,sum)   # *** voir question ci-dessous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apply(D,1,max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Eléments propres\n",
    "s=eigen(A[1:2,2:3])\n",
    "s$values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s$vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "\n",
    "- Que font {`rbind`} et {`cbind`}?\n",
    "- Décortiquer la ligne ci-dessus marquée `*` et décrire ce qu'elle fait.\n",
    "- Même chose avec `**`. \n",
    "- Que renvoie la ligne `***`? \n",
    "\n",
    "\n",
    "**Réponses**\n",
    "\n",
    "- `rbind` et `cbind` collent deux vecteurs ou matrices respectivement en ligne ou en colonne.\n",
    "- `C[C[,1]>0.1,]` peut se décomposer ainsi:\n",
    "\t- `C[,1]` extrait la première colonne de la matrice `C`\n",
    "\t- `C[,1]>0.1` renvoie un vecteur logique de longueur le nombre de lignes de C contenant `TRUE` si la valeur est supérieure à 0.1 et `FALSE` sinon.\n",
    "\t- `C[C[,1]>0.1,]` extrait de la matrice `C` les lignes où les éléments sur la première colonne sont supérieurs à 0.1 et toutes les colonnes si rien après la virgule.\n",
    "- `**` extrait de la colonne 2 de la matrice `D`, les lignes où l'élément sur la première colonne est supérieur à 0.5 et met à 0 ces éléments.\n",
    "- `***` renvoie un vecteur de longueur 5 (le nombre de colonnes de `A`) dont chaque élément est la somme des éléments d'une colonne de A.\n",
    "\n",
    "**Noter** l'importance de ces différentes \"astuces\" pour éviter des boucles `for` dont l'*usage est fortement déconseillé* avec un langage interprété sous peine de plomber les temps d'exécution.\n",
    "\n",
    "### 3.6 Les tableaux (`array`)\n",
    "Les tableaux sont des matrices de dimensions supérieures à 2. On peut les générer à partir de la commande `array(vec,c(n,p,q,...))` où `vec` est le vecteur contenant les éléments du tableau et l'argument `c(n,p,q,...)` désigne les dimensions du tableau : *n* lignes, *p* colonnes, *q* matrices, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array(c(1:8, rep(1,8),seq(0,1,len=8)), dim = c(2,4,3))\n",
    "E = .Last.value\n",
    "E[, , 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim(E);length(E);nrow(E);ncol(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E+10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H=array(1:12,c(2,3,2))\n",
    "apply(H,1,mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apply(H,2,mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apply(H,3,mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "\n",
    "- Expliquer les résulats des 3 appels à la fonction `apply()`.\n",
    "- Créer un `array` à 4 dimensions et calculer la somme des éléments dans toutes les dimensions.\n",
    "\n",
    "\n",
    "**Réponses**\n",
    "\n",
    "- Dans le premier cas, on calcule la moyenne de tous les éléments ligne par ligne. Les éléments de la ligne 1 sont tous les élements de la tranche supérieure horizontale du parallélépipède `H` (1,3,5,7,9,11) ; de la tranche inférieure pour la ligne 2 (2,4,6,8,10,12). Dans le deuxième cas, le calcul est effectué colonne par colonne, le vecteur résultat est donc de longueur 3 ; il contient la moyenne des éléments des 3 tranches verticales (gauche - [1,2,7,8], centre - [3,4,9,10] et droite - [5,6,11,12]). Dans le troisième cas, le calcul de moyenne est fait sur les 2 tranches verticales \"avant\" (1,2,3,4,5,6) et \"arrière\" (7,8,9,10,11,12).\n",
    "- Code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H2=array(1:24,c(2,3,2,2)) # crée un array à 4 dimensions équivalent dans cet exemple à 2 tableaux H \n",
    "apply(H,1,sum)\n",
    "apply(H,2,sum)\n",
    "apply(H,3,sum)\n",
    "apply(H,4,sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.7 Les listes (`list`)\n",
    "Une liste est une collection ordonnée d'objets qui peuvent être de classes différentes. Les listes sont en particulier utilisées par certaines fonctions (cf. tutoriel \"Programmation\") pour renvoyer des résultats complexes sous forme\n",
    "d'un seul objet. On utilise la fonction `list(nom1=el1,nom2=el2,...)` pour générer une liste. On peut accéder à chaque élément de la liste à l'aide de son index entre double crochets `[[...]]`, ou par son nom précédé du signe `$`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = list(\"toto\",1:8);x\n",
    "x[[1]];x[[1]]+1;x[[2]]+10 # *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = list(matrice=D,vecteur=f,texte=\"toto\",scalaire=8)\n",
    "names(y);y[[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y$matrice;y$vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y[c(\"texte\",\"scal\")] # **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y[c(\"texte\",\"scalaire\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "length(y);length(y$vecteur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cos(y$scalaire)+y[[2]][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summary(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "\n",
    "- Quel est le problème avec la ligne * ?\n",
    "- Et avec la ligne ** ?\n",
    "\n",
    "\n",
    "**Réponses**\n",
    "\n",
    "- C'est la 2ème commande de la ligne qui renvoie une erreur. On cherche à ajouter 1 à un élément qui n'est pas numérique.\n",
    "- Aucun composant de la liste ne s'appelle `scal` (\"lettre à lettre\"). \n",
    "\n",
    "\n",
    "### 3.8 Tableau de données (`data.frame`)\n",
    "Un *data frame* est analogue à une matrice dont les colonnes peuvent être *hétérogènes*. Un *tableau de données* est un ensemble de vecteurs, une *liste*, rangés colonne par colonne, chaque colonne correspondant à une variable, chaque ligne à un individu. Le type *data frame* est très important, c'est **la façon** de gérer les données à étudier sous R lors d'une étude statistique.\n",
    "\n",
    "Un tableau de données, est créé en regroupant des variables (vecteurs) de même longueur à l'aide de la commande  `data.frame(nom1=var1,nom2=var2,...)`. Une matrice est transformée en un tableau de données en utilisant la commande `as.data.frame(mat)`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "taille = runif(12,150,180)\n",
    "masse = runif(12,50,90)\n",
    "sexe = rep(c(\"M\",\"F\",\"F\",\"M\"),3)\n",
    "H = data.frame(taille,masse,sexe)\n",
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summary(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# analogies entre data.frame, list et matrix\n",
    "H[1,];H$taille;H$sexe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "is.data.frame(H); is.matrix(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MH = as.matrix(H)\n",
    "summary(MH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "as.list(H)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rm(taille);taille # (1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H$taille"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "attach(H);taille  # (2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "search()          # (3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "detach();taille   # (4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "\n",
    "- Tester la fonction `summary` sur d'autres types d'objets.\n",
    "- Quel est l'effet de la conversion \"forcée\" du `data.frame` en matrice opérée par la fonction `as.matrix()`?\n",
    "- Commenter l'enchaînement des lignes 1 à 4. Quel est l'effet de la fonction `attach`? De la fonction `search`? De la fonction `detach`?\n",
    "- Extraire la masse des individus dont la taille est supérieure à 160. \n",
    "- Extraire la masse et le sexe de ces mêmes individus.\n",
    "- Extraire la taille des individus de sexe masculin dont la masse est inférieure à 70. C'est possible en une seule ligne (voir l'opérateur `&`, `help(\"&\")`).\n",
    "\n",
    "\n",
    "**Réponses**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Fonction summary\n",
    "vec=c(2,5,3,6,5,4,1,8);summary(vec)\n",
    "mat=matrix(1:20,nc=4,nr=5)\n",
    "summary(mat);summary(c(mat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. La conversion en matrice implique que tous les éléments sont désormais du mode `character`. La fonction `summary()` ne calcule plus des indicateurs numériques pour les colonnes `taille` et `masse`.\n",
    "3. Enchaînement des lignes\n",
    "\t- (1) Supprime l'objet `taille` dans l'espace de travail courant ; l'objet `taille` n'est plus reconnu.\n",
    "\t- (2) Attache le data.frame `H` ; les composants de `H` deviennent accessibles directement.\n",
    "\t- (3) `search()` permet de lister les environnements liés à l'espace de travail courant.\n",
    "\t- (4) Détache l'environnement en position 2 dans la liste de `search()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4.\n",
    "H[H$taille>160,2]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5.\n",
    "H[H$taille>160,2:3]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6.\n",
    "H[H$masse<70 & H$sexe==\"M\",1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Entrée / Sortie\n",
    "\n",
    "### 4.1 Importation d'un jeu de données\n",
    "\n",
    "`Tab1 = read.table(\"Tableau.dat\")` lit le fichier nommé `Tableau.dat` pour créer le *data frame* `Tab1` en supposant que le fichier est bien dans le répertoire courant. Sinon il faut préciser le chemin. \n",
    "\n",
    "`help(read.table)` fournit la liste des nombreuses options de cette fonction très utile. Les fonctions `read.csv` et `read.csv2` en sont des cas particuliers, c'est-à-dire avec des options spécifiques (caractère séparateur, marque décimale) adaptées aux fichiers lus / écrits par des tableurs en format `.csv`.\n",
    "\n",
    "\n",
    "Utiliser un éditeur de texte pour créer les quatre fichiers `fic1.txt` à `fic4.txt` ci-dessous  en respectant scrupuleusement la ponctuation.\n",
    "\n",
    "\t\t\t5,2.5,3.8 \n",
    "\t\t\t8,3.2,3.4 \n",
    "\t\t\t12,4.6,5 \n",
    "\n",
    "N.B. séparateur par caractère de tabulation pour le fichier `fic2.txt`\n",
    "\n",
    "\t\t\t5       2.5     3.8  \n",
    "\t\t\t8       3.2     3.4  \n",
    "\t\t\t12      4.6     5  \n",
    "\n",
    "\t\t\tX1;X2;X3  \n",
    "\t\t\t5;2.5;3.8  \n",
    "\t\t\t8;3.2;3.4  \n",
    "\t\t\t12;4.6;5\t\n",
    "            \n",
    "\t\t\t5;2,5;3,8  \n",
    "\t\t\t8;3,2;3,4  \n",
    "\t\t\t12;4,6;5 \n",
    "\n",
    "Comparer les modes de lecture de fichiers en fonction du type, des séparateurs et de la présence de la première ligne de noms des variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fic1=read.table(\"fic1.csv\",sep=\",\")\n",
    "fic1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fic1b=read.csv(\"fic1.csv\")\n",
    "fic1b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fic1b=read.csv(\"fic1.csv\",header=FALSE)\n",
    "fic1b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Questions**\n",
    "\n",
    "Importer les fichiers {\\tt fic2.txt}, {\\tt fic3.txt} et {\\tt fic4.txt}.\n",
    "\n",
    "**Réponses**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fic2 = read.table(\"fic2.txt\")\n",
    "fic3 = read.table(\"fic3.txt\",header=T,sep=\";\")\n",
    "fic4 = read.table(\"fic4.txt\",sep=\";\",dec=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Exportation d'objets R\n",
    "Ecriture dans un fichier et traces des exécutions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=seq(1,10,l=50)\n",
    "write.table(A,\"A.txt\")\n",
    "sink(\"A2.txt\")  # Début, ouverture du fichier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A;summary(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sink()  # arrêt et fermeture du fichier\n",
    "summary(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 4.3 Liens avec un tableur\n",
    "L'échange de fichiers avec un tableur se fait simplement à travers le format `.csv` comme précédemment en faisant attention aux versions américaines dans lesquelles les séparateurs de deux valeurs sont des \",\" et les marques décimales des \".\" tandis que dans les version françaises, les séparateurs de valeurs sont des \";\" et les marques décimales des \",\".\n",
    "\n",
    "#### Passer d'un tableur à R\n",
    "- Dans Excel (ou *open office*) :\n",
    "\t 1. Ouvrir le fichier de données,\n",
    "\t 2. Enregistrer le fichier au format `csv` (*Comma Separated Value*) en le spécifiant dans la liste déroulante (Type de fichier). \n",
    "     3. Quitter Excel. \n",
    "\n",
    "- Dans R: L'importation du fichier de données s'effectue avec la fonction `read.table()`. L'aide en ligne fournit tous les détails sur l'utilisation de cette fonction. On peut en général assurer l'importation avec les 4 arguments: `file, header, sep, dec`:\n",
    "   - `file`  nom du fichier qui contient les données avec le chemin pour y accéder,\n",
    "   - `header` (`TRUE` ou `FALSE`): précise si la première ligne contient le titre des colonnes, \n",
    "   - `sep`  permet de préciser le caractère qui délimite les colonnes,\n",
    "   - `dec`  permet de préciser le séparateur décimal.\n",
    "- N.B. Le chemin pour accéder au fichier est indiqué par des \"/\" et non par des \"\\\".\n",
    "\n",
    "#### Retour dans le tableur de données traitées avec R\n",
    "\n",
    "La fonction `write.table` permet d'envoyer un jeu de données R dans un fichier texte. \n",
    "\n",
    "Exemple : exporter le jeu de données `resul.dat` dans un fichier afin de poursuivre son analyse avec Excel. Il suffit de préciser que le séparateur décimal est la virgule et le séparateur le point-virgule.\n",
    "\n",
    "      write.table(resul.dat,\"resul.csv\",sep=\";\",dec=\",\")\n",
    "\n",
    "Il existe des packages R permettant d'assurer plus directement ces transferts mais la procédure décrite ici est en général recommandée. Pour plus de détails,  se référer au document **R Data Import/Export** disponible sur le CRAN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}