Objets

Inf et -Inf sont l'infini positif et négatif alors que NaN signifie «Pas un nombre». (Celles-ci s'appliquent
aux valeurs numériques et aux parties réelles et imaginaires de valeurs complexes, mais pas aux valeurs
de vecteurs entiers.) Inf et NaN sont des mots réservés dans le langage R.

Exemple :

0/0
[1] NaN

Inf +1
[1] Inf

Inf - Inf
[1] NaN

Inf/Inf
[1] NaN

is.finite renvoie un vecteur de même longueur que x dont le jème élément est TRUE si x [j] est fini (c'est-
à-dire qu'il ne fait pas partie des valeurs NA, NaN, Inf ou -Inf) et FALSE sinon. Les nombres complexes
sont finis si les parties réelles et imaginaires le sont.

is.infinite renvoie un vecteur de même longueur que x dont le jème élément est TRUE si x [j] est infini
(c'est-à-dire égal à l'un de Inf ou -Inf) et FALSE sinon. Ce sera faux sauf si x est numérique ou complexe.
Les nombres complexes sont infinis si la partie réelle ou imaginaire l'est.

Exemple :

is.finite(3.1415)
[1] TRUE
is.infinite(Inf)
[1] TRUE
is.nan(NaN)
[1] TRUE
is.na(NA)
[1] TRUE

Mode() vs class()

Mode() est une classification d'objets mutuellement exclusifs selon leur structure de base. Les modes
'atomiques' sont numériques, complexes, charcter et logique. Les objets récursifs ont des modes tels
que 'liste' ou «fonction» ou quelques autres. Un objet a un et un seul mode.

class() est une propriété affectée à un objet qui détermine comment les fonctions génériques
fonctionnent avec lui. Ce n'est pas une classification mutuellement exclusive. Si un objet n'a pas de
classe spécifique qui lui est assignée, comme un simple vecteur numérique, sa classe est généralement
la même que son mode, par convention.

Exemple :
> x <- 1:16
> mode(x)
[1] "numeric"
> dim(x) <- c(4,4)
> mode(x)
[1] "numeric"
> class(x)
[1] "matrix"
> is.numeric(x)
[1] TRUE
> mode(x) <- "character"
> mode(x)
[1] "character"
> class(x)
[1] "matrix"

Pourtant:

> x <- factor(x)

> class(x)
[1] "factor"
> mode(x)
[1] "numeric"

point-point-point . . .

L'argument point-point-point permet à une fonction d'accepter un nombre quelconque d'arguments.

I L'argument point-point-point (. . . ) indique que la fonction accepte n'importe quoi d'autre comme
argument. Ce qu'il adviendra de ces arguments est déterminé e par la fonction. En général ils sont
transmis à d'autres fonctions. Par exemple, une fonction graphique de haut niveau transmettra
l'argument point-point-point à des fonctions graphiques de bas niveau pour traitement.
Les vecteurs

Un vecteur est une structure de données qui représente un ensemble de valeurs du MÊME TYPE
permettant d'effectuer des opérations de groupe.

Un moyen simple de créer des vecteurs consiste à générer une séquence de valeurs. Cette séquence
peut être:

- Une plage de valeurs, par exemple 1, 2, 3 et 4.

- Une séquence de valeurs suivant une règle, par exemple, 2, 5 et 8, c'est-à-dire une valeur de
séquence de 2 à 8 par 3.
- Une répétition de la même valeur: 5, 5, 5, 5 et 5.

Un vecteur est créé grâce à la fonction c () .Cette fonction reçoit une séquence de valeurs du MÊME
TYPE séparées par une virgule (,). R est en charge de créer le vecteur à partir de ces valeurs. Voici
quelques exemples de vecteurs.

La longueur des vecteurs est donnée par la fonction length() :

nb <- c(1, 2, 3, 4, 5)
length(x)

Une séquence de valeurs d'une valeur (from), à une autre valeur (to), par une valeur de pas (by) pourrait
être générée comme un vecteur en utilisant la fonction seq ().

Nous pouvons également répéter une valeur un nombre spécifié de fois (times) avec la fonction rep ().
R stocke les valeurs de sous l'espace mémoire et afin de permettre la manipulation / l'utilisation de ces
valeurs, R ajoute un numéro de position (appelé index) pour chaque valeur dans le vecteur. À partir de
ces indices, nous pouvons accéder aux valeurs qu'il contient. R est un langage de programmation indexé
1, ce qui signifie que le premier élément d'un vecteur se voit attribuer une position de un.

letters[10]
[1] "j"

Vec1 <- vec [1] # extraction d'un seul élément

Vec2 <- vec [c (3: 7)] # extraction d'une gamme d'éléments

Vec3 <- vec [c (2, 3, 6)] # extraction des éléments souhaités

Nous pouvons supprimer des valeurs du vecteur en spécifiant leur position précédée d'un signe moins
(-) entre crochets ([]) :

letters[-5]
[1] "a" "b" "c" "d" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t"
[20] "u" "v" "w" "x" "y" "z"
ind <- c(3,5,7)
letters[-ind]
[1] "a" "b" "d" "f" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v"
[20] "w" "x" "y" "z"

R permet d'utiliser directement le vecteur logique pour extraire les valeurs souhaitées, cad seuls les
éléments correspondant a une valeur TRUE par exemple sont retenus.

Nous pouvons y parvenir en spécifiant le nom de chaque valeur en utilisant l'égal (=) lors de la création
du vecteur. Lorsque l'ensemble de noms existe déjà en tant que vecteur, nous pouvons également y
parvenir en utilisant la fonction names ().
Les matrices

Les matrices peuvent être vues comme des tableaux de valeurs, à double entrée. Une matrice est donc
définie par son nombre de lignes et de colonnes. Ce sont des objets monotypes, c’est-à-dire de même
type pour tous ses éléments. Chaque valeur de la matrice peut être repérée par son numéro de ligne et
son numéro de colonne. 

Nous présentons dans ce paragraphe quelques fonctions utiles pour manipuler les matrices :

- Dim(x), qui retourne le nombre de lignes et le nombre de colonnes.

- Dimensions : nrow(X), ncol(X) donnent respectivement le nombre de lignes et de colonnes de X.
- Concaténation : par colonne avec la fonction  cbind  , par ligne avec la fonction  rbind 
- rownames(x) pour donner un nom au ligne
- colnames(x) pour donner un nom au colone
- diag() pour créer des matrices diagonales
Voici les principales façons de créer une matrice. La plus utilisée est la fonction matrix qui prend en
arguments le vecteur d’éléments et les dimensions - nombre de lignes ou de colonnes - de la matrice.
Par défaut, R range les valeurs dans une matrice par colonne. Pour ranger les éléments par ligne, on

utilise l’argument byrow :

Les opérations arithmétiques et les fonctions mathématiques usuelles travaillent toujours élément par
élément :

- Transposition : t(x)
- Addition : x+x
- Soustraction x-x
- Multiplication x*x 
- Division : x/x

Les facteurs :

Les facteurs sont des vecteurs un peu particuliers, facilitant la manipulation de données qualitatives
(qu’elles soient numériques ou caractères). En effet, en plus de stocker les différents éléments comme
un vecteur classique, il stocke également l’ensemble des différentes modalités possibles dans un attribut
accessible via la commande levels .

Ils forment une classe d’objets et bénéficient de traitements particuliers lors de leur manipulation et lors
de l’utilisation de certaines fonctions. Les facteurs peuvent être non ordonnés (homme, femme) ou
ordonnés (niveaux de douleur).

La fonction factor() permet de créer un facteur en définissant directement les différents éléments du
facteur.

couleurs <- c("bleu", "bleu", "bleu", "blanc", "rouge", "rouge", "noir")

fcouleurs <- factor(couleurs, levels = c("vert", "bleu", "blanc", "rouge"))
fcouleurs
[1] bleu bleu bleu blanc rouge rouge <NA>
Levels: vert bleu blanc rouge

Les listes

Une liste est un ensemble ordonné d’objets qui n’ont pas toujours le même mode ou la même longueur.
Les différents objets sont composés des composants et peuvent être associés à un nom spécifique (un
peu comme une variable). Les listes ont les deux attributs des vecteurs (longueur et mode) et l’attribut
supplémentaire des noms. Les listes sont des objets indispensables, car toutes les fonctions qui
retournent plusieurs objets le font sous la forme d'une liste.

La fonction de base pour créer une liste est la fonction  list()   :

On peut accéder aux éléments d’une liste en utilisant par exemple l'opérateur dollar ($) ou par position
avec l'opérateur double crochet [[]] ou L'opérateur [] qui renvoie une liste avec des éléments
sélectionnés.

Les dataframes
Les dataframes sont des listes particulières dont les composantes sont de même longueur, mais
les modes peuvent être différents. C’est d’ailleurs l’objet privilégié en analyse statistique : en effet,
un tableau de données est constitué de variables quantitatives et/ou qualitatives mesurées sur les
mêmes individus.

Création de dataframe:

Les principales manières de créer un dataframe consistent à utiliser les fonctions :

- data.frame  qui permet de concaténer des vecteurs de même taille et éventuellement de modes

différents ;
- read.table  qui permet d’importer un tableau de données provenant d’un fichier externe (csv,
txt, etc.)
- as.data.frame  pour la conversion explicite d’un objet à deux dimensions (comme une matrice).

Structure de contrôle

Il est important d’intégrer que R, comme Matlab, est un langage interprété donc lent, voire très lent,
losqu’il s’agit d’exécuter des boucles. Celles-ci doivent être éviter dès qu’une syntaxe, impliquant des
calculs matriciels ou les commandes de type apply, peut se substituer.

Structures conditionnelles

if(condition){instructions} est la syntaxe permettant de calculer les instructions uniquement si la

condition est vraie.

if(condition){ A }else{ B } calcule les instructions A si la condition est vraie et les instructions B sinon.
Structures iterative

Ces commandes définissent des boucles pour exécuter plusieurs fois une instruction ou un bloc
d’instructions. Les trois types de boucle sont :

- for var in seq) {commandes}

- while (condition) {commandes}
- repeat {commandes ; if (condition) break }

Dans une boucle for, le nombre d’itérations est fixe alors qu’il peut être infini pour les boucles while et
repeat ! La condition est évaluée avant toute exécution dans while alors que repeat exécute au moins
une fois les commandes.
Boucles implicates

Boucles implicates:

Apply():

apply () prend data frame ou la matrice comme entrée et donne la sortie sous forme de vecteur, de liste
ou de tableau. La fonction apply () est principalement utilisée pour éviter les utilisations explicites des
constructions de boucle. C'est la plus élémentaire de toutes les collections pouvant être utilisées sur une
matrice.

Cette fonction prend 3 arguments:

apply(X, MARGE, FUN)

-X: un tableau ou une matrice

-MARGIN: prenez une valeur ou une plage entre 1 et 2 pour définir où appliquer la fonction:

-MARGIN = 1`: la manipulation est effectuée sur les lignes

-MARGIN = 2`: la manipulation est effectuée sur les colonnes

-MARGIN = c (1,2) `la manipulation est effectuée sur les lignes et les colonnes

-FUN: indique la fonction à appliquer. Des fonctions intégrées telles que la moyenne, la médiane, la
somme, le min, le max et même les fonctions définies par l'utilisateur peuvent être appliquées>

lapply ()

La fonction lapply () est utile pour effectuer des opérations sur des objets de liste et renvoie un objet de
liste de la même longueur que l'ensemble d'origine. lappy () renvoie une liste de la même longueur que
l'objet de liste d'entrée, dont chaque élément est le résultat de l'application de FUN à l'élément
correspondant de la liste. lapply () prend une liste, un vecteur ou une data frame comme entrée et
donne la sortie dans la liste.

Cette fonction prend 2 arguments:

lapply (X, FUN)

-X: un vecteur ou un objet

-FUN: Fonction appliquée à chaque élément de x

sapply ()

La fonction sapply () prend une liste, un vecteur ou une trame de données comme entrée et donne une
sortie en vecteur ou en matrice. Il est utile pour les opérations sur les objets liste et renvoie un objet
liste de même longueur que l'ensemble d'origine. La fonction sapply () fait le même travail que la
fonction lapply () mais renvoie un vecteur.

sapply (X, FUN)

-X: un vecteur ou un objet

-FUN: Fonction appliquée à chaque élément de x

tapply ()

calcule une mesure (moyenne, médiane, min, max, etc.) ou une fonction pour chaque variable de
facteur dans un vecteur. C'est une fonction très utile qui vous permet de créer un sous-ensemble d'un
vecteur, puis d'appliquer certaines fonctions à chacun des sous-ensembles.

tapply (X, INDEX, FUN = NULL)

-X: un objet, généralement un vecteur

-INDEX: Une liste contenant un facteur

-FUN: Fonction appliquée à chaque élément de x