01-intro.Rmd

# Objets de R

On supposera que les objets de R sont bien connus. Dans ce court chapitre nous allons
simplement voir comment examiner leur structure.

## R objects have types

L'instruction `typeof` permet de voir le type des objets. Considérons trois vecteurs, une
matrice, une liste, un data frame, un facteur.

### Numerical types

```{r prompt = TRUE, comment = NA}
typeof( c(1.234, 12.34, 123.4, 1234) )
typeof( runif(10) )
```

```{r prompt = TRUE, comment = NA}
M <- matrix( rpois(12, 2), 4, 3)
typeof(M)
F <- factor( c("F", "M", "F", "F") )
typeof(F)
```

Il y a deux types de variables numériques : `double` (nombres « à virgule », en format dit « flottant ») et `integer`
(entiers). Les entiers s'obtiennent en tapant `0L`, `1L`, etc; certaines commandes renvoient des entiers:
```{r prompt = TRUE, comment = NA}
typeof(0)
typeof(0L)
typeof(0:10)
typeof( which(runif(5) > 0.5) )
typeof( rpois(10, 1) )
```
On remarque que le facteur `F` a pour type `integer`. Ce petit mystère s'éclaircira bientôt.

### Logical

We shall see later that, internally, the logical `TRUE` and `FALSE` are stored as
integers `1` and `0`. They however have their proper type.

```{r prompt = TRUE, comment = NA}
typeof( c(TRUE, FALSE) )
```

### Lists 

Data frame are lists. This will be clarified soon.

```{r prompt = TRUE, comment = NA}
L <- list(a = runif(10), b = "dada")
typeof(L)
D <- data.frame(x = 1:10, y = letters[1:10])
typeof(D)
```

### A glimpse on the objects type

Pour examiner le contenu d'un objet avec une information sur son 
type, on peut utiliser `str`. 

```{r prompt = TRUE, comment = NA}
str(M)
str(F)
str(L)
str(D)
```

## R objects have attributes.

Les objets de R ont des « attributs ». Ainsi donner des noms
aux éléments d'un vecteur revient à lui donner un attribut `names`.

```{r prompt = TRUE, comment = NA}
c <- runif(4)
names(c) <- c("elt1", "elt2", "elt3", "elt4")
c
attributes(c)
```

Ce qui différentie une matrice d'un vecteur, c'est l'attribut `dim`:

```{r prompt = TRUE, comment = NA}
attributes(M)
```

Les data frames et les facteurs ont également des attributs :
```{r prompt = TRUE, comment = NA}
attributes(D)
attributes(F)
```

Les attributs peuvent être modifiés avec la syntaxe `attributes(x) <- ...` 
ou un individuellement avec `attr(x, which)` :
```{r prompt = TRUE, comment = NA}
attr(M, "dim")
attr(M, "dim") <- c(2L, 6L)
M
```

## How to look further at the objects' structure

La fonction `dput` 
permet d'obtenir une forme qui peut être copiée dans une autre session R ; ceci
permet parfois d'obtenir des informations plus précises sur la représentation
interne d'un objet. Nous allons l'utiliser ici pour mieux comprendre la 
construction des matrices, des data frames, et des facteurs.

Il est nécessaire de jeter au préalable un œil à l'aide de `structure` pour mieux 
comprendre le résultat. On y précise notamment :
```
     For historical reasons (these names are used when deparsing),
     attributes ‘".Dim"’, ‘".Dimnames"’, ‘".Names"’, ‘".Tsp"’ and
     ‘".Label"’ are renamed to ‘"dim"’, ‘"dimnames"’, ‘"names"’,
     ‘"tsp"’ and ‘"levels"’.
```

### Matrices are vectors
```{r prompt = TRUE, comment = NA}
dput(M)
```
Une matrice est un vecteur muni d'un attribut `dim` (qui apparaît
comme `.Dim` dans le résultat de `dput`).

### Data Frame are lists

```{r prompt = TRUE, comment = NA}
dput(D)
```
Un data frame est une liste munie d'un attribut `class = "data.frame"` et
d'un attribut `row.names` (ici, la valeur de cet attribut est la convention
pour « 4 lignes non nommées »).

### Factors are integer vectors

```{r prompt = TRUE, comment = NA}
dput(F)
levels(F)
```
Un facteur est qu'un vecteur d'entiers muni d'attributs `class = "factor"`. 
et `levels` (les niveaux du facteur), qui apparaît dans `structure`
sous le nom `.Label` ; cet attribut est également accessible via 
la fonction `levels`.

On peut par exemple fabriquer un facteur à partir d'un vecteur d'entiers, ainsi :

```{r prompt = TRUE, comment = NA}
G <- c(2L, 1L, 1L, 2L)
attributes(G) <- list(levels = c("L1", "L2"), class = "factor")
G
```

## Pour les apprentis sorciers

La fonction interne `inspect` permet de voir l'adresse où se trouve
l'objet, son type (d'abord codé numériquement, par exemple `13` pour `integer`
puis le nom conventionnel de ce type, `INTSXP`), et quelques autres informations ;
les objets complexes (leurs attributs) sont déroulés.

```{r prompt = TRUE, comment = NA}
.Internal(inspect( 1:10 ))
.Internal(inspect( c(0.1, 0.2) ))
a <- c(0.1, 0.2)
.Internal(inspect( a ))
names(a) <- c("A", "B")
.Internal(inspect( M ))
.Internal(inspect( L ))
```

Les plus braves pourront consulter le code de cette fonction, ainsi que tout le code de R,
à cette adresse : [https://github.com/wch/r-source/tree/trunk/src]
plus précisément pour `inspect`, dans `src/main/inspect.c`...

<!--
Le package `pryr` écrit par Hadley Wickham (dont le livre, `Advanced R`, est chaudement
recommandé) propose la notamment la fonction `sexp_type` qui permet de 
connaître le type interne des objets.
On utilisera également plus loin dans ce pakage la fonction `bits`.
-->