PL2014

---
title: "Introduction à R"
author: "Herimanitra R."
date: "17 octobre 2014"
output: html_document
---
<h1>Installation et presentation de l'interface</h1>
R est le logiciel de programmation statistique la plus complète et la plus fournie au monde. 

Il contient des milliers de librairie ou package capable d’exécuter des taches spécifiques liées au domaine du calcul. De la bioinformatique à la Statistique en passant par l’économétrie, l’analyse numérique, la cartographie et le Data Mining.

Nous allons utiliser ce logiciel pour résoudre des PL dans le cadre de ce cours.

Pour cela, il vous faudra tout d’abord télécharger et installer le logiciel dans votre **PC-personnel**

Aller aux 02 sites suivants et installer successivement par ordre et selon les configurations de votre PC (MAC-OS, Linux, Windows / 32bits ou 64 bits) :

<http://cran.r-project.org/bin/windows/base/>

<http://www.rstudio.com/ide/download/>

Pour installer la librairie spécialisée dans la résolution de PL:
```{r , eval=FALSE}
install.packages('lpSolveAPI')
```
Chercher le package qui permet de charger n’importe quel fichier Excel
dans la mémoire de R:
``` {r, eval=FALSE}
install.packages('xlsx')
install.packages('gdata')
```

RStudio se décline sous 4 principales fenêtres:
<ul>
<li>En haut à gauche, on retrouve les scripts ou programmes. Notez qu'on peut y insérer plusieurs scripts et y travailler simultanément.</li>
<li>En haut, à droite, on retrouve l'espace de travail contenant tout les objets créés dans le Workspace.
On peut également consulter l'historique des commandes exécutés en cliquant
sur 'History' à droite de l'onglet <bold>Environment</bold>.</li>

<li>En bas de l'environnement de travail, on a la fenêtre des aides, des librairies ainsi
que la fenêtre d'affichage des graphiques.</li>
<li>Enfin, en bas de l'espace des scripts, on retrouve la fenêtre d'exécution (ou
Console) où le déroulement des programmes est affiché. Les commandes et
programmes peuvent être tapés directement à partir de la fenêtre d'exécution
soit exécutés à partir du script.</li>
</ul>
<h1>Structure de données dans R</h1>
Pour consulter les différentes données qui sont par défaut inclut dans le paquet
de base de R, il vous suffit de taper la commande (si vous êtes au niveau de la
console) ou d'exécuter (si vous êtes dans un script) :
```{r, echo=TRUE}
data()
```
Pour charger les données qui sont présents dans R,il faut taper: `data(nomdelabase)`

R peut stocker les données sous différents formats. Le plus utilisé est ce qu'on
appelle data.frame . 
Par défaut lorsque vous charger un jeu de données, R
l'enregistre automatiquement sous la classe data.frame accessible à travers la
commande `class()`

<h3>Chargement de la base 'swiss':</h3>
```{r, echo=TRUE}
data(swiss)
class(swiss)
```
La description des variables au sein du data.frame peut être obtenue en tapant la
commande `str(NomduDataframe)`:
```{r, echo=TRUE}
str(swiss)
```

Vous remarquerez que chaque variable du dataframe appartient à une classe
particulière. La classe d'une variable peut être numérique, entier, qualitative
(factor), caractère, booléen (logical), etc. . Ainsi, la classe n'est rien d'autre que le
type de la donnée/variable.
Dans le cas du jeu de données `swiss`, les variables `Fertility`, `Agriculture`,
`Education`, `Catholic` et `Infant.Mortality` sont numériques alors que
`Examination` et `Education` sont des entiers.
<h3>Création de data.frame</h3>
Vous pouvez créer votre propre data.frame et y définir les variables:

```{r echo=TRUE}
mabase=data.frame(sexe=c('Fille','Garcon','Garcon','Fille','Fille'),
age=c(25,21,18,35,24) )
```

On peut accéder à la dimension de notre dataframe grâce à la fonction
`dim(nomdemabase)`:
```{r echo=TRUE}
dim(mabase)
```
Un résumé du dataframe peut être utile commande: `summary(nomdemabase)` et cela est possible en tapant la
```{r echo=TRUE}
summary(swiss)
summary(mabase)
```
NB: les variables d'un même dataframe doivent avoir le même nombre de lignes
(~ nombre d'observations). Par conséquent, vous ne pourrez pas créer un
dataframe avec des variables n'ayant pas la même longueur .
Une manière de remédier à ce problème est de créer la structure de données
liste (list): dans ce cas, la variable `sexe` est de longueur 4 tandis que `age` est de longueur 5. 
Ce qui n'aurait pas été possible si vous avez définit un data.frame.
<h3>Chargement de données externes:</h3>
R peut lire directement un fichier Excel portant l'extension .csv (ou Comma Separated Virgule) sans avoir besoin d'installer un package spécialisé. Sachant que la base se trouve sous le répertoire courant de votre session, il vous suffit d'exécuter la commande suivante:
```{r eval=FALSE}
mabase=read.csv('nomduFichier.csv',sep=";")
```
L'argument 'sep' comme séparateur vous permet de spécifier le séparateur de données. 
Les plus courant sont:
<ol>
<li>virgule (sep=',') si les données se trouvent sur une même colonne séparée par une virgule</li>
<li>point-virgule(sep=';') dans le cas d'un espacement.</li>
</ol>
<h3>Manipulation de données dans R:</h3>
Dans cette partie, nous allons voir comment manipuler des données dans R. Cette partie constitue l'étape indispensable pour débuter l'apprentissage du logiciel. Les opérateurs permettant de manipuler des données dans R sont nombreux, puissants et certains sont destinés à la manipulation de données volumineuses nécessitant des performances de calculs optimales. Les maitriser vous permettra de formuler des opérations complexes sur les données. Cependant, le filtrage constitue une tache ardue du fait de l'interdépendance entre les différents objets dans R.
<h5>Manipulation des vecteurs:</h5>
Vous serez souvent amener à manipuler des vecteurs dans R. Pour définir un vecteur, il vous suffit de les mettre dans l'opérateur `c()` séparé par des virgules.
```{r echo=TRUE}
x=c(1,2,3,3.4)
x
length(x)
class(x)
```
Ici, on a définit un vecteur x de longueur 4 et dont le type est numérique. On a pour cela utilisé les fonctions `length()` qui renvoie la longueur d'un vecteur càd le nombre d'élément dans ce vecteur ainsi que le type du vecteur à partir de la fonction `class()`.
Il existe 5 façons d'accéder aux éléments de ce vecteur x:
En, utilisant leur position dans le vecteur. En effet, on pourra par exemple accéder aux 3ième et 4ième éléments de x en faisant:
```{r echo=TRUE}
x[c(3,4)]
```
On peut également ordonner les éléments de ce vecteur (par ordre croissant ou décravec la fonction order():
```{r echo=TRUE}
x[order(x,decreasing=TRUE)]
x[order(x,decreasing=FALSE)]
```
Si vous spécifiez n-fois la position de l'élément, R va retourner n-fois l'élément correspondant à cette position
```{r echo=TRUE}
x[c(1,1)]
```
On peut également dire à R de ne pas sélectionner un ou plusieurs éléments. Pour cela on utilise des entiers négatifs:
```{r echo=TRUE}
x[-3]
x[-c(1,4)]
```
L'indice `-3` précédente omet le 3ième élément du vecteur x tandis que `-c(2,4)` omet simultanément le 2ième et le 4ième élément du vecteur.
Notez qu'on ne peut pas omettre et spécifier en même temps. Le code suivant va générer une erreur:

```{r eval=FALSE}
x[c(1,-4)]
```

On peut aussi nommer les éléments du vecteur x et le copier sous un autre nom (ici y)
```{r echo=TRUE}
y=setNames(x,letters[1:4])
y
```
N.B: L'opérateur `=`  copie les éléments de x dans y sans pour autant effacer x du répertoire de travail.
Pour effacer x vous pouvez utiliser la fonction `rm()` comme remove
```{r echo=TRUE}
rm(x)
```
Après avoir défini les noms sur le vecteur y, nous pouvons maintenant faire une sous-sélection non plus à partir de la position mais avec les noms

```{r echo=TRUE}
y[c("a","d")]
y[c("c","c","c")]
```

Le premier sélectionne les éléments portant les noms "a" et "b" tandis que le 2ième sélectionne 3-fois l'élément nommé 'c'.
<h3>Manipulation des matrices:</h3>
La fonction matrix() permet de construire une matrice à partir d'un vecteur.
```{r echo=TRUE}
x= matrix(1:9, nrow=3)
x
x=matrix(1:9, ncol=3)
x
```
Les arguments ncol et nrow permettent de contrôler la disposition de la matrice. 
`ncol=3` demande à la fonction `matrix()` d'aligner les 3 premiers éléments sur une colonne et ainsi de suite. 
A l'inverse, `nrow=3` demande à la fonction matrix() d'aligner les 3 premiers éléments du vecteur sur la même ligne.
Il est impératif, lorsque vous construisez un objet de type matrice que la longueur du vecteur soit multiple de l'argument `ncol` ou `nrow`. 
```{r echo=TRUE}
x=matrix(1:9, ncol=4)
```
On peut aussi construire une matrice par concaténation de vecteurs avec la fonction cbind():
```{r echo=TRUE}
x=cbind(1:3, 4:6 , 7:9)
x
```
```{r echo=TRUE}
x= cbind(c(1,4,7),c(2,5,8),c(7,8,9))
```

<h2>TUTORIEL 1:</h2>
Maintenant que vous êtes habitués à l'environnement R. Nous allons résoudre des programmes linéaires.
Le programme qui suit va nous permettre de résoudre le PL de l'exercice 1: 
$$max(2x_{1} + 3x_{2})$$                                   
$$x_{1}\leq5$$
$$x_{1}-x_{2}+x_{3}\leq10$$
$$x_{2}\leq15$$
$$x_{3}\leq22$$
$$x_{1},x_{2},x_{3} \geq0$$

```{r echo=TRUE}
#charge la librairie
require(lpSolveAPI)
# initialise un PL à 4 contraintes et 3 variables de décision:
mylp=make.lp(4,3)
#specifie une maximisation (par defaut minimisation)
lp.control(mylp,sense="max")
mylp
#définit les contraintes (en colonne)
set.column(mylp, 1, c(1, 1,0, 0))
set.column(mylp, 2, c(0, -1,1, 0))
set.column(mylp, 3, c(0, 1,0, 1))
set.objfn(mylp, c(2, 3,0))
#définit les signes des inégalités au niveau des contraintes
set.constr.type(mylp, rep("<=", 4))
# puis le second membre du système de contraintes:
set.rhs(mylp, c(5, 10, 15,22))
# résoud le programme:
solve(mylp)
# affiche les resultats(valeur et solution optimale)
get.objective(mylp)
get.variables(mylp)
```

<h3>Application:</h3>
Ecrire les programmes de résolution de tous les exercices du TD1 dans le logiciel R.