Goulet Introduction Programmation R

Introduction la programmation en R
Vincent Goulet
Introduction la programmation en R
Vincent Goulet
cole dactuariat, Universit Laval
Troisime dition
2012 Vincent Goulet
Cette cration est mise disposition selon le contrat Paternit-Partage lidentique 2.5 Canada de Creative Commons. En vertu de ce contrat, vous tes libre de : partager reproduire, distribuer et communiquer luvre ; remixer adapter luvre ; utiliser cette uvre des ns commerciales. Selon les conditions suivantes : Attribution Vous devez attribuer luvre de la manire indique par lauteur de luvre ou le titulaire des droits (mais pas dune manire qui suggrerait quils vous soutiennent ou approuvent votre utilisation de luvre). Partage lidentique Si vous modiez, transformez ou adaptez cette uvre, vous navez le droit de distribuer votre cration que sous une licence identique ou similaire celle-ci. Code source A Le code source LTEX et R de ce document est disponible dans le dpt Subversion
https://svn.fsg.ulaval.ca/svn-pub/vgoulet/documents/intro_r/
ou en communiquant directement avec lauteur. ISBN 978-2-9811416-2-0 Dpt lgal Bibliothque et Archives nationales du Qubec, 2012 Dpt lgal Bibliothque et Archives Canada, 2012 Couverture Le hibou en couverture est un harfang des neiges (Bubo scandiacus), lemblme aviaire du Qubec. Ce choix relve galement dun clin dil la couverture de Braun et Murdoch (2007). Crdits photo : David G. Hemmings via Wikimedia Commons
Introduction
Depuis maintenant plus dune dcennie, le systme R connat une progression remarquable dans ses fonctionnalits, dans la varit de ses domaines dapplication ou, plus simplement, dans le nombre de ses utilisateurs. La documentation disponible a suivi la mme tangente, plusieurs maisons ddition ayant dmarr des collections ddies spciquement aux utilisations que lon fait de R en sciences naturelles, en sciences sociales, en nance, etc. Nanmoins, peu douvrages se concentrent sur lapprentissage de R en tant que langage de programmation sous-jacent aux fonctions statistiques. Cest la niche que nous tchons doccuper. Cette troisime dition de louvrage se distingue de la prcdente (Goulet, 2007) plusieurs gards. Tout dabord, le nouveau titre indique dj que nous ne traitons plus du systme S-PLUS. Sil y a eu lutte dimportance et dinuence entre le logiciel libre R et le logiciel commercial S-PLUS, la cause est aujourdhui entendue : R a gagn. Ensuite, lensemble du texte a fait lobjet dune rvision et dune mise jour en profondeur, en particulier les trois premiers chapitres. Enn, mme si nous conservons un biais en faveur du tandem GNU Emacs et ESS pour interagir avec R, la prsentation est moins lie ces outils. Louvrage est bas sur des notes de cours et des exercices utiliss lcole dactuariat de lUniversit Laval. Lenseignement du langage R est ax sur lexposition un maximum de code que nous avons la prtention de croire bien crit et sur la pratique de la programmation. Cest pourquoi les chapitres sont rdigs de manire synthtique et quils comportent peu dexemples au l du texte. En revanche, le lecteur est appel lire et excuter le code informatique se trouvant dans les sections dexemples la n de chacun des chapitres. Ce code et les commentaires qui laccompagnent reviennent sur lessentiel des concepts du chapitre et les complmentent souvent. Nous considrons lexercice dtude active consistant excuter du code et voir ses effet comme essentielle lapprentissage du langage R. Le texte des sections dexemples est disponible en format lectronique sous la rubrique de la documentation par des tiers (Contributed) du site Comprehensive R v
vi Archive Network :
http://cran.r-project.org/other-docs.html
Introduction
Certains exemples et exercices trahissent le premier public de ce document : on y fait loccasion rfrence des concepts de base de la thorie des probabilits et des mathmatiques nancires. Les contextes actuariels demeurent nanmoins peu nombreux et ne devraient gnralement pas drouter le lecteur pour qui ces notions sont moins familires. Nous tenons remercier M. Mathieu Boudreault pour sa collaboration dans la rdaction des exercices et Mme Mireille Ct pour la rvision linguistique de la seconde dition. Vincent Goulet Qubec, avril 2012
Table des matires

Introduction 1 Prsentation du langage R 1.1 Bref historique . . . . . . . . . . . 1.2 Description sommaire de R . . . 1.3 Interfaces . . . . . . . . . . . . . . 1.4 Stratgies de travail . . . . . . . . 1.5 diteurs de texte . . . . . . . . . . 1.6 Anatomie dune session de travail 1.7 Rpertoire de travail . . . . . . . . 1.8 Consulter laide en ligne . . . . . 1.9 O trouver de la documentation . 1.10 Exemples . . . . . . . . . . . . . . 1.11 Exercices . . . . . . . . . . . . . . v 1 1 2 3 4 5 8 9 9 9 10 11 13 13 15 16 20 21 24 26 26 28 39 41 41
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
Bases du langage R 2.1 Commandes R . . . . . . . . . . . . . 2.2 Conventions pour les noms dobjets 2.3 Les objets R . . . . . . . . . . . . . . . 2.4 Vecteurs . . . . . . . . . . . . . . . . . 2.5 Matrices et tableaux . . . . . . . . . . 2.6 Listes . . . . . . . . . . . . . . . . . . . 2.7 Data frames . . . . . . . . . . . . . . . 2.8 Indiage . . . . . . . . . . . . . . . . . 2.9 Exemples . . . . . . . . . . . . . . . . 2.10 Exercices . . . . . . . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
Oprateurs et fonctions 3.1 Oprations arithmtiques . . . . . . . . . . . . . . . . . . . . . . . . vii
viii 3.2 3.3 3.4 3.5 3.6 3.7 3.8 4 Oprateurs . . . . . . . . Appels de fonctions . . . Quelques fonctions utiles Structures de contrle . . Fonctions additionnelles Exemples . . . . . . . . . Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Table des matires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 43 44 50 51 52 60 63 63 64 66 68 69 70 73 73 74 74 75 76 76 77 78 82
Exemples rsolus 4.1 Calcul de valeurs prsentes . . . . . . . . 4.2 Fonctions de masse de probabilit . . . 4.3 Fonction de rpartition de la loi gamma 4.4 Algorithme du point xe . . . . . . . . . 4.5 Suite de Fibonacci . . . . . . . . . . . . . 4.6 Exercices . . . . . . . . . . . . . . . . . . Fonctions dnies par lusager 5.1 Dnition dune fonction . . 5.2 Retourner des rsultats . . . 5.3 Variables locales et globales 5.4 Exemple de fonction . . . . . 5.5 Fonctions anonymes . . . . 5.6 Dbogage de fonctions . . . 5.7 Styles de codage . . . . . . . 5.8 Exemples . . . . . . . . . . . 5.9 Exercices . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
Concepts avancs 6.1 Argument ... . . . . . . . . . . 6.2 Fonction apply . . . . . . . . . . 6.3 Fonctions lapply et sapply . . 6.4 Fonction mapply . . . . . . . . . 6.5 Fonction replicate . . . . . . . 6.6 Classes et fonctions gnriques 6.7 Exemples . . . . . . . . . . . . . 6.8 Exercices . . . . . . . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
87 . 87 . 88 . 90 . 92 . 93 . 94 . 95 . 102
Fonctions doptimisation 107 7.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 7.2 Fonctions doptimisation et de calcul de racines . . . . . . . . . . . 108
Table des matires 7.3 7.4 7.5 8 Pour en savoir plus . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 115 115 116 118 119 121 121 122 122 123 124 127 128 128 129 129 130 130 134 134 135 136 137 139 139 140 141 142 147 148 149 151 153
ix
Gnrateurs de nombres alatoires 8.1 Gnrateurs de nombres alatoires . . . . . . . . . . . . . . . . . 8.2 Fonctions de simulation de variables alatoires non uniformes 8.3 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . .
. . . .
A GNU Emacs et ESS : la base A.1 Mise en contexte . . . . . . . . . . . . . A.2 Installation . . . . . . . . . . . . . . . . A.3 Description sommaire . . . . . . . . . A.4 Emacs-ismes et Unix-ismes . . . . . . . A.5 Commandes de base . . . . . . . . . . A.6 Anatomie dune session de travail (bis) A.7 Conguration de lditeur . . . . . . . A.8 Aide et documentation . . . . . . . . . B Planication dune simulation en R B.1 Contexte . . . . . . . . . . . . . . . . . B.2 Premire approche : avec une boucle B.3 Seconde approche : avec sapply . . B.4 Variante de la seconde approche . . B.5 Gestion des chiers . . . . . . . . . . B.6 Excution en lot . . . . . . . . . . . . B.7 Conclusion . . . . . . . . . . . . . . . C Installation de packages dans R Rponses des exercices Chapitre 2 . . . . . . Chapitre 3 . . . . . . Chapitre 4 . . . . . . Chapitre 5 . . . . . . Chapitre 6 . . . . . . Chapitre 7 . . . . . . Chapitre 8 . . . . . . Bibliographie Index
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
1 Prsentation du langage R
Objectifs du chapitre
Connatre la provenance du langage R et les principes ayant guid son dveloppement. Comprendre ce quest un langage de programmation interprt. Savoir dmarrer une session R et excuter des commandes simples. Comprendre lutilit des chiers de script R et savoir les utiliser de manire interactive. Savoir crer, modier et sauvegarder ses propres chiers de script R.
1.1
Bref historique
lorigine fut le S, un langage pour programmer avec des donnes dvelopp chez Bell Laboratories partir du milieu des annes 1970 par une quipe de chercheurs mene par John M. Chambers. Au l du temps, le S a connu quatre principales versions communment identies par la couleur du livre dans lequel elles taient prsentes : version originale (Brown Book ; Becker et Chambers, 1984), version 2 (Blue Book ; Becker et collab., 1988), version 3 (White Book ; Chambers et Hastie, 1992) et version 4 (Green Book ; Chambers, 1998) ; voir aussi Chambers (2000) et Becker (1994) pour plus de dtails. Ds la n des annes 1980 et pendant prs de vingt ans, le S a principalement t popularis par une mise en uvre commerciale nomme S-PLUS. En 2008, Lucent Technologies a vendu le langage S Insightful Corporation, ce qui a effectivement stopp le dveloppement du langage par ses auteurs originaux. Aujourdhui, le S est commercialis de manire relativement condentielle sous le nom Spotre S+ par TIBCO Software. Ce qui a fortement contribu la perte dinuence de S-PLUS, cest une nouvelle mise en uvre du langage dveloppe au milieu des annes 1990. Inspirs 1
Prsentation du langage R la fois par le S et par Scheme (un driv du Lisp), Ross Ihaka et Robert Gentleman proposent un langage pour lanalyse de donnes et les graphiques quils nomment R (Ihaka et Gentleman, 1996). la suggestion de Martin Maechler de lETH de Zurich, les auteurs dcident dintgrer leur nouveau langage au projet GNU 1 , faisant de R un logiciel libre. Ainsi disponible gratuitement et ouvert aux contributions de tous, R gagne rapidement en popularit l mme o S-PLUS avait acquis ses lettres de noblesse, soit dans les milieux acadmiques. De simple driv not unlike S, R devient un concurrent srieux S-PLUS, puis le surpasse lorsque les efforts de dveloppement se rangent massivement derrire le projet libre. Dailleurs John Chambers place aujourdhui ses efforts de rexion et de dveloppement dans le projet R (Chambers, 2008).
1.2
Description sommaire de R
R est un environnement intgr de manipulation de donnes, de calcul et de prparation de graphiques. Toutefois, ce nest pas seulement un autre environnement statistique (comme SPSS ou SAS, par exemple), mais aussi un langage de programmation complet et autonome. Tel que mentionn prcdemment, le R est un langage principalement inspir du S et de Scheme (Abelson et collab., 1996). Le S tait son tour inspir de plusieurs langages, dont lAPL (autrefois un langage trs pris par les actuaires) et le Lisp. Comme tous ces langages, le R est interprt, cest--dire quil requiert un autre programme linterprte pour que ses commandes soient excutes. Par opposition, les programmes de langages compils, comme le C ou le C++, sont dabord convertis en code machine par le compilateur puis directement excuts par lordinateur. Le programme que lon lance lorsque lon excute R est en fait linterprte. Celui-ci attend que lon lui soumette des commandes dans le langage R, commandes quil excutera immdiatement, une une et en squence. Par analogie, Excel est certes un logiciel de manipulation de donnes, de mise en forme et de prparation de graphiques, mais cest aussi au sens large un langage de programmation interprt. On utilise le langage de programmation lorsque lon entre des commandes dans une cellule dune feuille de calcul. Linterprte excute les commandes et afche les rsultats dans la cellule. Le R est un langage particulirement puissant pour les applications mathmatiques et statistiques (et donc actuarielles) puisque prcisment dvelopp dans ce but. Parmi ses caractristiques particulirement intressantes, on note :
1. http://www.gnu.org
1.3. Interfaces
F IG . 1.1: Fentre de la console sous Mac OS X au dmarrage de R
langage bas sur la notion de vecteur, ce qui simplie les calculs mathmatiques et rduit considrablement le recours aux structures itratives (boucles for, while, etc.) ; pas de typage ni de dclaration obligatoire des variables ; programmes courts, en gnral quelques lignes de code seulement ; temps de dveloppement trs court.
1.3
Interfaces
R est dabord et avant tout une application noffrant quune invite de commande du type de celle prsente la gure 1.1. En soi, cela nest pas si diffrent dun tableur tel que Excel : la zone dentre de texte dans une cellule nest rien dautre quune invite de commande 2 , par ailleurs aux capacits ddition plutt rduites.
2. Merci Markus Gesmann pour cette observation.
Prsentation du langage R Sous Unix et Linux, R nest accessible que depuis la ligne de commande du systme dexploitation (terminal). Aucune interface graphique nest offerte avec la distribution de base de R. Sous Windows, une interface graphique plutt rudimentaire est disponible. Elle facilite certaines oprations tel que linstallation de packages externes, mais elle offre autrement peu de fonctionnalits additionnelles pour ldition de code R. Linterface graphique de R sous Mac OS X est la plus labore. Outre la console prsente la gure 1.1, lapplication R.app comporte de nombreuses fonctionnalits, dont un diteur de code assez complet.
1.4
Stratgies de travail
Dans la mesure o R se prsente essentiellement sous forme dune invite de commande, il existe deux grandes stratgies de travail avec cet environnement statistique. 1. On entre des expressions la ligne de commande pour les valuer immdiatement :
> 2 + 3 [1] 5
On peut galement crer des objets contenant le rsultat dun calcul. Ces objets sont stocks en mmoire dans lespace de travail de R :
> x <- exp(2) > x [1] 7.389056
Lorsque la session de travail est termine, on sauvegarde une image de lespace de travail sur le disque dur de lordinateur an de pouvoir conserver les objets pour une future sance de travail :
> save.image()
Par dfaut, limage est sauvegarde dans un chier nomm .RData dans le dossier de travail actif (voir la section 1.7) et cette image est automatiquement charge en mmoire au prochain lancement de R, tel quindiqu la n du message daccueil :
[Sauvegarde de la session prcdente restaure]
1.5. diteurs de texte Cette approche, dite de code virtuel et objets rels a un gros inconvnient : le code utilis pour crer les objets nest pas sauvegard entre les sessions de travail. Or, celui-ci est souvent bien plus compliqu que lexemple ci-dessus. De plus, sans accs au code qui a servi crer lobjet x, comment savoir ce que la valeur 7,389056 reprsente au juste ? 2. Lapproche dite de code rel et objets virtuels considre que ce quil importe de conserver dune session de travail lautre nest pas tant les objets que le code qui a servi les crer. Ainsi, on sauvegardera dans ce que lon nommera des chiers de script nos expressions R et le code de nos fonctions personnelles. Par convention, on donne aux chiers de script un nom se terminant avec lextension .R. Avec cette approche, les objets sont crs au besoin en excutant le code des chiers de script. Comment ? Simplement en copiant le code du chier de script et en le collant dans linvite de commande de R. La gure 1.2 illustre schmatiquement ce que le programmeur R a constamment sous les yeux : dun ct son chier de script et, de lautre, linvite de commande R dans laquelle son code a t excut. La mthode dapprentissage prconise dans cet ouvrage suppose que le lecteur utilisera cette seconde approche dinteraction avec R.
1.5
diteurs de texte
Dans la mesure o lon a recours des chiers de script tel quexpliqu la section prcdente, ldition de code R bncie grandement dun bon diteur de texte pour programmeur. Dans certains cas, lditeur peut mme rduire lopration de copier-coller un simple raccourci clavier. Un diteur de texte est diffrent dun traitement de texte en ce quil sagit dun logiciel destin la cration, ldition et la sauvegarde de chiers textes purs, cest--dire dpourvus dinformation de prsentation et de mise en forme. Les applications Bloc-notes sous Windows ou TextEdit sous Mac OS X sont deux exemples dditeurs de texte simples. Un diteur de texte pour programmeur saura en plus reconnatre la syntaxe dun langage de programmation et assister sa mise en forme : indentation automatique du code, coloration syntaxique, manipulation dobjets, etc. Le lecteur peut utiliser lditeur de texte de son choix pour ldition de code R. Certains diteurs offrent simplement plus de fonctionnalits que dautres.
Prsentation du langage R
## Fichier de script simple contenant des expressions R pour ## faire des calculs et crer des objets. 2 + 3 ## Probabilit d'une loi de Poisson(10) x <- 7 10^x * exp(-10) / factorial(x) ## Petite fonction qui fait un calcul trivial f <- function(x) x^2 ## valuation de la fonction f(2) R version 2.15.0 (2012-03-30) Copyright (C) 2012 The R Foundation for Statistical Computing ISBN 3-900051-07-0 Platform: x86_64-apple-darwin9.8.0/x86_64 (64-bit) [...] > ## Fichier de script simple contenant des expressions R pour > ## faire des calculs et crer des objets. > 2 + 3 [1] 5 > > ## Probabilit d'une loi de Poisson(10) > x <- 7 > 10^x * exp(-10) / factorial(x) [1] 0.09007923 > > ## Petite fonction qui fait un calcul trivial > f <- function(x) x^2 > > ## valuation de la fonction > f(2) [1] 4
F IG . 1.2: Fichier de script (en haut) et invite de commande R dans laquelle les expressions R ont t excutes (en bas). Les lignes dbutant par # dans le chier de script sont des commentaires ignors par linterprte de commandes.
1.5. diteurs de texte
F IG . 1.3: Fentre de GNU Emacs sous OS X en mode ddition de code R. Dans la partie du haut, on retrouve le chier de script de la gure 1.2 et dans la partie du bas, linvite de commandes R.
GNU Emacs est un trs ancien, mais aussi trs puissant diteur pour programmeur. la question 6.2 de la foire aux questions de R (Hornik, 2011), Devrais-je utiliser R lintrieur de Emacs ?, la rponse est : Oui, absolument. En effet, combin avec le mode ESS (Emacs Speaks Statistics), Emacs offre un environnement de dveloppement aussi riche quefcace. Entre autres fonctionnalits uniques cet diteur, le chier de script et linvite de commandes R sont regroups dans la mme fentre, comme on peut le voir la gure 1.3. Emblme du logiciel libre, Emacs est disponible gratuitement et lidentique sur toutes les plateformes supportes par R, dont Windows, OS X et Linux. Consulter lannexe A pour en savoir plus sur GNU Emacs et apprendre les com-
8 mandes essentielles pour y faire ses premiers pas.
Malgr tous ses avantages (ou cause de ceux-ci), Emacs est un logiciel difcile apprivoiser, surtout pour les personnes moins laise avec linformatique. Il existe plusieurs autres options que Emacs pour diter efcacement du code R et le Bloc-notes de Windows nen fait pas partie ! Nous recommandons plutt : sous Windows, lditeur Notepad++ additionn de lextension NppToR (Redd, 2010), tous deux des logiciels libres ; toujours sous Windows, le partagiciel WinEdt muni de lextension libre RWinEdt (Ligges, 2003) ; sous OS X, tout simplement lditeur de texte trs complet intgr lapplication R.app, ou alors lditeur de texte commercial TextMate (essai gratuit de 30 jours) ; sous Linux, Vim et Kate semblent les choix les plus populaires aprs Emacs dans la communaut R.
1.6
Anatomie dune session de travail
Dans ses grandes lignes, toute session de travail avec R se rduit aux tapes ci-dessous. 1. Ouvrir un chier de script existant ou en crer un nouveau laide de lditeur de texte de son choix. 2. Dmarrer une session R en cliquant sur licne de lapplication si lon utilise une interface graphique, ou alors en suivant la procdure explique lannexe A si lon utilise GNU Emacs. 3. Au cours de la phase de dveloppement, on fera gnralement de nombreux aller-retours la ligne de commande o lon testera des commandes et le chier de script o lon consignera le code R que lon souhaite sauvegarder et les commentaires qui nous permettront de sy retrouver plus tard. 4. Sauvegarder son chier de script et quitter lditeur. 5. Si ncessaire et cest rarement le cas sauvegarder lespace de travail de la session R avec save.image(). En fait, on ne voudra sauvegarder nos objets R que lorsque ceux-ci sont trs longs crer comme, par exemple, les rsultats dune simulation. 6. Quitter R en tapant q() la ligne de commande ou en fermant linterface graphique par la procdure usuelle. Encore ici, la manire de procder est quelque peu diffrente dans GNU Emacs ; voir lannexe A.
1.7. Rpertoire de travail videmment, les tapes 1 et 2 sont interchangeables, tout comme les tapes 4, 5 et 6.
1.7
Rpertoire de travail
Le rpertoire de travail (workspace) de R est le dossier par dfaut dans lequel le logiciel 1) va rechercher des chiers de script ou de donnes ; et 2) va sauvegarder lespace de travail dans le chier .RData. Le dossier de travail est dtermin au lancement de R. Les interfaces graphiques dmarrent avec un rpertoire de travail par dfaut. Pour le changer, utiliser lentre approprie dans le menu Fichier (Windows) ou Divers (Mac OS X). Consulter aussi les foires aux questions spciques aux interfaces graphiques (Ripley et Murdoch, 2011; Iacus et collab., 2011) pour des dtails additionnels sur la gestion des rpertoires de travail. Avec GNU Emacs, la situation est un peu plus simple puisque lon doit spcier un rpertoire de travail chaque fois que lon dmarre un processus R ; voir lannexe A.
1.8
Consulter laide en ligne
Les rubriques daide des diverses fonctions disponibles dans R contiennent une foule dinformations ainsi que des exemples dutilisation. Leur consultation est tout fait essentielle. Pour consulter la rubrique daide de la fonction foo, on peut entrer la ligne de commande
> ?foo
ou
> help(foo)
1.9
O trouver de la documentation
La documentation ofcielle de R se compose de six guides accessibles depuis le menu Aide des interfaces graphiques ou encore en ligne dans le site du projet R 3 , Pour le dbutant, seuls An Introduction to R et, possiblement, R Data Import/Export peuvent savrer des ressources utiles court terme.
3. http://www.r-project.org
10
Prsentation du langage R Plusieurs livres en versions papier ou lectronique, gratuits ou non ont t publis sur R. On en trouvera une liste exhaustive dans la section Documentation du site du projet R. Depuis plusieurs annes maintenant, les ouvrages de Venables et Ripley (2000, 2002) demeurent des rfrences standards de facto sur les langages S et R. Plus rcent, Braun et Murdoch (2007) participe du mme effort que le prsent ouvrage en se concentrant sur la programmation en R plutt que sur ses applications statistiques.
1.10
Exemples
### Gnrer deux vecteurs de nombres pseudo-alatoires issus ### d'une loi normale centre rduite. x <- rnorm(50) y <- rnorm(x) ### Graphique des couples (x, y). plot(x, y) ### Graphique d'une approximation de la densit du vecteur x. plot(density(x)) ### Gnrer la suite 1, 2, ..., 10. 1:10 ### La fonction 'seq' sert gnrer des suites plus gnrales. seq(from = -5, to = 10, by = 3) seq(from = -5, length = 10) ### La fonction 'rep' sert rpter des valeurs. rep(1, 5) # rpter 1 cinq fois rep(1:5, 5) # rpter le vecteur 1,...,5 cinq fois rep(1:5, each = 5) # rpter chaque lment du vecteur cinq fois ### Arithmtique v <- 1:12 v + 2 v * -12:-1 v + 1:3 vectorielle. # initialisation d'un vecteur # additionner 2 chaque lment de v # produit lment par lment # le vecteur le plus court est recycl
### Vecteur de nombres uniformes sur l'intervalle [1, 10]. v <- runif(12, min = 1, max = 10) v
1.11. Exercices
11
### Pour afficher le rsultat d'une affectation, placer la ### commande entre parenthses. ( v <- runif(12, min = 1, max = 10) ) ### Arrondi des valeurs de v l'entier prs. ( v <- round(v) ) ### Crer une matrice 3 x 4 partir des valeurs de ### v. Remarquer que la matrice est remplie par colonne. ( m <- matrix(v, nrow = 3, ncol = 4) ) ### ### m + m * m ^ Les oprateurs arithmtiques de base s'appliquent aux matrices comme aux vecteurs. 2 3 2
### liminer la quatrime colonne afin d'obtenir une matrice ### carre. ( m <- m[,-4] ) ### Transpose et inverse de la matrice m. t(m) solve(m) ### Produit matriciel. m %*% m # produit de m avec elle-mme m %*% solve(m) # produit de m avec son inverse round(m %*% solve(m)) # l'arrondi donne la matrice identit ### Consulter la rubrique d'aide de la fonction 'solve'. ?solve ### Liste des objets dans l'espace de travail. ls() ### Nettoyage. rm(x, y, v, m)
1.11
Exercices
1.1 Dmarrer une session R et entrer une une les expressions ci-dessous la ligne de commande. Observer les rsultats.
12
> ls() > pi > (v <- c(1, 5, 8)) > v * 2 > x <- v + c(2, 1, 7) > x > ls() > q()
1.2 Ouvrir dans un diteur de texte le chier de script contenant le code de la section prcdente. Excuter le code ligne par ligne et observer les rsultats. Repter lexercice avec un ou deux autres diteurs de texte an de les comparer et de vous permettre den choisir un pour la suite. 1.3 Consulter les rubriques daide dune ou plusieurs des fonctions rencontres lors de lexercice prcdent. Observer dabord comment les rubriques daide sont structures elles sont toutes identiques puis excuter quelques expressions tires des sections dexemples. 1.4 Excuter le code de lexemple de session de travail R que lon trouve lannexe A de Venables et collab. (2011). En plus daider se familiariser avec R, cet exercice permet de dcouvrir les fonctionnalits du logiciel en tant quoutil statistique.
2 Bases du langage R
Connatre la syntaxe et la smantique du langage R. Comprendre la notion dobjet et connatre les principaux types de donnes disponibles dans R. Comprendre et savoir tirer prot de larithmtique vectorielle. Comprendre la diffrence entre les divers modes dobjets (en particulier numeric, character et logical) et la conversion automatique de lun lautre. Comprendre la diffrence entre un vecteur, une matrice, un tableau, une liste et un data frame et savoir crer ces divers types dobjets. Savoir extraire des donnes dun objet ou y affecter de nouvelles valeurs laide des diverses mthodes dindiage.
Avant de pouvoir utiliser un langage de programmation, il faut en connatre la syntaxe et la smantique, du moins dans leurs grandes lignes. Cest dans cet esprit que ce chapitre introduit des notions de base du langage R telles que lexpression, laffectation et lobjet. Le concept de vecteur se trouvant au cur du langage, le chapitre fait une large place la cration et la manipulation des vecteurs et autres types dobjets de stockage couramment employs en programmation en R.
2.1
Commandes R
Tel que vu au chapitre prcdent, lutilisateur de R interagit avec linterprte R en entrant des commandes linvite de commande. Toute commande R est soit une expression, soit une affectation. Normalement, une expression est immdiatement value et le rsultat est afch lcran :
> 2 + 3
13
14
Bases du langage R
[1] 5 > pi [1] 3.141593 > cos(pi/4) [1] 0.7071068
Lors dune affectation, une expression est value, mais le rsultat est stock dans un objet (variable) et rien nest afch lcran. Le symbole daffectation est <-, cest--dire les deux caractres < et - placs obligatoirement lun la suite de lautre :
> a <- 5 > a [1] 5 > b <- a > b [1] 5
Pour affecter le rsultat dun calcul dans un objet et simultanment afcher ce rsultat, il suft de placer laffectation entre parenthses pour ainsi crer une nouvelle expression 1 :
> (a <- 2 + 3) [1] 5
Le symbole daffectation invers -> existe aussi, mais il est rarement utilis. viter dutiliser loprateur = pour affecter une valeur une variable puisque cette pratique est susceptible dengendrer de la confusion avec les constructions nom = valeur dans les appels de fonction. Astuce. Dans les anciennes versions de S et R, lon pouvait affecter avec le caractre de soulignement _. Cest emploi nest plus permis, mais la pratique subsiste dans le mode ESS de Emacs. Ainsi, taper le caractre _ hors dune chane de caractres dans Emacs gnre automatiquement <- . Si lon souhaite vritablement obtenir le caractre de soulignement, appuyer deux fois successives sur _. Que ce soit dans les chiers de script ou la ligne de commande, on spare les commandes R les unes des autres par un point-virgule ou par un retour la ligne.
1. En fait, cela devient un appel loprateur "(" qui ne fait que retourner son argument.
2.2. Conventions pour les noms dobjets On considre gnralement comme du mauvais style demployer les deux, cest-dire de placer des points-virgules la n de chaque ligne de code, surtout dans les chiers de script. Le point-virgule peut tre utile pour sparer deux courtes expressions ou plus sur une mme ligne :
> a <- 5; a + 2 [1] 7
15
Cest le seul emploi du point-virgule que lon rencontrera dans cet ouvrage. On peut regrouper plusieurs commandes en une seule expression en les entourant daccolades { }. Le rsultat du regroupement est la valeur de la dernire commande :
> { + + + + } [1] 5 a <- 2 + 3 b <- a b
Par consquent, si le regroupement se termine par une assignation, aucune valeur nest retourne ni afche lcran :
> { + + + } a <- 2 + 3 b <- a
Les rgles ci-dessus joueront un rle important dans la composition de fonctions ; voir le chapitre 5. Comme on peut le voir ci-dessus, lorsquune commande nest pas complte la n de la ligne, linvite de commande de R change de > + pour nous inciter complter notre commande.
2.2
Conventions pour les noms dobjets
Les caractres permis pour les noms dobjets sont les lettres minuscules az et majuscules AZ, les chiffres 09, le point . et le caractre de soulignement _. Selon lenvironnement linguistique de lordinateur, il peut tre permis dutiliser des lettres accentues, mais cette pratique est fortement dcourage puisquelle risque de nuire la portabilit du code.
16
Bases du langage R Les noms dobjets ne peuvent commencer par un chiffre. Sils commencent par un point, le second caractre ne peut tre un chiffre. Le R est sensible la casse, ce qui signie que foo, Foo et FOO sont trois objets distincts. Un moyen simple dviter des erreurs lies la casse consiste nemployer que des lettres minuscules. Certains noms sont utiliss par le systme R, aussi vaut-il mieux viter de les utiliser. En particulier, viter dutiliser
c, q, t, C, D, I, diff, length, mean, pi, range, var.
Certains mots sont rservs et il est interdit de les utiliser comme nom dobjet. Les mots rservs pour le systme sont :
break, else, for, function, if, in, next, repeat, return, while, TRUE, FALSE, Inf, NA, NaN, NULL, NA_integer_, NA_real_, NA_complex_, NA_character_, ..., ..1, ..2, etc.
Les variables T et F prennent par dfaut les valeurs TRUE et FALSE, respectivement, mais peuvent tre raffectes :
> T [1] TRUE > TRUE <- 3 Error in TRUE <- 3 : membre gauche de l'assignation (do_set) incorrect > (T <- 3) [1] 3
Nous recommandons de toujours crire les valeurs boolennes TRUE et FALSE au long pour viter des bogues difciles dtecter.
2.3
Les objets R
Tout dans le langage R est un objet : les variables contenant des donnes, les fonctions, les oprateurs, mme le symbole reprsentant le nom dun objet est lui-mme un objet. Les objets possdent au minimum un mode et une longueur et certains peuvent tre dots dun ou plusieurs attributs Le mode dun objet est obtenu avec la fonction mode :
2.3. Les objets R
17
Mode
numeric complex logical character function list expression
Contenu de lobjet nombres rels nombres complexes valeurs boolennes (vrai/faux) chanes de caractres fonction donnes quelconques expressions non values
TAB. 2.1: Modes disponibles et contenus correspondants
> v <- c(1, 2, 5, 9) > mode(v) [1] "numeric"
La longueur dun objet est obtenue avec la fonction length :

> length(v) [1] 4
2.3.1
Modes et types de donnes
Le mode prescrit ce quun objet peut contenir. ce titre, un objet ne peut avoir quun seul mode. Le tableau 2.1 contient la liste des principaux modes disponibles en R. chacun de ces modes correspond une fonction du mme nom servant crer un objet de ce mode. Les objets de mode "numeric", "complex", "logical" et "character" sont des objets simples (atomic en anglais) qui ne peuvent contenir que des donnes dun seul type. En revanche, les objets de mode "list" ou "expression" sont des objets rcursifs qui peuvent contenir dautres objets. Par exemple, une liste peut contenir une ou plusieurs autres listes ; voir la section 2.6 pour plus de dtails. La fonction typeof permet dobtenir une description plus prcise de la reprsentation interne dun objet (cest--dire au niveau de la mise en uvre en C). Le mode et le type dun objet sont souvent identiques.
18
Bases du langage R
2.3.2
Longueur
La longueur dun objet est gale au nombre dlments quil contient. La longueur, au sens R du terme, dune chane de caractres est toujours 1. Un objet de mode character doit contenir plusieurs chanes de caractres pour que sa longueur soit suprieure 1 :
> v1 <- "actuariat" > length(v1) [1] 1 > v2 <- c("a", "c", "t", "u", "a", "r", "i", "a", "t") > length(v2) [1] 9
On obtient le nombre de caractres dans un chane avec la fonction nchar :

> nchar(v1) [1] 9 > nchar(v2) [1] 1 1 1 1 1 1 1 1 1
Un objet peut tre de longueur 0 et doit alors tre interprt comme un contenant qui existe, mais qui est vide :
> v <- numeric(0) > length(v) [1] 0
2.3.3
Lobjet spcial NULL
Lobjet spcial NULL reprsente rien, ou le vide. Son mode est NULL. Sa longueur est 0. Toutefois diffrent dun objet vide : un objet de longueur 0 est un contenant vide ; NULL est pas de contenant. La fonction is.null teste si un objet est NULL ou non.
2.3. Les objets R
19
2.3.4
Valeurs manquantes, indtermines et infinies
Dans les applications statistiques, il est souvent utile de pouvoir reprsenter des donnes manquantes. Dans R, lobjet spcial NA remplit ce rle. Par dfaut, le mode de NA est logical, mais NA ne peut tre considr ni comme TRUE, ni comme FALSE. Toute opration impliquant une donne NA a comme rsultat NA. Certaines fonctions (sum, mean, par exemple) ont par consquent un argument na.rm qui, lorsque TRUE, limine les donnes manquantes avant de faire un calcul. La valeur NA nest gale aucune autre, pas mme elle-mme (selon la rgle ci-dessus, le rsultat de la comparaison est NA) :
> NA == NA [1] NA
Par consquent, pour tester si les lments dun objet sont NA ou non il faut utiliser la fonction is.na :
> is.na(NA) [1] TRUE
La norme IEEE 754 rgissant la reprsentation interne des nombres dans un ordinateur (IEEE, 2003) prvoit les valeurs mathmatiques spciales + et ainsi que les formes indtermines du type 0 ou inf inf. R dispose dobjets sp0 ciaux pour reprsenter ces valeurs.
Inf reprsente +. -Inf reprsente . NaN (Not a Number) reprsente une forme indtermine.
Ces valeurs sont testes avec les fonctions is.infinite, is.finite et is.nan.
2.3.5
Attributs
Les attributs dun objet sont des lments dinformation additionnels lis cet objet. La liste des attributs les plus frquemment rencontrs se trouve au tableau 2.2. Pour chaque attribut, il existe une fonction du mme nom servant extraire lattribut correspondant dun objet. Plus gnralement, la fonction attributes permet dextraire ou de modier la liste des attributs dun objet. On peut aussi travailler sur un seul attribut la fois avec la fonction attr.
20
Bases du langage R
Attribut
class dim dimnames names
Utilisation affecte le comportement dun objet dimensions des matrices et tableaux tiquettes des dimensions des matrices et tableaux tiquettes des lments dun objet TAB. 2.2: Attributs les plus usuels dun objet
On peut ajouter peu prs ce que lon veut la liste des attributs dun objet. Par exemple, on pourrait vouloir attacher au rsultat dun calcul la mthode de calcul utilise :
> x <- 3 > attr(x, "methode") <- "au pif" > attributes(x) $methode [1] "au pif"
Extraire un attribut qui nexiste pas retourne NULL :

> dim(x) NULL
linverse, donner un attribut la valeur NULL efface cet attribut :

> attr(x, "methode") <- NULL > attributes(x) NULL
2.4
Vecteurs
En R, toutes ns pratiques, tout est un vecteur. Contrairement certains autres langages de programmation, il ny a pas de notion de scalaire en R ; un scalaire est simplement un vecteur de longueur 1. Comme nous le verrons au chapitre 3, le vecteur est lunit de base dans les calculs. Dans un vecteur simple, tous les lments doivent tre du mme mode. Nous nous restreignons ce type de vecteurs pour le moment. Les fonctions de base pour crer des vecteurs sont : c (concatnation) ;
2.5. Matrices et tableaux numeric (vecteur de mode numeric) ; logical (vecteur de mode logical) ; character (vecteur de mode character). Il est possible (et souvent souhaitable) de donner une tiquette chacun des lments dun vecteur.
> (v <- c(a = 1, b = 2, c = 5)) a b c 1 2 5 > v <- c(1, 2, 5) > names(v) <- c("a", "b", "c") > v a b c 1 2 5
21
Ces tiquettes font alors partie des attributs du vecteur. Lindiage dans un vecteur se fait avec [ ]. On peut extraire un lment dun vecteur par sa position ou par son tiquette, si elle existe (auquel cas cette approche est beaucoup plus sre).
> v[3] c 5 > v["c"] c 5
La section 2.8 traite plus en dtail de lindiage des vecteurs et des matrices.
2.5
Matrices et tableaux
Le R tant un langage spcialis pour les calculs mathmatiques, il supporte tout naturellement et de manire intuitive une exception prs, comme nous le verrons les matrices et, plus gnralement, les tableaux plusieurs dimensions. Les matrices et tableaux ne sont rien dautre que des vecteurs dots dun attribut dim. Ces objets sont donc stocks, et peuvent tre manipuls, exactement comme des vecteurs simples. Une matrice est un vecteur avec un attribut dim de longueur 2. Cela change implicitement la classe de lobjet pour "matrix" et, de ce fait, le mode dafchage de lobjet ainsi que son interaction avec plusieurs oprateurs et fonctions.
22 La fonction de base pour crer des matrices est matrix :

> matrix(1:6, nrow = 2, ncol = 3) [,1] [,2] [,3] [1,] [2,] 1 2 3 4 5 6
Bases du langage R
> matrix(1:6, nrow = 2, ncol = 3, byrow = TRUE) [,1] [,2] [,3] [1,] [2,] 1 4 2 5 3 6
La gnralisation dune matrice plus de deux dimensions est un tableau (array). Le nombre de dimensions du tableau est toujours gal la longueur de lattribut dim. La classe implicite dun tableau est "array". La fonction de base pour crer des tableaux est array :
> array(1:24, dim = c(3, 4, 2)) , , 1 [,1] [,2] [,3] [,4] [1,] [2,] [3,] , , 2 [,1] [,2] [,3] [,4] [1,] [2,] [3,] 13 14 15 16 17 18 19 20 21 22 23 24 1 2 3 4 5 6 7 8 9 10 11 12
On remarquera ci-dessus que les matrices et tableaux sont remplis en faisant dabord varier la premire dimension, puis la seconde, etc. Pour les matrices, cela revient remplir par colonne. On conviendra que cette convention, hrite du Fortran, nest pas des plus intuitives. La fonction matrix a un argument byrow qui permet dinverser lordre de remplissage, mais il vaut mieux shabituer la convention de R que dessayer constamment de la contourner.
2.5. Matrices et tableaux
23
h h 1 2
E gg 1 2 E c gg 3 4
h 3
(a) trois dimensions
(b) quatre dimensions
F IG . 2.1: Reprsentation schmatique de tableaux. Les chiffres encercls identient lordre de remplissage.
Lordre de remplissage inhabituel des tableaux rend leur manipulation difcile si on ne les visualise pas correctement. Imaginons un tableau de dimensions 3 4 5. Il faut voir le tableau comme cinq matrices 34 (remplies par colonne !) les unes derrire les autres. Autrement dit, le tableau est un prisme rectangulaire haut de 3 units, large de 4 et profond de 5. Si lon ajoute une quatrime dimension, cela revient aligner des prismes les uns derrire les autres, et ainsi de suite. La gure 2.1 fournit une reprsentation schmatique des tableaux trois et quatre dimensions. Comme pour les vecteurs, lindiage des matrices et tableaux se fait avec [ ]. On extrait un lment dune matrice en prcisant ses positions dans chaque dimension de celle-ci, spares par des virgules :
> (m <- matrix(c(40, 80, 45, 21, 55, 32), nrow = 2, ncol = 3)) [,1] [,2] [,3] [1,] [2,] 40 80 45 21 55 32
> m[1, 2] [1] 45
On peut aussi ne donner que la position de llment dans le vecteur sousjacent :
24
Bases du langage R
> m[3] [1] 45
Lorsquune dimension est omise dans les crochets, tous les lments de cette dimension sont extraits :
> m[2, ] [1] 80 21 32
Les ides sont les mmes pour les tableaux. Pour le reste, les rgles dindiage de vecteurs exposes la section 2.8 sappliquent chaque position de lindice dune matrice ou dun tableau. Des fonctions permettent de fusionner des matrices et des tableaux ayant au moins une dimension identique. La fonction rbind permet de fusionner verticalement deux matrices (ou plus) ayant le mme nombre de colonnes.
> n <- matrix(1:9, nrow = 3) > rbind(m, n) [,1] [,2] [,3] [1,] [2,] [3,] [4,] [5,] 40 80 1 2 3 45 21 4 5 6 55 32 7 8 9
La fonction cbind permet de fusionner horizontalement deux matrices (ou plus) ayant le mme nombre de lignes.
> n <- matrix(1:4, nrow = 2) > cbind(m, n) [,1] [,2] [,3] [,4] [,5] [1,] [2,] 40 80 45 21 55 32 1 2 3 4
2.6
Listes
La liste est le mode de stockage le plus gnral et polyvalent du langage R. Il sagit dun type de vecteur spcial dont les lments peuvent tre de nimporte quel mode, y compris le mode list. Cela permet donc demboter des listes, do le qualicatif de rcursif pour ce type dobjet.
2.6. Listes La fonction de base pour crer des listes est list :
> (x <- list(size = c(1, 5, 2), user = "Joe", new = TRUE)) $size [1] 1 5 2 $user [1] "Joe" $new [1] TRUE
25
Dans lexemple ci-dessus, le premier lment de la liste est de mode "numeric", le second de mode "character" et le troisime de mode "logical". Nous recommandons de nommer les lments dune liste. En effet, les listes contiennent souvent des donnes de types diffrents et il peut savrer difcile didentier les lments sils ne sont pas nomms. De plus, comme nous le verrons ci-dessous, il est trs simple dextraire les lments dune liste par leur tiquette. La liste demeure un vecteur. On peut donc lindicer avec loprateur [ ]. Cependant, cela retourne une liste contenant le ou les lments indics. Cest rarement ce que lon souhaite. Pour indicer un lment dune liste et nobtenir que cet lment, et non une liste contenant llment, il faut utiliser loprateur dindiage [[ ]]. Comparer
> x[1] $size [1] 1 5 2
et
> x[[1]] [1] 1 5 2
videmment, on ne peut extraire quun seul lment la fois avec les crochets doubles [[ ]]. Petite subtilit peu employe, mais lgante. Si lindice utilis dans [[ ]] est un vecteur, il est utilis rcursivement pour indicer la liste : cela slectionnera la composante de la liste correspondant au premier lment du vecteur, puis llment de la composante correspondant au second lment du vecteur, et ainsi de suite.
26
Bases du langage R Une autre et, en fait, la meilleure faon dindicer un seul lment dune liste est par le biais de loprateur $, avec une construction x$etiquette :
> x$size [1] 1 5 2
La fonction unlist convertit une liste en un vecteur simple. Elle est surtout utile pour concatner les lments dune liste lorsque ceux-ci sont des scalaires. Attention, cette fonction peut tre destructrice si la structure interne de la liste est importante.
2.7 Data frames

Les vecteurs, les matrices, les tableaux et les listes sont les types dobjets les plus frquemment utiliss en programmation en R. Toutefois, un grand nombre de procdures statistiques pensons la rgression linaire, par exemple repose davantage sur les data frames pour le stockage des donnes. Un data frame est une liste de classe "data.frame" dont tous les lments sont de la mme longueur (ou comptent le mme nombre de lignes si les lments sont des matrices). Il est gnralement reprsent sous la forme dun tableau deux dimensions. Chaque lment de la liste sous-jacente correspond une colonne. Bien que visuellement similaire une matrice un data frame est plus gnral puisque les colonnes peuvent tre de modes diffrents ; pensons un tableau avec des noms (mode character) dans une colonne et des notes (mode numeric) dans une autre. On cre un data frame avec la fonction data.frame ou, pour convertir un autre type dobjet en data frame, avec as.data.frame. Le data frame peut tre indic la fois comme une liste et comme une matrice. Les fonctions rbind et cbind peuvent tre utilises pour ajouter des lignes ou des colonnes un data frame. On peut rendre les colonnes dun data frame (ou dune liste) visibles dans lespace de travail avec la fonction attach, puis les masquer avec detach.
2.8
Indiage
Lindiage des vecteurs et matrices a dj t brivement prsent aux sections 2.4 et 2.5. La prsente section contient plus de dtails sur cette procdure
2.8. Indiage des plus communes lors de lutilisation du langage R. On se concentre toutefois sur le traitement des vecteurs. Lindiage sert principalement deux choses : extraire des lments dun objet avec la construction x[i] ou les remplacer avec la construction x[i] <- y. Il est utile de savoir que ces oprations sont en fait traduites par linterprte R en des appels des fonctions nommes [ et [<-, dans lordre. De mme, les oprations dextraction et de remplacement dun lment dune liste de la forme x$etiquette et x$etiquette <- y correspondent des appels aux fonctions $ et $<-. Il existe quatre faons dindicer un vecteur dans le langage R. Dans tous les cas, lindiage se fait lintrieur de crochets [ ]. 1. Avec un vecteur dentiers positifs. Les lments se trouvant aux positions correspondant aux entiers sont extraits du vecteur, dans lordre. Cest la technique la plus courante :
> x <- c(A = 2, B = 4, C = -1, D = -5, E = 8) > x[c(1, 3)] A C 2 -1
27
2. Avec un vecteur dentiers ngatifs. Les lments se trouvant aux positions correspondant aux entiers ngatifs sont alors limins du vecteur :
> x[c(-2, -3)] A D E 8 2 -5
3. Avec un vecteur boolen. Le vecteur dindiage doit alors tre de la mme longueur que le vecteur indic. Les lments correspondant une valeur TRUE sont extraits du vecteur, alors que ceux correspondant FALSE sont limins :
> x > 0 A TRUE B C D E TRUE TRUE FALSE FALSE
> x[x > 0] A B E 2 4 8
4. Avec un vecteur de chanes de caractres. Utile pour extraire les lments dun vecteur condition que ceux-ci soient nomms :
28
Bases du langage R
> x[c("B", "D")] B D 4 -5
5. Lindice est laiss vide. Tous les lments du vecteur sont alors slectionns :
> x[] A 2 B C D E 8 4 -1 -5
Remarquer que cela est diffrent dindicer avec un vecteur vide ; cette opration retourne un vecteur vide.
2.9
Exemples
### ### COMMANDES R ### ## Les expressions entres la ligne de commande sont ## immdiatement values et le rsultat est affich ## l'cran, comme avec une grosse calculatrice. 1 # une constante (2 + 3 * 5)/7 # priorit des oprations 3^5 # puissance exp(3) # fonction exponentielle sin(pi/2) + cos(pi/2) # fonctions trigonomtriques gamma(5) # fonction gamma ## Lorsqu'une expression est syntaxiquement incomplte, ## l'invite de commande change de '> ' '+ '. 2 # expression incomplte 5 * # toujours incomplte 3 # complte ## Taper le nom d'un objet affiche son contenu. Pour une ## fonction, c'est son code source qui est affich. pi # constante numrique intgre letters # chane de caractres intgre LETTERS # version en majuscules matrix # fonction ## Ne pas utiliser '=' pour l'affectation. Les oprateurs
2.9. Exemples
29
## d'affectation standard en R sont '<-' et '->'. x <- 5 # affecter 5 l'objet 'x' 5 -> x # idem, mais peu usit x # voir le contenu (x <- 5) # affecter et afficher y <- x # affecter la valeur de 'x' 'y' x <- y <- 5 # idem, en une seule expression y # 5 x <- 0 # changer la valeur de 'x'... y # ... ne change pas celle de 'y' ## Pour regrouper plusieurs expressions en une seule commande, ## il faut soit les sparer par un point-virgule ';', soit les ## regrouper l'intrieur d'accolades { } et les sparer par ## des retours la ligne. x <- 5; y <- 2; x + y # compact; viter dans les scripts x <- 5; # viter les ';' superflus { # dbut d'un groupe x <- 5 # premire expression du groupe y <- 2 # seconde expression du groupe x + y # rsultat du groupe } # fin du groupe et rsultat {x <- 5; y <- 2; x + y} # valide, mais redondant ### ### NOMS D'OBJETS ### ## Quelques exemples de noms valides et invalides. foo <- 5 # valide foo.123 <- 5 # valide foo_123 <- 5 # valide 123foo <- 5 # invalide; commence par un chiffre .foo <- 5 # valide .123foo <- 5 # invalide; point suivi d'un chiffre ## Liste des objets dans l'espace de travail. Les objets dont ## le nom commence par un point sont considrs cachs. ls() # l'objet '.foo' n'est pas affich ls(all.names = TRUE) # objets cachs aussi affichs ## R est sensible la casse foo <- 1 Foo FOO
30
Bases du langage R
### ### LES OBJETS R ### ## MODES ET TYPES DE DONNES ## Le mode d'un objet dtermine ce qu'il peut contenir. Les ## vecteurs simples ("atomic") contiennent des donnes d'un ## seul type. mode(c(1, 4.1, pi)) # nombres rels mode(c(2, 1 + 5i)) # nombres complexes mode(c(TRUE, FALSE, TRUE)) # valeurs boolennes mode("foobar") # chanes de caractres ## Si l'on mlange dans un mme vecteur des objets de mode ## diffrents, il y a conversion automatique vers le mode pour ## lequel il y a le moins de perte d'information, c'est--dire ## vers le mode qui permet le mieux de retrouver la valeur ## originale des lments. c(5, TRUE, FALSE) # conversion en mode 'numeric' c(5, "z") # conversion en mode 'character' c(TRUE, "z") # conversion en mode 'character' c(5, TRUE, "z") # conversion en mode 'character' ## La plupart des autres types d'objets sont rcursifs. Voici ## quelques autres modes. mode(seq) # une fonction mode(list(5, "foo", TRUE)) # une liste mode(expression(x <- 5)) # une expression non value ## LONGUEUR ## La longueur d'un vecteur est gale au nombre d'lments ## dans le vecteur. (x <- 1:4) length(x) ## Une chane de caractres ne compte que pour un seul ## lment. (x <- "foobar") length(x) ## Pour obtenir la longueur de la chane, il faut utiliser ## nchar().
2.9. Exemples
31
nchar(x) ## Un objet peut nanmoins contenir plusieurs chanes de ## caractres. (x <- c("f", "o", "o", "b", "a", "r")) length(x) ## La longueur peut tre 0, auquel cas on a un objet vide, ## mais qui existe. (x <- numeric(0)) # cration du contenant length(x) # l'objet 'x' existe... x[1] <- 1 # possible, 'x' existe X[1] <- 1 # impossible, 'X' n'existe pas ## L'OBJET SPECIAL 'NULL' mode(NULL) length(NULL) x <- c(NULL, NULL) x; length(x); mode(x) ## L'OBJET SPCIAL 'NA' x <- c(65, NA, 72, 88) x + 2 mean(x) mean(x, na.rm = TRUE) is.na(x)
# # # #
le mode de 'NULL' est NULL longueur nulle s'utilise comme un objet normal mais donne toujours le vide
# # # # #
trait comme une valeur tout calcul avec 'NA' donne NA voil qui est pire liminer les 'NA' avant le calcul tester si les donnes sont 'NA'
## VALEURS INFINIES ET INDTERMINES 1/0 # +infini -1/0 # -infini 0/0 # indtermination x <- c(65, Inf, NaN, 88) # s'utilisent comme des valeurs is.finite(x) # quels sont les nombres rels? is.nan(x) # lesquels ne sont pas un nombre? ## ATTRIBUTS ## Les objets peuvent tre dots d'un ou plusieurs attributs. data(cars) # jeu de donnes intgr attributes(cars) # liste de tous les attributs attr(cars, "class") # extraction d'un seul attribut ## Attribut 'class'. Selon la classe d'un objet, certaines ## fonctions (dites fonctions gnriques) vont se comporter ## diffremment.
32
Bases du langage R
x <- sample(1:100, 10) class(x) plot(x) class(x) <- "ts" plot(x) class(x) <- NULL; x
# # # # # # # # #
chantillon alatoire de 10 nombres entre 1 et 100 classe de l'objet graphique pour cette classe 'x' est maintenant une srie chronologique graphique pour les sries chronologiques suppression de l'attribut 'class'
## Attribut 'dim'. Si l'attribut 'dim' compte deux valeurs, ## l'objet est trait comme une matrice. S'il en compte plus ## de deux, l'objet est trait comme un tableau (array). x <- 1:24 # un vecteur dim(x) <- c(4, 6) # ajoute un attribut 'dim' x # l'objet est une matrice dim(x) <- c(4, 2, 3) # change les dimensions x # l'objet est maintenant un tableau ## Attribut 'dimnames'. Permet d'assigner des tiquettes (ou ## noms) aux dimensions d'une matrice ou d'un tableau. dimnames(x) <- list(1:4, c("a", "b"), c("A", "B", "C")) dimnames(x) # remarquer la conversion x # affichage avec tiquettes attributes(x) # tous les attributs de 'x' attributes(x) <- NULL; x # supprimer les attributs ## Attributs 'names'. Similaire 'dimnames', mais pour les ## lments d'un vecteur ou d'une liste. names(x) <- letters[1:24] # attribution d'tiquettes x # identification facilite ### ### VECTEURS ### ## La fonction de base pour crer des vecteurs est 'c'. Il ## peut s'avrer utile de donner des tiquettes aux lments ## d'un vecteur. x <- c(a = -1, b = 2, c = 8, d = 10) # cration d'un vecteur names(x) # extraire les tiquettes names(x) <- letters[1:length(x)] # changer les tiquettes x[1] # extraction par position x["c"] # extraction par tiquette x[-2] # limination d'un lment
2.9. Exemples
33
## La fonction 'vector' sert initialiser des vecteurs avec ## des valeurs prdtermines. Elle compte deux arguments: le ## mode du vecteur et sa longueur. Les fonctions 'numeric', ## 'logical', 'complex' et 'character' constituent des ## raccourcis pour des appels 'vector'. vector("numeric", 5) # vecteur initialis avec des 0 numeric(5) # quivalent numeric # en effet, voici la fonction logical(5) # initialis avec FALSE complex(5) # initialis avec 0 + 0i character(5) # initialis avec chanes vides ### ### MATRICES ET TABLEAUX ### ## Une matrice est un vecteur avec un attribut 'dim' de ## longueur 2 une classe implicite "matrix". La manire ## naturelle de crer une matrice est avec la fonction ## 'matrix'. (x <- matrix(1:12, nrow = 3, ncol = 4)) # crer la matrice length(x) # 'x' est un vecteur... dim(x) # ... avec un attribut 'dim'... class(x) # ... et classe implicite "matrix" ## Une manire moins naturelle mais quivalente --- et parfois ## plus pratique --- de crer une matrice consiste ajouter ## un attribut 'dim' un vecteur. x <- 1:12 # vecteur simple dim(x) <- c(3, 4) # ajout d'un attribut 'dim' x; class(x) # 'x' est une matrice! ## Les matrices sont remplies par colonne par dfaut. Utiliser ## l'option 'byrow' pour remplir par ligne. matrix(1:12, nrow = 3, byrow = TRUE) ## Indicer la matrice ou le vecteur sous-jacent est ## quivalent. Utiliser l'approche la plus simple selon le ## contexte. x[1, 3] # l'lment en position (1, 3)... x[7] # ... est le 7e lment du vecteur x[1, ] # premire ligne x[, 2] # deuxime colonne nrow(x) # nombre de lignes
34
Bases du langage R
dim(x)[1] ncol(x) dim(x)[2]
# idem # nombre de colonnes # idem
## Fusion de matrices et vecteurs. x <- matrix(1:12, 3, 4) # 'x' est une matrice 3 x 4 y <- matrix(1:8, 2, 4) # 'y' est une matrice 2 x 4 z <- matrix(1:6, 3, 2) # 'z' est une matrice 3 x 2 rbind(x, 1:4) # ajout d'une ligne 'x' rbind(x, y) # fusion verticale de 'x' et 'y' cbind(x, 1:3) # ajout d'une colonne 'x' cbind(x, z) # concatnation de 'x' et 'z' rbind(x, z) # dimensions incompatibles cbind(x, y) # dimensions incompatibles ## Les vecteurs ligne et colonne sont rarement ncessaires. On ## peut les crer avec les fonctions 'rbind' et 'cbind', ## respectivement. rbind(1:3) # un vecteur ligne cbind(1:3) # un vecteur colonne ## Un tableau (array) est un vecteur avec un attribut 'dim' de ## longueur suprieure 2 et une classe implicite "array". ## Quant au reste, la manipulation des tableaux est en tous ## points identique celle des matrices. Ne pas oublier: ## les tableaux sont remplis de la premire dimension la ## dernire! x <- array(1:60, 3:5) # tableau 3 x 4 x 5 length(x) # 'x' est un vecteur... dim(x) # ... avec un attribut 'dim'... class(x) # ... une classe implicite "array" x[1, 3, 2] # l'lment en position (1, 3, 2)... x[19] # ... est l'lment 19 du vecteur ## Le tableau ci-dessus est un prisme rectangulaire 3 units ## de haut, 4 de large et 5 de profond. Indicer ce prisme avec ## un seul indice quivaut en extraire des tranches, alors ## qu'utiliser deux indices quivaut en tirer des carottes ## (au sens gologique du terme). Il est laiss en exercice de ## gnraliser plus de dimensions... x # les cinq matrices x[, , 1] # tranches de haut en bas x[, 1, ] # tranches d'avant l'arrire x[1, , ] # tranches de gauche droite x[, 1, 1] # carotte de haut en bas
2.9. Exemples
35
x[1, 1, ] x[1, , 1] ### ### LISTES ###
# carotte d'avant l'arrire # carotte de gauche droite
La liste est l'objet le plus gnral en R. C'est un objet rcursif qui peut contenir des objets de n'importe quel mode et longueur. <- list(joueur = c("V", "C", "C", "M", "A"), score = c(10, 12, 11, 8, 15), expert = c(FALSE, TRUE, FALSE, TRUE, TRUE), niveau = 2)) is.vector(x) # vecteur... length(x) # ... de quatre lments... mode(x) # ... de mode "list" is.recursive(x) # objet rcursif ## Comme tout autre vecteur, une liste peut tre concatne ## avec un autre vecteur avec la fonction 'c'. y <- list(TRUE, 1:5) # liste de deux lments c(x, y) # liste de six lments ## Pour initialiser une liste d'une longueur dtermine, mais ## dont chaque lment est vide, uitliser la fonction ## 'vector'. vector("list", 5) # liste de NULL ## Pour extraire un lment d'une liste, il faut utiliser les ## doubles crochets [[ ]]. Les simples crochets [ ] ## fonctionnent aussi, mais retournent une sous liste -- ce ## qui est rarement ce que l'on souhaite. x[[1]] # premier lment de la liste... mode(x[[1]]) # ... un vecteur x[1] # aussi le premier lment... mode(x[1]) # ... mais une sous liste... length(x[1]) # ... d'un seul lment x[[2]][1] # 1er lment du 2e lment x[[c(2, 1)]] # idem, par indiage rcursif ## ## ## ## Les lments d'une liste tant gnralement nomms (c'est une bonne habitude prendre!), il est souvent plus simple et sr d'extraire les lments d'une liste par leur tiquette.
## ## ## (x
36
Bases du langage R
x$joueur x$score[1] x[["expert"]] x$level <- 1
# # # #
quivalent a[[1]] quivalent a[[c(2, 1)]] aussi valide, mais peu usit aussi pour l'affectation
## Une liste peut contenir n'importe quoi... x[[5]] <- matrix(1, 2, 2) # ... une matrice... x[[6]] <- list(20:25, TRUE)# ... une autre liste... x[[7]] <- seq # ... mme le code d'une fonction! x # eh ben! x[[c(6, 1, 3)]] # de quel lment s'agit-il? ## Pour supprimer un lment d'une liste, lui assigner la ## valeur 'NULL'. x[[7]] <- NULL; length(x) # suppression du 7e lment ## Il est parfois utile de convertir une liste en un simple ## vecteur. Les lments de la liste sont alors drouls, y ## compris la matrice en position 5 (qui n'est rien d'autre ## qu'un vecteur, on s'en souviendra). unlist(x) # remarquer la conversion unlist(x, recursive = FALSE) # ne pas appliquer aux sous-listes unlist(x, use.names = FALSE) # liminer les tiquettes ### ### DATA FRAMES ### ## Un data frame est une liste dont les lments sont tous de ## mme longueur. Il comporte un attribut 'dim', ce qui fait ## qu'il est reprsent comme une matrice. Cependant, les ## colonnes peuvent tre de modes diffrents. (DF <- data.frame(Noms = c("Pierre", "Jean", "Jacques"), Age = c(42, 34, 19), Fumeur = c(TRUE, TRUE, FALSE))) mode(DF) # un data frame est une liste... class(DF) # ... de classe 'data.frame' dim(DF) # dimensions implicites names(DF) # titres des colonnes row.names(DF) # titres des lignes (implicites) DF[1, ] # premire ligne DF[, 1] # premire colonne DF$Name # idem, mais plus simple ## Lorsque l'on doit travailler longtemps avec les diffrentes
2.9. Exemples
37
## colonnes d'un data frame, il est pratique de pouvoir y ## accder directement sans devoir toujours indicer. La ## fonction 'attach' permet de rendre les colonnes ## individuelles visibles dans l'espace de travail. Une fois ## le travail termin, 'detach' masque les colonnes. exists("Noms") # variable n'existe pas attach(DF) # rendre les colonnes visibles exists("Noms") # variable existe Noms # colonne accessible detach(DF) # masquer les colonnes exists("Noms") # variable n'existe plus ### ### INDIAGE ### ## ## ## ## ## ## ## ## ## (x Les oprations suivantes illustrent les diffrentes techniques d'indiage d'un vecteur pour l'extraction et l'affectation, c'est--dire que l'on utilise la fois la fonction '[' et la fonction '[<-'. Les mmes techniques existent aussi pour les matrices, tableaux et listes. On cre d'abord un vecteur quelconque form de vingt nombres alatoires entre 1 et 100 avec rptitions possibles. <- sample(1:100, 20, replace = TRUE))
## On ajoute des tiquettes aux lments du vecteur partir ## de la variable interne 'letters'. names(x) <- letters[1:20] ## On gnre ensuite cinq nombres alatoires entre 1 et 20 ## (sans rptitions). (y <- sample(1:20, 5)) ## On remplace maintenant les lments de 'x' correspondant ## aux positions dans le vecteur 'y' par des donnes ## manquantes. x[y] <- NA x ## Les cinq mthodes d'indiage de base. x[1:10] # avec des entiers positifs "["(x, 1:10) # idem, avec la fonction '[' x[-(1:3)] # avec des entiers ngatifs
38
Bases du langage R
x[x < 10] x[c("a", "k", "t")] x[] x[numeric(0)]
# # # #
avec un vecteur boolen par tiquettes aucun indice... ... diffrent d'indice vide
## Il arrive souvent de vouloir indicer spcifiquement les ## donnes manquantes d'un vecteur (pour les liminer ou les ## remplacer par une autre valeur, par exemple). Pour ce ## faire, on utilise la fonction 'is.na' et l'indiage par un ## vecteur boolen. (Note: l'oprateur '!' ci-dessous est la ## ngation logique.) is.na(x) # positions des donnes manquantes x[!is.na(x)] # suppression des donnes manquantes x[is.na(x)] <- 0; x # remplace les NA par des 0 "[<-"(x, is.na(x), 0) # idem, mais trs peu usit ## On laisse tomber les tiquettes de l'objet. names(x) <- NULL ## Quelques cas spciaux d'indiage. length(x) # un rappel x[1:25] # allonge le vecteur avec des NA x[25] <- 10; x # remplis les trous avec des NA x[0] # n'extraie rien x[0] <- 1; x # n'affecte rien x[c(0, 1, 2)] # le 0 est ignor x[c(1, NA, 5)] # indices NA retourne NA x[2.6] # fractions tronques vers 0 ## On laisse tomber les 5 derniers lments et on convertit le ## vecteur en une matrice 4 x 5. x <- x[1:20] # ou x[-(21:25)] dim(x) <- c(4, 5); x # ajouter un attribut 'dim' ## Dans l'indiage des matrices et tableaux, l'indice de ## chaque dimension obit aux mmes rgles que ci-dessus. On ## peut aussi indicer une matrice (ou un tableau) avec une ## matrice. Si les exemples ci-dessous ne permettent pas d'en ## comprendre le fonctionnement, consulter la rubrique d'aide ## de la fonction '[' (ou de 'Extract'). x[1, 2] # lment en position (1, 2) x[1, -2] # 1re range sans 2e colonne x[c(1, 3), ] # 1re et 3e ranges x[-1, ] # supprimer 1re range x[, -2] # supprimer 2e colonne
2.10. Exercices
39
x[x[, 1] > 10, ] # lignes avec 1er lment > 10 x[rbind(c(1, 1), c(2, 2))] # lments x[1, 1] et x[2, 2] x[cbind(1:4, 1:4)] # lments x[i, i] (diagonale) diag(x) # idem et plus explicite
2.10
Exercices
> x [[1]] [1] 1 2 3 4 5 $data [,1] [,2] [,3] [1,] [2,] [[3]] [1] 0 0 0 $test [1] FALSE FALSE FALSE FALSE 1 2 3 4 5 6
2.1 a) crire une expression R pour crer la liste suivante :
b) Extraire les tiquettes de la liste. c) Trouver le mode et la longueur du quatrime lment de la liste. d) Extraire les dimensions du second lment de la liste. e) Extraire les deuxime et troisime lments du second lment de la liste. f) Remplacer le troisime lment de la liste par le vecteur 3:8. 2.2 Soit x un vecteur contenant les valeurs suivantes dun chantillon :
> x [1] 9 9 3 16 1 7 1 6 13 1 18 13 4 2 12 2 [17] 18 1 10 12
crire une expression R permettant dextraire les lments suivants. a) Le deuxime lment de lchantillon. b) Les cinq premiers lments de lchantillon. c) Les lments strictement suprieurs 14. d) Tous les lments sauf les lments en positions 6, 10 et 12.
40 2.3 Soit x une matrice 10 7 obtenue alatoirement avec

> x <- matrix(sample(1:100, 70), 7, 10)
Bases du langage R
crire des expressions R permettant dobtenir les lments de la matrice demands ci-dessous. a) Llment (4, 3). b) Le contenu de la sixime ligne. c) Les premire et quatrime colonnes (simultanment). d) Les lignes dont le premier lment est suprieur 50.
3 Oprateurs et fonctions
Connatre les rgles de larithmtique vectorielle caractristique du langage R. Savoir faire lappel dune fonction dans R ; comprendre comment les arguments sont passs la fonction et le traitement des valeurs par dfaut. Connatre et savoir utiliser les oprateurs R les plus courants, notamment pour le traitement des vecteurs, le calcul de sommaires et la manipulation des matrices et tableaux Savoir utiliser la fonction if pour lexcution conditionnelle de commandes R. Distinguer la construction if() ... else de la fonction ifelse. Savoir faire des boucles en R. Savoir choisir entre les oprateurs for, while et repeat lors de la construction dune boucle R.
Ce chapitre prsente les principaux oprateurs arithmtiques, fonctions mathmatiques et structures de contrle disponibles dans R. La liste est videmment loin dtre exhaustive, surtout tant donn lvolution rapide du langage. Un des meilleurs endroits pour dcouvrir de nouvelles fonctions demeure la section See Also des rubriques daide, qui offre des hyperliens vers des fonctions apparentes au sujet de la rubrique.
3.1
Oprations arithmtiques
Lunit de base en R est le vecteur. Les oprations sur les vecteurs sont effectues lment par lment :
> c(1, 2, 3) + c(4, 5, 6) [1] 5 7 9 > 1:3 * 4:6
41
42
Oprateurs et fonctions
[1]
4 10 18
Si les vecteurs impliqus dans une expression arithmtique ne sont pas de la mme longueur, les plus courts sont recycls de faon correspondre au plus long vecteur. Cette rgle est particulirement apparente avec les vecteurs de longueur 1 :
> 1:10 + 2 [1] 3 4 5 6 7 8 9 10 11 12
> 1:10 + rep(2, 10) [1] 3 4 5 6 7 8 9 10 11 12
Si la longueur du plus long vecteur est un multiple de celle du ou des autres vecteurs, ces derniers sont recycls un nombre entier de fois :
> 1:10 + 1:5 + c(2, 4) [1] 4 8 # vecteurs recycls 2 et 5 fois
8 12 12 11 11 15 15 19 # quivalent
> 1:10 + rep(1:5, 2) + rep(c(2, 4), 5) [1] 4 8 8 12 12 11 11 15 15 19
Sinon, le plus court vecteur est recycl un nombre fractionnaire de fois, mais comme ce rsultat est rarement souhait et provient gnralement dune erreur de programmation, un avertissement est afch :
> 1:10 + c(2, 4, 6) [1] 3 6 9 6 9 12 9 12 15 12 Message d'avis : In 1:10 + c(2, 4, 6) : la taille d'un objet plus long n'est pas un multiple de la taille d'un objet plus court
3.2
Oprateurs
Le tableau 3.1 prsente les oprateurs mathmatiques et logiques les plus frquemment employs, en ordre dcroissant de priorit des oprations. Le tableau contient galement les oprateurs dassignation et dextraction prsents au chapitre prcdent ; il est utile de connatre leur niveau de priorit dans les expressions R. Les oprateurs de puissance () et dassignation gauche (<-, <<-) sont valus de droite gauche ; tous les autres de gauche droite. Ainsi, 2 ^ 2 ^ 3 est 2 ^ 8, et non 4 ^ 3, alors que 1 - 1 - 1 vaut -1, et non 1.
3.3. Appels de fonctions
43
Oprateur
$ : %*% %% %/% * / + < <= == >= > != ! & && | || -> ->> <- <<-
Fonction extraction dune liste puissance changement de signe gnration de suites produit matriciel, modulo, division entire multiplication, division addition, soustraction plus petit, plus petit ou gal, gal, plus grand ou gal, plus grand, diffrent de ngation logique et logique ou logique assignation assignation
TAB. 3.1: Principaux oprateurs du langage R, en ordre dcroissant de priorit
3.3
Appels de fonctions
Les oprateurs du tableau 3.1 constituent des raccourcis utiles pour accder aux fonctions les plus courantes de R. Pour toutes les autres, il faut appeler la fonction directement. Cette section passe en revue les rgles dappels dune fonction et la faon de spcier les arguments, quil sagisse dune fonction interne de R ou dune fonction personnelle (voir le chapitre 5). Il ny a pas de limite pratique quant au nombre darguments que peut avoir une fonction. Les arguments dune fonction peuvent tre spcis selon lordre tabli dans la dnition de la fonction. Cependant, il est beaucoup plus prudent et fortement recommand de spcier les arguments par leur nom, avec une construction de la forme nom = valeur, surtout aprs les deux ou trois premiers arguments. Lordre des arguments est important ; il est donc ncessaire de les nommer sils ne sont pas appels dans lordre. Certains arguments ont une valeur par dfaut qui sera utilise si largument nest pas spci dans lappel de la fonction. Par exemple, la dnition de la fonction matrix est la suivante :
44
matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)
La fonction compte cinq arguments : data, nrow, ncol, byrow et dimnames. Ici, chaque argument a une valeur par dfaut (ce nest pas toujours le cas). Ainsi, un appel matrix sans argument rsulte en une matrice 1 1 remplie par colonne (sans importance, ici) de lobjet NA et dont les dimensions sont dpourvues dtiquettes :
> matrix() [,1] [1,] NA
Appel plus labor utilisant tous les arguments. Le premier argument est rarement nomm :
> matrix(1:6, nrow = 2, ncol = 3, byrow = TRUE, + + Gauche Droit dimnames = list(c("Gauche", "Droit"), c("Rouge", "Vert", "Bleu"))) Rouge Vert Bleu 1 4 2 5 3 6
3.4
Quelques fonctions utiles
Le langage R compte un trs grand nombre (des milliers !) de fonctions internes. Cette section en prsente quelques-unes seulement, les fonctions de base les plus souvent utilises pour programmer en R et pour manipuler des donnes. Pour chaque fonction prsente dans les sections suivantes, on fournit un ou deux exemples dutilisation. Ces exemples sont souvent loin de courvrir toutes les utilisations possibles dune fonction. La section 3.7 fournit des exemples additionnels, mais il est recommand de consulter les diverses rubriques daide pour connatre toutes les options des fonctions.
3.4.1
seq
Manipulation de vecteurs
gnration de suites de nombres
> seq(1, 9, by = 2) [1] 1 3 5 7 9
rep
rptition de valeurs ou de vecteurs
3.4. Quelques fonctions utiles

> rep(2, 10) [1] 2 2 2 2 2 2 2 2 2 2 sort
45
tri en ordre croissant ou dcroissant

> sort(c(4, -1, 2, 6)) [1] -1 2 4 6
order
ordre dextraction des lments dun vecteur pour les placer en ordre croissant ou dcroissant
> order(c(4, -1, 2, 6)) [1] 2 3 1 4
rank
rang des lments dun vecteur dans lordre croissant ou dcroissant

> order(c(4, -1, 2, 6)) [1] 2 3 1 4
rev
renverser un vecteur
> rev(1:10) [1] 10 9 8 7 6 5 4 3 2 1
head
extraction des n premiers lments dun vecteur (n > 0) ou suppression des n derniers (n < 0)
> head(1:10, 3); head(1:10, -3) [1] 1 2 3 [1] 1 2 3 4 5 6 7
tail
extraction des n derniers lments dun vecteur (n > 0) ou suppression des n premiers (n < 0)
> tail(1:10, 3); tail(1:10, -3) [1] [1] 8 4 9 10 5 6 7 8 9 10
unique
extraction des lments diffrents dun vecteur

> unique(c(2, 4, 2, 5, 9, 5, 0)) [1] 2 4 5 9 0
3.4.2
Recherche dlments dans un vecteur
Les fonctions de cette sous-section sont toutes illustres avec le vecteur

> x [1] which 4 -1 2 -3 6
positions des valeurs TRUE dans un vecteur boolen
46
> which(x < 0) [1] 2 4 which.min
position du minimum dans un vecteur

> which.min(x) [1] 4
which.max
position du maximum dans un vecteur

> which.max(x) [1] 5
match
position de la premire occurrence dun lment dans un vecteur

> match(2, x) [1] 3
%in%
appartenance dune ou plusieurs valeurs un vecteur

> -1:2 %in% x [1] TRUE FALSE FALSE TRUE
3.4.3
Arrondi

> x [1] -3.6800000 -0.6666667 [5] round 2.5200000 3.1415927 0.3333333
arrondi un nombre dni de dcimales (par dfaut 0)

> round(x) [1] -4 -1 3 0 3 3.142 0.333 2.520 > round(x, 3) [1] -3.680 -0.667
floor
plus grand entier infrieur ou gal largument

> floor(x) [1] -4 -1 3 0 2
ceiling
plus petit entier suprieur ou gal largument

> ceiling(x) [1] -3 0 4 1 3
trunc
troncature vers zro ; diffrent de floor pour les nombres ngatifs

> trunc(x) [1] -3 0 3 0 2
47
3.4.4
Sommaires et statistiques descriptives

> x [1] 14 17 sum, prod 7 9 3 4 25 21 24 11
somme et produit des lments dun vecteur

> sum(x); prod(x) [1] 135 [1] 24938020800
diff
diffrences entre les lments dun vecteur (oprateur mathmatique )

> diff(x) [1] 3 -10 2 -6 1 21 -4 3 -13
mean
moyenne arithmtique (et moyenne tronque avec largument trim)

> mean(x) [1] 13.5
var, sd
variance et cart type (versions sans biais)

> var(x) [1] 64.5
min, max
minimum et maximum dun vecteur

> min(x); max(x) [1] 3 [1] 25
range
vecteur contenant le minimum et le maximum dun vecteur

> range(x) [1] 3 25
median
mdiane empirique
> median(x) [1] 12.5
quantile
quantiles empiriques
> quantile(x) 0% 3.0 25% 50% 75% 100% 7.5 12.5 20.0 25.0
summary
statistiques descriptives dun chantillon

> summary(x) Min. 1st Qu. 3.0 7.5 Median 12.5 Mean 3rd Qu. 13.5 20.0 Max. 25.0
48
3.4.5
Sommaires cumulatifs et comparaisons lment par lment

> x [1] 14 17 7 9 3
cumsum, cumprod
somme et produit cumulatif dun vecteur

> cumsum(x); cumprod(x) [1] 14 31 38 47 50 [1] 14 238 1666 14994 44982
cummin, cummax
minimum et maximum cumulatif

> cummin(x); cummax(x) [1] 14 14 7 7 3 [1] 14 17 17 17 17
pmin, pmax
minimum et maximum en parallle, cest--dire lment par lment entre deux vecteurs ou plus
> pmin(x, c(16, 23, [1] 14 17 [1] 16 23 4 9 3 4, 12, 3)) 3 > pmax(x, c(16, 23, 7 12 4, 12, 3))
3.4.6
Oprations sur les matrices
Les fonctions de cette sous-section sont toutes illustres avec la matrice

> x [,1] [,2] [1,] [2,] nrow, ncol 2 1 4 3
nombre de lignes et de colonnes dune matrice

> nrow(x); ncol(x) [1] 2 [1] 2
rowSums, colSums
sommes par ligne et par colonne, respectivement, des lments dune matrice ; voir aussi la fonction apply la section 6.2

> rowSums(x) [1] 6 4 rowMeans, colMeans
49
moyennes par ligne et par colonne, respectivement, des lments dune matrice ; voir aussi la fonction apply la section 6.2
> colMeans(x) [1] 1.5 3.5
transpose
> t(x) [,1] [,2] [1,] [2,] 2 4 1 3
det
dterminant
> det(x) [1] 2
solve
1) avec un seul argument (une matrice carre) : inverse dune matrice ; 2) avec deux arguments (une matrice carre et un vecteur) : solution du systme dquations linaires Ax = b
> solve(x) [,1] [,2] [1,] 1.5 -2 1 1.5 [2,] -0.5 [1] -2.5
> solve(x, c(1, 2))
diag
1) avec une matrice en argument : diagonale de la matrice ; 2) avec un vecteur en argument : matrice diagonale forme avec le vecteur ; 3) avec un scalaire p en argument : matrice identit p p
> diag(x) [1] 2 3
3.4.7
Produit extrieur
Le produit extrieur nest pas la fonction la plus intuitive utiliser, mais savre extrmement utile pour faire plusieurs oprations en un seul appel de fonction tout en vitant les boucles. La syntaxe de la fonction outer est
outer(X, Y, FUN)
50
Oprateurs et fonctions Le rsultat est lapplication la fonction FUN (prod par dfaut) entre chacun des lments de X et chacun des lments de Y, autrement dit
FUN(X[i], Y[j])
pour toutes les valeurs des indices i et j. La dimension du rsultat est par consquent c(dim(X), dim(Y)). Par exemple, le rsultat du produit extrieur entre deux vecteurs est une matrice contenant tous les produits entre les lments des deux vecteurs :
> outer(c(1, 2, 5), c(2, 3, 6)) [,1] [,2] [,3] [1,] [2,] [3,] 2 4 10 3 6 15 6 12 30
Loprateur %o% est un raccourci de outer(X, Y, prod).
3.5
Structures de contrle
Les structures de contrle sont des commandes qui permettent de dterminer le ux dexcution dun programme : choix entre des blocs de code, rptition de commandes ou sortie force. On se contente, ici, de mentionner les structures de contrle disponibles en R. Se reporter la section 3.7 pour des exemples dutilisation.
3.5.1
Excution conditionnelle
if (condition) branche.vrai else branche.faux
Si condition est vraie, branche.vrai est excute, sinon ce sera branche.faux. Dans le cas o lune ou lautre de branche.vrai ou branche.faux comporte plus dune expression, grouper celles-ci dans des accolades { }.
ifelse(condition, expression.vrai, expression.faux)
Fonction vectorielle qui retourne un vecteur de la mme longueur que condition form ainsi : pour chaque lment TRUE de condition on choisit llment correspondant de expression.vrai et pour chaque lment FALSE on choisit llment correspondant de expression.faux. Lutilisation nest pas trs intuitive, alors examiner attentivement les exemples de la rubrique daide.
3.6. Fonctions additionnelles
51
switch(test, cas.1 = action.1, cas.2 = action.2, ...)
Structure utilise plutt rarement. Consulter la rubrique daide au besoin.
3.5.2
Boucles
Les boucles sont et doivent tre utilises avec parcimonie en R, car elles sont gnralement inefcaces. Dans la majeure partie des cas, il est possible de vectoriser les calculs pour viter les boucles explicites, ou encore de sen remettre aux fonctions outer, apply, lapply sapply et mapply (section 6.2) pour raliser les boucles de manire plus efcace.
for (variable in suite) expression
Excuter expression successivement pour chaque valeur de variable contenue dans suite. Encore ici, on groupera les expressions dans des accolades { }. noter que suite na pas tre compose de nombres conscutifs, ni mme de nombres, en fait.
while (condition) expression
Excuter expression tant que condition est vraie. Si condition est fausse lors de lentre dans la boucle, celle-ci nest pas excute. Une boucle while nest par consquent pas ncessairement toujours excute.
repeat expression
Rpter expression. Cette dernire devra comporter un test darrt qui utilisera la commande break. Une boucle repeat est toujours excute au moins une fois.
break
Sortie immdiate dune boucle for, while ou repeat.

next
Passage immdiat la prochaine itration dune boucle for, while ou repeat.
3.6
Fonctions additionnelles
La bibliothque des fonctions internes de R est divise en ensembles de fonctions et de jeux de donnes apparents nomms packages (terme que lquipe de traduction franaise de R a choisi de conserver tel quel). On dmarrage, R charge automatiquement quelques packages de la bibliothque, ceux contenant les fonctions les plus frquemment utilises. On peut voir la liste des packages dj en mmoire avec
52
> search() [1] ".GlobalEnv" [3] "package:graphics" [5] "package:utils" [7] "package:methods" [9] "package:base" "package:stats" "package:grDevices" "package:datasets" "Autoloads"
et le contenu de toute la bibliothque avec la fonction library (rsultat non montr ici). Une des grandes forces de R est la facilit avec laquelle on peut ajouter des fonctionnalits au systme par le biais de packages externes. Ds les dbuts de R, les dveloppeurs et utilisateurs ont mis sur pied le dpt central de packages Comprehensive R Archive Network (CRAN ; http://cran.r-project.org). Ce site compte aujourdhui plusieurs centaines dextensions et le nombre ne cesse de crotre. Le systme R rend simple de tlcharger et dinstaller de nouveaux packages avec la fonction install.packages. Lannexe C explique plus en dtails comment grer sa bibliothque personnelle et installer des packages externes.
3.7
Exemples
### ### OPRATIONS ARITHMTIQUES ### ## L'arithmtique vectorielle caractristique du langage R ## rend trs simple et intuitif de faire des oprations ## mathmatiques courantes. L o plusieurs langages de ## programmation exigent des boucles, R fait le calcul ## directement. En effet, les rgles de l'arithmtique en R ## sont globalement les mmes qu'en algbre vectorielle et ## matricielle. 5 * c(2, 3, 8, 10) # multiplication par une constante c(2, 6, 8) + c(1, 4, 9) # addition de deux vecteurs c(0, 3, -1, 4)^2 # lvation une puissance ## ## ## ## ## Dans les rgles de l'arithmtique vectorielle, les longueurs des vecteurs doivent toujours concorder. R permet plus de flexibilit en recyclant les vecteurs les plus courts dans une opration. Il n'y a donc peu prs jamais d'erreurs de longueur en R! C'est une arme deux
3.7. Exemples
53
## tranchants: le recyclage des vecteurs facilite le codage, ## mais peut aussi rsulter en des rponses compltement ## errones sans que le systme ne dtecte d'erreur. 8 + 1:10 # 8 est recycl 10 fois c(2, 5) * 1:10 # c(2, 5) est recycl 5 fois c(-2, 3, -1, 4)^1:4 # quatre puissances diffrentes ## On se rappelle que les matrices (et les tableaux) sont des ## vecteurs. Les rgles ci-dessus s'appliquent donc aussi aux ## matrices, ce qui rsulte en des oprateurs qui ne sont pas ## dfinis en algbre linaire usuelle. (x <- matrix(1:4, 2)) # matrice 2 x 2 (y <- matrix(3:6, 2)) # autre matrice 2 x 2 5 * x # multiplication par une constante x + y # addition matricielle x * y # produit *lment par lment* x %*% y # produit matriciel x / y # division *lment par lment* x * c(2, 3) # produit par colonne ### ### OPRATEURS ### ## Seuls les oprateurs %%, %/% et logiques sont illustrs ## ici. Premirement, l'oprateur modulo retourne le reste ## d'une division. 5 %% 2 # 5/2 = 2 reste 1 5 %% 1:5 # remarquer la priodicit 10 %% 1:15 # x %% y = x si x < y ## Le modulo est pratique dans les boucles, par exemple pour ## afficher un rsultat toutes les n itrations seulement. for (i in 1:50) { ## Affiche la valeur du compteur toutes les 5 itrations. if (0 == i %% 5) print(i) } ## La division entire retourne la partie entire de la ## division d'un nombre par un autre. 5 %/% 1:5 10 %/% 1:15
54
## Le ET logique est vrai seulement lorsque les deux ## expressions sont vraies. c(TRUE, TRUE, FALSE) & c(TRUE, FALSE, FALSE) ## Le OU logique est faux seulement lorsque les deux ## expressions sont fausses. c(TRUE, TRUE, FALSE) | c(TRUE, FALSE, FALSE) ## La ngation logique transforme les vrais en faux et vice ## versa. ! c(TRUE, FALSE, FALSE, TRUE) ## On peut utiliser les oprateurs logiques &, | et ! ## directement avec des nombres. Dans ce cas, le nombre zro ## est trait comme FALSE et tous les autres nombres comme ## TRUE. 0:5 & 5:0 0:5 | 5:0 !0:5 ## Ainsi, dans une expression conditionnelle, inutile de ## vrifier si, par exemple, un nombre est gal zro. On ## peut utiliser le nombre directement et sauver des ## oprations de comparaison qui peuvent devenir coteuses en ## temps de calcul. x <- 1 # valeur quelconque if (x != 0) x + 1 # TRUE pour tout x != 0 if (x) x + 1 # tout fait quivalent! ## L'exemple de boucle ci-dessus peut donc tre lgrement ## modifi. for (i in 1:50) { ## Affiche la valeur du compteur toutes les 5 itrations. if (!i %% 5) print (i) } ## Dans les calculs numriques, TRUE vaut 1 et FALSE vaut 0. a <- c("Impair", "Pair") x <- c(2, 3, 6, 8, 9, 11, 12) x %% 2 (!x %% 2) + 1 a[(!x %% 2) + 1]
3.7. Exemples
55
## Un mot en terminant sur l'oprateur '=='. C'est l'oprateur ## utiliser pour vrifier si deux valeurs sont gales, et ## non '='. C'est l une erreur commune --- et qui peut tre ## difficile dtecter --- lorsque l'on programme en R. 5 = 2 # erreur de syntaxe 5 == 2 # comparaison ### ### APPELS DE FONCTIONS ### ## Les invocations de la fonction 'matrix' ci-dessous sont ## toutes quivalentes. On remarquera, entre autres, comment ## les arguments sont spcifis (par nom ou par position). matrix(1:12, 3, 4) matrix(1:12, ncol = 4, nrow = 3) matrix(nrow = 3, ncol = 4, data = 1:12) matrix(nrow = 3, ncol = 4, byrow = FALSE, 1:12) matrix(nrow = 3, ncol = 4, 1:12, FALSE) ### ### QUELQUES FONCTIONS UTILES ### ## MANIPULATION DE VECTEURS x <- c(50, 30, 10, 20, 60, 30, 20, 40)
# vecteur non ordonn
## Squences de nombres. seq(from = 1, to = 10) # quivalent 1:10 seq(-10, 10, length = 50) # incrment automatique seq(-2, by = 0.5, along = x) # mme longueur que 'x' ## Rptition de nombres ou de vecteurs complets. rep(1, 10) # utilisation de base rep(x, 2) # rpter un vecteur rep(x, times = 2, each = 4) # combinaison des arguments rep(x, times = 1:8) # nombre de rptitions diffrent # pour chaque lment de 'x' ## Classement en ordre croissant ou dcroissant. sort(x) # classement en ordre croissant sort(x, decr = TRUE) # classement en ordre dcroissant sort(c("abc", "B", "Aunt", "Jemima")) # chanes de caractres sort(c(TRUE, FALSE)) # FALSE vient avant TRUE
56
## La fonction 'order' retourne la position, dans le vecteur ## donn en argument, du premier lment selon l'ordre ## croissant, puis du deuxime, etc. Autrement dit, on obtient ## l'ordre dans lequel il faut extraire les donnes du vecteur ## pour les obtenir en ordre croissant. order(x) # regarder dans le blanc des yeux x[order(x)] # quivalent 'sort(x)' ## Rang des lments d'un vecteur dans l'ordre croissant. rank(x) # rang des lment de 'x' ## Renverser l'ordre d'un vecteur. rev(x) ## Extraction ou suppression en tte ou en queue de vecteur. head(x, 3) # trois premiers lments head(x, -2) # tous sauf les deux derniers tail(x, 3) # trois derniers lments tail(x, -2) # tous sauf les deux premiers ## Expressions quivalentes sans 'head' et 'tail' x[1:3] # trois premiers lments x[1:(length(x) - 2)] # tous sauf les deux derniers x[(length(x)-2):length(x)] # trois derniers lments rev(rev(x)[1:3]) # avec petits vecteurs seulement x[c(-1, -2)] # tous sauf les deux premiers ## Seulement les lments diffrents d'un vecteur. unique(x) ## RECHERCHE D'LMENTS DANS UN VECTEUR which(x >= 30) # positions des lments >= 30 which.min(x) # position du minimum which.max(x) # position du maximum match(20, x) # position du premier 20 dans 'x' match(c(20, 30), x) # aussi pour plusieurs valeurs 60 %in% x # 60 appartient 'x' 70 %in% x # 70 n'appartient pas 'x' ## ARRONDI (x <- c(-21.2, -pi, -1.5, -0.2, 0, 0.2, 1.7823, 315)) round(x) # arrondi l'entier round(x, 2) # arrondi la seconde dcimale round(x, -1) # arrondi aux dizaines ceiling(x) # plus petit entier suprieur
3.7. Exemples
57
floor(x) trunc(x)
# plus grand entier infrieur # troncature des dcimales
## SOMMAIRES ET STATISTIQUES DESCRIPTIVES sum(x) # somme des lments prod(x) # produit des lments diff(x) # x[2] - x[1], x[3] - x[2], etc. mean(x) # moyenne des lments mean(x, trim = 0.125) # moyenne sans minimum et maximum var(x) # variance (sans biais) (length(x) - 1)/length(x) * var(x) # variance biaise sd(x) # cart type max(x) # maximum min(x) # minimum range(x) # c(min(x), max(x)) diff(range(x)) # tendue de 'x' median(x) # mdiane (50e quantile) empirique quantile(x) # quantiles empiriques quantile(x, 1:10/10) # on peut spcifier les quantiles summary(x) # plusieurs des rsultats ci-dessus ## SOMMAIRES CUMULATIFS ET COMPARAISONS LMENT PAR LMENT (x <- sample(1:20, 6)) (y <- sample(1:20, 6)) cumsum(x) # somme cumulative de 'x' cumprod(y) # produit cumulatif de 'y' rev(cumprod(rev(y))) # produit cumulatif renvers cummin(x) # minimum cumulatif cummax(y) # maximum cumulatif pmin(x, y) # minimum lment par lment pmax(x, y) # maximum lment par lment ## OPRATIONS SUR LES MATRICES (A <- sample(1:10, 16, replace = TRUE)) # avec remise dim(A) <- c(4, 4) # conversion en une matrice 4 x 4 b <- c(10, 5, 3, 1) # un vecteur quelconque A # la matrice 'A' t(A) # sa transpose solve(A) # son inverse solve(A, b) # la solution de Ax = b A %*% solve(A, b) # vrification de la rponse diag(A) # extraction de la diagonale de 'A' diag(b) # matrice diagonale forme avec 'b' diag(4) # matrice identit 4 x 4 (A <- cbind(A, b)) # matrice 4 x 5
58
nrow(A) ncol(A) rowSums(A) colSums(A) apply(A, 1, sum) apply(A, 2, sum) apply(A, 1, prod) ## PRODUIT EXTRIEUR x <- c(1, 2, 4, 7, 10, 12) y <- c(2, 3, 6, 7, 9, 11) outer(x, y) x %o% y outer(x, y, "+") outer(x, y, "<=") outer(x, y, pmax) ### ### STRUCTURES DE CONTRLE ###
# # # # # # #
nombre de lignes de 'A' nombre de colonnes de 'A' sommes par ligne sommes par colonne quivalent 'rowSums(A)' quivalent 'colSums(A)' produit par ligne avec 'apply'
# # # # #
produit extrieur quivalent plus court somme extrieure toutes les comparaisons possibles idem
## Pour illustrer les structures de contrle, on a recours ## un petit exemple tout fait artificiel: un vecteur est ## rempli des nombres de 1 100, l'exception des multiples ## de 10. Ces derniers sont affichs l'cran. ## ## noter qu'il est possible --- et plus efficace --- de ## crer le vecteur sans avoir recours des boucles. (1:100)[-((1:10) * 10)] # sans boucle! rep(1:9, 10) + rep(0:9*10, each = 9) # une autre faon! ## Bon, l'exemple proprement x <- numeric(0) # j <- 0 # for (i in 1:100) { if (i %% 10) # x[j <- j + 1] <- i # else # print(i) # } x # dit... initialisation du contenant 'x' compteur pour la boucle
si i n'est pas un multiple de 10 stocker sa valeur dans 'x' sinon afficher la valeur l'cran vrification
## Mme chose que ci-dessus, mais sans le compteur 'j' et les ## valeurs manquantes aux positions 10, 20, ..., 100 sont
3.7. Exemples
59
## limines la sortie de la boucle. x <- numeric(0) for (i in 1:100) { if (i %% 10) x[i] <- i else print(i) } x <- x[!is.na(x)] x ## On peut refaire l'exemple avec une boucle 'while', mais ## cette structure n'est pas naturelle ici puisque l'on sait ## d'avance qu'il faudra faire la boucle exactement 100 ## fois. Le 'while' est plutt utilis lorsque le nombre de ## rptitions est inconnu. De plus, une boucle 'while' n'est ## pas ncessairement excute puisque le critre d'arrt est ## valu ds l'entre dans la boucle. x <- numeric(0) j <- 0 i <- 1 # pour entrer dans la boucle [*] while (i <= 100) { if (i %% 10) x[j <- j + 1] <- i else print(i) i <- i + 1 # incrmenter le compteur! } x ## La remarque faite au sujet de la boucle 'while' s'applique ## aussi la boucle 'repeat'. Par contre, le critre d'arrt ## de la boucle 'repeat' tant valu la toute fin, la ## boucle est excute au moins une fois. S'il faut faire la ## manoeuvre marque [*] ci-dessus pour s'assurer qu'une ## boucle 'while' est excute au moins une fois... c'est ## qu'il faut utiliser 'repeat'. x <- numeric(0) j <- 0 i <- 1 repeat { if (i %% 10)
60
x[j <- j + 1] <- i else print(i) if (100 < (i <- i + 1)) # incrment et critre d'arrt break } x ### ### FONCTIONS ADDITIONNELLES ### ## La fonction 'search' retourne la liste des environnements ## dans lesquels R va chercher un objet (en particulier une ## fonction). '.GlobalEnv' est l'environnement de travail. search() ## Liste de tous les packages installs sur votre systme. library() ## Chargement du package 'MASS', qui contient plusieurs ## fonctions statistiques trs utiles. library("MASS")
3.8
Exercices
3.1 laide des fonctions rep, seq et c seulement, gnrer les squences suivantes. a) 0 6 0 6 0 6 b) 1 4 7 10 c) 1 2 3 1 2 3 1 2 3 1 2 3 d) 1 2 2 3 3 3 e) 1 1 1 2 2 3 f) 1 5.5 10 g) 1 1 1 1 2 2 2 2 3 3 3 3 3.2 Gnrer les suites de nombres suivantes laide des fonctions : et rep seulement, donc sans utiliser la fonction seq. a) 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2
3.8. Exercices b) 1 3 5 7 9 11 13 15 17 19 c) -2 -1 0 1 2 -2 -1 0 1 2 d) -2 -2 -1 -1 0 0 1 1 2 2 e) 10 20 30 40 50 60 70 80 90 100 3.3 laide de la commande apply, crire des expressions R qui remplaceraient les fonctions suivantes. a) rowSums b) colSums c) rowMeans d) colMeans 3.4 Sans utiliser les fonctions factorial, lfactorial, gamma ou lgamma, gnrer la squence 1 !, 2 !, ..., 10 ! 3.5 Trouver une relation entre x, y, x %% y (modulo) et x %/% y (division entire), o y != 0. 3.6 Simuler un chantillon x = (x 1 , x 2 , x 3 , ..., x 20 ) avec la fonction sample. crire une expression R permettant dobtenir ou de calculer chacun des rsultats demands ci-dessous. a) Les cinq premiers lments de lchantillon. b) La valeur maximale de lchantillon. c) La moyenne des cinq premiers lments de lchantillon. d) La moyenne des cinq derniers lments de lchantillon. 3.7 a) Trouver une formule pour calculer la position, dans le vecteur sous-jacent, de llment (i , j ) dune matrice I J remplie par colonne. b) Rpter la partie a) pour llment (i , j , k ) dun tableau I J K . 3.8 Simuler une matrice mat 10 7, puis crire des expressions R permettant deffectuer les tches demandes ci-dessous. a) Calculer la somme des lments de chacunes des lignes de la matrice. b) Calculer la moyenne des lments de chacunes des colonnes de la matrice. c) Calculer la valeur maximale de la sous-matrice forme par les trois premires lignes et les trois premires colonnes. d) Extraire toutes les lignes de la matrice dont la moyenne des lments est suprieure 7.
61
62
Oprateurs et fonctions 3.9 On vous donne la liste et la date des 31 meilleurs temps enregistrs au 100 mtres homme entre 1964 et 2005 :
> temps <- c(10.06, 10.03, 10.02, + + + + + + + + + + + + + + 9.96, 9.87, 9.82, 9.99, 9.92, 9.85, 9.78, 9.77) 9.95, 10.04, 10.07, 10.08, 9.97, 9.86, 9.79, 9.93, 9.88, 9.80, 9.94, 9.90, 9.89, 10.05, 9.98, 10.09, 10.01, 10.00, 9.91, 9.84,
> names(temps) <- c("1964-10-15", "1968-06-20", "1968-10-13", "1968-10-14", "1968-10-14", "1968-10-14", "1968-10-14", "1975-08-20", "1977-08-11", "1978-07-30", "1979-09-04", "1981-05-16", "1983-05-14", "1983-07-03", "1984-05-05", "1984-05-06", "1988-09-24", "1989-06-16", "1991-06-14", "1991-08-25", "1991-08-25", "1993-08-15", "1994-07-06", "1994-08-23", "1996-07-27", "1996-07-27", "1999-06-16", "1999-08-22", "2001-08-05", "2002-09-14", "2005-06-14")
Extraire de ce vecteur les records du monde seulement, cest--dire la premire fois que chaque temps a t ralis.
4 Exemples rsolus
Mettre en pratique les connaissances acquises dans les chapitres prcdents. Savoir tirer prot de larithmtique vectorielle de R pour effectuer des calculs complexes sans boucles. Utiliser linitialisation de vecteurs et leur indiage de manire rduire le temps de calcul.
Ce chapitre propose de faire le point sur les concepts tudis jusqu maintenant par le biais de quelques exemples rsolus. On y met particulirement en vidence les avantages de lapproche vectorielle du langage R. La comprhension du contexte de ces exemples requiert quelques connaissances de base en mathmatiques nancires et en thorie des probabilits.
4.1
Calcul de valeurs prsentes
De manire gnrale, la valeur prsente dune srie de paiements P 1 , P 2 , . . . , P n la n des annes 1, 2, . . . , n est
n j j =1 k =1
(1 + i k )1 P j ,
(4.1)
o i k est le taux dintrt effectif annuellement durant lanne k. Lorsque le taux dintrt est constant au cours des n annes, cette formule se simplie en
n j =1
(1 + i ) j P j .
(4.2)
Un prt est rembours par une srie de cinq paiements, le premier tant d dans un an. On doit trouver le montant du prt pour chacune des hypothses cidessous. 63
64
Exemples rsolus a) Paiement annuel de 1 000, taux dintrt de 6 % effectif annuellement. Avec un paiement annuel et un taux dintrt constants, on utilise la formule (4.2) avec P j = P = 1 000 :
> 1000 * sum((1 + 0.06)^(-(1:5))) [1] 4212.364
Remarquer comme lexpression R se lit exactement comme la formule mathmatique. b) Paiements annuels de 500, 800, 900, 750 et 1 000, taux dintrt de 6 % effectif annuellement. Les paiements annuels sont diffrents, mais le taux dintrt est toujours le mme. La formule (4.2) sapplique donc directement :
> sum(c(500, 800, 900, 750, 1000) * (1 + 0.06)^(-(1:5))) [1] 3280.681
c) Paiements annuels de 500, 800, 900, 750 et 1 000, taux dintrt de 5 %, 6 %, 5,5 %, 6,5 % et 7 % effectifs annuellement. Avec diffrents paiements annuels et des taux dintrt diffrents, il faut employer la formule (4.1). Le produit cumulatif des taux dintrt est obtenu avec la fonction cumprod :
> sum(c(500, 800, 900, 750, 1000) / + cumprod(1 + c(0.05, 0.06, 0.055, 0.065, 0.07))) [1] 3308.521
4.2
Fonctions de masse de probabilit
On doit calculer toutes ou la majeure partie des probabilits de deux lois de probabilit, puis vrier que la somme des probabilits est bien gale 1. Cet exemple est quelque peu articiel dans la mesure o il existe dans R des fonctions internes pour calculer les principales caractristiques des lois de probabilit les plus usuelles. Nous utiliserons dailleurs ces fonctions pour vrier nos calculs. a) Calculer toutes les masses de probabilit de la distribution binomiale pour des valeurs des paramtres n et p quelconques. La fonction de masse de probabilit de la binomiale est f (x ) = n x p x (1 p )n x , x = 0, . . . , n.
4.2. Fonctions de masse de probabilit Soit n = 10 et p = 0,8. Les coefcients binomiaux sont calculs avec la fonction choose :
> n <- 10 > p <- 0.8 > x <- 0:n > choose(n, x) * p^x * (1 - p)^rev(x) [1] 0.0000001024 0.0000040960 0.0000737280 [4] 0.0007864320 0.0055050240 0.0264241152 [7] 0.0880803840 0.2013265920 0.3019898880 [10] 0.2684354560 0.1073741824
65
On vrie les rponses obtenues avec la fonction interne dbinom :

> dbinom(x, n, prob = 0.8) [1] 0.0000001024 0.0000040960 0.0000737280 [4] 0.0007864320 0.0055050240 0.0264241152 [7] 0.0880803840 0.2013265920 0.3019898880 [10] 0.2684354560 0.1073741824
On vrie enn que les probabilits somment 1 :

> sum(choose(n, x) * p^x * (1 - p)^rev(x)) [1] 1
b) Calculer la majeure partie des masses de probabilit de la distribution de Poisson, dont la fonction de masse de probabilit est f (x ) = o x! = x (x 1) 2 1. x e x! , x = 0, 1, . . . ,
La loi de Poisson ayant un support inni, on calcule les probabilits en x = 0, 1, . . . , 10 seulement avec = 5. On calcule les factorielles avec la fonction factorial. On notera au passage que factorial(x) == gamma(x + 1), o la fonction R gamma calcule les valeurs de la fonction mathmatique du mme nom (n ) = x n 1 e x d x = (n 1)(n 1),
0
avec (0) = 1. Pour n entier, on a donc (n ) = (n 1)!.

> lambda <- 5 > x <- 0:10 > exp(-lambda) * (lambda^x / factorial(x))
66
Exemples rsolus
[1] 0.006737947 0.033689735 0.084224337 [4] 0.140373896 0.175467370 0.175467370 [7] 0.146222808 0.104444863 0.065278039 [10] 0.036265577 0.018132789
Vrication avec la fonction interne dpois :

> dpois(x, lambda) [1] 0.006737947 0.033689735 0.084224337 [4] 0.140373896 0.175467370 0.175467370 [7] 0.146222808 0.104444863 0.065278039 [10] 0.036265577 0.018132789
Pour vrier que les probabilits somment 1, il faudra dabord tronquer le support inni de la Poisson une grande valeur. Ici, 200 est sufsamment loign de la moyenne de la distribution, 5. Remarquer que le produit par e est plac lextrieur de la somme pour ainsi faire un seul produit plutt que 201.
> x <- 0:200 > exp(-lambda) * sum((lambda^x / factorial(x))) [1] 1
4.3
Fonction de rpartition de la loi gamma
La loi gamma est frquemment utilise pour la modlisation dvnements ne pouvant prendre que des valeurs positives et pour lesquels les petites valeurs sont plus frquentes que les grandes. Par exemple, on utilise parfois la loi gamma en sciences actuarielles pour la modlisation des montants de sinistres. Nous utiliserons la paramtrisation o la fonction de densit de probabilit est f (x ) = () x 1 e x , x > 0, (4.3)
o () est la fonction gamma dnie dans lexemple prcdent. Il nexiste pas de formule explicite de la fonction de rpartition de la loi gamma. Nanmoins, la valeur de la fonction de rpartition dune loi gamma de paramtre entier et = 1 peut tre obtenue partir de la formule F (x; , 1) = 1 e x
1 j =0
xj j!
(4.4)
4.3. Fonction de rpartition de la loi gamma a) valuer F (4; 5, 1). Cet exercice est simple puisquil sagit de calculer une seule valeur de la fonction de rpartition avec un paramtre xe. Par une application directe de (4.4), on a :
> alpha <- 5 > x <- 4 > 1 - exp(-x) * sum(x^(0:(alpha - 1))/gamma(1:alpha)) [1] 0.3711631
67
Vrication avec la fonction interne pgamma :

> pgamma(x, alpha) [1] 0.3711631
On peut aussi viter de gnrer essentiellement la mme suite de nombres deux reprises en ayant recours une variable intermdiaire. Au risque de rendre le code un peu moins lisible (mais plus compact !), laffectation et le calcul nal peuvent mme se faire dans une seule expression.
> 1 - exp(-x) * sum(x^(-1 + (j <- 1:alpha))/gamma(j)) [1] 0.3711631
b) valuer F (x; 5, 1) pour x = 2, 3, . . . , 10 en une seule expression. Cet exercice est beaucoup plus compliqu quil ny parat au premier abord. Ici, la valeur de demeure xe, mais on doit calculer, en une seule expression, la valeur de la fonction de rpartition en plusieurs points. Or, cela exige de faire dun coup le calcul x j pour plusieurs valeur de x et plusieurs valeurs de j . Cest un travail pour la fonction outer :
> x <- 2:10 > 1 - exp(-x) * colSums(t(outer(x, 0:(alpha-1), "^")) / + gamma(1:alpha)) [1] 0.05265302 0.18473676 0.37116306 0.55950671 [5] 0.71494350 0.82700839 0.90036760 0.94503636 [9] 0.97074731
Vrication avec la fonction interne pgamma :

> pgamma(x, alpha) [1] 0.05265302 0.18473676 0.37116306 0.55950671 [5] 0.71494350 0.82700839 0.90036760 0.94503636 [9] 0.97074731
68
Exemples rsolus Il est laiss en exercice de dterminer pourquoi la transpose est ncessaire dans lexpression ci-dessus. Excuter lexpression tape par tape, de lintrieur vers lextrieur, pour mieux comprendre comment on arrive faire le calcul en (4.4).
4.4
Algorithme du point fixe
Trouver la racine dune fonction g cest--dire le point x o g (x ) = 0 est un problme classique en mathmatiques. Trs souvent, il est possible de reformuler le problme de faon plutt chercher le point x o f (x ) = x. La solution dun tel problme est appele point xe. Lalgorithme du calcul numrique du point xe dune fonction f (x ) est trs simple : 1. choisir une valeur de dpart x 0 ; 2. calculer x n = f (x n 1 ) pour n = 1, 2, . . . ; 3. rpter ltape 2 jusqu ce que x n x n 1 < ou x n x n 1 1 (1 + i )10 i x n 1 < . On doit trouver, laide de la mthode du point xe, la valeur de i telle que a 10 =
= 8,21,
cest dire le taux de rendement dune srie de 10 versements de 1 pour laquelle on a pay un montant de 8,21. Puisque, dune part, nous ignorons combien de fois la procdure itrative devra tre rpte et que, dautre part, il faut excuter la procdure au moins une fois, le choix logique pour la structure de contrle utiliser dans cette procdure itrative est repeat. De plus, il faut comparer deux valeurs successives du taux dintrt, nous devrons donc avoir recours deux variables. On a :
> i <- 0.05 > repeat + { + + + + + } > i [1] 0.03756777 it <- i i <- (1 - (1 + it)^(-10))/8.21 if (abs(i - it)/it < 1E-10) break
4.5. Suite de Fibonacci Vrication :

> (1 - (1 + i)^(-10))/i [1] 8.21
69
Nous verrons au chapitre 5 comment crer une fonction partir de ce code.
4.5
Suite de Fibonacci
La suite de Fibonacci est une suite de nombres entiers trs connue. Les deux premiers termes de la suite sont 0 et 1 et tous les autres sont la somme des deux termes prcdents. Mathmatiquement, les valeurs de la suite de Fibonacci sont donnes par la fonction f (0 ) = 0 f (1 ) = 1 f (n ) = f ( n 1 ) + f ( n 2 ), n 2.
Le quotient de deux termes successifs converge vers (1 + 5) 2, le nombre dor. On veut calculer les n > 2 premiers termes de la suite de Fibonacci. Ce problme tant intrinsquement rcursif, nous devons utiliser une boucle. Voici une premire solution pour n = 10 :
> n <- 10 > x <- c(0, 1) > for (i in 3:n) x[i] <- x[i - 1] + x[i - 2] > x [1] 0 1 1 2 3 5 8 13 21 34
La procdure ci-dessus a un gros dfaut : la taille de lobjet x est constamment augmente pour stocker une nouvelle valeur de la suite. Tentons une analogie alimentaire pour cette manire de procder. Pour ranger des biscuits frais sortis du four, on prend un premier biscuit et on le range dans un plat ne pouvant contenir quun seul biscuit. Arriv au second biscuit, on constate que le contenant nest pas assez grand, alors on sort un plat pouvant contenir deux biscuits, on change le premier biscuit de plat et on y range aussi le second biscuit. Arriv au troisime biscuit, le petit mange recommence, et ainsi de suite jusqu ce que le plateau de biscuit soit puis. Cest exactement ce qui se passe dans la mmoire de lordinateur avec la procdure ci-dessus, lodeur des bons biscuits chauds en moins. En effet, le systme
70
Exemples rsolus doit constamment allouer de la nouvelle mmoire et dplacer les termes dj sauvegards au fur et mesure que le vecteur x grandit. On aura compris quune telle faon de faire est viter absolument lorsque cest possible et a lest la plupart du temps. Quand on sait quelle sera la longueur dun objet, comme cest le cas dans cet exemple, il vaut mieux crer un contenant vide de la bonne longueur et le remplir par la suite. Cela nous donne une autre faon de calculer la suite de Fibonacci :
> n <- 10 > x <- numeric(n) > x[2] <- 1 > x [1] 0 1 1 2 3 5 8 13 21 34 # contenant cr # x[1] vaut dj 0
> for (i in 3:n) x[i] <- x[i - 1] + x[i - 2]
Dans les exemples du chapitre 5, nous composeront des fonctions avec ces deux exemples et nous comparerons les temps de calcul pour n grand.
4.6
Exercices
Dans chacun des exercices ci-dessous, crire une expression R pour faire le calcul demand. Parce quelles ne sont pas ncessaires, il est interdit dutiliser des boucles. 4.1 Calculer la valeur prsente dune srie de paiements fournie dans un vecteur P en utilisant les taux dintrt annuels dun vecteur i. 4.2 tant donn un vecteur dobservations x = (x 1 , . . . , x n ) et un vecteur de poids correspondants w = (w 1 , . . . , w n ), calculer la moyenne pondre des observations, n wi xi , w i =1 o w = n=1 w i . Tester lexpression avec les vecteurs de donnes i x = (7, 13, 3, 8, 12, 12, 20, 11) et w = (0,15, 0,04, 0,05, 0,06, 0,17, 0,16, 0,11, 0,09).
4.6. Exercices 4.3 Soit un vecteur dobservations x = (x 1 , . . . , x n ). Calculer la moyenne harmonique de ce vecteur, dnie comme n 1 x1
71
+ +
1 xn
Tester lexpression avec les valeurs de lexercice 4.2. 4.4 Calculer la fonction de rpartition en x = 5 dune loi de Poisson avec paramtre = 2, qui est donne par
5 k =0
2k e 2 k!
o k! = 1 2 k. 4.5 a) Calculer lesprance dune variable alatoire X dont le support est x = 1, 10, 100, . . . , 1 000 000 et les probabilits correspondantes sont 1 2 7 , , . . . , 28 , dans lordre. 28 28 b) Calculer la variance de la variable alatoire X dnie en a). 4.6 Calculer le taux dintrt nominal compos quatre fois par anne, i (4) , quivalent un taux de i = 6 % effectif annuellement. 4.7 La valeur prsente dune srie de n paiements de n danne un taux dintrt i effectif annuellement est a n = v + v 2 + + v n = 1 vn i ,
o v = (1 + i )1 . Calculer en une seule expression, toujours sans boucle, un tableau des valeurs prsentes de sries de n = 1, 2, . . . , 10 paiements chacun des taux dintrt effectifs annuellement i = 0,05, 0,06, . . . , 0,10. 4.8 Calculer la valeur prsente dune annuit croissante de 1 $ payable annuellement en dbut danne pendant 10 ans si le taux dactualisation est de 6 %. Cette valeur prsente est donne par I a 10 = toujours avec v = (1 + i )1 . 4.9 Calculer la valeur prsente de la squence de paiements 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 si les paiements sont effectus en n danne et que le taux dactualisation est de 7 %.
10 k =1
kv k 1 ,
72
Exemples rsolus 4.10 Calculer la valeur prsente de la squence de paiements dnie lexercice 4.9 en supposant que le taux dintrt dactualisation alterne successivement entre 5 % et 8 % chaque anne, cest--dire que le taux dintrt est de 5 %, 8 %, 5 %, 8 %, etc.
5 Fonctions dfinies par lusager
Savoir dnir une fonction R, ses divers arguments et, le cas chant, les valeurs par dfaut de ceux-ci. tre en mesure de dboguer une fonction R. Adopter un style de codage correspondant la pratique en R.
La possibilit pour lusager de dnir facilement et rapidement de nouvelles fonctions et donc des extensions au langage est une des grandes forces de R. Les fonctions personnelles dnies dans lespace de travail ou dans un package sont traites par le systme exactement comme les fonction internes. Ce court chapitre passe en revue la syntaxe et les rgles pour crer des fonctions dans R. On discute galement brivement de dbogage et de style de codage.
5.1
Dfinition dune fonction
On dnit une nouvelle fonction avec la syntaxe suivante :

fun <- function(arguments) expression
o
fun est le nom de la fonction (les rgles pour les noms de fonctions tant les
mmes que celles prsentes la section 2.2 pour tout autre objet) ;
arguments est la liste des arguments, spars par des virgules ; expression constitue le corps de la fonction, soit une expression ou un groupe
dexpressions runies par des accolades. 73
74
Fonctions dnies par lusager
5.2
Retourner des rsultats
La plupart des fonctions sont crites dans le but de retourner un rsultat. Or, les rgles dinterprtation dun groupe dexpressions prsentes la section 2.1 sappliquent ici au corps de la fonction. Une fonction retourne tout simplement le rsultat de la dernire expression du corps de la fonction. On vitera donc que la dernire expression soit une affectation, car la fonction ne retournera alors rien et on ne pourra utiliser une construction de la forme x <- f() pour affecter le rsultat de la fonction une variable. Si on doit retourner un rsultat sans tre la dernire ligne de la fonction ( lintrieur dun bloc conditionnel, par exemple), on utilise la fonction return. Lutilisation de return la toute n dune fonction est tout fait inutile et considre comme du mauvais style en R. Lorsquune fonction doit retourner plusieurs rsultats, il est en gnral prfrable davoir recours une liste nomme.
5.3
Variables locales et globales
Comme la majorit des langages de programmation, R comporte des concepts de variable locale et de variable globale. Toute variable dnie dans une fonction est locale cette fonction, cest--dire quelle : napparat pas dans lespace de travail ; ncrase pas une variable du mme nom dans lespace de travail. Il est possible de dnir une variable dans lespace de travail depuis une fonction avec loprateur daffectation <<-. Il est trs rare et gnralement non recommand de devoir recourir de telles variables globales. On peut dnir une fonction lintrieur dune autre fonction. Cette fonction sera locale la fonction dans laquelle elle est dnie. Le lecteur intress en savoir plus pourra consulter les sections de la documentation de R portant sur la porte lexicale (lexical scoping). Cest un sujet important et intressant, mais malheureusement trop avanc pour ce document dintroduction la programmation en R.
5.4. Exemple de fonction
75
fp <- function(k, n, start = 0.05, TOL = 1E-10) { ## Fonction pour trouver par la mthode du point ## fixe le taux d'intrt pour lequel une srie de ## 'n' paiements vaut 'k'. ## ## ARGUMENTS ## ## ## ## ## ## RETOURNE ## ## Le taux d'intrt i <- start repeat { it <- i i <- (1 - (1 + it)^(-n))/k if (abs(i - it)/it < TOL) break } i } k: la valeur prsente des paiements n: le nombre de paiements TOL: niveau de prcision souhait
## start: point de dpart des itrations
F IG . 5.1: Exemple de fonction de point xe
5.4
Exemple de fonction
Le code dvelopp pour lexemple de point xe de la section 4.4 peut tre intgr dans une fonction ; voir la gure 5.1. Le nom de la fonction est fp. La fonction compte quatre arguments : k, n, start et TOL.
76
Fonctions dnies par lusager Les deux derniers arguments ont des valeurs par dfaut de 0,05 et 1010 , respectivement. La fonction retourne la valeur de la variable i.
5.5
Fonctions anonymes
Il est parfois utile de dnir une fonction sans lui attribuer un nom do la notion de fonction anonyme. Il sagira en gnral de fonctions courtes utilises dans une autre fonction. Par exemple, pour calculer la valeur de x y 2 pour toutes les combinaisons de x et y stockes dans des vecteurs du mme nom, on pourrait utiliser la fonction outer ainsi :
> x <- 1:3; y <- 4:6 > f <- function(x, y) x * y^2 > outer(x, y, f) [,1] [,2] [,3] [1,] [2,] [3,] 16 32 48 25 50 75 36 72 108
Cependant, si la fonction f ne sert rien ultrieurement, on peut se contenter de passer lobjet fonction outer sans jamais lui attribuer un nom :
> outer(x, y, function(x, y) x * y^2) [,1] [,2] [,3] [1,] [2,] [3,] 16 32 48 25 50 75 36 72 108
On a alors utilis dans outer une fonction anonyme.
5.6
Dbogage de fonctions
Il est assez rare darriver crire un bout de code sans bogue du premier coup. Par consquent, qui dit programmation dit sances de dbogage. Les techniques de dbogages les plus simples et naves sont parfois les plus efcaces et certainement les plus faciles apprendre. Loin dun trait sur le dbogage de code R, nous offrons seulement ici quelques trucs que nous utilisons rgulirement.
5.7. Styles de codage Les erreurs de syntaxe sont les plus frquentes (en particulier loubli de virgules). Lors de la dnition dune fonction, une vrication de la syntaxe est effectue par linterprte R. Attention, cependant : une erreur peut prendre sa source plusieurs lignes avant celle que linterprte pointe comme faisant problme. Les messages derreur de linterprte ne sont pas toujours dun grand secours. . . tant que lon na pas appris les reconnatre. Un exemple de message derreur frquemment rencontr :
valeur manquante l o TRUE / FALSE est requis
77
Cette erreur provient gnralement dune commande if dont largument vaut NA plutt que TRUE ou FALSE. La raison : des valeurs manquantes se sont faules dans les calculs notre insu jusqu linstructions if, qui naccepte que des valeurs boolennes en arguement. Lorsquune fonction ne retourne pas le rsultat attendu, placer des commandes print lintrieur de la fonction, de faon pouvoir suivre les valeurs prises par les diffrentes variables. Par exemple, la modication suivante la boucle de la fonction fp permet dafcher les valeurs successives de la variable i et de dtecter une procdure itrative divergente :
repeat { it <- i i <- (1 - (1 + it)^(-n))/k print(i) if (abs((i - it)/it < TOL)) break }
Quand ce qui prcde ne fonctionne pas, ne reste souvent qu excuter manuellement la fonction. Pour ce faire, dnir dans lespace de travail tous les arguments de la fonction, puis excuter le corps de la fonction ligne par ligne. La vrication du rsultat de chaque ligne permet gnralement de retrouver la ou les expressions qui causent problme.
5.7
Styles de codage
Si tous conviennent que ladoption dun style propre et uniforme favorise le dveloppement et la lecture de code, il existe plusieurs chapelles dans le monde
78
Fonctions dnies par lusager des programmeurs quant la bonne faon de prsenter et, surtout, dindenter le code informatique. Par exemple, Emacs reconnat et supporte les styles de codage suivants, entre autres : C++/Stroustrup
for (i in 1:10) { expression }
K&R (1TBS)
for (i in 1:10){ expression }
Whitesmith
GNU
Pour des raisons gnrales de lisibilit et de popularit, le style C++, avec les accolades sur leurs propres lignes et une indentation de quatre (4) espaces est considr comme standard pour la programmation en R. La version de GNU Emacs distribue par lauteur est dj congure pour utiliser ce style de codage. Consulter la documentation de votre diteur de texte pour savoir si vous pouvez congurer le niveau dindentation. La plupart des bons diteurs pour programmeurs le permettent. Surtout, viter de ne pas du tout indenter le code.
5.8
Exemples
### POINT FIXE ## Comme premier exemple de fonction, on ralise une mise en ## oeuvre de l'algorithme du point fixe pour trouver le taux ## d'intrt tel que a_angle{n} = k pour 'n' et 'k' donns.
5.8. Exemples
79
## Cette mise en oeuvre est peu gnrale puisqu'il faudrait ## modifier la fonction chaque fois que l'on change la ## fonction f(x) dont on cherche le point fixe. fp1 <- function(k, n, start = 0.05, TOL = 1E-10) { i <- start repeat { it <- i i <- (1 - (1 + it)^(-n))/k if (abs(i - it)/it < TOL) break } i } fp1(7.2, 10) fp1(7.2, 10, 0.06) i start # # # # valeur de dpart par dfaut valeur de dpart spcifie les variables n'existent pas... ... dans l'espace de travail
## Gnralisation de la fonction 'fp1': la fonction f(x) dont ## on cherche le point fixe (c'est--dire la valeur de 'x' ## tel que f(x) = x) est passe en argument. On peut faire ## a? Bien sr, puisqu'une fonction est un objet comme un ## autre en R. On ajoute galement la fonction un argument ## 'echo' qui, lorsque TRUE, fera en sorte d'afficher ## l'cran les valeurs successives de 'x'. ## ## Ci-dessous, il est implicite que le premier argument, FUN, ## est une fonction. fp2 <- function(FUN, start, echo = FALSE, TOL = 1E-10) { x <- start repeat { xt <- x if (echo) print(xt) x <- FUN(xt) # inutile de faire 'if (echo == TRUE)'
# appel de la fonction
if (abs(x - xt)/xt < TOL) break
80
} x } f <- function(i) (1 - (1+i)^(-10))/7.2 # dfinition de f(x) fp2(f, 0.05) # solution fp2(f, 0.05, echo = TRUE) # avec rsultats intermdiaires fp2(function(x) 3^(-x), start = 0.5) # avec fonction anonyme ## Amlioration mineure la fonction 'fp2': puisque la ## valeur de 'echo' ne change pas pendant l'excution de la ## fonction, on peut viter de refaire le test chaque ## itration de la boucle. Une solution lgante consiste ## utiliser un outil avanc du langage R: les expressions. ## ## L'objet cr par la fonction 'expression' est une ## expression non encore value (comme si on n'avait pas ## appuy sur Entre la fin de la ligne). On peut ensuite ## valuer l'expression (appuyer sur Entre) avec 'exec'. fp3 <- function(FUN, start, echo = FALSE, TOL = 1E-10) { x <- start ## Choisir l'expression excuter plus loin if (echo) expr <- expression(print(xt <- x)) else expr <- expression(xt <- x) repeat { eval(expr) x <- FUN(xt)
# valuer l'expression # appel de la fonction
if (abs(x - xt)/xt < TOL) break } x } fp3(f, 0.05, echo = TRUE) # avec rsultats intermdiaires fp3(function(x) 3^(-x), start = 0.5) # avec une fonction anonyme ### SUITE DE FIBONACCI
5.8. Exemples
81
## On a prsent au chapitre 4 deux manires diffrentes de ## pour calculer les 'n' premires valeurs de la suite de ## Fibonacci. On cre d'abord des fonctions partir de ce ## code. Avantage d'avoir des fonctions: elles sont valides ## pour tout 'n' > 2. ## ## D'abord la version inefficace. fib1 <- function(n) { res <- c(0, 1) for (i in 3:n) res[i] <- res[i - 1] + res[i - 2] res } fib1(10) fib1(20) ## Puis la version supposement plus efficace. fib2 <- function(n) { res <- numeric(n) # contenant cr res[2] <- 1 # res[1] vaut dj 0 for (i in 3:n) res[i] <- res[i - 1] + res[i - 2] res } fib2(5) fib2(20) ## A-t-on vraiment gagn en efficacit? Comparons le temps ## requis pour gnrer une longue suite de Fibonacci avec les ## deux fonctions. system.time(fib1(10000)) # version inefficace system.time(fib2(10000)) # version efficace ## ## ## ## ## ## ## ## ## Variation sur un mme thme: une fonction pour calculer non pas les 'n' premires valeurs de la suite de Fibonacci, mais uniquement la 'n'ime valeur. Mais il y a un mais: la fonction 'fib3' est truffe d'erreurs (de syntaxe, d'algorithmique, de conception). vous de trouver les bogues. (Afin de prserver cet exemple, copier le code erron plus bas ou dans un autre fichier avant d'y faire les corrections.)
82
fib3 <- function(nb) { x <- 0 x1 _ 0 x2 <- 1 while (n > 0)) x <- x1 + x2 x2 <- x1 x1 <- x n <- n - 1 } fib3(1) fib3(2) fib3(5) fib3(10) fib3(20)
# # # # #
devrait devrait devrait devrait devrait
donner donner donner donner donner
0 1 3 34 4181
5.9
Exercices
5.1 La fonctions var calcule lestimateur sans biais de la variance dune population partir de lchantillon donn en argument. crire une fonction variance qui calculera lestimateur biais ou sans biais selon que largument biased sera TRUE ou FALSE, respectivement. Le comportement par dfaut de variance devrait tre le mme que celui de var. Lestimateur sans biais de la variance partir dun chantillon X 1 , . . . , X n est
2 S n 1 =
n 1 i =1
( X i X )2 ,
alors que lestimateur biais est

2 Sn =
n i =1
( X i X )2 ,
o X = n 1 ( X 1 + + X n ). 5.2 crire une fonction matrix2 qui, contrairement la fonction matrix, remplira par dfaut la matrice par ligne. La fonction ne doit pas utiliser matrix. Les arguments de la fonction matrix2 seront les mmes que ceux de matrix, sauf que largument byrow sera remplac par bycol. 5.3 crire une fonction phi servant calculer la fonction de densit de probabilit dune loi normale centre rduite, soit
2 1 (x ) = e x 2 , 2
< x < .
5.9. Exercices La fonction devrait prendre en argument un vecteur de valeurs de x. Comparer les rsultats avec ceux de la fonction dnorm. 5.4 crire une fonction Phi servant calculer la fonction de rpartition dune loi normale centre rduite, soit ( x ) =
x
83
1 2
e y
d y,
< x < .
Supposer, pour le moment, que x 0. Lvaluation numrique de lintgrale ci-dessus peut se faire avec lidentit ( x ) = 1 2
+ (x )
x 2n +1
n =0 1 3 5
(2n + 1)
x 0.
Utiliser la fonction phi de lexercice 5.3 et tronquer la somme innie une grande valeur, 50 par exemple. La fonction ne doit pas utiliser de boucles, mais peut ne prendre quune seule valeur de x la fois. Comparer les rsultats avec ceux de la fonction pnorm. 5.5 Modier la fonction Phi de lexercice 5.4 an quelle admette des valeurs de x ngatives. Lorsque x < 0, (x ) = 1 (x ). La solution simple consiste utiliser une structure de contrle if ... else, mais les curieux chercheront sen passer. 5.6 Gnraliser maintenant la fonction de lexercice 5.5 pour quelle prenne en argument un vecteur de valeurs de x. Ne pas utiliser de boucle. Comparer les rsultats avec ceux de la fonction pnorm. 5.7 Sans utiliser loprateur %*%, crire une fonction prod.mat qui effectuera le produit matriciel de deux matrices seulement si les dimensions de celles-ci le permettent. Cette fonction aura deux arguments (mat1 et mat2) et devra tout dabord vrier si le produit matriciel est possible. Si celui-ci est impossible, la fonction retourne un message derreur. a) Utiliser une structure de contrle if ... else et deux boucles. b) Utiliser une structure de contrle if ... else et une seule boucle. Dans chaque cas, comparer le rsultat avec loprateur %*%. 5.8 Vous devez calculer la note nale dun groupe dtudiants partir de deux informations : 1) une matrice contenant la note sur 100 des tudiants chacune des valuations, et 2) un vecteur contenant la pondration des valuations. Un de vos collgues a compos la fonction notes.finales ci-dessous an de faire le calcul de la note nale pour chacun de ses tudiants. Votre collgue
84
Fonctions dnies par lusager vous mentionne toutefois que sa fonction est plutt lente et inefcace pour de grands groupes dtudiants. Modiez la fonction an den rduire le nombre doprations et faire en sorte quelle nutilise aucune boucle.
notes.finales <- function(notes, p) { netud <- nrow(notes) neval <- ncol(notes) final <- (1:netud) * 0 for(i in 1:netud) { for(j in 1:neval) { final[i] <- final[i] + notes[i, j] * p[j] } } final }
5.9 Trouver les erreurs qui empchent la dnition de la fonction ci-dessous.

AnnuiteFinPeriode <- function(n, i) {{ v <- 1/1 + i) ValPresChaquePmt <- v^(1:n) sum(ValPresChaquepmt) }
5.10 La fonction ci-dessous calcule la valeur des paramtres dune loi normale, gamma ou Pareto partir de la moyenne et de la variance, qui sont connues par lutilisateur.
param <- function(moyenne, variance, loi) { loi <- tolower(loi) if (loi == "normale") param1 <- moyenne param2 <- sqrt(variance) return(list(mean = param1, sd = param2)) if (loi == "gamma") param2 <- moyenne/variance
5.9. Exercices
85
param1 <- moyenne * param2 return(list(shape = param1, scale = param2)) if (loi == "pareto") cte <- variance/moyenne^2 param1 <- 2 * cte/(cte-1) param2 <- moyenne * (param1 - 1) return(list(alpha = param1, lambda = param2)) stop("La loi doit etre une de \"normale\", \"gamma\" ou \"pareto\"") }
Lutilisation de la fonction pour diverses lois donne les rsultats suivants :

> param(2, 4, "normale") $mean [1] 2 $sd [1] 2 > param(50, 7500, "gamma") Erreur dans param(50, 7500, "gamma") : Objet "param1" non trouv > param(50, 7500, "pareto") Erreur dans param(50, 7500, "pareto") : Objet "param1" non trouv
a) Expliquer pour quelle raison la fonction se comporte ainsi. b) Appliquer les correctifs ncessaires la fonction pour que celle-ci puisse calculer les bonnes valeurs. (Les erreurs ne se trouvent pas dans les mathmatiques de la fonction.) Astuce : tirer prot du moteur dindentation de votre diteur de texte pour programmeur.
6 Concepts avancs
Savoir passer des valeurs une fonction via largument .... Savoir effectuer des sommaires sur des tableaux laide de la fonction apply. Savoir rduire des listes avec les fonctions lapply, sapply et mapply ; connatre les diffrences entre ces fonctions. Comprendre comment la classe dun objet peut modier le traitement quen feront les fonctions gnriques.
Ce chapitre traite de divers concepts et fonctions un peu plus avancs du langage R, dont les fonctions de la famille apply auxquelles nous avons fait rfrence quelques reprises dans les chapitres prcdents. Ce sont des fonctions dune grande importance en R.
6.1
Argument ...
La mention ... apparat dans la dnition de plusieurs fonctions en R. Il ne faut pas voir l de la paresse de la part des rdacteurs des rubriques daide, mais bel et bien un argument formel dont ... est le nom. Cet argument signie quune fonction peut accepter un ou plusieurs autres arguments autres que ceux faisant partie de sa dnition. Le contenu de largument ... nest ni pris en compte, ni modi par la fonction. Il est gnralement simplement pass tel quel une autre fonction qui, elle, saura traiter les arguments qui lui sont ainsi passs. Pour des exemples, voir les dnitions des fonctions apply, lapply et sapply, ci-dessous. 87
88
Concepts avancs
6.2
Fonction apply
La fonction apply sert appliquer une fonction quelconque sur une partie dune matrice ou, plus gnralement, dun tableau. La syntaxe de la fonction est la suivante :
apply(X, MARGIN, FUN, ...),
o
X est une matrice ou un tableau ; MARGIN est un vecteur dentiers contenant la ou les dimensions de la matrice ou
du tableau sur lesquelles la fonction doit sappliquer ;

FUN est la fonction appliquer ;
... est un ensemble darguments supplmentaires, spars par des virgules, passer la fonction FUN. Lorsque X est une matrice, apply sert principalement calculer des sommaires par ligne (dimension 1) ou par colonne (dimension 2) autres que la somme ou la moyenne (puisque les fonctions rowSums, colSums, rowMeans et colMeans existent pour ce faire). Utiliser la fonction apply plutt que des boucles puisque celle-ci est plus efcace. Considrer les exemples suivants :
> (x <- matrix(sample(1:100, 20, rep = TRUE), 5, 4)) [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,] [5,] 27 38 58 91 21 90 95 67 63 7 21 18 69 39 77 50 72 100 39 78 # variance par ligne 335.000 612.000 1376.917 # minimum par colonne
> apply(x, 1, var) [1] 978.000 1181.583
> apply(x, 2, min) [1] 21 7 18 39
> apply(x, 1, mean, trim = 0.2) # moyenne tronque par ligne [1] 47.00 55.75 73.50 58.00 45.75
Puisquil nexiste pas de fonctions internes pour effectuer des sommaires sur des tableaux, il faut toujours utiliser la fonction apply.
6.2. Fonction apply Si X est un tableau de plus de deux dimensions, alors largument pass FUN peut tre une matrice ou un tableau. Lorsque X est un tableau trois dimensions et que MARGIN est de longueur 1, cela quivaut appliquer la fonction FUN sur des tranches (des matrices) de X. Si MARGIN est de longueur 2, on applique FUN sur des carottes (des vecteurs) tires de X. Truc mnmotechnique : la ou les dimensions absentes de MARGIN sont celles qui disparaissent aprs le passage de apply. Considrer les exemples suivants :
> (x <- array(sample(1:10, 80, rep = TRUE), c(3, 3, 4))) , , 1 [,1] [,2] [,3] [1,] [2,] [3,] , , 2 [,1] [,2] [,3] [1,] [2,] [3,] , , 3 [,1] [,2] [,3] [1,] [2,] [3,] , , 4 [,1] [,2] [,3] [1,] [2,] [3,] 5 8 7 5 9 5 3 1 1 # dterminants des quatre matrices 3 x 3 8 5 9 7 8 6 6 8 1 4 5 6 5 2 9 7 8 2 10 3 7 2 3 4 1 4 9
89
> apply(x, 3, det)
90
Concepts avancs
[1]
103
149 -103
-54 # sommes des trois tranches horizontales
> apply(x, 1, sum) [1] 63 64 66
> apply(x, c(1, 2), sum) # sommes des neuf carottes horizontales [,1] [,2] [,3] [1,] [2,] [3,] 27 21 29 19 22 24 17 21 13
> apply(x, c(1, 3), sum) # sommes des 12 carottes transversales [,1] [,2] [,3] [,4] [1,] [2,] [3,] 13 10 20 16 15 17 21 21 16 13 18 13
> apply(x, c(2, 3), sum) # sommes des 12 carottes verticales [,1] [,2] [,3] [,4] [1,] [2,] [3,] 20 9 14 15 16 17 22 21 15 20 19 5
6.3
Fonctions lapply et sapply
Les fonctions lapply et sapply sont similaires la fonction apply en ce quelles permettent dappliquer une fonction aux lments dune structure le vecteur ou la liste en loccurrence. Leur syntaxe est similaire :
lapply(X, FUN, ...) sapply(X, FUN, ...)
La fonction lapply applique une fonction FUN tous les lments dun vecteur ou dune liste X et retourne le rsultat sous forme de liste. Le rsultat est donc :
list(FUN(X[[1]], ...), FUN(X[[2]], ...), FUN(X[[3]], ...), ...)
Les lments de X sont passs comme la fonction FUN sans tre nomms. Les rgles habituelles dvaluation dun appel de fonction sappliquent. Par consquent, les lments de X seront considrs comme les premiers arguments de FUN moins que des arguments nomms dans ... aient prsance.
6.3. Fonctions lapply et sapply Par exemple, on cre une liste forme de quatre vecteurs alatoires de taille 5, 6, 7 et 8.
> (x <- lapply(5:8, sample, x = 1:10)) [[1]] [1] [[2]] [1] 3 2 4 7 8 5 [[3]] [1] [[4]] [1] 5 6 8 4 3 1 7 2 8 4 9 2 1 10 6 7 4 3 10 9
91
Le premier argument de la fonction sample est x. Dans lexpression ci-dessus, cet argument est pass la fonction via largument .... Par consquent, les valeurs successives de 5:8 servent comme deuxime argument la fonction sample, soit la taille de lchantillon. On peut ensuite calculer la moyenne de chacun des vecteurs obtenus ci-dessus, toujours sans faire de boucle :
> lapply(x, mean) [[1]] [1] 6.6 [[2]] [1] 4.833333 [[3]] [1] 5.714286 [[4]] [1] 4.5
La fonction sapply est similaire lapply, sauf que le rsultat est retourn sous forme de vecteur, si possible. Le rsultat est donc simpli par rapport celui de lapply, do le nom de la fonction. Dans lexemple ci-dessus, il est souvent plus utile dobtenir les rsultats sous la forme dun vecteur :
92
Concepts avancs
> sapply(x, mean) [1] 6.600000 4.833333 5.714286 4.500000
Si le rsultat de chaque application de la fonction est un vecteur et que les vecteurs sont tous de la mme longueur, alors sapply retourne une matrice, remplie comme toujours par colonne :
> (x <- lapply(rep(5, 3), sample, x = 1:10)) [[1]] [1] 6 2 9 5 4 [[2]] [1] [[3]] [1] 6 5 8 4 9 > sapply(x, sort) [,1] [,2] [,3] [1,] [2,] [3,] [4,] [5,] 2 4 5 6 9 1 4 6 7 10 4 5 6 8 9 1 10 6 7 4
Dans un grand nombre de cas, il est possible de remplacer les boucles for par lutilisation de lapply ou sapply. On ne saurait donc trop insister sur limportance de ces fonctions.
6.4
Fonction mapply
La fonction mapply est une version multidimensionnelle de sapply. Sa syntaxe est, essentiellement,
mapply(FUN, ...)
Le rsultat de mapply est lapplication de la fonction FUN aux premiers lments de tous les arguments contenus dans ..., puis tous les seconds lments, et ainsi de suite. Ainsi, si v et w sont des vecteurs, mapply(FUN, v, w) retourne sous forme de liste, de vecteur ou de matrice, selon le cas, FUN(v[1], w[1]), FUN(v[2], w[2]), etc.
6.5. Fonction replicate Par exemple :

> mapply(rep, 1:4, 4:1) [[1]] [1] 1 1 1 1 [[2]] [1] 2 2 2 [[3]] [1] 3 3 [[4]] [1] 4
93
Les lments de ... sont recycls au besoin.

> mapply(seq, 1:6, 6:8) [[1]] [1] 1 2 3 4 5 6 [[2]] [1] 2 3 4 5 6 7 [[3]] [1] 3 4 5 6 7 8 [[4]] [1] 4 5 6 [[5]] [1] 5 6 7 [[6]] [1] 6 7 8
6.5
Fonction replicate
La fonction replicate est une fonction enveloppante de sapply simpliant la syntaxe pour lexcution rpte dune expression.
94
Concepts avancs Son usage est particulirement indiqu pour les simulations. Ainsi, on peut construire une fonction fun qui fait tous les calculs dune simulation, puis obtenir les rsultats pour, disons, 10 000 simulations avec
> replicate(10000, fun(...))
Lannexe B prsente en dtail diffrentes stratgies dont lutilisation de la fonction replicate pour la ralisation dtudes de simulation en R.
6.6
Classes et fonctions gnriques
Dans le langage R, tous les objets ont une classe. La classe est parfois implicite ou drive du mode de lobjet (consulter la rubrique daide de class pour de plus amples dtails). Certaines fonctions, dites fonctions gnriques, se comportent diffremment selon la classe de lobjet donn en argument. Les fonctions gnriques les plus frquemment employes sont print, plot et summary. Une fonction gnrique possde une mthode correspondant chaque classe quelle reconnat et, gnralement, une mthode default pour les autres objets. La liste des mthodes existant pour une fonction gnrique sobtient avec la fonction methods :
> methods(plot) [1] plot.acf* plot.data.frame* [3] plot.decomposed.ts* plot.default [5] plot.dendrogram* [7] plot.ecdf [9] plot.formula* [11] plot.hclust* [13] plot.HoltWinters* [15] plot.lm [17] plot.mlm [19] plot.prcomp* [21] plot.profile.nls* [23] plot.stepfun [25] plot.table* [27] plot.tskernel* plot.density plot.factor* plot.function plot.histogram* plot.isoreg* plot.medpolish* plot.ppr* plot.princomp* plot.spec plot.stl* plot.ts plot.TukeyHSD
Non-visible functions are asterisked
6.7. Exemples chaque mthode methode dune fonction gnrique fun correspond une fonction fun.methode. Cest donc la rubrique daide de cette dernire fonction quil faut consulter au besoin, et non celle de la fonction gnrique, qui contient en gnral peu dinformations. Il est intressant de savoir que lorsque lon tape le nom dun objet la ligne de commande pour voir son contenu, cest la fonction gnrique print qui est appele. On peut donc compltement modier la reprsentation lcran du contenu dun objet en crant une nouvelle classe et une nouvelle mthode pour la fonction print.
95
6.7
Exemples
### ### FONCTION 'apply' ### ## Cration d'une matrice et d'un tableau trois dimensions ## pour les exemples. m <- matrix(sample(1:100, 20), nrow = 4, ncol = 5) a <- array(sample(1:100, 60), dim = 3:5) ## Les fonctions 'rowSums', 'colSums', 'rowMeans' et ## 'colMeans' sont des raccourcis pour des utilisations ## frquentes de 'apply'. rowSums(m) # somme par ligne apply(m, 1, sum) # idem, mais moins lisible colMeans(m) # somme par colonne apply(m, 2, mean) # idem, mais moins lisible ## Puisqu'il n'existe pas de fonctions comme 'rowMax' ou ## 'colProds', il faut utiliser 'apply'. apply(m, 1, max) # maximum par ligne apply(m, 2, prod) # produit par colonne ## L'argument '...' de 'apply' permet de passer des arguments ## la fonction FUN. m[sample(1:20, 5)] <- NA # ajout de donnes manquantes apply(m, 1, var, na.rm = TRUE) # variance par ligne sans NA ## Lorsque 'apply' est utilise sur un tableau, son rsultat ## est de dimensions dim(X)[MARGIN], d'o le truc ## mnmotechnique donn dans le texte du chapitre.
96
Concepts avancs
apply(a, c(2, 3), sum) apply(a, 1, prod)
# le rsultat est une matrice # le rsultat est un vecteur
## L'utilisation de 'apply' avec les tableaux peut rapidement ## devenir confondante si l'on ne visualise pas les calculs ## qui sont raliss. On reprend ici les exemples du chapitre ## en montrant comment l'on calculerait le premier lment de ## chaque utilisation de 'apply'. Au besoin, retourner ## l'indiage des tableaux au chapitre 2. (x <- array(sample(1:10, 80, rep = TRUE), c(3, 3, 4))) apply(x, 3, det) # dterminants des quatre matrices 3 x 3 det(x[, , 1]) # quivalent pour le premier dterminant apply(x, 1, sum) sum(x[1, , ]) # sommes des trois tranches horizontales # quivalent pour la premire somme
apply(x, c(1, 2), sum) # sommes des neuf carottes horizontales sum(x[1, 1, ]) # quivalent pour la premire somme apply(x, c(1, 3), sum) # sommes des 12 carottes transversales sum(x[1, , 1]) # quivalent pour la premire somme apply(x, c(2, 3), sum) # sommes des 12 carottes verticales sum(x[, 1, 1]) # quivalent pour la premire somme ### ### FONCTIONS 'lapply' ET 'sapply' ### ## La fonction 'lapply' applique une fonction tous les ## lments d'une liste et retourne une liste, peu importe les ## dimensions des rsultats. La fonction 'sapply' retourne un ## vecteur ou une matrice, si possible. ## ## Somme interne des lments d'une liste. (x <- list(1:10, c(-2, 5, 6), matrix(3, 4, 5))) sum(x) # erreur lapply(x, sum) # sommes internes (liste) sapply(x, sum) # sommes internes (vecteur) ## Cration de la suite 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, ..., 1, ## 2, ..., 9, 10. lapply(1:10, seq) # le rsultat est une liste unlist(lapply(1:10, seq)) # le rsultat est un vecteur
6.7. Exemples
97
## Soit une fonction calculant la moyenne pondre d'un ## vecteur. Cette fonction prend en argument une liste de deux ## lments: 'donnees' et 'poids'. fun <- function(liste) sum(liste$donnees * liste$poids)/sum(liste$poids) On peut maintenant calculer la moyenne pondre de plusieurs ensembles de donnes runis dans une liste itre. <- list(list(donnees = 1:7, poids = (5:11)/56), list(donnees = sample(1:100, 12), poids = 1:12), list(donnees = c(1, 4, 0, 2, 2), poids = c(12, 3, 17, 6, 2)))) sapply(x, fun) # aucune boucle explicite! ### ### FONCTION 'mapply' ### ## Cration de quatre chantillons alatoires de taille 12. x <- lapply(rep(12, 4), sample, x = 1:100) ## Moyennes tronques 0, 10, 20 et 30%, respectivement, de ## ces quatre chantillons alatoires. mapply(mean, x, 0:3/10) ### ### FONCTION 'replicate' ### ## La fonction 'replicate' va rpter un certain nombre de ## fois une expression quelconque. Le principal avantage de ## 'replicate' sur 'sapply' est qu'on n'a pas se soucier des ## arguments passer une fonction. ## ## Par exemple, on veut simuler dix chantillons alatoires ## indpendants de longueur 12. On peut utiliser 'sapply', ## mais la syntaxe n'est ni lgante, ni facile lire ## (l'argument 'i' ne sert rien). sapply(rep(1, 10), function(i) sample(1:100, 12)) ## En utilisant 'replicate', on sait tout de suite de quoi il ## s'agit. noter que les chantillons se trouvent dans les ## ## ## (x
98
Concepts avancs
## colonnes de la matrice rsultante. replicate(10, sample(1:100, 12)) ## Vrification que la moyenne arithmtique (bar{X}) est un ## estimateur sans biais de la moyenne de la loi normale. On ## doit calculer la moyenne de plusieurs chantillons ## alatoires, puis la moyenne de toutes ces moyennes. ## ## On dfinit d'abord une fonction pour faire une simulation. ## Remarquer que dans la fonction ci-dessous, 'mean' est tour ## tour le nom d'un argument (qui pourrait aussi bien tre ## toto) et la fonction pour calculer une moyenne. fun <- function(n, mean, sd) mean(rnorm(n, mean = mean, sd = sd)) ## Avec 'replicate', on fait un grand nombre de simulations. x <- replicate(10000, fun(100, 0, 1)) # 10000 simulations hist(x) # distribution de bar{X} mean(x) # moyenne de bar{X} ### ### CLASSES ET FONCTIONS GNRIQUES ### ## Pour illustrer les classes et fonctions gnriques, on ## reprend la fonction de point fixe 'fp3' des exemples du ## chapitre 5 en y faisant deux modifications: ## ## 1. ajout d'un compteur pour le nombre d'itrations; ## 2. la fonction retourne une liste de classe 'fp' ## contenant diverses informations relatives la ## procdure de point fixe. ## ## Ainsi, la fonction 'fp4' retourne un objet qui peut ensuite ## tre manipul par des mthodes de fonctions gnriques. ## C'est l'approche de programmation objet favorise dans le ## langage R. fp4 <- function(FUN, start, echo = FALSE, TOL = 1E-10) { x <- start # valeur de dpart i <- 0 # compteur des itrations if (echo) expr <- expression(print(xt <- x)) else
6.7. Exemples
99
expr <- expression(xt <- x) repeat { eval(expr) x <- FUN(xt) i <- i + 1 # nouvelle valeur # incrmenter le compteur
if (abs(x - xt)/xt < TOL) break } structure(list(fixed.point = x, # point fixe nb.iter = i, # nombre d'itrations fun = FUN, # fonction f(x) x0 = start, # valeur de dpart TOL = TOL), # prcision relative class = "fp") } ## On cre maintenant des mthodes pour la classe 'fp' pour ## les fonctions gnriques les plus courantes, soit 'print', ## 'summary' et 'plot'. ## ## La mthode de 'print' sera utilise pour afficher seulement ## la valeur du point fixe. C'est en quelque sorte ## l'utilisation la plus simple de la fonction 'fp4'. ## ## La mthode de 'summary' fournira un peu plus d'informations ## sur la procdure de point fixe. ## ## Enfin, la mthode de 'plot' fera un graphique de la ## fonction f(x) et son intersection avec la droite y = x. print.fp <- function(x) print(x$fixed.point) summary.fp <- function(x) { if (class(x) != "fp") stop("object is not of class 'fp'") cat("Function:\n ") print(x$fun) cat("\n") cat("Fixed point:\n ", x$fixed.point, fill = TRUE)
100
Concepts avancs
cat("\n") cat("Number of iterations:\n ", x$nb.iter, fill = TRUE) cat("\n") cat("Precision:\n ", x$TOL, fill = TRUE) } plot.fp <- function(x, ...) { ## Valeur du point fixe fp <- x$fixed.point ## Il faut dterminer un intervalle pour lequel tracer la ## fonction. Celui-ci est dtermin de faon arbitraire ## comme un multiple de la distance entre la valeur de ## dpart et la valeur du point fixe. r <- abs(x$x0 - fp) ## Fonction tracer FUN <- x$fun ## Fonction y = x. 'FUN2' est ncessaire parce que 'curve' ## n'admet pas de fonctions anonymes en argument. FUN2 <- function(x) x ## Graphique de la fonction 'FUN' curve(FUN, from = fp - 3 * r, to = fp + 3 * r, xlab = "x", ylab = "f(x)", lwd = 2) ## Ajout de la droite 'FUN2' au graphique curve(FUN2, add = TRUE, lwd = 1) ## Ajout d'un point sur le point fixe points(fp, FUN(fp), ...) } ## Exemples d'utilisation x <- fp4(function(x) 3^(-x), x # summary(x) # plot(x) # plot(x, pch = 21, # bg = "orange", # cex = 2, lwd = 2) # ###
start = 0.5) affichage de 'print.fp' plus d'information graphique de base graphique plus labor... ... consulter la rubrique ... d'aide de 'par'
6.7. Exemples
101
### OPRATEURS EN TANT QUE FONCTIONS ### ## Les oprateurs reprsents par des caractres spciaux sont ## des fonctions comme les autres. On peut donc les appeler ## comme toute autre fonction. (En fait, l'interprte R fait ## cette traduction l'interne.) x <- sample(1:100, 12) # un vecteur x + 2 # appel usuel "+"(x, 2) # quivalent x[c(3, 5)] # extraction usuelle "["(x, c(3, 5)) # quivalent x[1] <- 0; x # assignation usuelle "[<-"(x, 2, 0) # quivalent ( x[2] <- 0) ## D'une part, cela explique pourquoi il faut placer les ## oprateurs entre guillemets (" ") lorsqu'on les utilise ## dans les fonctions comme 'outer', 'lapply', etc. outer(x, x, +) # erreur de syntaxe outer(x, x, "+") # correct ## D'autre part, cela permet d'utiliser les oprateurs ## d'extraction "[" et "[[" dans de telles fonctions. Par ## exemple, voici comment extraire le deuxime lment de ## chaque lment d'une liste. (x <- list(1:4, 8:2, 6:12, -2:2)) # liste quelconque x[[1]][2] # 2e lment du 1er lment x[[2]][2] # 2e lment du 2e lment x[[3]][2] # 2e lment du 3e lment x[[4]][2] # 2e lment du 4e lment lapply(x, "[", 2) # mme chose en une ligne sapply(x, "[", 2) # rsultat sous forme de vecteur ### ### COMMENT JOUER DES TOURS AVEC R ### ## Redfinir un oprateur dans l'espace de travail de ## quelqu'un... "+" <- function(x, y) x * y # redfinition de "+" 5 + 2 # ouch! ls() # tratrise dvoile... rm("+") # ... puis limine 5 + 2 # c'est mieux
102
Concepts avancs
## Faire croire qu'une fonction fait autre chose que ce ## qu'elle fait en ralit. Si l'attribut "source" d'une ## fonction existe, c'est son contenu qui est affich lorsque ## l'on examine une fonction. f <- function(x, y) x + y # vraie fonction attr(f, "source") <- "function(x, y) x * y" # ce qui est affich f # une fonction pour faire le produit? f(2, 3) # non! str(f) # structure de l'objet attr(f, "source") <- NULL # attribut "source" effac f # c'est mieux ## Redfinir la mthode de 'print' pour une classe d'objet... ## Ici, l'affichage d'un objet de classe "lm" cause la ## fermeture de R! print.lm <- function(x) q("ask") x <- rnorm(10) y <- x + 2 + rnorm(10) lm(y ~ x) # chantillon alatoire # modle de rgression linaire # rpondre "c"!
6.8
Exercices
6.1 lexercice 4.2, on a calcul la moyenne pondre dun vecteur dobservations n wi Xi , Xw = w i =1 o w = n=1 w i . Si lon a plutt une matrice n p dobservations X i j , on peut i dnir les moyennes pondres Xi w = Xw j = et Xww =
n p p j =1 n i =1
wi j wi wi j w j
Xi j , Xi j ,
wi = w j =
p j =1 n i =1
wi j wi j
wi j w
i =1 j =1
Xi j ,
w =
i =1 j =1
wi j .
De mme, on peut dnir des moyennes pondres calcules partir dun tableau de donnes X i j k de dimensions n p r dont la notation suit la mme
6.8. Exercices logique que ci-dessus. crire des expressions R pour calculer, sans boucle, les moyennes pondres suivantes. a) X i w en supposant une matrice de donnes n p. b) X w j en supposant une matrice de donnes n p. c) X w w en supposant une matrice de donnes n p. d) X i j w en supposant un tableau de donnes n p r . e) X i w w en supposant un tableau de donnes n p r . f) X w j w en supposant un tableau de donnes n p r . g) X w w w en supposant un tableau de donnes n p r . 6.2 Gnrer les suites de nombres suivantes laide dexpressions R. (videmment, il faut trouver un moyen de gnrer les suites sans simplement concatner les diffrentes sous-suites.) a) 0, 0, 1, 0, 1, 2, . . . , 0, 1, 2, 3, . . . , 10. b) 10, 9, 8, . . . , 2, 1, 10, 9, 8, . . . 3, 2, . . . , 10, 9, 10. c) 10, 9, 8, . . . , 2, 1, 9, 8, . . . , 2, 1, . . . , 2, 1, 1. 6.3 La fonction de densit de probabilit et la fonction de rpartition de la loi de Pareto de paramtres et sont, respectivement, f (x ) = et F (x ) = 1 x +
103
(x + )+1
La fonction suivante simule un chantillon alatoire de taille n issu dune distribution de Pareto de paramtres et :
rpareto <- function(n, alpha, lambda) lambda * (runif(n)^(-1/alpha) - 1)
a) crire une expression R utilisant la fonction rpareto ci-dessus qui permet de simuler cinq chantillons alatoires de tailles 100, 150, 200, 250 et 300 dune loi de Pareto avec = 2 et = 5 000. Les chantillons alatoires devraient tre stocks dans une liste. b) On vous donne lexemple suivant dutilisation de la fonction paste :
> paste("a", 1:5, sep = "")
104
Concepts avancs
[1] "a1" "a2" "a3" "a4" "a5"
Nommer les lments de la liste cre en a) sample1, . . ., sample5. c) Calculer la moyenne de chacun des chantillons alatoires obtenus en a). Retourner le rsultat dans un vecteur. d) valuer la fonction de rpartition de la loi de Pareto(2, 5 000) en chacune des valeurs de chacun des chantillons alatoires obtenus en a). Retourner les valeurs de la fonction de rpartition en ordre croissant. e) Faire lhistogramme des donnes du cinquime chantillon alatoire avec la fonction hist. f) Ajouter 1 000 toutes les valeurs de tous les chantillons simuls en a), ceci an dobtenir des observations dune distribution de Pareto translate. 6.4 Une base de donnes contenant toutes les informations sur les assurs est stocke dans une liste de la faon suivante :
> x[[1]] $num.police [1] 1001 $franchise [1] 500 $nb.acc [1] 0 1 1 0 $montants [1] 3186.864 3758.389 > x[[2]] $num.police [1] 1002 $franchise [1] 250 $nb.acc [1] 4 0 0 4 1 1 0 $montants [1] 16728.7354 1414.7264 1825.7495 282.5609
6.8. Exercices
105
[5]
1684.6686
14869.1731 2775.3161
7668.4196
2501.7257
[9] 108979.3725
Ainsi, x[[i]] contient les informations relatives lassur i . Sans utiliser de boucles, crire des expressions ou des fonctions R qui permettront de calculer les quantits suivantes. a) La franchise moyenne dans le portefeuille. b) Le nombre annuel moyen de rclamations par assur. c) Le nombre total de rclamations dans le portefeuille. d) Le montant moyen par accident dans le portefeuille. e) Le nombre dassurs nayant eu aucune rclamation. f) Le nombre dassurs ayant eu une seule rclamation dans leur premire anne. g) La variance du nombre total de sinistres. h) La variance du nombre de sinistres pour chaque assur. i) La probabilit empirique quune rclamation soit infrieure x (un scalaire) dans le portefeuille. j) La probabilit empirique quune rclamation soit infrieure x (un vecteur) dans le portefeuille.
7 Fonctions doptimisation
Connatre et savoir utiliser les diffrentes fonctions de calcul de racines de R. Connatre et savoir utiliser les diffrentes fonctions doptimisation de R. Savoir reformuler un problme doptimisation en base logarithmique pour viter les difcults numriques.
7.1
Contexte
Les mthodes de bissection, du point xe, de NewtonRaphson et consorts permettent de rsoudre des quations une variable de la forme f (x ) = 0 ou g (x ) = x. Il existe galement des versions de ces mthodes pour les systmes plusieurs variables de la forme f 1 (x 1 , x 2 , x 3 ) = 0 f 2 (x 1 , x 2 , x 3 ) = 0 f 3 (x 1 , x 2 , x 3 ) = 0. De tels systmes dquations surviennent plus souvent quautrement lors de loptimisation dune fonction. Par exemple, en recherchant le maximum ou le minimum dune fonction f (x, y ), on souhaitera rsoudre le systme dquations x y f (x, y ) = 0 f (x, y ) = 0.
En infrence statistique, les fonctions doptimisation sont frquemment employes pour calculer numriquement des estimateurs du maximum de vraisemblance. 107
108
Fonctions doptimisation La grande majorit des suites logicielles de calcul comportent des outils doptimisation de fonctions. Ce chapitre passe en revue les fonctions disponibles dans R. Comme pour les chapitres prcdents, des exemples dutilisation de chacune des fonctions se trouvent dans le code informatique de la section 7.4.
7.2
Fonctions doptimisation et de calcul de racines
Le systme R compte un certain nombre de fonctions pour trouver numriquement le minimum ou le maximum dune fonction ainsi que pour calculer la racine dune fonction dans un intervalle ou toutes les racines dun polynme. Ces fonctions diffrent par certaines de leurs fonctionnalits et leur interface, mais aussi par les algorithmes utiliss. Consulter les rubriques daide pour les dtails.
7.2.1
Fonction uniroot
La fonction uniroot recherche la racine dune fonction dans un intervalle. Cest donc la fonction de base pour trouver la solution (unique) de lquation f (x ) = 0 dans un intervalle dtermin.
7.2.2
Fonction optimize
La fonction optimize recherche le minimum local (par dfaut) ou le maximum local dune fonction dans un intervalle donn.
7.2.3
Fonction nlm
La fonction nlm minimise une fonction non linaire sur un nombre arbitraire de paramtres.
7.2.4
Fonction nlminb
La fonction nlminb est similaire nlm, sauf quelle permet de spcier des bornes infrieure et/ou suprieure pour les paramtres. Attention, toutefois : les arguments de la fonction ne sont ni les mmes, ni dans le mme ordre que ceux de nlm.
7.2.5
Fonction optim
La fonction optim est loutil doptimisation tout usage de R. ce titre, la fonction est souvent utilise par dautres fonctions. Elle permet de choisir parmi plu-
7.3. Pour en savoir plus sieurs algorithmes doptimisation diffrents et, selon lalgorithme choisi, de xer des seuils minimum et/ou maximum aux paramtres optimiser.
109
7.2.6 polyroot
En terminant, un mot sur polyroot(), qui nest pas proprement parler une fonction doptimisation, mais qui pourrait tre utilise dans ce contexte. La fonction polyroot calcule toutes les racines (complexes) du polynme n=0 a i x i . Le i premier argument est le vecteur des coefcients a 0 , a 1 , . . . , a n , dans cet ordre.
7.3
Pour en savoir plus
Les packages disponible sur CRAN fournissent plusieurs autres outils doptimisation pour R. Pour un bon rsum des options disponibles, consulter la CRAN Task View consacre loptimisation :
http://cran.r-project.org/web/views/Optimization.html
7.4
Exemples
### ### FONCTION 'uniroot' ### ## La fonction 'uniroot' recherche la racine d'une fonction ## 'f' dans un intervalle spcifi soit comme une paire de ## valeurs dans un argument 'interval', soit via des arguments ## 'lower' et 'upper'. ## ## On calcule la solution de l'quation x - 2^(-x) = 0 dans ## l'intervalle [0, 1]. f <- function(x) x - 2^(-x) # fonction uniroot(f, c(0, 1)) # appel simple uniroot(f, lower = 0, upper = 1) # quivalent ## On peut aussi utiliser 'uniroot' avec une fonction anonyme. uniroot(function(x) x - 2^(-x), lower = 0, upper = 1) ### ### FONCTION 'optimize' ###
110
Fonctions doptimisation
## On cherche le maximum local de la densit d'une loi bta ## dans l'intervalle (0, 1), son domaine de dfinition. (Ce ## problme est facile rsoudre explicitement.) ## ## Les arguments de 'optimize' sont essentiellement les mmes ## que ceux de 'uniroot'. Ici, on utilise aussi l'argument ## '...' pour passer les paramtres de la loi bta 'dbeta'. ## ## Par dfaut, la fonction recherche un minimum. Il faut donc ## lui indiquer de rechercher plutt un maximum. optimize(dbeta, interval = c(0, 1), maximum = TRUE, shape1 = 3, shape2 = 2) ## On pourrait aussi avoir recours une fonction auxiliaire. ## Moins lgant et moins flexible. f <- function(x) dbeta(x, 3, 2) optimize(f, lower = 0, upper = 1, maximum = TRUE) ### ### FONCTION 'nlm' ### ## Pour la suite, nous allons donner des exemples ## d'utilisation des fonctions d'optimisation dans un contexte ## d'estimation des paramtres d'une loi gamma par la mthode ## du maximum de vraisemblance. ## ## On commence par se donner un chantillon alatoire de la ## loi. videmment, pour ce faire nous devons connatre les ## paramtres de la loi. C'est un exemple fictif. set.seed(1) # toujours le mme chantillon x <- rgamma(10, 5, 2) ## ## ## ## ## ## ## ## ## ## ## ## Les estimateurs du maximum de vraisemblance des paramtres 'shape' et 'rate' de la loi gamma sont les valeurs qui maximisent la fonction de vraisemblance prod(dgamma(x, shape, rate)) ou, de manire quivalente, qui minimisent la fonction de log-vraisemblance ngative -sum(log(dgamma(x, shape, rate))). On remarquera au passage que les fonctions de calcul de
7.4. Exemples
111
## densits de lois de probabilit dans R ont un argument ## 'log' qui, lorsque TRUE, retourne la valeur du logarithme ## (naturel) de la densit de manire plus prcise qu'en ## prenant le logarithme aprs coup. Ainsi, pour faire le ## calcul ci-dessus, on optera plutt, pour l'expression ## ## -sum(dgamma(x, shape, rate, log = TRUE)) ## ## La fonction 'nlm' suppose que la fonction optimiser ## passe en premier argument a elle-mme comme premier ## argument le vecteur 'p' des paramtres optimiser. Le ## second argument de 'nlm' est un vecteur de valeurs de ## dpart, une pour chaque paramtre. ## ## Ainsi, pour trouver les estimateurs du maximum de ## vraisemblance avec la fonction 'nlm' pour l'chantillon ## ci-dessus, on doit d'abord dfinir une fonction auxiliaire ## conforme aux attentes de 'nlm' pour calculer la fonction de ## log-vraisemblance ( un signe prs). f <- function(p, x) -sum(dgamma(x, p[1], p[2], log = TRUE)) ## L'appel de 'nlm' est ensuite tout simple. Remarquer comment ## on passe notre chantillon alatoire (contenu dans l'objet ## 'x') comme second argument 'f' via l'argument '...' de ## 'nlm'. Le fait que l'argument de 'f' et l'objet contenant ## les valeurs portent le mme nom est sans importance. R sait ## faire la diffrence entre l'un et l'autre. nlm(f, c(1, 1), x = x) ## ## ## ## ## ## ## ## ## f2 { L'optimisation ci-dessus a gnr des avertissements? C'est parce que la fonction d'optimisation s'est gare dans les valeurs ngatives, alors que les paramtres d'une gamma sont strictement positifs. Cela arrive souvent. On peut pallier ce problme avec le truc suivant: plutt que d'estimer les paramtres eux-mmes, on estime leurs logarithmes. Ceux-ci demeurent alors valides sur tout l'axe des rels. <- function(logp, x) p <- exp(logp) # retour aux paramtres originaux -sum(dgamma(x, p[1], p[2], log = TRUE)) } nlm(f2, c(0, 0), x = x)
112
Fonctions doptimisation
## Les valeurs obtenues ci-dessus sont toutefois les ## estimateurs des logarithmes des paramtres de la loi gamma. ## On retrouve les estiamteurs des paramtres en prenant ## l'exponentielle des rponses. exp(nlm(f2, c(0, 0), x = x)$estimate) ### ### FONCTION 'nlminb' ### ## L'utilisation de la fonction 'nlminb' peut s'avrer ## intressante dans notre contexte puisque l'on sait que les ## paramtres d'une loi gamma sont strictement positifs. nlminb(c(1, 1), f, x = x, lower = 0, upper = Inf) ### ### FONCTION 'optim' ### ## La fonction 'optim' est trs puissante, mais requiert ## une bonne dose de prudence. Ses principaux arguments ## ## par: un vecteur contenant les valeurs initiales des ## paramtres; ## fn: la fonction minimiser. Le premier argument de ## doit tre le vecteur des paramtres. ## ## Comme pour les autres fonctions tudies ci-dessus, on ## passer des arguments 'fn' (les donnes, par exemple) ## le biais de l'argument '...' de 'optim'. optim(c(1, 1), f, x = x) aussi sont:
fn
peut par
## L'estimation par le maximum de ## vraisemblance\index{vraisemblance} est de beaucoup ## simplifie par l'utilisation de la fonction ## \fonction{fitdistr} du package ## \texttt{MASS}\index{package!MASS@\texttt{MASS}}. ### ### FONCTION 'polyroot' ### ## Racines du polynme x^3 + 4 x^2 - 10. Les rponses sont ## donnes sous forme de nombre complexe. Utiliser les ## fonctions 'Re' et 'Im' pour extraire les parties relles et
7.5. Exercices
113
## imaginaires des polyroot(c(-10, 0, Re(polyroot(c(-10, Im(polyroot(c(-10,
nombres, respectivement. 4, 1)) # racines 0, 4, 1))) # parties relles 0, 4, 1))) # parties imaginaires
7.5
Exercices
7.1 Trouver la solution des quations suivantes laide des fonctions R appropries. a) x 3 2x 2 5 = 0 pour 1 x 4 b) x 3 + 3x 2 1 = 0 pour 4 x 0 c) x 2x = 0 pour 0 x 1 d) e x + 2x + 2 cos x 6 = 0 pour 1 x 2 e) e x x 2 + 3x 2 = 0 pour 0 x 1 7.2 En thorie de la crdibilit, lestimateur dun paramtre a est donn sous forme de point xe 1 n a= z i ( X i X z )2 , n 1 i =1 o aw i + s 2 n zi Xz = Xi z i =1 et X 1 , . . . , X n , w 1 , . . . , w n et s 2 sont des donnes. Calculer la valeur de a si s 2 = 140 000 000 et que les valeurs de X i et w i sont telles quelles apparaissent dans le tableau ci-dessous. i Xi wi 1 2 061 100 155 2 1 511 19 895 3 1 806 13 735 4 1 353 4 152 5 1 600 36 110 zi = aw i
7.3 Les fonctions de densit de probabilit et de rpartition de la distribution de Pareto sont donnes lexercice 6.3. Calculer les estimateurs du maximum de vraisemblance des paramtres de la Pareto partir dun chantillon alatoire obtenu par simulation avec la commande
> x <- lambda * (runif(100)^(-1/alpha) - 1)
pour des valeurs de alpha et lambda choisies.
8 Gnrateurs de nombres alatoires

Savoir gnrer des nombres alatoires uniformes avec la fonction runif. Savoir gnrer des nombres alatoires non uniformes provenant de lois de probabilit discrtes et continues. Savoir gnrer des nombres alatoires provenant dune distribution discrte quelconque. Savoir tirer prot de la nature vectorielle des fonctions de simulation de R.
Avant dutiliser pour quelque tche de simulation moindrement importante un gnrateur de nombres alatoires inclus dans un logiciel, il importe de sassurer de la qualit de cet outil. On trouvera en gnral relativement facilement de linformation dans Internet. On prsente ici, sans entrer dans les dtails, les gnrateurs de nombres uniformes utiliss dans R ainsi que la liste des diffrentes fonctions de simulation de variables alatoires.
8.1
Gnrateurs de nombres alatoires
On obtient des nombres uniformes sur un intervalle quelconque avec la fonction runif dans R. La fonction set.seed permet de spcier la valeur de lamorce du gnrateur alatoire, ce qui est utile si on veut rpter une simulation absolument lidentique. R offre la possibilit de choisir entre plusieurs gnrateurs de nombres alatoires diffrents, ou encore de spcier son propre gnrateur. Par dfaut, R utilise le gnrateur MarsenneTwister, considr comme le plus avanc en ce moment. 115
116
Gnrateurs de nombres alatoires La priode de ce gnrateur est 219 937 1 (rien de moins !) et la distribution des nombres est uniforme dans 623 dimensions conscutives sur toute la priode. Pour de plus amples dtails et les dernires informations sur les gnrateurs disponibles et la procdure de rglage de lamorce, consulter les rubriques daide des fonctions .Random.seed et set.seed.
8.2
Fonctions de simulation de variables alatoires non uniformes
Un large ventail de fonctions donne directement accs aux caractristiques de plusieurs lois de probabilit dans R. Pour chaque racine loi, il existe quatre fonctions diffrentes : 1. dloi calcule la fonction de densit de probabilit (loi continue) ou la fonction de masse de probabilit (loi discrte) ; 2. ploi calcule la fonction de rpartition ; 3. qloi calcule la fonction de quantile ; 4. rloi simule des observations de cette loi. Les diffrentes lois de probabilit disponibles dans le systme R de base, leur racine et le nom de leurs paramtres sont rassembls au tableau 8.1. Des packages fournissent des fonctions pour dautres lois dont, entre autres, actuar (Dutang et collab., 2008) et SuppDists (Wheeler, 2009). Toutes les fonctions du tableau 8.1 sont vectorielles, cest--dire quelles acceptent en argument un vecteur de points o la fonction (de densit, de rpartition ou de quantile) doit tre value et mme un vecteur de paramtres. Par exemple,
> dpois(c(3, 0, 8), lambda = c(1, 4, 10)) [1] 0.06131324 0.01831564 0.11259903
retourne la probabilit que des lois de Poisson de paramtre 1, 4 et 10 prennent les valeurs 3, 0 et 8, dans lordre. Le premier argument des fonctions de simulation est la quantit de nombres alatoires dsire. Ainsi,
> rpois(3, lambda = c(1, 4, 10)) [1] 2 8 7
8.2. Fonctions de simulation de variables alatoires non uniformes
117
Loi de probabilit Bta Binomiale Binomiale ngative Cauchy Exponentielle F (Fisher) Gamma Gomtrique Hypergomtrique Khi carr Logistique Log-normale Normale Poisson t (Student) Uniforme Weibull Wilcoxon
Racine dans R
beta binom nbinom cauchy exp f gamma geom hyper chisq logis lnorm norm pois t unif weibull wilcox
Noms des paramtres

shape1, shape2 size, prob size, prob ou mu location, scale rate df1, df2 shape, rate ou scale prob m, n, k df location, scale meanlog, sdlog mean, sd lambda df min, max shape, scale m, n
TAB. 8.1: Lois de probabilit pour lesquelles il existe des fonctions dans le systme R de base
retourne trois nombres alatoires issus de distributions de Poisson de paramtre 1, 4 et 10, respectivement. videmment, passer un vecteur comme premier argument na pas tellement de sens, mais, si cest fait, R retournera une quantit de nombres alatoires gale la longueur du vecteur (sans gard aux valeurs contenues dans le vecteur). La fonction sample permet de simuler des nombres dune distribution discrte quelconque. Sa syntaxe est
sample(x, size, replace = FALSE, prob = NULL),
o x est un vecteur des valeurs possibles de lchantillon simuler (le support de la distribution), size est la quantit de nombres simuler et prob est un vecteur de probabilits associes chaque valeur de x (1/length(x) par dfaut). Enn, si replace est TRUE, lchantillonnage se fait avec remise.
118
Gnrateurs de nombres alatoires
8.3
Exemples
### ### GNRATEURS DE NOMBRES ALATOIRES ### ## La fonction de base pour simuler des nombres uniformes est ## 'runif'. runif(10) # sur (0, 1) par dfaut runif(10, 2, 5) # sur un autre intervalle 2 + 3 * runif(10) # quivalent, moins lisible ## R est livr avec plusieurs gnrateurs de nombres ## alatoires. On peut en changer avec la fonction 'RNGkind'. RNGkind("Wichmann-Hill") # gnrateur de Excel runif(10) # rien de particulier voir RNGkind("default") # retour au gnrateur par dfaut ## La fonction 'set.seed' est trs utile pour spcifier ## l'amorce d'un gnrateur. Si deux simulations sont ## effectues avec la mme amorce, on obtiendra exactement les ## mmes nombres alatoires et, donc, les mmes rsultats. ## Trs utile pour rpter une simulation l'identique. set.seed(1) # valeur sans importance runif(5) # 5 nombres alatoires runif(5) # 5 autres nombres set.seed(1) # rinitialisation de l'amorce runif(5) # les mmes 5 nombres que ci-dessus ### ### FONCTIONS POUR LA SIMULATION DE VARIABLES ALATOIRES NON ### UNIFORMES ### ## Plutt que de devoir utiliser la mthode de l'inverse ou un ## autre algorithme de simulation pour obtenir des nombres ## alatoires d'une loi de probabilit non uniforme, R fournit ## des fonctions de simulation pour bon nombre de lois. Toutes ## ces fonctions sont vectorielles. Ci-dessous, P == Poisson ## et G == Gamma pour conomiser sur la notation. n <- 10 # taille des chantillons rbinom(n, 5, 0.3) # Binomiale(5, 0,3) rbinom(n, 1, 0.3) # Bernoulli(0,3) rnorm(n) # Normale(0, 1)
8.4. Exercices
119
rnorm(n, 2, 5) rpois(n, c(2, 5)) rgamma(n, 3, 2:11) rgamma(n, 11:2, 2:11)
# # # #
Normale(2, 25) P(2), P(5), P(2), ..., P(5) G(3, 2), G(3, 3), ..., G(3, 11) G(11, 2), G(10, 3), ..., G(2, 11)
## La fonction 'sample' sert pour simuler d'une distribution ## discrte quelconque. Le premier argument est le support de ## la distribution et le second, la taille de l'chantillon ## dsire. Par dfaut, l'chantillonnage se fait avec remise ## et avec des probabilits gales sur tout le support. sample(1:49, 7) # numros pour le 7/49 sample(1:10, 10) # mlange des nombres de 1 10 ## On peut chantilloner avec remise. sample(1:10, 10, replace = TRUE) ## On peut aussi spcifier une distribution de probabilits ## non uniforme. x <- sample(c(0, 2, 5), 1000, prob = c(2, 5, 3)/10) table(x) # tableau de frquences
8.4
Exercices
8.1 La loi log-normale est obtenue par transformation de la loi normale : si la distribution de la variable alatoire X est une normale de paramtres et 2 , alors la distribution de e X est une log-normale. Simuler 1 000 observations 1 dune loi log-normale de paramtres = ln 5000 2 et 2 = 1, puis tracer lhistogramme de lchantillon alatoire obtenu. 8.2 Simuler 10 000 observations dun mlange continu Poisson/gamma o les paramtres de la loi gamma sont = 5 et = 4, puis tracer la distribution de frquence de lchantillon alatoire obtenu laide des fonctions plot et table. Superposer ce graphique la fonction de probabilit dune binomiale ngative de paramtres r = 5 et = 0,8. 8.3 Simuler 10 000 observations dun mlange discret de deux distributions lognormales, lune de paramtres ( = 3,5, 2 = 0,6) et lautre de paramtres ( = 4,6, 2 = 0,3). Utiliser un paramtre de mlange p = 0,55. Tracer ensuite lhistogramme de lchantillon alatoire obtenu.
A GNU Emacs et ESS : la base

Emacs est lditeur de texte des diteurs de texte. Conu lorigine comme un diteur pour les programmeurs (avec des modes spciaux pour une multitude de langages diffrents), Emacs est devenu au l du temps un environnement logiciel en soi dans lequel on peut raliser une foule de tches diffrentes : rdiger des A documents LTEX, interagir avec R, SAS ou un logiciel de base de donnes, consulter son courrier lectronique, grer son calendrier ou mme jouer Tetris ! Cette annexe passe en revue les quelques commandes essentielles connatre pour commencer travailler avec GNU Emacs et le mode ESS. Louvrage de Cameron et collab. (2004) constitue une excellente rfrence pour lapprentissage plus pouss de lditeur.
A.1
Mise en contexte
Emacs est le logiciel tendard du projet GNU (GNU is not Unix), dont le principal commanditaire est la Free Software Foundation (FSF) lorigine de tout le mouvement du logiciel libre. Richard M. Stallman, prsident de la FSF et grand aptre du libre, a crit la premire version de Emacs et il continue ce jour contribuer au projet. Les origines de Emacs remontent au dbut des annes 1980, une poque o les interfaces graphiques nexistaient pas, le parc informatique tait beaucoup plus htrogne quaujourdhui (les claviers ntaient pas les mmes dune marque dordinateur une autre) et les modes de communication entre les ordinateurs demeuraient rudimentaires. Lge vnrable de Emacs transparat plusieurs endroits, notamment dans la terminologie inhabituelle, les raccourcis clavier qui ne correspondent pas aux standards daujourdhui ou la manipulation des fentres qui ne se fait pas avec une souris. 121
122
GNU Emacs et ESS : la base Emacs sadapte diffrentes tches par lentremise de modes qui modient son comportement ou lui ajoutent des fonctionnalits. Lun de ces modes est ESS (Emacs Speaks Statistics). ESS permet dinteragir avec des logiciels statistiques (en particulier R, S+ et SAS) directement depuis Emacs. Quelques-uns des dveloppeurs de ESS sont aussi des dveloppeurs de R, dont la grande compatibilit entre les deux logiciels. Lorsque ESS est install, le mode est activ automatiquement en ouvrant dans Emacs un chier dont le nom se termine par lextension .R.
A.2
Installation
GNU Emacs et le mode ESS sont normalement livrs dofce avec toutes les distributions Linux. Pour les environnements Windows et Mac OS X, le plus simple consiste tlcharger et installer les distributions prpares par le prsent auteur. Consulter le site
http://vgoulet.act.ulaval.ca/emacs/
A.3
Description sommaire
Au lancement, Emacs afche un cran dinformation contenant des liens vers diffrentes ressources. Cet cran disparat ds que lon appuie sur une touche. La fentre Emacs se divise en quatre zone principales (voir la gure A.1) : 1. tout au haut de la fentre (ou de lcran sous OS X), on trouve lhabituelle barre de menu dont le contenu change selon le mode dans lequel se trouve Emacs ; 2. lessentiel de la fentre set afcher un buffer, soit le contenu dun chier ouvert ou linvite de commande dun programme externe ; 3. la ligne de mode est le sparateur horizontal contenant diverses informations sur le chier ouvert et ltat de Emacs ; 4. le minibuffer est la rgion au bas de la fentre o lon entre des commandes et reoit de linformation de Emacs. Il est possible de sparer la fentre Emacs en sous-fentres pour afcher plusieurs buffers la fois. Il y a alors une ligne de mode pour chaque buffer.
A.4. Emacs-ismes et Unix-ismes

Barre de menu
123
Buffer
Ligne de mode Minibuffer
F IG . A.1: Fentre GNU Emacs et ses diffrentes parties au lancement de lapplication sous Mac OS X. Sous Windows et Linux, la barre de menu se trouve lintrieur de la fentre.
A.4 Emacs-ismes et Unix-ismes

Emacs possde sa propre terminologie quil vaut mieux connatre lorsque lon consulte la documentation. De plus, lditeur fait siennes certaines conventions du monde Unix et qui sont moins usites sur les plateformes Windows et OS X. Dans les dnitions de raccourcis claviers : C est la touche Contrle ( ) ; M est la touche Meta, qui correspond la touche Alt de gauche sur un PC ou la touche Option ( ) sur un Mac (toutefois, voir lencadr la page suivante) ;
124
GNU Emacs et ESS : la base
Par dfaut sous Mac OS X, la touche Meta est assigne Option ( ). Sur les claviers franais, cela empche daccder certains caractres spciaux tels que [, ], { ou }. Une solution consiste plutt assigner la touche Meta Commande ( ). Cela bloque alors laccs certains raccourcis Mac, mais la situation est moins critique ainsi. Pour assigner la touche Meta Commande ( ), il suft dinsrer les lignes suivantes dans son chier de conguration .emacs (voir la section A.7) :
;;; ==================================== ;;; Assigner la touche Meta Commande ;;; ==================================== (setq-default ns-command-modifier 'meta) ; Commande est Meta (setq-default ns-option-modifier 'none) ; Option est Option
ESC est la touche chap ( ) et est quivalente Meta ; SPC est la barre despacement ; RET est la touche Entre ( ). Toutes les fonctionnalits de Emacs correspondent une commande pouvant tre tape dans le minibuffer. M-x dmarre linvite de commande. Le caractre ~ reprsente le dossier vers lequel pointe la variable denvironnement $HOME (Linux, OS X) ou %HOME% (Windows). Cest le dossier par dfaut de Emacs. La barre oblique (/) est utilise pour sparer les dossiers dans les chemins daccs aux chiers, mme sous Windows. En gnral, il est possible dappuyer sur TAB dans le minibuffer pour complter les noms de chiers ou de commandes.
A.5
Commandes de base
Emacs comporte une plthore de commandes, il serait donc futile de tenter den faire une liste exhaustive ici. Nous nous contenterons de mentionner les commandes les plus importantes regroupes par tche. Pour dbuter, il est utile de suivre le Tour guid de Emacs 1 et de lire le tutoriel de Emacs, que lon dmarre avec C-h t.
1. http://www.gnu.org/software/emacs/tour/ ou cliquer sur le lien dans lcran daccueil.
A.5. Commandes de base
125
A.5.1
M-x C-g
Les essentielles
dmarrer linvite de commande bouton de panique : annuler, quitter ! Presser plus dune fois au besoin.
A.5.2
Manipulation de fichiers
Entre parenthses, le nom de la commande Emacs correspondante. On peut entrer cette commande dans le minibuffer au lieu dutiliser le raccourci clavier. On remarquera quil nexiste pas de commande nouveau chier dans Emacs. Pour crer un nouveau chier, il suft douvrir un chier nexistant pas.
C-x C-f C-x C-s C-x C-w C-x k C-_ C-s C-r M-%
ouvrir un chier (find-file) sauvegarder (save-buffer) sauvegarder sous (write-file) fermer un chier (kill-buffer) annuler (pratiquement illimit) ; aussi C-x u (undo) recherche incrmentale avant (isearch-forward) Recherche incrmentale arrire (isearch-backward) rechercher et remplacer (query-replace)
A.5.3
C-SPC C-w M-w C-y M-y
Slection de texte, copier, coller, couper

dbute la slection (set-mark-command) couper la slection (kill-region) copier la slection (kill-ring-save) coller (yank) remplacer le dernier texte coll par la slection prcdente (yank-pop)
Il est possible dutiliser les raccourcis clavier usuels de Windows (C-c, C-x, C-v) et OS X ( C, X, V) en activant le mode CUA dans le menu Options. On peut copier-coller directement avec la souris dans Windows en slectionnant du texte puis en appuyant sur le bouton central (ou la molette) lendroit souhait pour y copier le texte.
126
A.5.4
C-x b C-x 2 C-x 1 C-x 0 C-x o
Manipulation de fentres
changer de buffer (switch-buffer) sparer lcran en deux fentres (split-window-vertically) conserver uniquement la fentre courante (delete-other-windows) fermer la fentre courante (delete-window) aller vers une autre fentre lorsquil y en a plus dune (other-window)
A.5.5
Manipulation de fichiers de script dans le mode ESS

valuer la ligne sous le curseur dans le processus R, puis dplacer le curseur la prochaine expression (ess-eval-line-and-step) valuer la rgion slectionne dans le processus R (ess-eval-region) valuer le code de la fonction courante dans le processus R (ess-eval-function) valuer le code du chier courant en entier dans le processus R (ess-load-file) aide sur une commande R (ess-display-help-on-object)
C-c C-n C-c C-r C-c C-f C-c C-l C-c C-v
A.5.6
Interaction avec linvite de commande R

navigation dans lhistorique des commandes (previous-matching-history-from-input, next-matching-history-from-input) replacer la dernire ligne au bas de la fentre (comint-show-maximum-output) slectionner le rsultat de la dernire commande (mark-paragraph) effacer le rsultat de la dernire commande (comint-delete-output) aide sur une commande R (ess-display-help-on-object) terminer le processus R (ess-quit)
M-p, M-n
C-c C-e M-h C-c C-o C-c C-v C-c C-q
A.5.7
h n, p
Consultation des rubriques daide de R

ouvrir une nouvelle rubrique daide, par dfaut pour le mot se trouvant sous le curseur (ess-display-help-on-object) aller la section suivante (n) ou prcdente (p) de la rubrique (ess-skip-to-next-section, ess-skip-to-previous-section)
A.6. Anatomie dune session de travail (bis) valuer la ligne sous le curseur ; pratique pour excuter les exemples (ess-eval-line-and-step) valuer la rgion slectionne (ess-eval-region) retourner au processus ESS en laissant la rubrique daide visible (ess-switch-to-end-of-ESS) fermer la rubrique daide et retourner au processus ESS (ess-kill-buffer-and-go)
127
l r q x
A.6
Anatomie dune session de travail (bis)
On reprend ici les tapes dune session de travail type prsentes la section 1.6, mais en expliquant comment complter chacune dans Emacs avec le mode ESS. 1. Lancer Emacs et ouvrir un chier de script avec
C-x C-f
ou avec le menu
File|Open file...
En spciant un nom de chier qui nexiste pas dj, on se trouve crer un nouveau chier de script. Sassurer de terminer le nom des nouveaux chiers par .R pour que Emacs reconnaisse automatiquement quil sagit de chiers de script R. 2. Dmarrer un processus R lintrieur mme de Emacs avec
M-x R
Emacs demandera alors de spcier de rpertoire de travail (starting data directory). Accepter la valeur par dfaut, par exemple
~/
ou indiquer un autre dossier. Un ventuel message de Emacs leffet que le chier .Rhistory na pas t trouv est sans consquence et peut tre ignor. 3. Composer le code. Lors de cette tape, on se dplacera souvent du chier de script la ligne de commande an dessayer diverses expressions. On excutera galement des parties seulement du code se trouvant dans le chier de script. Les commandes les plus utilises sont alors
C-x o pour se dplacer dune fentre lautre ; C-c C-n pour excuter une ligne du chier de script ; C-c C-e pour replacer la ligne de commande au bas de la fentre.
128 4. Sauvegarder le chier de script :

C-x C-s
Les quatrime et cinquime caractres de la ligne de mode changent de ** --. 5. Sauvegarder si dsir lespace de travail de R avec save.image(). On le rpte, cela nest habituellement pas ncessaire moins que lespace de travail ne contienne des objets importants ou longs recrer. 6. Quitter le processus R avec
C-c C-q
Cette commande ESS se chargera de fermer tous les chiers associs au processus R. On peut ensuite quitter Emacs en fermant lapplication de la manire usuelle.
A.7
Configuration de lditeur
Une des grandes forces de Emacs est qu peu prs chacune de ses facettes est congurable : couleurs, polices de caractre, raccourcis clavier, etc. Un utilisateur place ses commandes de conguration dans un chier nomm .emacs (le point est important !) que Emacs lit au dmarrage. Le chier .emacs doit se trouver dans le dossier ~/, cest--dire dans le dossier de dpart de lutilisateur sous Linux et OS X, et dans le dossier rfrenc par la variable denvironnement %HOME% sous Windows.
A.8
Aide et documentation
Emacs possde son propre systme daide trs exhaustif, mais dont la navigation est peu intuitive selon les standards daujourdhui. Consulter le menu Help. Autrement, on trouvera les manuels de Emacs et de ESS en divers formats dans les sites respectifs des deux projets :
http://www.gnu.org/software/emacs http://ess.r-project.org
Enn, si le dsespoir vous prend au cours dune sance de codage intensive, vous pouvez toujours consulter le psychothrapeute Emacs. On le trouve, bien entendu, dans le menu Help !
B Planification dune simulation en R

Il existe de multiples faons de raliser la mise en uvre informatique dune simulation, mais certaines sont plus efcaces que dautres. Cette annexe passe en revue diverses faons de faire des simulations avec R laide dun exemple simple de nature statistique.
B.1
Contexte
Soit X 1 , . . . , X n un chantillon alatoire tir dune population distribue selon 1 une loi uniforme sur lintervalle ( 2 , + 1 ). On considre trois estimateurs sans 2 biais du paramtre inconnu : 1. la moyenne arithmtique 1 n 1 = Xi ; n i =1 2. la mdiane empirique 2 = X ( n +1 ) ,
1 ( X ( n ) + X ( n +1) ), 2 2 2
2
n impair n pair,
o X (k ) est la k e statistique dordre de lchantillon alatoire ; 3. la mi-tendue 3 = X (1) + X (n ) 2 .
laide de la simulation on veut, dune part, vrier si les trois estimateurs sont bel et bien sans biais et, dautre part, dterminer lequel a la plus faible variance. Pour ce faire, on doit dabord simuler un grand nombre N dchantillons alatoires de taille n dune distribution U ( 1 , + 1 ) pour une valeur de choisie. 2 2 129
130
Planication dune simulation en R Pour chaque chantillon, on calculera ensuite les trois estimateurs ci-dessus, puis la moyenne et la variance, par type destimateur, de tous les estimateurs obte nus. Si la moyenne des N estimateurs i , i = 1, 2, 3 est prs de , alors on pourra i est sans biais. De mme, on dterminera lequel des trois estimaconclure que teurs a la plus faible variance selon le classement des variances empiriques.
B.2
Premire approche : avec une boucle
La faon la plus intuitive de mettre en uvre cette tude de simulation en R consiste utiliser une boucle for. Avec cette approche, il est ncessaire dinitialiser une matrice de 3 lignes et N colonnes (ou linverse) dans laquelle seront stockes les valeurs des trois estimateurs pour chaque simulation. Une fois la matrice remplie dans la boucle, il ne reste plus qu calculer la moyenne et la variance par ligne pour obtenir les rsultats souhaits. La gure B.1 prsente un exemple de code adquat pour raliser la simulation laide dune boucle. Si lon souhaite pouvoir excuter le code de la gure B.1 facilement laide dune seule expression, il suft de placer lensemble du code dans une fonction. La fonction simul1 de la gure B.2 reprend le code de la gure B.1, sans les commentaires. On a alors :
> simul1(10000, 100, 0) $biais Moyenne Mediane Mi-etendue 1.158071e-05 -5.475023e-05 -1.230907e-04 $variances Moyenne Mediane Mi-etendue 0.0008281255 0.0024482918 0.0000484432
B.3
Seconde approche : avec sapply
On le sait, les boucles sont inefcaces en R. Il est en gnral plus efcace de dlguer les boucles aux fonctions lapply et sapply (section 6.3). On rappelle que la syntaxe de ces fonctions est
lapply(x, FUN, ...) sapply(x, FUN, ...)
B.3. Seconde approche : avec sapply
131
## Bonne habitude prendre: stocker les constantes dans ## des variables faciles modifier au lieu de les crire ## explicitement dans le code. size <- 100 nsimul <- 10000 theta <- 0 # taille de chaque chantillon # nombre de simulations # la valeur du paramtre
## Les lignes ci-dessous viteront de faire deux additions ## 'nsimul' fois. a <- theta - 0.5 b <- theta + 0.5 # borne infrieure de l'uniforme # borne suprieure de l'uniforme
## Initialisation de la matrice dans laquelle seront ## stockes les valeurs des estimateurs. On donne galement ## des noms aux lignes de la matrice afin de facilement ## identifier les estimateurs. x <- matrix(0, nrow = 3, ncol = nsimul) rownames(x) <- c("Moyenne", "Mediane", "Mi-etendue") ## Simulation comme telle. for (i in 1:nsimul) { u <- runif(size, a, b) x[, i] <- c(mean(u), median(u) } ## On peut maintenant calculer la moyenne et la variance ## par ligne. rowMeans(x) - theta apply(x, 1, var) # vrification du biais # comparaison des variances # moyenne # mdiane
mean(range(u))) # mi-tendue
F IG . B.1: Code pour la simulation utilisant une boucle for
132
Planication dune simulation en R
simul1 <- function(nsimul, size, theta) { a <- theta - 0.5 b <- theta + 0.5 x <- matrix(0, nrow = 3, ncol = nsimul) rownames(x) <- c("Moyenne", "Mediane", "Mi-etendue") for (i in 1:nsimul) { u <- runif(size, a, b) x[, i] <- c(mean(u), median(u), mean(range(u))) } list(biais = rowMeans(x) - theta, variances = apply(x, 1, var)) }
F IG . B.2: Dnition de la fonction simul1
Ces fonctions appliquent la fonction FUN tous les lments de la liste ou du vecteur x et retournent les rsultats sous forme de liste (lapply) ou, lorsque cest possible, de vecteur ou de matrice (sapply). Il est important de noter que les valeurs successives de x seront passes comme premier argument la fonction FUN. Le cas chant, les autres arguments de FUN sont spcis dans le champ .... Pour pouvoir utiliser ces fonctions dans le cadre dune simulation comme celle dont il est question ici, il sagit de dnir une fonction qui fera tous les calculs pour une simulation, puis de la passer sapply pour obtenir les rsultats de N simulations. La gure B.3 prsente une premire version dune telle fonction. On remarquera que largument i ne joue aucun rle dans la fonction. Voici un exemple dutilisation pour un petit nombre de simulations (4) :
> sapply(1:4, fun1, size = 10, a = -0.5, b = 0.5) [,1] Moyenne Mediane Mi-etendue [,2] [,3] 0.02463859 0.11141037 -0.096559263 -0.047190233 -0.065582015 -0.082029770 0.005047172
0.008949292 -0.03506855
B.3. Seconde approche: avec sapply
133
fun1 <- function(i, size, a, b) { u <- runif(size, a, b) c(Moyenne = mean(u), Mediane = median(u), "Mi-etendue" = mean(range(u))) } simul2 <- function(nsimul, size, theta) { a <- theta - 0.5 b <- theta + 0.5 x <- sapply(1:nsimul, fun1, size, a, b) list(biais = rowMeans(x) - theta, variances = apply(x, 1, var)) }
F IG . B.3: Dnitions des fonction fun1 et simul2
[,4] Moyenne Mediane -0.05667023 -0.06164078
Mi-etendue -0.04438876
On remarque donc que les rsultats de chaque simulation se trouvent dans les colonnes de la matrice obtenue avec sapply. Pour complter lanalyse, on englobe le tout dans une fonction simul2, dont le code se trouve la gure B.3 :
> simul2(10000, 100, 0) $biais Moyenne Mediane Mi-etendue -0.0001949077 -0.0002907399 -0.0001114678 $variances
134
Moyenne
Mediane
Mi-etendue
8.293582e-04 2.419974e-03 4.921899e-05
Il est gnralement plus facile de dboguer le code avec cette approche puisque lon peut rapidement circonscrire un ventuel problme fun1 ou simul2.
B.4
Variante de la seconde approche
Une chose manque dlgance dans la seconde approche : lobligation dinclure un argument factice dans la fonction fun1. La fonction replicate (section 6.5) permet toutefois de passer outre cette contrainte. En effet, cette fonction excute un nombre donn de fois une expression quelconque. Les fonctions fun2 et simul3 de la gure B.4 sont des versions lgrement modies de fun1 et simul2 pour utilisation avec replicate. On a alors
> simul3(10000, 100, 0) $biais Moyenne -0.0001443050 $variances Moyenne Mediane Mi-etendue 8.510722e-04 2.496812e-03 4.918979e-05 Mediane Mi-etendue 0.0001392598 -0.0001046946
B.5
Gestion des fichiers
Pour un petit projet comme celui utilis en exemple ici, il est simple et pratique de placer tout le code informatique dans un seul chier de script. Pour un plus gros projet, cependant, il vaut souvent mieux avoir recours plusieurs chiers diffrents. Le prsent auteur utilise pour sa part un chier par fonction. des ns dillustration, supposons que lon utilise lapproche de la section B.4 avec la fonction replicate et que le code des fonctions fun2 et simul3 est sauvegard dans des chiers fun2.R et simul3.R, dans lordre. Si lon cre un autre chier, disons go.R, ne contenant que des expressions source pour lire les autres chiers, il est alors possible de dmarrer des simulations en excutant ce seul chier. Dans notre exemple, le chier go.R contiendrait les lignes suivantes :
source("fun2.R") source("simul3.R") simul3(10000, 100, 0)
B.6. Excution en lot
135
fun2 <- function(size, a, b) { u <- runif(size, a, b) c(Moyenne = mean(u), Mediane = median(u), "Mi-etendue" = mean(range(u))) } simul3 <- function(nsimul, size, theta) { a <- theta - 0.5 b <- theta + 0.5 x <- replicate(nsimul, fun2(size, a, b)) list(biais = rowMeans(x) - theta, variances = apply(x, 1, var)) }
F IG . B.4: Dnitions des fonction fun2 et simul3
Une simple commande

> source("go.R")
excutera alors une simulation complte.
B.6
Excution en lot
Les utilisateurs plus avancs pourront vouloir excuter leur simulation R en lot (batch) pour en acclrer le traitement. Dans ce mode, aucune interface graphique nest dmarre et tous les rsultats sont redirigs vers un chier pour consultation ultrieure. Pour les simulations demandant un long temps de calcul, cest trs pratique. On excute R en lot depuis la ligne de commande (Invite de commande sous Windows, Terminal sous OS X ou Linux). Une fois plac dans le rpertoire contenant les chiers de script, il suft dentrer la ligne de commande
136
R CMD BATCH go.R
La sortie de cette commande (et donc tous les rsultats des expressions R du chier go.R) seront placs par dfaut dans le chier go.Rout. Sous Windows, le dossier dinstallation de R peut ne pas se trouver dans la variable denvironnement %PATH%, auquel cas il faut spcier le chemin daccs complet de lexcutable la ligne de commande :
"c:\Program Files\R\R-x.y.z\bin\R" CMD BATCH go.R
Remplacer R-x.y.z par le numro de version courant de R.
B.7
Conclusion
Le nombre de simulations, N , et la taille de lchantillon, n, ont tous deux un impact sur la qualit des rsultats, mais de manire diffrente. Quand n augmente, la prcision des estimateurs augmente. Ainsi, dans lexemple ci-dessus, le biais et la variance des estimateurs de seront plus faibles. Dautre part, laugmentation du nombre de simulations diminue limpact des chantillons alatoires individuels et, de ce fait, amliore la abilit des conclusions de ltude. Dailleurs, les conclusions de ltude de simulation sur le biais et la variance des trois estimateurs de la moyenne dune loi uniforme sont les suivantes : les trois estimateurs sont sans biais et la mi-tendue a la plus faible variance. En effet, on peut dmontrer mathmatiquement que, pour n impair, Var[1 ] = Var[2 ] = Var[3 ] = et donc Var[3 ] Var[1 ] Var[2 ] pour tout n 2. 1 12n 1 4n + 2 1
2(n + 1)(n + 2)
C Installation de packages dans R

Un package R est un ensemble cohrent de fonctions, de jeux de donnes et de documentation permettant de complter les fonctionnalits du systme ou den ajouter de nouvelles. Les packages sont normalement installs depuis le site Comprehensive R Archive Network (CRAN ; http://cran.r-project.org). Cette annexe explique comment congurer R pour faciliter linstallation et ladministration de packages externes. Les instructions ci-dessous sont centres autour de la cration dune bibliothque personnelle o seront installs les packages R tlchargs de CRAN. Il est fortement recommand de crer une telle bibliothque. Cela permet dviter les problmes daccs en criture dans la bibliothque principale et de conserver les packages intacts lors des mises jour de R. Nous montrons galement comment spcier le site miroir de CRAN pour viter davoir le rpter chaque installation de package. 1. Identier le dossier de dpart de lutilisateur. En cas dincertitude, examiner la valeur de la variable denvironnement HOME 1 , depuis R avec la commande
> Sys.getenv("HOME")
ou, pour les utilisateurs de Emacs, directement depuis lditeur avec

M-x getenv RET HOME RET
Nous rfrerons ce dossier par le symbole ~. 2. Crer un dossier qui servira de bibliothque de packages personnelle. Dans la suite, nous utiliserons ~/R/library. 3. Dans un chier nomm ~/.Renviron (donc situ dans le dossier de dpart), enregistrer la ligne suivante :
R_LIBS_USER="~/R/library
1. Pour les utilisateurs de GNU Emacs sous Windows, la variable est cre par lassistant dinstallation de Emacs lorsquelle nexiste pas dj.
137
138
Installation de packages dans R Au besoin, remplacer le chemin ~/R/library par celui du dossier cr ltape prcdente. Utiliser la barre oblique avant (/) dans le chemin pour sparer les dossiers. 4. Dans un chier nomm ~/.Rprofile, enregistrer loption suivante :
options(repos = "http://cran.ca.r-project.org")
Si dsir, remplacer la valeur de loption repos par lURL dun autre site miroir de CRAN. Les utilisateurs de GNU Emacs voudront ajouter une autre option. Le code a entrer dans le chier ~/.Rprofile sera plutt
options(repos = "http://cran.ca.r-project.org", menu.graphics = FALSE)
Consulter la rubriques daide de Startup pour les dtails sur la syntaxe et lemplacement des chiers de conguration, celles de library et .libPaths pour la gestion des bibliothques et celle de options pour les diffrentes options reconnues par R. Aprs un redmarrage de R, la bibliothque personnelle aura prsance sur la bibliothque principale et il ne sera plus ncessaire de prciser le site miroir de CRAN lors de linstallation de packages. Ainsi, la simple commande
> install.packages("actuar")
tlchargera le package de fonctions actuarielles actuar depuis le miroir canadien de CRAN et linstallera dans le dossier ~/R/library. Pour charger le package en mmoire, on fera
> library("actuar")
On peut arriver au mme rsultat sans utiliser les chiers de conguration

.Renviron et .Rprofile. Il faut cependant recourir aux arguments lib et repos
de la fonction install.packages et largument lib.loc de la fonction library. Consulter les rubriques daide de ces deux fonctions pour de plus amples informations.
Rponses des exercices

Chapitre 2
2.1 a) Il y a plusieurs faons de crer les troisime et quatrime lments de la liste. Le plus simple consiste utiliser numeric() et logical() :
> x <- list(1:5, data = matrix(1:6, 2, 3), numeric(3), + test = logical(4))
b) > names(x) c) > mode(x$test)

> length(x$test)
d) > dim(x$data) e) > x[[2]][c(2, 3)] f) > x[[3]] <- 3:8 2.2 a) > x[2] b) > x[1:5] c) > x[x > 14] d) > x[-c(6, 10, 12)] 2.3 a) > x[4, 3] b) > x[6, ] c) > x[, c(1, 4)] d) > x[x[, 1] > 50, ] 139
140
Chapitre 3
3.1 a) > rep(c(0, 6), 3) b) > seq(1, 10, by = 3) c) > rep(1:3, 4) d) > rep(1:3, 1:3) e) > rep(1:3, 3:1) f) > seq(1, 10, length = 3) g) > rep(1:3, rep(4,3)) 3.2 a) > 11:20 / 10 b) > 2 * 0:9 + 1 c) > rep(-2:2, 2) d) > rep(-2:2, each = 2) e) > 10 * 1:10 3.3 Soit mat une matrice. a) > apply(mat, 1, sum) b) > apply(mat, 2, sum) c) > apply(mat, 1, mean) d) > apply(mat, 2, mean) 3.4 > cumprod(1:10) 3.5 x == (x %% y) + y * (x %/% y) 3.6 a) > x[1:5]
> head(x, 5)
b) > max(x) c) > mean(x[1:5])

> mean(head(x, 5))
Rponses des exercices d) > mean(x[16:20])

> mean(x[(length(x) - 4):length(x)]) > mean(tail(x, 5)) # plus gnral # plus lisible!
141
3.7 a) (j - 1)*I + i b) ((k - 1)*J + j - 1)*I + i 3.8 a) > rowSums(mat) b) > colMeans(mat) c) > max(mat[1:3, 1:3]) d) > mat[rowMeans(mat) > 7,] 3.9 > temps[match(unique(cummin(temps)), temps)]
Chapitre 4
4.1 > sum(P / cumprod(1 + i)) 4.2 > x <- c(7, 13, 3, 8, 12, 12, 20, 11)
> w <- c(0.15, 0.04, 0.05, 0.06, 0.17, 0.16, 0.11, 0.09) > sum(x * w)/sum(w)
4.3 > 1/mean(1/x) 4.4 > lambda <- 2

> x <- 5 > exp(-lambda) * sum(lambda^(0:x)/gamma(1 + 0:x))
4.5 a) > x <- 10^(0:6)

> probs <- (1:7)/28
b) > sum(x^2 * probs) - (sum(x * probs))^2 4.6 > i <- 0.06

> 4 * ((1 + i)^0.25 - 1)
4.7 > n <- 1:10

> i <- seq(0.05, 0.1, by = 0.01) > (1 - outer((1 + i), -n, "^"))/i
142 ou
> n <- 1:10 > i <- (5:10)/100 > apply(outer(1/(1+i), n, "^"), 1, cumsum)
4.8 > v <- 1/1.06

> k <- 1:10 > sum(k * v^(k - 1))
4.9 > pmts <- rep(1:4, 1:4)

> v <- 1/1.07 > k <- 1:10 > sum(pmts * v^k)
4.10 > v <- cumprod(1/(1 + rep(c(0.05, 0.08), 5)))

> pmts <- rep(1:4, 1:4) > sum(pmts * v)
Chapitre 5
5.1 variance <- function(x, biased = FALSE)
{ if (biased) { n <- length(x) (n - 1)/n * var(x) } else var(x) }
5.2 Une premire solution utilise la transpose. La premire expression de la fonction sassure que la longueur de data est compatible avec le nombre de lignes et de colonnes de la matrice demande.
matrix2 <- function(data = NA, nrow = 1, ncol = 1, bycol = FALSE, dimnames = NULL) { data <- rep(data, length = nrow * ncol)
143
if (bycol) dim(data) <- c(nrow, ncol) else { dim(data) <- c(ncol, nrow) data <- t(data) } dimnames(data) <- dimnames data }
La seconde solution na pas recours la transpose. Pour remplir la matrice par ligne, il suft de rordonner les lments du vecteur data en utilisant la formule obtenue lexercice 3.7.
matrix2 <- function(data = NA, nrow = 1, ncol = 1, bycol = FALSE, dimnames = NULL) { data <- rep(data, length = nrow * ncol) if (!bycol) { i <- 1:nrow j <- rep(1:ncol, each = nrow) data <- data[(i - 1)*ncol + j] } dim(data) <- c(nrow, ncol) dimnames(data) <- dimnames data }
5.3 phi <- function(x)

{ exp(-x^2/2) / sqrt(2 * pi) }
5.4 Phi <- function(x)

{ n <- 1 + 2 * 0:50
144
0.5 + phi(x) * sum(x^n / cumprod(n)) }
5.5 Premire solution utilisant une fonction interne et une structure de contrle if ... else.
Phi <- function(x) { fun <- function(x) { n <- 1 + 2 * 0:50 0.5 + phi(x) * sum(x^n / cumprod(n)) } if (x < 0) 1 - fun(-x) else fun(x) }
Seconde solution sans structure de contrle if ... else. Rappelons que dans des calculs algbriques, FALSE vaut 0 et TRUE vaut 1.
Phi <- function(x) { n <- 1 + 2 * 0:50 neg <- x < 0 x <- abs(x) neg + (-1)^neg * (0.5 + phi(x) * sum(x^n / cumprod(n))) }
5.6 Phi <- function(x)

{ n <- 1 + 2 * 0:30 0.5 + phi(x) * colSums(t(outer(x, n, "^")) / cumprod(n)) }
5.7 a) prod.mat <- function(mat1, mat2)

{ if (ncol(mat1) == nrow(mat2))
145
{ res <- matrix(0, nrow = nrow(mat1), ncol = ncol(mat2)) for (i in 1:nrow(mat1)) { for (j in 1:ncol(mat2)) { res[i, j] <- sum(mat1[i,] * mat2[,j]) } } res } else stop("Les dimensions des matrices ne permettent pas le produit matriciel.") }
b) prod.mat<-function(mat1, mat2)
{ if (ncol(mat1) == nrow(mat2)) { res <- matrix(0, nrow = nrow(mat1), ncol = ncol(mat2)) for (i in 1:nrow(mat1)) res[i,] <- colSums(mat1[i,] * mat2) res } else stop("Les dimensions des matrices ne permettent pas le produit matriciel.") }
Solutions bonus : deux faons de faire quivalentes qui cachent la boucle dans un sapply.
prod.mat<-function(mat1, mat2) { if (ncol(mat1) == nrow(mat2)) t(sapply(1:nrow(mat1), function(i) colSums(mat1[i,] * mat2))) else stop("Les dimensions des matrices ne permettent
146
pas le produit matriciel.") } prod.mat<-function(mat1, mat2) { if (ncol(mat1) == nrow(mat2)) t(sapply(1:ncol(mat2), function(j) colSums(t(mat1) * mat2[,j]))) else stop("Les dimensions des matrices ne permettent pas le produit matriciel.") }
5.8 Le calcul faire nest quun simple produit matriciel, donc :

notes.finales <- function(notes, p) notes %*% p
5.10 param <- function (moyenne, variance, loi)

{ loi <- tolower(loi) if (loi == "normale") { param1 <- moyenne param2 <- sqrt(variance) return(list(mean = param1, sd = param2)) } if (loi == "gamma") { param2 <- moyenne/variance param1 <- moyenne * param2 return(list(shape = param1, scale = param2)) } if (loi == "pareto") { cte <- variance/moyenne^2 param1 <- 2 * cte/(cte-1) param2 <- moyenne * (param1 - 1) return(list(alpha = param1, lambda = param2)) } stop("La loi doit etre une de \"normale\", \"gamma\" ou \"pareto\"")
147
Chapitre 6
6.1 Soit Xij et wij des matrices, et Xijk et wijk des tableaux trois dimensions. a) > rowSums(Xij * wij)/rowSums(wij) b) > colSums(Xij * wij)/colSums(wij) c) > sum(Xij * wij)/sum(wij) d) > apply(Xijk * wijk, c(1, 2), sum)/apply(wijk, c(1, 2), sum) e) > apply(Xijk * wijk, 1, sum)/apply(wijk, 1, sum) f) > apply(Xijk * wijk, 2, sum)/apply(wijk, 2, sum) g) > sum(Xijk * wijk)/sum(wijk) 6.2 a) > unlist(lapply(0:10, seq, from = 0)) b) > unlist(lapply(1:10, seq, from = 10)) c) > unlist(lapply(10:1, seq, to = 1)) 6.3 a) > ea <- lapply(seq(100, 300, by = 50), rpareto, alpha = 2, lambda = 5000) b) > names(ea) <- paste("sample", 1:5, sep = "") c) > sapply(ea, mean) d) > lapply(ea, function(x) sort(ppareto(x, 2, 5000)))
> lapply(lapply(ea, sort), ppareto, alpha = 2, lambda = 5000)
e) > hist(ea$sample5) f ) > lapply(ea, "+", 1000) 6.4 a) > mean(sapply(x, function(liste) liste$franchise)) Les crochets utiliss pour lindiage constituent en fait un oprateur dont le nom est [[. On peut donc utiliser cet oprateur dans la fonction sapply :
> mean(sapply(x, "[[", "franchise"))
b) > sapply(x, function(x) mean(x$nb.acc))
148
Rponses des exercices c) > sum(sapply(x, function(x) sum(x$nb.acc))) ou

> sum(unlist(sapply(x, "[[", "nb.acc")))
d) > mean(unlist(lapply(x, "[[", "montants"))) e) > sum(sapply(x, function(x) sum(x$nb.acc) == 0)) f) > sum(sapply(x, function(x) x$nb.acc[1] == 1)) g) > var(unlist(lapply(x, function(x) sum(x$nb.acc)))) h) > sapply(x, function(x) var(x$nb.acc)) i) > y <- unlist(lapply(x, "[[", "montants"))
> sum(y <= x)/length(y)
La fonction ecdf retourne une fonction permettant de calculer la fonction de rpartition empirique en tout point :
> ecdf(unlist(lapply(x, "[[", "montants")))(x)
j) > y <- unlist(lapply(x, "[[", "montants"))

> colSums(outer(y, x, "<="))/length(y)
La fonction retourne par ecdf accepte un vecteur de points en argument :

> ecdf(unlist(lapply(x, "[[", "montants")))(x)
Chapitre 7
7.1 a) > f <- function(x) x^3 - 2 * x^2 - 5
> uniroot(f, lower = 1, upper = 4)
b) Comme un simple graphique le dmontre, il y a deux racines dans lintervalle.

> f <- function(x) x^3 + 3 * x^2 - 1 > curve(f, xlim = c(-4, 0)) > uniroot(f, lower = -4, upper = -1) > uniroot(f, lower = -1, upper = 0)
c) > f <- function(x) x - 2^(-x)

Rponses des exercices d) > f <- function(x) exp(x) + 2^(-x) + 2 * cos(x) - 6

149
e) > f <- function(x) exp(x) - x^2 + 3 * x - 2

7.2 > X <- c(2061, 1511, 1806, 1353, 1600)

> w <- c(100155, 19895, 13735, 4152, 36110) > g <- function(a, X, w, s2) + { + + + + } > uniroot(function(x) g(x, X, w, 140E6) - x, c(50000, 80000)) z <- 1/(1 + s2/(a * w)) Xz <- sum(z * X)/sum(z) sum(z * (X - Xz)^2)/(length(X) - 1)
7.3 > dpareto <- function(x, alpha, lambda)

+ { + + } > f <- function(par, x) -sum(log(dpareto(x, par[1], par[2]))) > optim(c(1, 1000), f, x = x) (alpha * lambda^alpha)/(x + lambda)^(alpha+1)
ou, en utilisant le truc du logarithme des paramtres expliqu dans le code informatique de la section 7.4 pour viter les soucis de convergence :
> dpareto <- function(x, logAlpha, logLambda) + { + + + + } > optim(c(log(2), log(1000)), f, x = x) > exp(optim(c(log(2), log(1000)), f, x = x)$par) alpha <- exp(logAlpha) lambda <- exp(logLambda) (alpha * lambda^alpha)/(x + lambda)^(alpha+1)
Chapitre 8
8.1 > x <- rlnorm(1000, meanlog = log(5000) - 0.5, sdlog = 1)
> hist(x)
150
8.2 > x <- rpois(10000, lambda = rgamma(10000, shape = 5, rate = 4))

> xx <- seq(min(x), max(x)) > px <- table(x) > plot(xx, dnbinom(xx, size = 5, prob = 0.8), + type = "h", lwd = 5, col = "blue") > points(xx, px/length(x), pch = 16)
8.3 > w <- rbinom(1, 10000, 0.55)

> x <- c(rlnorm(w, 3.5, 0.6), rlnorm(10000 - w, 4.6, 0.3)) > hist(x)
Bibliographie
Abelson, H., G. J. Sussman et J. Sussman. 1996, Structure and Interpretation of Computer Programs, 2e d., MIT Press, ISBN 0-26201153-0. Becker, R. A. 1994, A brief history of S, cahier de recherche, AT&T Bell Laboratories. URL http://cm.bell-labs.com/cm/ms/departments/sia/doc/94.11. ps. Becker, R. A. et J. M. Chambers. 1984, S: An Interactive Environment for Data Analysis and Graphics, Wadsworth, ISBN 0-53403313-X. Becker, R. A., J. M. Chambers et A. R. Wilks. 1988, The New S Language: A Programming Environment for Data Analysis and Graphics, Wadsworth & Brooks/Cole, ISBN 0-53409192-X. Braun, W. J. et D. J. Murdoch. 2007, A First Course in Statistical Programming with R, Cambridge University Press, ISBN 978-0-52169424-7. Cameron, D., J. Elliott, M. Loy, E. S. Raymond et B. Rosenblatt. 2004, Leaning GNU Emacs, 3e d., OReilly, Sebastopol, CA, ISBN 0-59600648-9. Chambers, J. M. 1998, Programming with Data: A Guide to the S Language, Springer, ISBN 0-38798503-4. Chambers, J. M. 2000, Stages in the evolution of S, URL http://cm.bell-labs. com/cm/ms/departments/sia/S/history.html. Chambers, J. M. 2008, Software for Data Analysis: Programming with R, Springer, ISBN 978-0-38775935-7. Chambers, J. M. et T. J. Hastie. 1992, Statistical Models in S, Wadsworth & Brooks/Cole, ISBN 0-53416765-9. 151
152
Bibliographie Dutang, C., V. Goulet et M. Pigeon. 2008, actuar: An R package for actuarial science, Journal of Statistical Software, vol. 25, no 7. URL http://www. jstatsoft.org/v25/i07. Goulet, V. 2007, Introduction la programmation en S, 2e d., Document libre publi sous contrat GNU FDL, ISBN 978-2-9809136-7-9. Hornik, K. 2011, The R FAQ, URL http://cran.r-project.org/doc/FAQ/ R-FAQ.html, ISBN 3-90005108-9. Iacus, S. M., S. Urbanek et R. J. Goedman. 2011, R for Mac OS X FAQ, URL http: //cran.r-project.org/bin/macosx/RMacOSX-FAQ.html. IEEE. 2003, 754-1985 IEEE Standard for Binary Floating-Point Arithmetic, IEEE, Piscataway, NJ. Ihaka, R. et R. Gentleman. 1996, R: A language for data analysis and graphics, Journal of Computational and Graphical Statistics, vol. 5, no 3, p. 299314. Ligges, U. 2003, R-winedt, dans Proceedings of the 3rd International Workshop on Distributed Statistical Computing (DSC 2003), dit par K. Hornik, F. Leisch et A. Zeileis, TU Wien, Vienna, Austria, ISSN 1609-395X. URL http://www.ci. tuwien.ac.at/Conferences/DSC-2003/Proceedings/. Redd, A. 2010, Introducing NppToR: R interaction for Notepad++, R Journal, vol. 2, no 1, p. 6263. URL http://journal.r-project.org/archive/2010-1/ RJournal_2010-1.pdf. Ripley, B. D. et D. J. Murdoch. 2011, R for Windows FAQ, URL http://cran. r-project.org/bin/windows/base/rw-FAQ.html. Venables, W. N. et B. D. Ripley. 2000, S Programming, Springer, New York, ISBN 0-38798966-8. Venables, W. N. et B. D. Ripley. 2002, Modern Applied Statistics with S, 4e d., Springer, New York, ISBN 0-38795457-0. Venables, W. N., D. M. Smith et R Development Core Team. 2011, An Introduction to R, R Foundation for Statistical Computing. URL http://cran.r-project. org/doc/manuals/R-intro.html. Wheeler, B. 2009, SuppDists: Supplementary Distributions. URL http://www. bobwheeler.com/stat, r package version 1.1-8.
Index
Les numros de page en caractres gras indiquent les pages o les concepts sont introduits, dnis ou expliqus.
!, 43 !=, 43 *, 43 +, 43 -, 43 ->, 14, 43 ->>, 43 -Inf, 19 ..., 87, 132 /, 43 :, 43, 60 ;, 14 <, 43 <-, 14, 42, 43 <<-, 43, 74 <=, 43 =, 14 ==, 43 >, 43 >=, 43 [, 27 [<-, 27 [[, 147 [[ ]], 25, 25 [ ], 21, 23, 25, 27 $, 26, 27, 43 $<-, 27 abs, 79, 80, 99, 100 add, 100 %*%, 43, 83 %/%, 43 %%, 43 %in%, 46, 56 %o%, 50, 58 &, 43 &&, 43 , 42, 43 { }, 15
affectation, 13 apply, 51, 58, 61, 87, 88, 8890, 95, 96 array, 22, 34, 95, 96 array (classe), 22 arrondi, 46 as.data.frame, 26 attach, 26, 37 attr, 19, 31, 102 attribut, 19 attributes, 19, 31, 32 boucle, 51, 70, 130 break, 51, 60, 79, 80, 99 by, 10, 55 byrow, 22, 44 153
154
c, 20 cat, 99, 100 cbind, 24, 26, 34, 39, 57 ceiling, 46, 56 character, 21, 33 character (mode), 17, 21 choose, 65 class, 3234, 36, 94, 99 class (attribut), 20 colMeans, 49, 61, 88, 95 colSums, 48, 58, 61, 68, 88
Index bta, 117 binomiale, 64, 117 binomiale ngative, 117 Cauchy, 117 exponentielle, 117 F, 117 gamma, 66, 84, 117 gomtrique, 117 hypergomtrique, 117 khi carr, 117 log-normale, 117, 119 logistique, 117 mlange discret, 119 mlange Poisson/gamma, 119 normale, 8284, 117 Pareto, 84, 103 Poisson, 65, 71, 117 t, 117 uniforme, 117 Weibull, 117 Wilcoxon, 117 dnorm, 83 dossier de travail, voir rpertoire de travail dpois, 66 cart type, 47 ecdf, 148 else, 50, 5860, 80, 98 Emacs, 7, 78 C-_, 125 C-g, 125 C-r, 125 C-s, 125 C-SPC, 125 C-w, 125 C-x 0, 126 C-x 1, 126 C-x 2, 126 C-x b, 126
compil (langage), 2 complex, 33 complex (mode), 17 cos, 28 cummax, 48, 57 cummin, 48, 57 cumprod, 48, 57, 64 cumsum, 48, 57 curve, 100
data, 31, 44, 55
data frame, 26 data.frame, 26 data.frame (classe), 26 dbeta, 110 dbinom, 65 density, 10 det, 49 detach, 26, 37 dgamma, 111 diag, 39, 49, 57 diff, 47, 57 diffrences, 47 dim, 3234, 36, 38, 57, 95 dim (attribut), 20, 21, 22 dimension, 20, 39 dimnames, 32, 44 dimnames (attribut), 20 distribution
Index
C-x C-f, 125 C-x C-s, 125, 128 C-x C-w, 125 C-x k, 125 C-x o, 126 C-x o , 127 C-x u, 125 C-y, 125 eval, 80, 99 exists, 37 exp, 28, 65, 67, 111, 112
155
conguration, 128 M-%, 125 M-w, 125 M-x, 125 M-y, 125 nouveau chier, 125 rechercher et remplacer, 125 slection, 125 sauvegarder, 125 sauvegarder sous, 125 ESS, 7 C-c C-e, 126 C-c C-e , 127 C-c C-f, 126 C-c C-l, 126 C-c C-n, 126 C-c C-n , 127 C-c C-o, 126 C-c C-q, 126, 128 C-c C-r, 126 C-c C-v, 126 h, 126 l, 127 M-h, 126 M-n, 126 M-p, 126 n, 126 p, 126 q, 127 r, 127 x, 127 tiquette, 20, 39
expression, 13 expression, 30, 80, 98, 99 expression (mode), 17 extraction, voir aussi indiage derniers lments, 45 lments diffrents, 45 premiers lments, 45
F, voir FALSE factorial, 61, 65 FALSE, 16, 77 floor, 46, 56
fonction anonyme, 76 appel, 43 dbogage, 76 dnie par lusager, 73 gnrique, 94 maximum local, 108 minimum, 108 minimum local, 108 optimisation, 108 racine, 108 rsultat, 74 for, 51, 53, 54, 58, 59, 81, 92, 130 function, 73, 7982, 97102, 109111 function (mode), 17
gamma, 28, 61, 65 head, 45, 56 hist, 98, 104 if, 50, 53, 54, 5860, 77, 79, 80, 98, 99 ifelse, 50 Im, 113
indiage liste, 25, 39
156 matrice, 23, 26, 40 vecteur, 26, 39 Inf, 19 install.packages, 52 interprt (langage), 2 is.finite, 19 is.infinite, 19 is.na, 19, 31, 38, 59 is.nan, 19 is.null, 18
lapply, 51, 87, 90, 9092, 96, 97, 101,
Index
matrix, 11, 22, 28, 33, 34, 36, 53, 55,
82, 95, 96
matrix (classe), 21 max, 10, 11, 47, 57, 95
130, 132 length, 10, 17, 3036, 38, 5557 lfactorial, 61 lgamma, 61 library, 52, 60 list, 25, 30, 32, 35, 36, 96, 97, 99, 101 list (mode), 17, 24 liste, 24 lm, 102 log, 111 logical, 21, 33 logical (mode), 17, 19, 21 longueur, 18, 39 lower, 109, 110, 112 ls, 11, 29, 101
mapply, 51, 92, 97 match, 46, 56
maximum cumulatif, 48 dun vecteur, 47 local, 108 parallle, 48 position dans un vecteur, 46 mean, 19, 31, 47, 57, 95, 98 median, 47, 57 mdiane, 47 methods, 94 min, 10, 11, 47, 57 minimum cumulatif, 48 dun vecteur, 47 fonction non linaire, 108 local, 108 parallle, 48 position dans un vecteur, 46 mode, 17, 39 mode, 16, 30, 31, 35, 36 moyenne arithmtique, 47 harmonique, 71 pondre, 70, 102 tronque, 47
NA, 19, 77 na.rm, 19, 31, 95 names, 32, 3638 names (attribut), 20 NaN, 19 nchar, 18, 30 ncol, 11, 33, 34, 44, 48, 55, 58, 95 next, 51 nlm, 108, 108, 111, 112 nlminb, 108
matrice, 61, 82, 83, 88 diagonale, 49 identit, 49 inverse, 49 moyennes par colonne, 49 moyennes par ligne, 49 somme par colonne, 48 sommes par ligne, 48 transpose, 49
Index noms dobjets conventions, 15 rservs, 16 Notepad++, 8 nrow, 11, 33, 44, 48, 55, 57, 95 NULL, 18, 20 NULL (mode), 18 numeric, 21, 31, 33, 38, 58, 59, 81 numeric (mode), 17, 21
optim, 108, 112 optimize, 108, 110 order, 45, 56 outer, 49, 51, 58, 67, 76, 101 rank, 45, 56 rbind, 24, 26, 34, 39 rbinom, 118 Re, 113
157
package, 51 paste, 103 pgamma, 67 plot, 10, 32, 94, 100, 119 pmax, 48, 57, 58 pmin, 48, 57 pnorm, 83 point xe, 68, 75 points, 100 polyroot, 109, 113 print, 53, 54, 5860, 77, 79, 80, 94, 95, 98, 99 prod, 47, 50, 57, 58, 95, 96 produit, 47 cumulatif, 48 extrieur, 49
q, 8, 102
renverser un vecteur, 45 rep, 10, 44, 55, 58, 60, 96, 97 repeat, 51, 59, 68, 79, 80, 99 rpertoire de travail, 9 rptition de valeurs, 44 replace, 37, 57, 119 replicate, 93, 98, 134 return, 74 rev, 45, 56, 57, 65 rgamma, 110, 119 rm, 11, 101 RNGkind, 118 rnorm, 10, 98, 102, 118 round, 11, 46, 56 row.names, 36 rowMeans, 49, 61, 88 rowSums, 48, 58, 61, 88, 95 rpois, 119 runif, 10, 11, 118 S, 1, 2 S+, 1 S-PLUS, 1 sample, 32, 37, 57, 61, 91, 9598, 101, 117, 119 sapply, 51, 87, 90, 9193, 96, 97, 101, 130, 132, 145 save.image, 4, 8, 128 Scheme, 2 sd, 47, 57, 98 search, 51, 60 seq, 10, 30, 36, 44, 55, 60, 96 simulation nombres uniformes, 115 planication, 129136 variables alatoires, 116
quantile, 47 quantile, 47, 57 racine dun polynme, 109 dune fonction, 108 rang, 45 range, 47, 57
158
sin, 28 solve, 11, 49, 57 which, 45, 56 which.max, 46, 56 which.min, 46, 56 while, 51, 59, 82
Index
somme, 47 cumulative, 48 sort, 45, 55 source, 134 start, 79, 80, 98, 100 stop, 99 structure, 99 style, 77 suite de nombres, 44 sum, 19, 47, 57, 58, 9597, 111 summary, 47, 57, 94, 100 switch, 51 system.time, 81
T, voir TRUE t, 11, 49, 57 table, 119
WinEdt, 8
tableau, 61, 88 tail, 45, 56 tri, 45 TRUE, 16, 77 trunc, 46, 57 typeof, 17
unique, 45, 56 uniroot, 108, 109 unlist, 26, 36, 96 upper, 109, 110, 112
valeur prsente, 63, 7072 var, 47, 57, 82 variable globale, 74 locale, 74 variance, 47 vecteur, 20, 41 vector, 33, 35 vide, voir NULL
ISBN 978-2-9811416-2-0
9 782981 141620

Goulet Introduction Programmation R

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Goulet Introduction Programmation R

Transféré par

Droits d'auteur :

Formats disponibles

Introduction la programmation en R

2012 Vincent Goulet

Table des matires

Oprateurs et fonctions 3.1 Oprations arithmtiques . . . . . . . . . . . . . . . . . . . . . . . . vii

Table des matires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 43 44 50 51 52 60 63 63 64 66 68 69 70 73 73 74 74 75 76 76 77 78 82

F IG . 1.1: Fentre de la console sous Mac OS X au dmarrage de R

1.5. diteurs de texte

8 mandes essentielles pour y faire ses premiers pas.

Anatomie dune session de travail

Consulter laide en ligne

[1] 5 > pi [1] 3.141593 > cos(pi/4) [1] 0.7071068

Conventions pour les noms dobjets

2.3. Les objets R

TAB. 2.1: Modes disponibles et contenus correspondants

> v <- c(1, 2, 5, 9) > mode(v) [1] "numeric"

La longueur dun objet est obtenue avec la fonction length :

Modes et types de donnes

On obtient le nombre de caractres dans un chane avec la fonction nchar :

Lobjet spcial NULL

2.3. Les objets R

Valeurs manquantes, indtermines et infinies

Extraire un attribut qui nexiste pas retourne NULL :

linverse, donner un attribut la valeur NULL efface cet attribut :

22 La fonction de base pour crer des matrices est matrix :

2.5. Matrices et tableaux

(b) quatre dimensions

> m[1, 2] [1] 45

On peut aussi ne donner que la position de llment dans le vecteur sousjacent :

> m[3] [1] 45

2.7 Data frames

> x[x > 0] A B E 2 4 8

> x[c("B", "D")] B D 4 -5

dim(x)[1] ncol(x) dim(x)[2]

# idem # nombre de colonnes # idem

x[1, 1, ] x[1, , 1] ### ### LISTES ###

# carotte d'avant l'arrire # carotte de gauche droite

x$joueur x$score[1] x[["expert"]] x$level <- 1

x[x < 10] x[c("a", "k", "t")] x[] x[numeric(0)]

2.1 a) crire une expression R pour crer la liste suivante :

40 2.3 Soit x une matrice 10 7 obtenue alatoirement avec

> 1:10 + rep(2, 10) [1] 3 4 5 6 7 8 9 10 11 12

> 1:10 + rep(1:5, 2) + rep(c(2, 4), 5) [1] 4 8 8 12 12 11 11 15 15 19

3.3. Appels de fonctions

TAB. 3.1: Principaux oprateurs du langage R, en ordre dcroissant de priorit

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)

Quelques fonctions utiles

rptition de valeurs ou de vecteurs

3.4. Quelques fonctions utiles

tri en ordre croissant ou dcroissant

rang des lments dun vecteur dans lordre croissant ou dcroissant

extraction des lments diffrents dun vecteur

Recherche dlments dans un vecteur

Les fonctions de cette sous-section sont toutes illustres avec le vecteur

positions des valeurs TRUE dans un vecteur boolen

position du minimum dans un vecteur

position du maximum dans un vecteur

position de la premire occurrence dun lment dans un vecteur

appartenance dune ou plusieurs valeurs un vecteur

Les fonctions de cette sous-section sont toutes illustres avec le vecteur

arrondi un nombre dni de dcimales (par dfaut 0)

plus grand entier infrieur ou gal largument

plus petit entier suprieur ou gal largument

troncature vers zro ; diffrent de floor pour les nombres ngatifs

3.4. Quelques fonctions utiles