Programmer en R/Les types de base

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche

R comme une calculatrice[modifier | modifier le wikicode]

En mode interactif, il est possible d'utiliser R comme une calculatrice. Le séparateur décimal est le point. La notation exponentielle utilise le e : 4e+5 pour 4·105. Pour les nombres complexes, l'imaginaire i se note 1i.

Ci-dessous quelques exemples de calculs.

> 2+3
[1] 5
> 3+7/5
[1] 4.4
> Arg(1i)
[1] 1.570796
> 2==8
[1] FALSE

Le langage R permet de faire des calculs, en utilisant le signes classiques +, -, *, /, ^ (élévation à la puissance), et les fonctions classiques sqrt() (racine carrée, square root), exp() (exponentielle), cos(), acos(), cosh(), round() (arrondi mathématique)[1], floor() (troncature), … Les angles sont exprimés en radians. Les fonctions mathématiques standard sont :

abs     sign    sqrt
floor   ceiling round

exp     expm1
log2    log10   log1p
cos     sin     tan
acos    asin    atan
cosh    sinh    tanh
acosh   asinh   atanh

gamma   lgamma  digamma trigamma

cumsum  cumprod cummax  cummin

Im  Re  Arg  Conj  Mod

La division euclidienne se fait avec %/% : a%/%b donne normalement la même chose que floor(a/b), mais les algorithmes étant différents, les résultats peuvent différer si a et b ne sont pas des entiers. Le reste (modulo) s'obtient avec a%%b.

Ainsi, la parité d'un entier a se teste avec

a%%2 == 0

(le reste de la division par deux est-il nul ?)

Notons que la précision de calcul est limitée :

> sin(pi)
[1] 1.224606e-16

La valeur de sin(π) est normalement de 0.

Constantes prédéfinies[modifier | modifier le wikicode]

Les constantes prédéfinies dans R sont :

  • pi : π (≈ 3,14) ;
  • LETTERS : lettres capitales de l'alphabet ; la n-ième lettre s'obtient par LETTERS[n] ;
  • letters : lettres minuscules ;
  • month.name : nom des mois en anglais ("January" "February" "March"…) ;
  • month.abb : nom des mois abrégés en anglais ("Jan" "Feb" "Mar"…) ;
  • 1i : imaginaire pur i.

Les variables[modifier | modifier le wikicode]

Comme tout langage, R dispose de variables.

Le typage des variables est implicite : il est déterminé lors de l'initialisation de la variable. Les variables n'ont pas besoin d'être déclarées au préalable, leur portée est celle du groupe d'instruction dans lequel elles ont été initialisées.

Il y a deux manières pour affecter une variable, soit avec le signe =, soit avec <- :

> a = 5
> a
[1] 5
> b <- 7
> b
[1] 7

Un nom de variable peut être composé de lettres, chiffres, et des caractères « . » (point) et « _ » (tiret de soulignement, underscore), mais :

  • il doit commencer par une lettre ou un point ;
  • s'il commence par un point, le deuxième caractère ne doit pas être un nombre.

L'interpréteur R est sensible à la casse[2]. D'autres caractères peuvent être autorisés selon la configuration régionale, comme par exemple les lettres accentuées, mais cela réduit la portabilité du code.

La commande ls() fournit la liste des variables créées (ne pas oublier la paire de parenthèses vide). On peut supprimer une variable x avec la commande rm(x) (remove).

Notons que certains noms d'une lettre sont déjà utilisés par R, et ne devraient donc pas être utilisés comme nom de variable. Il s'agit de :

C D F I T
c q t

Les nombres[modifier | modifier le wikicode]

Le type de nombre est déterminé de manière implicite lors de l'initialisation d'une variable. R dispose d'entiers (integer), de nombres en virgule flottante avec une double précision (double), et de nombre complexe (complex). Les types suivent la norme IEEE 754.

> a = 2
> is (a)
[1] "numeric" "vector" 
> b = 3.6
> is (b)
[1] "numeric" "vector" 
> c = 1+1i
> is (c)
[1] "complex" "vector"

La fonction is retourne le type de l'objet. Pour forcer l'utilisation d'un type particulier on peut utiliser les fonctions as.integer, as.complexet as.double.

> a = as.integer (2.6)
> a
[1] 2
> is (a)
[1] "integer"             "numeric"             "vector"             
[4] "data.frameRowLabels"
<source>

Les fonctions <code>is.''type''</code> permettent de tester le type d'une variable.

<source lang="rsplus">
> a = 7.3
> is.integer (a)
[1] FALSE

Les valeurs « infini » et « (ceci n'est) pas un nombre » (not a number, selon IEEE 754) sont notées respectivement Inf et NaN. Elles sont considérés comme des nombres de type double.

> x = Inf
> 1/x
[1] 0
> 0/0
[1] NaN

Comparaison et logique booléenne[modifier | modifier le wikicode]

Les valeurs booléennes, appelées « logiques » (logic) dans R, sont TRUE pour vrai et FALSE pour faux (en lettres capitales) ; on peut les abréger en T et F. Elles s'obtiennent avec des comparaisons, qui se font avec les signes classiques

<, <=, >, >=. Pour l'égalité, on utilise ==, et pour l'inégalité, !=.

La comparaison d'un vecteur avec une valeur donne un vecteur de booléens :

> c(1:5) == 1
[1]  TRUE FALSE FALSE FALSE FALSE

La comparaison de deux vecteurs donne un vecteur booléen issu de la comparaison terme à terme

> c(1, 2, 3, 4) == c(1, 4, 3, 4)
[1]  TRUE FALSE  TRUE  TRUE

L'opération « ou » se note avec le tube |, le « et » avec la perluette & et le « non » avec le point d'exclamation ! :

> TRUE | FALSE
[1] TRUE
> ! TRUE
[1] FALSE

Le « ou exclusif » se note xor() ; c'est une fonction :

> xor(T, T)
[1] FALSE
> xor(T, F)
[1] TRUE

Ces opérateurs ou fonctions font des comparaisons terme à terme entre vecteurs de booléens.

Les fonctions any() (« au moins un ») et all() (« tous ») appliquent respectivement le « ou » et le « et » sur tout un vecteur.

> any(T, F, T)
[1] TRUE
> all(T, F, T)
[1] FALSE

Les chaînes de caractères[modifier | modifier le wikicode]

Les chaines de caractère sont délimitées par les caractères " ou '.

> a = "Ceci est une chaïne de caractère"
> a
[1] "Ceci est une chaïne de caractère"
> is (a)
[1] "character"           "vector"              "data.frameRowLabels"
> b = 'et une autre'
> b
[1] "et une autre"
> c = 'l\'apostrophe s\'écrit en mettant un anti-slash devant \''
> c
[1] "l'apostrophe s'écrit en mettant un anti-slash devant '"

Scalaire ou vecteur ?[modifier | modifier le wikicode]

Nous avons vu ici des variables de type « scalaire », c'est-à-dire ne contenant qu'une seule valeur. Pour R, un scalaire est un vecteur d'une composante. Les opérations que nous avons vues s'appliquent donc également aux vecteurs, mais par défaut, elles s'appliquent terme à terme. Par exemple, x*y crée le vecteur (x[1]×y[1], x[2]×y[2], …).

Ceci est étudié dans le chapitre suivant Les vecteurs.

Notes et références[modifier | modifier le wikicode]

  1. contrairement à l'habitude, round(1.5) = 1 ; par contre, round(1.5) = 2
  2. il distingue les minuscules et les capitales