POLY SASetR 2016

1 2
Masters 1 ISEFAR, EA, MBFA

2015-2016
Cours d’initiation à SAS et R
Cécile Durot et Olivier Couronné
4 TABLE DES MATIÈRES
Table des matières
1 Introduction à SAS 5
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2 Mise en route . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Organisation des données sous SAS : l’étape data . . . . . . . . . . . . . . . 9
1.4 L’étape proc ; exemples de procédures . . . . . . . . . . . . . . . . . . . . . . 22
1.5 Le macro-langage SAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.6 Compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2 Introduction à R 51
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.2 Mise en route . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
2.3 Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.4 Lire et enregistrer des données . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2.5 Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.6 Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Nota Bene. Pour tous les exemples fournis dans ce document, il est demandé de sai-
sir le code dans la fenêtre adéquate, d’éxécuter ce code, de vérifier qu’il est correctement
exécuté (examiner les éventuels messages d’erreur), et de corriger la saisie si nécessaire. At-
tention à respectec la syntaxe exacte. Lorsque le code est correctement exécuté, sauvegarder
le code et les résultats obtenus dûment commentés (par exemple dans un document ope-
noffice ou word). Dans ce cours, les fichiers sont souvent placés dans le dossier C:\temp ;
suivant la version de Windows, il conviendra éventuellement de les placer dans le dossier
C:\users\etudiant\Bureau.
3
6 CHAPITRE 1. INTRODUCTION À SAS
1.6.4 Le langage de bases de données SQL . . . . . . . . . . . . . . . . . . 45

1.6.5 Le langage matriciel IML ; connexion avec R . . . . . . . . . . . . . . 47
1.1 Introduction
Chapitre 1 SAS est un système (à la fois logiciel et langage de programmation) permettant l’accès, la
gestion, l’analyse et la présentation des données (nombres ou caractères alpha-numériques).
SAS est subdivisé en plusieurs modules destinés à des types de traitement particulier : par
Introduction à SAS exemple, SAS de base (module incontournable contenant le langage de gestion des données),
SAS/STAT pour les statistiques, SAS/IML pour les calculs matriciels, SAS/GRAPH pour les
graphiques. Certains modules (comme Insight et Enterprise) permettent un traitement de
l’information sans nécessiter d’écrire un programme, et donc, sans connaı̂tre la syntaxe SAS.
Le module Enterprise guide peut même générer du code modifiable par l’utilisateur. SAS
Sommaire
est un logiciel payant, qui ne s’achète pas mais se loue par modules.
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Plusieurs utilisations du logiciel sont disponibles : unix, windows, mode interactif ou non
1.2 Mise en route . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
interactif. Nous nous intéressons ici plus particulièrement au mode non interactif sous win-
1.2.1 Installation de SAS . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
dows.
1.2.2 Manager de fenêtres . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.3 Principes généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Documents et ouvrages d’initiation à SAS :
1.2.4 Mise en forme du listing (pages output) . . . . . . . . . . . . . . . . 8
— Consulter en priorité le guide d’utilisation de SAS. Il comporte de nombreux exemples
1.3 Organisation des données sous SAS : l’étape data . . . . . . . . . 9
et la description détaillée de chaque procédure. Accessible à l’adresse
1.3.1 Création de tableaux par lecture . . . . . . . . . . . . . . . . . . . . 9 http://support.sas.com/documentation/onlinedoc/bookshelf/94/desktop.html
1.3.2 Création, lecture et gestion de fichiers permanents SAS . . . . . . . 13 (taper sas online doc dans un moteur de recherche)
1.3.3 Manipulation de tableaux SAS . . . . . . . . . . . . . . . . . . . . . 13 — Un cours très fourni sur le site polymorphe (rechercher ’sas’ sur ce site) :
1.3.4 Gestion des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 http://www.polymorphe.org/index.php?/Voir-details/13-SAS-cours-IUT-STID
1.3.5 Gestion des observations . . . . . . . . . . . . . . . . . . . . . . . . . 18 — Une introduction générale avec SQL et IML :
1.3.6 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 http://maths.cnam.fr/IMG/pdf/SAS COURS 1-2.pdf
1.4 L’étape proc ; exemples de procédures . . . . . . . . . . . . . . . . 22
1.4.1 Les options génériques . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.4.2 Les instructions génériques . . . . . . . . . . . . . . . . . . . . . . . 23 1.2 Mise en route
1.4.3 Quelques procédures de gestion et édition de tableaux . . . . . . . . 23
1.4.4 Quelques procédures graphiques . . . . . . . . . . . . . . . . . . . . 26 1.2.1 Installation de SAS
1.4.5 Etude d’un échantillon : les procédures univariate et means . . . . 28 Pour installer SAS sur votre ordinateur, rendez-vous à l’adresse
1.4.6 Régression linéaire sur variables quantitatives : la procédure reg . . 30 https://lad.education-recherche.fr
1.4.7 Quelques autres procédures de statistiques . . . . . . . . . . . . . . . 33 et laissez vous guider.
1.5 Le macro-langage SAS . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.5.1 Macro-variables définies par l’utilisateur . . . . . . . . . . . . . . . . 35
1.2.2 Manager de fenêtres
1.5.2 Macro-variables automatiques . . . . . . . . . . . . . . . . . . . . . . 36
1.5.3 Utilisation de macro-variables . . . . . . . . . . . . . . . . . . . . . . 36 Une fois SAS installé, selon le système d’exploitation, on peut lancer SAS en tapant SAS
1.5.4 Macro-variables locales ou globales . . . . . . . . . . . . . . . . . . . 37 & dans une fenêtre de commandes (le symbole & permet de garder la main) et/ou en cliquant
1.5.5 Les macros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 sur l’icone. On a alors accès à des menus déroulants (fichier, Edition. . .) et plusieurs fenêtres :
1.5.6 Compléments sur le macro langage . . . . . . . . . . . . . . . . . . . 39 — Editeur ou Editor : pour taper, charger du code SAS à exécuter
1.6 Compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 — Sortie ou Output : pour visualiser les résultats après exécution,
1.6.1 Valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 — Journal ou Log : pour récupérer la trace d’exécution, et s’assurer que les instructions
1.6.2 Les dates dans SAS . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 SAS ne contiennent pas d’erreur syntaxique (messages Warning, error de di↵érentes
1.6.3 Exporter et importer ; connexion avec Excel . . . . . . . . . . . . . 42 couleurs). Il est important de consulter ces messages (depuis le début !), même si le
5
1.2. MISE EN ROUTE 7 8 CHAPITRE 1. INTRODUCTION À SAS
programme semble avoir été bien exécuté : vérifiez par exemple que vos tableaux de /⇤ commentaire ⇤/
données ont été correctement définis. ou
⇤ commentaire;
Les noms SAS (nom de variable, de tableau etc ...) doivent comporter au plus 32 ca-
ractères, commencer par une lettre ou un blanc souligné et ne pas comporter de blanc. Ils
peuvent comporter des chi↵res. Un nom attribué par l’utilisateur ne peut pas être l’un des
noms SAS réservés.
Une liste SAS est une suite de mots séparés par un (ou plusieurs) blanc(s).
1.2.4 Mise en forme du listing (pages output)

Depuis la version 9.3, les résultats ne s’affichent plus dans la fenêtre output mais dans une L’instruction title
fenêtre ouverte automatiquement à l’éxécution, au format html. Pour nettoyer cette fenêtre, Par défaut, SAS indique en haut de chaque page output le titre “The SAS System”. Il est
on peut valider les commandes suivantes dans la fenêtre Editeur : ods html close; ods possible de modifier ce titre grâce à l’instruction title, qui peut figurer en tout endroit du
html; programme SAS selon la syntaxe
title ’titre’ ;
On peut entrer les commandes SAS (exécuter un programme, gérer les fenêtres, . . .) L’e↵et de cette commande persiste jusqu’à la fin de la session SAS, à moins d’être modifié
soit en utilisant la fenêtre de commandes (petite fenêtre rectangulaire ne comportant qu’une par une nouvelle instruction title ou d’être éliminé par l’instruction
ligne), ou en utilisant le menu et la souris. Citons quelques commandes et raccourcis clavier : title;
— Submit ou End exécute le programme de la fenêtre Program editor (raccourci F8). On peut spécifier jusqu’à 10 lignes de titres. Par exemple, les instructions
— Clear nettoie la fenêtre courante (raccourci CTRL E). title1 ’Presidents’;
— File permet de sauvegarder la fenêtre active dans un fichier (raccourci CTRL S).
title3 ’democrates’;
— recall pour rappeler le dernier code soumis dans la fenêtre editeur (raccourci F4).
permettent d’écrire President en première ligne et democrates en troisième ligne. L’instruc-
— key pour obtenir la liste des raccourcis clavier (raccourci F9).
tion title1 produit le même e↵et que title. On élimine le titre de la n-ième ligne ainsi que
tous les suivants par l’instruction
Attention : En fin de session, le contenu des fenêtres et les résultats ou données genérés
titlen;
au cours de la session sont détruits. Il convient donc de sauvegarder tout ce que nécessaire.
Redéfinir le titre de la n-ième ligne supprime tous les suivants. Pour supprimer tous les titres,
taper title;
1.2.3 Principes généraux
Un programme SAS est une succession d’étapes data et d’étapes proc. Le début d’une L’instruction footnote
étape est repéré par le mot clé data ou proc tandis que la fin d’une étape est repérée par Similaire à l’instruction title, pour des commentaires en bas de pages output.
le début de l’étape suivante ou par l’instruction run;. Chaque étape est constituée d’une
suite d’instructions commençant souvent par un mot clé et se terminant toujours par “ ;”. Les L’instruction options
étapes data permettent d’organiser les données sous une forme acceptable pour SAS tandis Dans les versions antérieures à 9.3, par défaut, SAS numérote et date les pages output, et
que les étapes proc permettent, par le biais de sous-programmes disponibles sur SAS, de affiche les di↵érents résultats sur des pages di↵érentes, en les centrant. Cette présentation
traiter ces données. peut être modifiée grâce à l’instruction
options liste-d’options ;
La présentation d’un programme SAS est libre, puisque seul le caractère “ ;” détermine en début de programme. L’e↵et des options ainsi définies persiste jusqu’à la fin de la session
la fin d’une instruction. Ainsi, une instruction peut occuper plusieurs lignes, occuper ou non SAS, ou jusqu’à ce qu’elles soient modifiées. Citons quelques options possibles : nonumber
les premières colonnes de chaque ligne ; une même ligne peut contenir plusieurs instructions. élimine la numérotation des pages, nocenter aligne le texte à gauche, nodate supprime la
De plus, les instructions peuvent être saisies indi↵éremment en minuscules ou majuscules. date, pagesize=nombre impose le nombre de lignes par page, linesize=nombre impose le
Pour plus de lisibilité, on préfère généralement écrire une seule instruction par ligne, mettre nombre de caractères par ligne, formdlim=’delimiter-character’ précise comment délimiter les
en évidence les di↵érentes étapes data et proc en écrivant les mots data et proc en début de pages. Par exemple, formdlim=’’ crée physiquement une nouvelle page pour chaque page de
ligne et en décalant à droite les autres instructions, insérer des commentaires sous la forme sortie, tandis que formdlim=’-’ sépare les pages de sortie par une ligne.
1.3. ORGANISATION DES DONNÉES SOUS SAS : L’ÉTAPE DATA 9 10 CHAPITRE 1. INTRODUCTION À SAS
1.3 Organisation des données sous SAS : l’étape data Si le symbole @@ n’est pas spécifié en fin d’instruction input, les données doivent être saisies
(à la suite de l’instruction cards ou dans un fichier) à raison d’une observation maximum
Le système SAS organise les données sous forme de tableaux appelés sas data set ou par ligne (par défaut, SAS va à la ligne lorsque l’observation courante est incomplète pour
table ou tableau. Dans une table, chaque ligne est appelée observation (ou individu) et pouvoir lire les autres variables, et passe à la ligne suivante lorsqu’il a terminé la lecture d’une
chaque colonne est appelée variable. Les données peuvent être de type numérique (s’il s’agit observation). La ième donnée doit correspondre à la valeur de la ième variable déclarée dans
d’un nombre) ou alpha-numérique (s’il s’agit d’une chaine de caractères ; on parle aussi de l’instruction input. Si aucun format n’est précisé pour les variables, les données doivent être
variable caractère, et par défaut, les valeurs de ces variables sont tronquées à 8 caractères). Une séparées par un ou plusieurs blancs. Si @@ est spécifié en fin d’instruction input, il est possible
étape data permet de mettre les données sous forme de tableaux, de définir des variables (par de saisir plusieurs observations par ligne. Pour déclarer les variables :
lecture ou par calcul), d’ajouter et/ou de supprimer des observations et/ou des variables, de - On donne la liste des noms de variables, après le mot input et avant le ;
fusionner ou de concaténer des tableaux pré-existants. Une étape data ne donne lieu à aucune - Si une variable est de type caractère, son nom doit être suivi du symbole $, le nom et le
sortie (utiliser une procédure print pour éditer le tableau créé). La syntaxe est : $ étant ou non séparés par un blanc. On peut faire suivre le symbole $ de “ :nombre.”
data nom1 nom2 ... nomn; pour indiquer que les valeurs de la variable peuvent contenir jusqu’à nombre caractères,
instructions ; lorsque ce nombre est supérieur à 8 (sinon, les valeurs sont tronquées à 8 caractères).
run; - On peut faire suivre le nom d’une variables (ou le symbole $ associé s’il y a lieu) de
Le mot data signale le début d’une étape data, nom1 nom2 . . .nomn sont les noms at- “nombre.” où nombre est le nombre de caractères occupés par cette variable.
tribués aux tableaux créés par cette étape. Le choix d’un nom de tableau est libre, à condition - Dans le cas de données organisées en colonnes, on peut faire suivre le nom d’une
de contenir 32 caractères maximum et de commencer par une lettre ou un blanc souligné. Si variable (ou le symbole $ associé s’il y a lieu) par les numéros de colonnes de début et
aucun nom n’est précisé, SAS attribue par défaut les noms data1, data2, etc . . .Le run est de fin “n1-n2” sur lesquelles sont saisies les valeurs correspondantes (dans un fichier ou
facultatif si l’étape data est suivie d’une autre étape. Noter que SAS fonctionne de la façon dans le programme). Ceci autorise par exemple les variables à comporter des blancs,
suivante : les données correspondant à une observation sont lues, puis chaque instruction de ou plus de 8 caractères, mais les données doivent être saisies en tenant compte de ce
l’étape data concernant cette observation est exécutée avant que cette observation ne soit format.
enregistrée dans la table en création et que ne soient lues les observations suivantes. - On peut faire précéder le nom de la variable par @numero où numero est le numéro de
colonne sur laquelle doit commencer la lecture de la variable : l’option @numero place
1.3.1 Création de tableaux par lecture le curseur permettant de lire les données au caractère numero. De même, +n déplace
le curseur de n colonnes vers la droite, et / déplace le curseur à la ligne suivante.
Pour créer une table SAS par saisie de données, la syntaxe est Par exemple, l’instruction
data nom; input var1 1-8 var2 $ 10-15 @17 var3;
<infile cards <liste-d’options>;> déclare deux variables numériques var1 et var3 et une variable caractère var2. Les valeurs
input liste-de-variables <@@>; de var1 sont à lire sur les colonnes 1 à 8, celles de var2 sur les colonnes 10 à 15, et celles de
cards; var3 à partir de la colonne 17.
donnees
; L’instruction cards
run; Lorsque les données sont saisies au cours d’une étape data, l’instruction input doit être sui-
Noter l’absence de point-virgule sur les lignes de saisie de données. Pour créer une table SAS vie de l’instruction cards. Les données doivent être saisies sur la ligne immédiatement après
à partir de données stockées dans un fichier .txt, la syntaxe est cards;, les di↵érentes valeurs sur une même ligne étant séparées par au moins un blanc, les
data nom; données manquantes étant indiquées par un point (SAS prévoit le traitement des données
infile ’nom-de-fichier’ <liste-d’options>; manquantes). La fin de la saisie est indiquée par un point vigule, qui doit figurer seul sur une
input liste-de-variables <@@>; ligne.
run;
Exercice 1.1 Tapez et exécutez les instructions SAS suivantes, puis renouvelez en rem-
L’instruction input plaçant la ligne input par input pays $ :12. genre $ nb typ $ val;. Renouvelez encore
Elle indique comment lire les données et comment définir les variables qui constitueront la en faisant en sorte que la valeur agriculture ne soit pas tronquée. Essayez sans le $ après
nouvelle table en indiquant leur nom, leur type et éventuellement leur format. Elle est tou- pays.
jours associée data ex1;
- à une instruction cards si les données sont saisies dans le programme SAS même. input pays $ genre $ nb typ $ val;
- à une instruction infile si les données sont stockées sur support externe (fichier). cards ;
Irlande Femmes 598 Services 79.3
Irlande Hommes 931 Agriculture 15.6 cards (avec infile cards) ou dans un fichier (avec infile nom-de-fichier). Dans ce dernier
Luxembourg Femmes 56 Industrie 6.6 cas, les données doivent avoir été saisies et sauvegardées dans un fichier de la même façon que
Luxembourg Femmes 56 Services 92.1 l’on aurait saisi ces données suite à une instruction cards. Si le fichier contient des variables
; qu’on ne souhaite pas traiter, il suffit de ne pas les décrire dans l’instruction input, mais il
proc print; run; est alors obligatoire de préciser les colonnes occupées par les valeurs de ces variables.
Parmi les options possibles pour l’instruction infile, citons firstobs et obs, qui in-
Exercice 1.2 Voici les températures, degrés d’hygrométries et superficie pour les di↵érentes diquent respectivement le numéro de ligne de la première et de la dernière observation à
pièces d’un appartement : prendre en compte lors de la lecture des données (par exemple, firstobs=2 si la première
ligne correspond à un titre), dlm=, qui précise le caractère séparateur (un blanc par défaut,
Salon 2041186 mais ce peut être par exemple une tabulation notée ’09’x ou une virgule ’,’), missover,
Cuisine 2146115 qui empêche SAS de passer à la ligne pour terminer la lecture d’une observation (si une
Chambre 1943108 observation est incomplète sur une ligne, il sera attribué une valeur manquante aux dernières
variables de cette observation) et truncover, qui permet de lire sans difficulté des données
La température est donnée sur 2 chi↵res, le degré d’hygrométrie également et la superficie est organisées en lignes de plus de 80 caractères (la longueur d’une ligne de données étant par
donnée avec 3 chi↵res. Ecrire le programme permettant de rentrer ces données en utilisant défaut de 80).
input nom $ temp 2. hydr 2. aire 3.
Exercice 1.6 Utilisez un éditeur de texte pour créer dans le répertoire C:\temp un fichier
Exercice 1.3 Tapez et exécutez les instructions SAS suivantes, puis renouvelez avec l’ob- europe.txt contenant les données
servation supplémentaire FRANCE 1952 1970 76.5 en précisant la position de la variable an Allemagne 82 356854 23950 1957 euro
en colonnes 13 à 16. Autriche 8.1 8358 26680 1995 euro
data desc; Pour cela, e↵ectuez un clic droit dans le dossier, allez dans “nouveau” puis dans “document
input pays $ 1-12 an va vb; texte”. Saisissez les données puis sauvegardez, en vérifiant que l’extension retenue est .txt et
cards ; qu’en particulier, vous n’avez pas mis une extension .txt.txt. Exécutez ensuite dans SAS
NEW ZEALAND 1950 1914 80.9 les commandes
NEW ZEALAND 1951 1960 72.5 data europe ;
; infile ’C:\temp\europe.txt’;
proc print; run; input pays $ population superficie pib date monnaie $ ;
run;
Exercice 1.4 Tapez et exécutez les instructions SAS suivantes. proc print; run;
data tab ; Noter que l’on a ici précisé le chemin absolu du fichier.
input pays $ @37 X Y;
cards ; Exercice 1.7 Editer les tableaux suivants (procédure print). Les comparer. Dans le second,
Belgique "donnees a verifier" 166 23 ajouter un $ après y et observez comment SAS gère les valeurs alphanumériques vides.
France "l’annee 1982 est manquante" 191 21
; data tab; data tab;
data tab;
proc print ; run ; infile cards missover; infile cards;
input x y;
input x y; input x y;
cards;
Exercice 1.5 Nous disposons de deux notes pour plusieurs étudiants, présentées comme suit : cards; cards;
8 .
8 8
. 9
12 15 16 08 11 09
6
19 18 06 04 9 9
.
6 6
Ecrivez le programme permettant de rentrer les données dans le data notes en utilisant ;
; ;
input note1 note2 @@;
Enlevez le @@ et observez le résultat. Utiliser des labels : l’instruction label
Pour plus de lisibilité des listings, on peut associer un libellé, ou label, à une variable. On
L’instruction infile cards ou infile nom-de-fichier utilise pour cela l’instruction label au cours de l’étape data où est définie cette variable.
Elle doit précéder l’instruction input et permet de localiser les données : suite à l’instruction La variable peut alors être représentée par son label (et non plus par son nom) sur les pages
output. Pour que ces labels soient utilisés au cours de procédures, il convient de faire suivre L’instruction set permet de créer un nouveau tableau à partir d’un tableau existant. Les
le nom de la procédure par l’option label dans l’étape proc (par défaut, une variable est instructions
représentée par son nom même si un label lui a été associé). La syntaxe de l’instruction label data nom2;
est : set nom1;
label nom-de-variable=’chaine-de-caractères’; <instructions;>
La chaine de caractères peut comporter jusqu’à 256 caractères, y compris des blancs. Cette run;
instruction peut être utilisée au cours d’étapes proc ou d’étapes data. créent un nouveau tableau nom2 à partir du tableau existant nom1. Les instructions (par
exemple keep, drop, if... décrites ci-après) indiquent comment modifier les données de
1.3.2 Création, lecture et gestion de fichiers permanents SAS nom1 pour construire nom2. Si nom1 est un fichier permanent SAS, on fait précéder l’étape
data de l’instruction
Les tableaux créés ci-dessus sont temporaires : leur existence se limite à la durée de la libname librairie "adresse du fichier SAS " ;
session. Plus précisément, les tableaux sont crées dans le répertoire Work qui est automati-
quement nettoyé en fin de session. Pour créer un tableau permanent dans un fichier (qui est
alors binaire), on fait précéder l’étape data de création de tableau par l’instruction Exercice 1.9 Exécutez les instructions SAS ci-dessous. Ici, la procédure contents produit
libname librairie "répertoire " ; un résumé des caractéristiques du tableau spécifié après data=.
et on attribue au tableau un nom de la forme librairie.nom. L’instruction libname indique /*Analyse des donnees europeennes, acces aux donnees*/
à SAS dans quel répertoire (ou librairie) enregistrer le fichier, ainsi que le nom sous lequel libname repdata ’c:\temp’;
ce répertoire sera désigné sous SAS. Ce nom doit comporter au plus 8 caractères et ne peut data fic1;
pas être le nom de l’une des librairies allouées automatiquement par SAS (work, qui est est set repdata.europe;
la librairie utilisée par SAS pour les jeux de données temporaires, sasuser, sashelp, maps). run;
Lorsqu’une table SAS a été stokée dans un fichier permanent nom du répertoire répertoire, proc print data=fic1; run;
on peut le récupérer sous SAS par les instructions proc contents data=fic1; run;
libname librairie "répertoire "; Concaténation de tableaux
data nom2; L’instruction set permet également de concaténer des tables SAS. Les instructions
set librairie.nom; data nom;
run; set nom1 nom2 ... nomn;
Il convient ici de donner le chemin absolu du répertoire. <instructions;>
run;
Les fichiers permanents SAS peuvent être gérés grâce à le procédure datasets, qui permet créent un nouveau tableau nom en lisant d’abord toutes les observations du tableau nom1,
par exemple de les copier d’une librairie à une autre, de les renommer, de les supprimer, d’en puis toutes les observations de nom2, jusqu’à nomn. Sauf indication contraire (drop), nom
gérer le mot de passe, de lister les tableaux SAS présents dans une librairie. comporte toutes les variables apparaissant dans l’un au moins des tableaux appelés (nom1
Exercice 1.8 Exécutez les instructions SAS ci-dessous, observez la fenêtre log, et vérifiez nom2 ... nomn). Si une variable figure dans l’un des tableaux appelés mais pas un autre, elle
qu’un fichier SAS a bien été créé dans le répertoire adéquat. Quel est son nom ? apparait dans nom avec des valeurs manquantes pour les observations issues des tableaux
libname repdata ’c:\temp’; appelés dans lesquels elle ne figure pas. Les instructions (par exemple keep, drop, if...
data repdata.europe ; décrites ci-après) indiquent comment modifier les données des tableaux appelés pour créer le
infile ’C:\temp\europe.txt’; nouveau tableau. On peut appeler jusqu’à 100 tableaux.
input pays $ population superficie pib date monnaie $ ; On peut, grâce à l’option IN=nomIN, di↵érencier des autres les observations provenant de
run; l’un des tableaux appelés. Cette option, placée entre parenthèses dans l’instruction set après
proc print data=repdata.europe; run; le nom de ce tableau, crée une variable temporaire nomIN, qui vaut 1 pour les observations
issues de ce tableau et 0 pour les autres. Cette variable n’est pas ajoutée au tableau en cours
mais peut être utile pour créer de nouvelles variables dont la valeur en une observation dépend
1.3.3 Manipulation de tableaux SAS
de la provenance de cette observation. On peut utiliser cette option avec chacun des tableaux
Il est possible de créer de nouveaux tableaux SAS à partir de tableaux SAS existants. appelés par l’instruction set. Par exemple,
Les formes d’appel les plus fréquemment utilisées sont set et merge, qui indiquent que l’on data tab3;
va travailler sur un (des) tableau(x) existants (jusqu’à 100 tableaux). set tab1 (IN=ind) tab2;
<instructions;>
Modification d’un tableau run;
concatène les tableaux tab1 et tab2, et crée une variable ind qui vaut 1 pour les observations T X Z T Y Z
issues de tab1 et 0 pour les autres. 4 X4 Z4 5 Y5 ZP5
5 X5 Z5 6 Y6 ZP6
Fusion de tableaux 6 X6 Z6 7 Y7 ZP7
La fusion de tableaux est réalisée par les instructions set ou merge. La syntaxe est Pour la création de FA, le input sera donc input T X $ Z $ ;.
data nom; 2. L’option (IN=ind) peut s’employer dans l’instruction merge comme dans l’instruction
set nom1; set nom2; ...set nomn; set. Que produisent donc les commandes suivantes ?
<instructions;> data tab; merge FA(in=A) FB(in=B); by t;
run; if A and B; run;
ou bien Essayer sans la commande if A and B; puis avec if not B à la place de if A and
data nom; B.
merge nom1 nom2 . . .nomn;
<instructions;> Mise à jour d’un tableau
run; L’instruction update permet de mettre à jour un tableau à partir d’un autre. Nous ne
Chaque instruction set (ou l’instruction merge) apporte des éléments à la même ligne du détaillons pas son utilisation.
data nom. Si une variable est commune à plusieurs tableaux appelés, la valeur retenue est
celle du dernier tableau concerné. Si l’instruction set est utilisée, le processus s’arrête dès que 1.3.4 Gestion des variables
SAS rencontre une fin de tableau, tandis que si l’instruction merge est utilisée, le processus
se poursuit jusqu’à épuisement des données et les tableaux les plus courts sont complétés par Des instructions SAS permettent de créer de nouvelles variables et/ou d’éliminer certaines
des données manquantes. Ici encore, on peut modifier les données en utilisant les commandes variables ou observations. Elles doivent être placées dans l’étape data, après l’instruction data
delete, keep, drop... décrites ci-après. et avant l’instruction cards, si l’étape data en contient une.
L’instruction merge peut être employée pour fusionner plusieurs tableaux selon une va-
riable commune. Les tableaux doivent pour cela être classés selon cette variable commune Instructions d’a↵ectation
(grâce à la proc sort), et il convient alors de faire suivre l’instruction merge par l’instruc- L’instruction
tion resultante=expression ;
by nom-de-variable; permet de modifier la valeur d’une variable pré-existante, ou de créer une nouvelle variable
qui précise le nom de cette variable commune. en lui a↵ectant une valeur. Le membre de droite (qui peut être le nom d’une variable définie
dans le tableau en cours, une constante ou une expression avec ou sans fonction) est évalué et
Exercice 1.10 Créer les tableaux suivants, concaténer Tab1 et Tab3, puis fusionner Tab1 sa valeur est stockée dans la variable résultante désignée au membre de gauche. Le membre
et Tab2. Combien de variables la fusion de Tab1 et Tab2 comporte-t-elle ? Fusionner ensuite de droite indique à SAS le type de la nouvelle variable : caractère si l’expression est entre
Tab1 et Tab3 en utilisant set puis en utilisant merge. quotes (simples ou doubles), numérique sinon. Il indique également le format de la nouvelle
variable : c’est la longueur de la première occurence de cette variable. Si ce format ne vous
Tab1 Tab2 Tab3 convient pas, spécifiez le format de votre variable en début d’étape data grâce à l’instruction
x y x z x y length.
1 2 3 5 2 3
7 9 6 8 Exercice 1.12
Reprenez le tableau tab1 de l’exercice 1.10 et tapez les instructions suivantes :
Pour le premier tableau, on exécutera data tab2;
data Tab1 ; input x y ; cards ; set tab1;
1 2 length T $ 5;
7 9 z=(x+y)**2+4;
; T=’oui’;
run ; u=log(z);
run;
Exercice 1.11 1. Créez les deux tableaux FA et FB suivants (noter que ces tableaux Editez le tableau créé. Il contient les variables x, y, z, u et T. Les variables z et u sont
possèdent tous deux des données pour T=5 et T=6) : numériques (et ne peuvent être ainsi définies que si les variables x et y sont numériques),
tandis que T est une variable caractère.
On peut également modifier une variable. Par exemple, l’instruction x=x/10; remplace les et le poids. Cette table est présente dans la bibliothèque SASHELP, sous le nom de class.
valeurs de x par ces valeurs divisées par 10. 1. Copiez la table sashelp.class dans la table enfants1.
2. Copiez la table enfants1 dans la table enfants2, en renommant les variables name et
SAS met à votre disposition les opérateurs arithmétiques ( , +, ⇤, /, ⇤⇤) les fonctions sex en prenom et genre, et en créant la variable taille (donnant la taille exprimée
classiques, des fonctions arithmétiques et statistiques. En voici quelques exemples : en cm) valant height multiplié par 2,54, ainsi que la variable poids (donnant le poids
— abs(x) valeur absolue de x exprimé en kg) valant weight multiplié par 0,454. Utilisez à bon escient la commande
— int(x) partie entière de x drop et éditez la table créée.
— fuzz(x) si x est à mois de 10 12 d’un entier, fuzz(x) vaut cet entier. 3. Calculez, pour chaque enfant, l’indice de masse corporelle, obtenu en divisant le poids
— max(x1,...,xn) plus grande valeur non manquante (exprimé en kg) par la taille (exprimée en m) au carré. Stockez les valeurs dans une
— min(x1,...,xn) plus petite valeur non manquante variable IMC.
— round(x) ou round(x,d) arrondit x à l’unité d’ordre d la plus proche. Par exemple, 4. Exécutez les commandes suivantes puis éditer la table obtenue (procédure print).
round(3.251) vaut 3 et round(325.1,100) vaut 300 data nomgenre;
— sqrt(x)racine carrée de x set enfants2;
— sign(x) vaut -1, 0 ou 1 selon que x est négatif, nul ou positif keep prenom genre;
— arcos(x), arsin(x), cos(x), tan(x) : fonctions trigonométriques (x est exprimé 5. Renouvelez la question précédente en remplaçant keep par drop.
en radians) 6. Créez aléatoirement une variable contenant la couleur des cheveux selon le code 1= brun ,
— exp(x), log(x) exponentielle et logarithme népérien de x 2= châtain et 3= blond :
— log2(x), log10(x) logarithme de base 2 et 10 de x data enfants;
— probnorm(x) fonction de répartition de la loi Gaussienne centrée et réduite au point set enfants2;
x cheveux=int(3*ranuni(4))+1;
— probit(p) fonction inverse de la fonction probnorm : donne la valeur x telle que 7. Editez la table enfants et sauvegardez-la sous forme d’une table permanente dans le
probnorm(x)=p (0 < p < 1) réptoire C:\temp.
— probf(x,d1,d2) fonction de répartition de la loi de Fisher-Snedecor à d1 et d2 degrés
de liberté au point x (x 2 R, d1 > 0, d2 > 0) Exercice 1.14 On reprend ici le tableau enfants de l’exercice 1.13.
— finv(p,d1,d2) fonction inverse de la fonction probf : donne la valeur x telle que 1. Créer une table poids contenant uniquement le poids et le prénom des enfants en
probf(x,d1,d2)=p (0 < p < 1) exécutant les commandes
— tinv(p,d) inverse de la fonction de répartition de la loi de Student à d degrés de data poids;
liberté : donne la valeur x telle que P (T  x) = p si T ⇠ t(d), 0 < p < 1. set enfants;
— probchi(x,n) fonction de répartition de la loi de 2 à n degrés de liberté. keep prenom poids;
Les instructions keep et drop 2. Créer de même une table taille contenant uniquement la taille et le prénom, puis
L’instruction une table genre contenant uniquement le genre et le prénom.
keep liste-de-variables; 3. Fusionner les trois tables en exécutant :
où liste-de-variables est une liste de noms de variables présentes dans le tableau en cours, data fusion;
permet de ne conserver dans le tableau en cours que les variables citées dans la liste. Si le merge poids taille genre;
nombre de variables à éliminer est faible, on préfère utiliser l’instruction run ;
drop liste-de-variables;
Seules les variables non citées dans cette liste sont alors conservées dans le tableau en cours. 1.3.5 Gestion des observations
On ne peut pas utiliser les instructions drop et keep dans la même étape data. Lorsque l’une
de ces instructions est utilisée, il est conseillé de la faire figurer immédiatement après l’ins- Des instructions SAS permettent d’éliminer certaines observations. Elles doivent être
truction data, afin de laisser ensemble le nom du tableau et son contenu. placées dans l’étape data, après l’instruction data et avant l’instruction cards, si l’étape
data en contient une. Il est également possible d’ajouter des observations à un tableau grâce
L’instruction rename à l’instruction set ci-dessus, ou grâce à la procédure append.
L’instruction rename permet de renommer une variable. La syntaxe est
rename ancien-nom=nouveau-nom ; Les instructions if et where
Elles permettent de sélectionner certaines observations et d’éliminer les autres. La syntaxe
Exercice 1.13 Pour un groupe d’enfants, nous connaissons le prénom, l’âge, le genre, la taille pour if est
if expression-logique; sta2 17 15 9
La syntaxe pour where est identique. Les deux instructions donnent le même résultat : l’ob- ;
servation courante est prise en compte ssi l’expression logique est vraie (i.e. di↵érente de zéro). Une fois le programme compris, ajoutez une instruction keep pour ne garder que les variables
Cependant, where agit comme un filtre sur les observations et est plus rapide que if ; elle d’intérêt.
doit donc être préférée. Voici quelques exemples d’expressions logiques
nom1>10 L’instruction if then / else
(nom1>10) and (nom2<20) Elle permet d’exécuter des instructions conditionnelles. La syntaxe est
T=’non’ if expression-logique then instruction;
Les opérateurs de comparaison sont < ou LT, > ou GT, <= ou LE, >= ou GE, = ou EQ, NE <else instruction;>
pour non égal, IN pour égal à un élément de la liste (par exemple, x IN ("22","29","35")). où l’instruction else est facultative. Par exemple,
Les opérateurs logiques sont and (et), or (ou), not (négation). Placez des parenthèses pour if nom1>10 then nom1=nom1/10;
préciser les priorités dans une expression logique comportant plusieurs opérateurs logiques Dans le cas où plusieurs instructions sont à exécuter après l’instruction then, la syntaxe est
(par défaut, les and sont prioritaires sur les or). Attention, dans les comparaisons de va- if expression-logique then
riables de type caractère, les minuscules sont distinguées des majuscules, et par exemple if do;
T=’non’ n’est pas équivalent à if T=’NON’. De plus, la valeur de ces variables doit être instructions ;
donnée entre quotes (simples ou doubles). end;
<else instruction ;>
L’instruction output La syntaxe est identique si plusieurs instructions sont à exécuter après l’instruction else.
Elle écrit les valeurs courantes des variables dans une observation. Deux instructions souvent utilisées dans ce cadre sont output et delete, selon la syntaxe
La première syntaxe est if expression-logique then delete;
output ; if expression-logique then output;
qui ajoute l’observation à toutes les tables créées par l’étape data. Dans le premier cas, l’observation courante est prise en compte ssi l’expression logique est
La deuxième syntaxe est fausse (c’est-à-dire égale à zéro). Dans le second cas, elle est prise en compte ssi l’expression
output liste de tables ; logique est vraie.
qui ajoute l’observation aux tables de la liste.
Exercice 1.16 Reprenons la table enfants de l’exercice 1.13.
Exercice 1.15 On dispose de plusieurs valeurs de températures pour deux stations, sous la 1. Exécuter les commandes suivantes, puis éditer les tables crées (procédure print).
forme data filles;
Sta1 20 18 15.4 set enfants;
Sta2 17 15 9 if genre= "M" then delete;
data filles2;
A l’aide de l’instruction output et de variables intermédiaires, on va réécrire ces données sous set enfants;
la forme if genre= "F" then output;
Station temp data bruns;
sta1 20 set enfants;
sta1 18 if cheveux=1;
sta1 15.4 2. Sélectionner les enfants faisant plus de 1m60.
sta2 17 3. Sélectionner les enfants bruns faisant plus de 1m50.
sta2 15
sta2 9 Exercice 1.17 Exécuter les commandes suivantes.
data garcons chatains;
Exécutez le programme : set enfants;
data meteo ; if genre="M" then output garcons;
input sta $ t1-t3 ; if cheveux=2 then output chatains;
t=t1 ; output ; t=t2 ; output ; t=t3 ; output ; run;
cards ; proc print data=garcons ;
sta1 20 18 15.4 proc print data=chatains ; run;
L’instruction select / where Exercice 1.20 Créer les tableaux des filles et des garçons de moins de 1m50 en exécutant
L’instruction select permet d’exécuter des instructions conditionnelles. La syntaxe est les commandes suivantes, puis afficher les tableaux créés.
select < (nom-de-variable) > ; data garcons filles;
when (when-condition1) set enfants;
do; where taille <150;
instructions1 ; select(genre);
end; when("F") output filles;
when (when-condition2) bloc-instructions2; otherwise output garcons;
otherwise bloc-instructions3; end;
end; run ;
Si une variable est spécifiée dans l’instruction select, alors chaque when-condition est une
valeur du même type que cette variable. Dans ce cas, les instructions1 sont exécutées si la La variable N
variable spécifiée par select est égale à when-condition1. Sinon, la seconde instruction when SAS associe à chaque sas data set une variable temporaire N , qui numérote les observa-
est lue et ainsi de suite. Les do / end sont facultatifs dans le cas d’une unique instruction. tions. Il est possible d’utiliser cette variable au cours d’une étape data pour selectionner des
Si aucune variable n’est spécifiée dans select, alors les when-conditions sont des ex- observations. Si par exemple on souhaite construire un tableau tab2 comportant uniquement
pressions logiques (comme avec le if). Dans ce cas, les instructions1 sont exécutées si la la première observation du tableau tab1, on peut utiliser les instructions suivantes :
when-condition1 est satisfaite. Sinon, la seconde instruction when est lue et ainsi de suite. data tab2;
L’instruction otherwise est exécutée si aucune when-condition n’est vérifiée. Elle est obliga- set tab1;
toire même si aucune instuction n’y est rattachée. En ce cas, on écrit simplement if N =1;
otherwise ; run;
Il est possible de faire figurer plusieurs instructions when (deux ou plus). L’instruction
select / when permet en particulier de séparer un tableau en plusieurs sous-tableaux (voir 1.3.6 Boucles
les exercices ci-dessous). Bien que l’instruction if / then output permette également de
Il est possible d’éxécuter des boucles au cours d’une étape data. Avec le do itératif, la
séparer un tableau en plusieurs sous-tableaux, il est préférable pour ce problème d’employer
syntaxe est soit
l’instruction select / when, qui est plus rapide.
do ind=début to fin <by pas>;
Exercice 1.18 Découper le tableau enfants (voir exercice 1.13) en fonction des modalités instructions;
de genre en exécutant les commandes suivantes, puis afficher les tableaux créés. end;
data garcons filles; soit
set enfants; do ind=v1,. . .,vn;
select(genre); instructions;
when("F") output filles; end;
otherwise output garcons; Ici, ind est la variable index, début et fin indiquent la plage dans laquelle elle varie, pas indique
end; le pas (1 par défaut), et v1,. . .,vn est la liste des valeurs à parcourir par ind. D’autres types
run ; de boucles sont possibles (do/while, do/until).
Exercice 1.19 Séparer les observations du tableau enfants (voir exercice 1.13) en trois Exercice 1.21 Que produit le programme suivant ? (La fonction rannor permet d’obtenir
groupes suivant leur taille en exécutant les commandes suivantes, puis afficher les tableaux le tirage d’un échantillon i.i.d. de la loi gaussienne centrée réduite.)
créés. data tab5 ; do x=1, 2 ;
data petits moyens grands; do i=1 to 10 ; y=x+rannor(3) ; z=x+1+rannor(5) ; output ; end ; end ;
set enfants;
select; 1.4 L’étape proc ; exemples de procédures
when(taille<150) output petits;
when(taille<160) output moyens; Une procédure est un sous-programme disponible sur SAS qui lit un tableau préalablement
otherwise output grands; défini (par exemple par une étape data), le traite et l’analyse avant d’afficher les résultats
end; obtenus. Une procédure permet par exemple d’imprimer les données, de les trier, de produire
run ; des histogrammes ou des tableaux, d’e↵ectuer une régression, etc . . .Certaines procédures
1.4. L’ÉTAPE PROC ; EXEMPLES DE PROCÉDURES 23 24 CHAPITRE 1. INTRODUCTION À SAS
peuvent créer des tableaux SAS contenant les résultats. Les appels de procédures se font au au cours d’une étape data, notamment en cas de tableaux volumineux. Cependant, elle ne
cours des étapes proc, dont la structure est : permet pas, contrairement à une étape data, de créer de nouvelles variables.
proc nom <liste-d’options>;
instructions < / liste-d’options>; Exercice 1.22
run; Exécutez le programme suivant puis affichez la dernière table modifiée.
Le mot proc signale le début d’une étape proc, nom est le nom de l’une des procédures data tab1; input x y; cards;
disponibles sur SAS, choisie selon le traitement souhaité. Il existe deux types d’options : les 1 2
options de la procédure doivent figurer en fin d’instruction proc nom, immédiatement après 7 9
le nom de la procédure (et avant le point virgule) tandis que les options d’une instruction ;
doivent figurer en fin d’instruction, et doivent être précédées du symbole /. data tab2; input x y; cards;
2 3
1.4.1 Les options génériques ;
proc append base=tab1 dat=tab2;
Les options acceptables sont propres à chaque procédure ou instruction. Cependant, un
certain nombre d’options sont identiques à toutes les procédures, par exemple
— data= nom permet de préciser le nom du tableau sur lequel doit agir la procédure (la La procédure contents
procédure agit par défaut sur le dernier tableau créé). Cette option peut elle-même être Elle donne les caractéristiques d’un tableau SAS.
affinée par des options qui devront être placées entre parenthèses après nom : keep=liste
ou drop=liste pour préciser les variables à traiter ou à ne pas traiter par la procédure, La procédure format
firstobs=numero (resp. obs=numero) pour indiquer le numéro de la première (resp. Elle permet notamment d’attribuer des libellés aux variables codées, selon la syntaxe
dernière) observation à prendre en compte dans la procédure, where=(expression lo- proc format <options>;
gique) pour sélectionner les observations à traiter par la procédure. value nom-de-format valeur1=libellé1 . . .valeurn=libellén;
— noprint si l’on ne souhaite pas voir apparaitre en output les résultats de la procédure. run;
Ici, nom-de-format indique le nom attribué à la variable format, valeur1, . . ., valeurn indiquent
les di↵érentes valeurs auxquelles attribuer un libellé, libellé1, . . ., libellén indiquent les libellés
1.4.2 Les instructions génériques
correspondants. En cas de valeurs alphanumériques, il convient de faire précéder nom-de-
Les instructions acceptables sont propres à chaque procédure. Cependant, un certain format par un dollar, et d’employer des quotes pour ces valeurs. Par défaut, les formats ainsi
nombre d’instructions sont identiques à toutes les procédures, par exemple créés sont stockés dans un catalogue temporaire Formats de la librairie (temporaire) Work.
— by liste-de-variables; demande à SAS d’exécuter la procédure sur chaque sous-groupe L’option library=nom-librairie permet de les stocker dans un catalogue appelé Formats de
défini par la liste de variables. Attention, le tableau traité ainsi doit être trié selon ces la librairie spécifiée. Pour que les formats définis par cette procédure soient utilisés au cours
mêmes sous-groupes. Il convient donc de trier le tableau (sauf s’il est parfaitement d’une autre procédure, par exemple la procédure print, il convient d’employer l’instruction
clair qu’il est déjà trié, mais dans le doute . . .), par exemple avec la procédure sort. format nom nom-de-format.;
— var liste-de-variables; spécifie les variables sur lesquelles exécuter la procédure (par au cours de la procédure en question. Ici, nom est le nom de la variable à laquelle appliquer
défaut, la procédure est exécutée sur toutes les variables). les libellés, et nom-de-format est le nom de la variable format à considérer. Noter la présence
— freq nom-de-variable; indique une variable représentant le nombre d’occurences de du point après nom-de-format.
chaque observation.
— weight nom-de-variable; indique une variable pondérant les observations. Exercice 1.23 Nous étudions des individus dont le genre est codé par ⌧ 1 pour masculin
— output out=nom; indique le nom à attribuer à la table SAS contenant les résultats et ⌧ 2 pour féminin. Exécuter le programme suivant et le commenter.
de la procédure. proc format;
value genref 1=’masculin’ 2=’feminin’; run;
data donnees;
1.4.3 Quelques procédures de gestion et édition de tableaux
input genre @@;
La procédure append cards;
Elle permet d’ajouter des observations à un tableau. La syntaxe est 1 2 2 2 1 2
proc append base=nom data=nom2 ; run; ;
base=nom indique le tableau auquel on va ajouter des observations (si ce tableau n’existe pas, proc print data=donnees;
SAS le crée), et data=nom2 indique le tableau contenant les observations supplémentaires. format genre genref.;
Cette procédure permet de concaténer des tableaux plus rapidement qu’une instruction set run;
La procédure sort — var liste-de-variables; pour n’éditer que les variables citées dans liste-de-variables,
Elle permet de trier les observations d’une table SAS. La syntaxe est : dans l’ordre où elles ont été citées. Par défaut, toutes les variables du tableau sont
proc sort <data=nom> <out=nom-sortie>; éditées, dans l’ordre de leur création.
by liste-de-variables; — where expression-logique; pour n’éditer que les observations satisfaisant expression-
run; logique. Par défaut, toutes les observations du tableau sont éditées.
Le tableau nom est alors classé par ordre croissant (ou alphabétique pour les variables de — sum liste-de-variables; demande le calcul de la somme des valeurs des variables citées
type caractère) de la première variable spécifiée dans l’instruction by, puis les observations dans liste-de-variables. Combinée à une instruction by, elle demande également le calcul
pour lesquelles cette variable prend la même valeur sont triées par ordre croissant de la de la somme par groupes.
seconde variable et ainsi de suite. Pour réaliser un classement par ordre décroissant suivant
Exercice 1.25 On travaille encore sur le tableau enfants, voir exercice 1.13.
une variable, spécifiez descending devant le nom de cette variable dans l’instruction by.
1. Exécuter les commandes suivantes.
La procédure sort ne donne lieu à aucune sortie. Le tableau trié est stocké dans le tableau
proc sort data=enfants;
nom-sortie si l’option out=nom-sortie est employée, et dans le tableau initial sinon. Attention,
by genre;
dans ce dernier cas, le tableau non trié est perdu. Par exemple, avec les instructions
proc print data=enfants;
proc sort data=tab out=tab2;
by genre;
by var1 descending var2;
where taille<150;
run;
run;
le tableau initial tab est inchangée. Le tableau tab2 contient les mêmes données que le tableau
2. Calculer la somme des tailles des filles, et la somme des tailles de garçons.
tab, classées par ordre croissant de la variable var1 puis par ordre décroissant de la variable
var2. La procédure transpose
Exercice 1.24 On travaille ici sur le tableau enfants, voir exercice 1.13. Elle transpose une table, c’est-à-dire qu’elle transforme les observations en variables et les
1. Exécuter les commandes suivantes. variables en observations.
proc sort data=enfants;
by taille; 1.4.4 Quelques procédures graphiques
run; Les procédures plot et gplot
2. Editer le tableau enfants grâce à la procédure print en utilisant un format pour les Elles permettent de représenter un nuage de points défini par deux variables, dans un système
cheveux. à deux dimensions, de façon grossière pour plot et plus fine pour gplot. La syntaxe de la
3. Trier les données suivant la couleur des cheveux et la taille. procédure plot est
4. Créer un tableau enfants age contenant les données triées selon l’âge, les enfants les proc plot < data=nom-de-tableau >;
plus âgés apparaissant avant les plus jeunes. Editer ce nouveau tableau. plot v1*h1 <v2*h2 ... vn*hn>< /liste-d’options >;
5. Que produisent les commandes suivantes ? <plot ... ; ... >
proc sort data=enfants (where=(genre=’M’)) out=garcons poids; run;
by poids; Une procédure plot doit comporter au moins une instruction plot ; le nombre d’instructions
run; plot au cours d’une même procédure n’est pas limité. Par défaut, une instruction plot donne
La procédure print lieu à autant de graphes qu’elle comporte de formules de la forme v*h (un graphe par formule),
Elle permet d’éditer tout ou partie d’un tableau. Les sorties de la procédure print comportent et les observations sont représentées par une lettre, située au point du graphe dont l’abscisse
par défaut une colonne obs précisant le numéro des observations. La syntaxe est et l’ordonnée sont données par les variables v1 et h1 pour le premier graphe, v2 et h2 pour le
proc print <liste-d’options>; second graphe etc (la lettre est A s’il y a une seule observation au point considéré, B s’il y en a
<instructions;> deux etc. . .). Il est possible de modifier cette représentation, par exemple en remplaçant v1*h1
run; par v1*h1=’.’ pour que chaque observation soit représentée par un point, ou par v1*h1=nom
Les principales options acceptables par la procédure print (outre l’option data=) sont noobs, pour qu’elle soit représentée par le premier caractère de la valeur correspondante de la variable
qui supprime la colonne obs, et label, qui ordonne l’utilisation du label des variables si elles nom.
en possèdent un. Les principales instructions sont : Les principales options acceptables pour l’instruction plot (à faire figurer si besoin en fin
— id nom-de-variable; pour spécifier la variable à éditer en première colonne (la colonne d’instruction plot, juste avant le “ ;” et précédées par le symbole “/”) sont :
obs est alors supprimée des pages output). overlay superpose tous les graphes déclarés dans l’instruction plot
— by nom-de-variable; pour éditer les données par groupes (par défaut, les données sont vpos= contrôle la dimension de l’axe vertical
éditées dans leur ensemble). hpos= contrôle la dimension de l’axe horizontal
La syntaxe de la procédure gplot est comparable à celle de la procédure plot. Elle o↵re 1.4.5 Etude d’un échantillon : les procédures univariate et means
en outre la possibilité, grâce à l’instruction
symbol <i=ligne> < v=point> <c=couleur>; La procédure univariate
d’imposer le type de courbe souhaitée selon la valeur de ligne (spline pour une courbe Elle produit des statistiques descriptives associées à des variables numériques, et permet de
régulière, none pour que les points ne soient pas reliés, join pour une ligne brisée, rl pour réaliser di↵érents tests statistiques et de construire des intervalles de confiance sous l’hy-
une régression linéaire), le caractère à utiliser pour représenter les points selon la valeur de pothèse que les données sont issues de variables aléatoires i.i.d. Les principales
point (par exemple, plus, none, circle, dot, square), ou la couleur. On peut utiliser statistiques pouvant être calculées par la procédure sont :
plusieurs instructions symbol (par exemple si lon souhaite superposer des graphes). L’ins- — N, nmiss : nombre d’observations non manquantes n, nombre d’observations man-
truction symbol peut être placée en dehors d’une étape proc et son e↵et persiste jusqu’à la quantes P P
fin de la session SAS. Elle est en ce sens comparable à l’instruction title. Une nouvelle com- — sum, mean : somme xi , moyenne x̄ = xi /n P
mande symbol ne redéfinit que les options qu’elle spécifie. Toutes les options d’une instruction — var, std : estimateur sans biais de la variance s2 = (xi x̄)2 /(n 1), écart-type s
symbol sont annulées par symbol;. Dans le cas d’une instruction plot v*h=nom; di↵érents — min, max, range : valeur minimale, valeur maximale, écart entre ces deux valeurs
symboles seront utilisés pour di↵érentes valeurs de nom. Par exemple, — Q1, madian, Q3 : premier quartile, médiane, troisième quartile
proc gplot; — Pi : ième percentile (i peut prendre les valeurs 1, 5, 10, 90, 95, 99)
symbol1 i=spline v=star; symbol2 i=spline v=none; — mode : valeur la plus fréquente
plot y*date=1 pred*date=2/overlay; — T, probt : statistique de Student et p-valeur associée pour tester la nullité de l’espérance.
La syntaxe générale est :
Exercice 1.26 A partir des données enfants (voir exercice 1.13), comparer les représentations proc univariate <liste-d’options>;
fournies par le programme suivant. <instructions;>
proc gplot data=enfants; plot taille*age; run;
proc gplot data=enfants; plot taille*age=genre; run; Les principales options acceptables par la procédure univariate sont data=, noprint, plots
symbol v=plus i=rl; pour demander des représentations graphiques, freq pour demander un tableau de fréquences
proc gplot data=enfants; plot taille*age; et de fréquences cumulées, normal pour construire des tests de normalité (on obtient alors
proc gplot data=enfants; plot taille*age=genre; run; la statistique de test et la p-valeur des tests de Shapiro-Wilks lorsque n  2000, de Kol-
mogorov, Cranér-von Mises, Anderson Darling), cibasic qui demande la construction d’in-
Les procédures chart et gchart
tervalles de confiance sous l’hypothèse que les données sont gaussiennes. L’option cibasic
Elles permettent de représenter graphiquement une variable. Les principales instructions ac-
peut elle-même être affinée par des options qui devront être placées entre parenthèses :
ceptables par ces procédures précisent le type de graphe souhaité et les variables à représenter,
type=mot-clé, où mot-clé peut être upper, lower ou twosided et précise le type d’inter-
par exemple
valle de confiance souhaité, et alpha=↵ pour imposer un niveau de confiance 100(1 ↵)%
- hbar variables; pour un histogramme horizontal
(par défaut, type=twosided et alpha = 0.05). D’autres options permettent par exemple de
- vbar variables; pour un histogramme vertical
calculer des intervalles de confiance pour les quantiles, préciser un nombre de valeurs extrêmes
- block variables; pour un graphique en blocs
ou d’observations extrêmes.
- pie variables; pour un graphique circulaire
Ces instructions peuvent être raffinées par des options, par exemple missing pour que les
Les principales instructions sont :
valeurs manquantes constituent une modalité, discrete pour préciser qu’une variable est
discrète. — les instructions génériques var, by, freq, weight
— output <out=nom-de-tableau> <liste-de-stat-output>; Si l’instruction output est uti-
Exercice 1.27 Exécuter les commandes suivantes lisée, alors l’instruction var est obligatoire. Elle ordonne la création d’un nouveau
proc gchart data=enfants; tableau nom-de-tableau, qui contient les valeurs des statistiques nommées dans liste-
vbar poids; de-stat-output. Le nombre d’observations dans le nouveau tableau nom-de-tableau est
pie cheveux/discrete value=inside slice=outside; égal au nombre de groupes définis par l’instruction by (si l’instruction by n’est pas
Essayer di↵érents graphiques (vbar, hbar, pie) sur les di↵érentes variables en utilisant si besoin utilisée, alors le nouveau tableau contient une unique observation). La liste liste-de-
un format. Que produisent les commandes suivantes ? stat-output précise les statistiques à conserver dans le nouveau tableau, et nomme les
proc sort data=enfants; nouvelles variables décrivant ces statistiques. Les éléments de la liste sont de la forme
by genre; mot-clé=liste-de-noms
proc gchart data=enfants; Le ième élément de la liste-de-noms est le nom attribué à la variable associée à la valeur
vbar poids; by genre; run; de la statistique mot-clé calculée pour la ième variable de l’instruction var. On peut
Pourquoi avoir employé ici une procédure sort ? utiliser plusieurs instructions output au cours d’une même étape proc univariate :
autant de tableaux que d’instructions output sont alors créés. 0 8 1 18 2 17 3 9 4 3

— class liste-de-variables; pour réaliser une étude par groupes, les groupes étant déterminés ;
par liste-de-variables (les variables nommées dans cette liste peuvent être de type proc print data=tab; sum eff;
numérique ou caractère). Il n’est pas nécessaire que le tableau soit trié suivant ces proc means;
groupes pour pouvoir utiliser l’instruction class. var nb;
— Plusieurs instructions permettent de réaliser des représentations graphiques (cdfplot, freq eff ; run ;
histogram, ppplot, probplot, qqplot).
Exercice 1.32 On travaille ici sur le tableau tab5, voir l’exercice 1.21. Exécuter les com-
Exercice 1.28 On travaille ici sur le tableau tab5, voir l’exercice 1.21. Que produit l’option mandes suivantes. Quelle di↵érence y a-t-il entre les instructions class et by ?
freq dans le programme suivant ? proc means data=tab5; var Y ; by X ;
proc univariate freq data=tab5; var Y; run; proc means ; var Y ; class X ; run ;
Exercice 1.29 Exécuter le programme suivant, éditer le tableau généré par ce programme, Exercice 1.33 La procédure means permet de tester si une moyenne est nulle dans le cadre
et commenter le résultat. En particulier, préciser ce que représentent mpoids, mtaille, d’un modèle à données i.i.d. gaussiennes. Dans cet exercice, on va montrer comment, par une
stdpoids, stdtail. translation de la variable, on peut tester si la moyenne est égale à une valeur quelconque
proc univariate data=enfants; donnée.
var poids taille;
output out=meanstd mean=mpoids mtaille std=stdpoids stdtail; 1. Exécuter le programme suivant. Ici, la variable temps décrit le temps d’attente (en
run; minutes) dans une file.
data pg;
Exercice 1.30 Exécuter le programme suivant et commenter le résultat. En particulier, input temps @@;
préciser le modèle statistique considéré et donner la construction théorique de l’intervalle tempstr=temps-4;
de confiance obtenu pour l’espérance. On pourra pour cela consulter le manuel SAS page 383 cards;
http ://support.sas.com/documentation/cdl/en/procstat/67528/PDF/default/procstat.pdf 6.1 4.7 2.3 1.9 4.8 4.4 5.5 5.2 4.5 4.8 6.1 5.2
data tab ; ;
do i=1 to 40 ; x=rannor(2) ;output; proc means n mean t prt;
end ; run ; var tempstr; run;
proc univariate cibasic (alpha=0.10); var x ; run; 2. Au niveau 5%, peut-on rejeter l’hypothèse nulle que le temps d’attente moyen est de
4 minutes ? Peut-on rejeter l’hypothèse nulle qu’il est inférieur à 4 minutes ? Vous
expliquerez la construction théorique des deux tests statistiques, le lien entre les p-
La procédure means valeurs de ces deux tests, et préciserez les hypothèses de modélisation.
Elle produit des statistiques descriptives associées à des variables numériques, mais contrai-
rement à la procédure univariate, elle ne permet ni de calculer des quantiles, ni de réaliser
1.4.6 Régression linéaire sur variables quantitatives : la procédure reg
des tests de normalité. La syntaxe est :
proc means < data=nom-de-tableau > <liste-de-mots-clés>; Elle permet l’étude de modèles de régression linéaire uni- ou multi-dimensionnels selon la
<class liste-de-variables;> méthode des moindres carrés. Nous considérons seulement ici le cas uni-dimensionnel, c’est-
<var liste-de-variables;> à-dire que les réponses y1 , . . . , yn sont supposées être les réalisations de variables aléatoires
<output <out=nom-de-tableau> <liste-de-stat-output>;> réelles indépendantes Y1 , . . . , Yn modélisées par
run;
La liste de mots-clés donnée en fin d’instruction proc means précise les statistiques que Yi = 0 + 1 x1i + ... p xpi + "i , i = 1, . . . , n,
l’on souhaite calculer. Par défaut, les statistiques produites par la procédure means sont N,
means, std, min, max. D’autres statistiques accessibles sont nmiss, var, range, sum, où x1i (resp. x2i ,...xpi ) est la ième valeur du regresseur x1 (resp. x2,...,xp) supposé déterministe,
skewness, kurtosis. Les instructions class, var et output s’emploient de le même façon "1 . . . , "n sont des variables aléatoires centrées, non corrélées et de même variance inconnue
que pour la procédure univariate. (que nous noterons 2 ) et 0 , ... p sont des paramètres inconnus. Lorsqu’un test d’hypothèse
est réalisé, les erreurs sont en outre supposées i.i.d. gaussiennes. Les observations prenant une
Exercice 1.31 Décrire le tableau de données ci-dessous, et expliquer comment est calculée valeur manquante pour au moins l’une des variables du modèle ne sont pas prises en compte.
la moyenne. La syntaxe est :
data tab ; input nb eff @@; cards ; proc reg < liste-d0 options > ;
model réponse=< liste-de-regresseurs > < /liste-d0 options >; est alors crée et ajoutée au tableau spécifié après out=. Les mots clé sont par exemple
<var liste-de-variables;>
predicted (ou p) valeurs prédites
<freq nom-de-variable;>
residual (ou r) valeurs résiduelles (i.e. la di↵érence entre la réponse et la valeur
<output out=nom-de-tableau liste-de-stat-output;>
prédite)
<plot liste-de-graphes < /liste-d’options >;>
h xi ( t XX) t xi , où xi est la ième ligne de X et ( t XX) désigne
<restrict équation1, <équation2,. . .,équationI >;>
un inverse (généralisé) de t XX.
<label: test équation1, <équation2,. . .,équationI >;>
L95 et U95 bornes inférieure et supérieure de l’intervalle de prédiction pour
run;
les valeurs futures prédites
Les options les plus utilisées pour la procédure reg sont data=tab1, outest=tab2 (crée un
L95M et U95M bornes inférieure et supérieure de l’intervalle de confiance pour les
tableau contenant entre autres les estimations des paramètres) et simple, qui demande le
espérances des observations
calcul de statistiques simples pour les variables nommées dans les instructions model et var.
press (Yi Ybi )/(1 hi ) où hi est défini comme ci-dessus et Ybi est le
prédicteur de yi .
L’instruction model
stdr estimation de 2 .
Plusieurs instructions model pouvent être employées au cours d’une même procédure reg. Une
telle instruction permet de déclarer la variable réponse ainsi que les di↵érents regresseurs du Par exemple, l’instruction
modèle, qui doivent être des variables numériques. Par défaut, SAS ajoute à ces regresseurs un output out=tab2 p=pred stdr=ecart;
e↵et constant (l’intercept). Si aucun régresseur n’est spécifié, l’espérance des observations est produit un tableau tab2 contenant les variables du tableau initial ainsi que deux nouvelles
supposée constante (i.e. E(Yi ) = 0 ). Citons quelques options acceptables pour l’instruction variables : pred qui donne pour chaque observation la réponse prédite, et ecart qui donne
model : pour chaque observation la valeur estimée de 2 (toutes les valeurs de cette variable sont
— clm demande le calcul d’un intervalle de confiance à 95% pour l’espérance de chaque identiques).
observation, ainsi que le calcul des valeurs prédites.
— cli demande le calcul d’un intervalle de prédiction à 95% pour chaque valeur future L’instruction plot
prédite, ainsi que le calcul des valeurs prédites. Elle s’emploie de la même façon que pour la procédure plot (en particulier, on peut employer
— noint supprime l’intercept du modèle l’option overlay pour superposer des graphes). Elle permet de représenter graphiquement les
— p calcule les valeurs prédites pour chaque observation variables spécifiées dans les instructions model et var, ou des variables crées par la procédure,
— r demande une analyse des résidus. ou encore la variable obs, qui donne le numéro de chaque observation. On peut employer
— selection= précise la méthode de sélection de modèle à employer. Le signe = doit être plusieurs instructions plot au cours d’une même procédure reg. Les éléments de la liste-de-
suivi de l’un des noms forward, backward, stepwise, Rsquare, Cp. On ne peut graphes sont de la forme vertical*horizontal <= symbole>. Pour représenter une variable créée
spécifier qu’une méthode de sélection par instruction model. Si l’on souhaite utiliser par la procédure, on la déclare par le mot-clé qui lui est associé suivi d’un point (par exemple,
plusieurs méthodes de sélection di↵érentes, il faut utiliser plusieurs instructions model plot residuals.*obs.;). Le symbole peut être un caractère entre quotes ou le nom d’une
et spécifier une méthode par instruction model. variable du tableau sur lequel agit la procédure reg.
Remarque : Comment déclarer le modèle Yi = 0 + 1 x2i + "i , la variable x2 ne pouvant pas
être déclarée comme régresseur ? L’instruction restrict
data tab2; Elle permet de poser des restrictions linéraires sur les paramètres du modèle. Il est possible de
set tab; poser simultanément plusieurs restrictions en donnant après le mot restrict la liste des res-
xcarre=x**2; trictions sous forme d’équations c1*var1+...+ck*vark=c, où c,c1,...ck sont des constantes
proc reg data=tab2; et var1,...,vark sont soit des noms de régresseurs soit le mot intercept.
model y= xcarre;
run; L’instruction test
Elle permet de réaliser des tests d’hypothèses sur les paramètres du modèle. Pour réaliser
L’instruction output plusieurs tests, il suffit de faire figurer autant d’instructions test que de tests souhaités. Le
Plusieurs instructions output peuvent être employées au cours d’une même procédure reg. label figurera sur la page output. Chaque équation spécifie une hypothèse linéaire et doit être
Une telle instruction crée un nouveau sas data set dont le nom est déclaré après out= de la forme c1*var1+...+ck*vark=c, où c,c1,...ck sont des constantes et var1,...,vark
et contenant les variables du tableau initial ainsi que des nouvelles variables décrivant les sont soit des noms de régresseurs soit le mot intercept. La procédure reg réalise alors un
résultats de la procédure. La liste-de-stat-output spécifie les valeurs à inclure dans ce tableau test de l’hypothèse (multiple si plusieurs équations sont spécifiées) ainsi définie. On teste par
et leur attribue un nom, les éléments de la liste étant de la forme mot-clé=nom. Une nouvelle exemple l’hypothèse ” 0 + 1 = 0” dans le modèle Yi = 0 + 1 xi + "i grâce à l’instruction
variable nom contenant les valeurs de la statistique mot-clé calculées pour chaque observation somme : test intercept+x=0;
Exercice 1.34 3. Afin que les résultats soient donnés dans l’ordre d’apparition des données, ajouter
l’option order=data :
1. Entrer le code suivant pour créer le tableau d’étude : proc freq order=data; table x*y; weight c; run;
data Tab; do x1=1 to 50; 4. Afin que les résultats soient donnés suivant les fréquences, ajouter l’option order=freq :
x2=0.1*x1+5*rannor(8); x3=0.2*x2+5*rannor(7); proc freq order=freq; table x*y; weight c; run;
x4=0.2*x1+0.3*x3+7*rannor(6); x5=0.5*x2+5*rannor(4); Comparaison de deux échantillons : la procédure ttest
x6=2*ranuni(3); x7=3+rannor(1); x8=1+0.2*rannor(7); La procédure ttest réalise le test de Student d’égalité des espérances des deux échantillons
y=x1+0.6*x2+0.7*x3+x4-x5+0.2*x8+10*rannor(1); output; end; gaussiens indépendants, lorsque les variances de ces échantillons sont identiques. Elle calcule
2. Faire la régression de y par rapport aux variables x1-x8. Trouver dans la sortie également la statistique de Satterthwaite permettant de tester l’égalité des espérances des
l’équation de la régression. deux échantillons lorsque les variances de ces échantillons sont di↵érentes. Une statistique
3. Afficher le graphique des résidus par rapport à x1, des résidus par rapport aux valeurs permettant de tester l’égalité des variances est également produite. La syntaxe est :
prédites. proc ttest < data=nom-de-tableau >;
4. Réaliser les sélections forward, backward et stepwise pour le même modèle. class nom-de-variable;
<var liste-de-variables;>
5. Tester si 4 = 5. run;
6. Restreindre la régression avec la condition 1 = 4 , et afficher les intervalles de L’instruction class est obligatoire et donne le nom d’une variable prenant exactement deux
confiance et de prédiction de niveau de confiance 95 %. valeurs, qui définissent les deux échantillons à comparer.
7. Créer pour la régression ci-dessus, un tableau contenant les valeurs prédites et les
intervalles de prédiction de niveau de confiance 95 %. Exercice 1.36
Exécutez le programme suivant. Peut-on affirmer au niveau 1% que les enfants de 15 ans ont
un meilleur résultat que ceux de 13 ans ?
1.4.7 Quelques autres procédures de statistiques
data tab;
Sans en détailler la syntaxe, nous citons ci-dessous quelques procédures statistiques cou- age=13;
rantes. do i=1 to 12;
result=5+rannor(8); output; end;
Tableaux de contingence : procédure freq age=15;
Pour obtenir des tableaux de fréquence sur une variable (qualitative) ou des tableaux de do i=1 to 16;
contingence entre plusieurs variables (qualitatives). Dans le cas de deux variables, la procédure result=7.4+rannor(8); output; end;
calcule également des mesures d’association. Dans le cas d’une seule variable, la procédure proc ttest;
permet de tester l’égalité des fréquences de chaque classe ou l’adéquation à une loi donnée. class age;
var result; run;
Exercice 1.35 1. Construire un sas data set avec les données suivantes, où x et y sont
les variables d’intérêt et c représente l’e↵ectif de chaque couple de modalités.
Produire des statistiques sous forme d’un tableau : procédure tabulate
x y c La procédure tabulate permet d’éditer des statistiques descriptives sous forme de tableaux,
1 2 3 en utilisant tout ou partie des variables du tableau courant. Il est possible de créer une grande
1 1 5 variété de tableaux, allant du plus simple au plus personnalisé. Cette procédure calcule un
2 2 2 grand nombre de statistiques descriptives calculées également, par exemple, par la procédure
2 1 6 means. Ses atouts sont notamment de fournir des méthodes simples de création de rapports
2. Construire un tableau de contingence grâce aux commandes suivantes : en tableaux, et de permettre un découpage de la population de manière intuitive.
proc freq; table x*y; weight c; run;
Il y a quatre valeurs dans chaque cellule du tableau obtenu. La première indique Analyse de la variance : procédure anova
l’e↵ectif nij du couple de modalités (i, j) associé à la cellule, la deuxième indique la
fréquence P
fij = nij /n de ce couple (avec n l’e↵ectif total), la troisième
P donne les profils Analyse des correspondances : procédure corresp
ligne fij / k fik et la quatrième donne les profils colonne fij / l flj .Il y a par exemple
3 personnes qui vérifient x=1 et y=2, ce qui représente 18,75 % (=3/16) de la population Analyse en composantes principales : procédure princomp
totale.
1.5. LE MACRO-LANGAGE SAS 35 36 CHAPITRE 1. INTRODUCTION À SAS
Modèles linéaires gaussiens : procédure glm L’instruction call symput

On peut créer une macro-variable au cours d’une étape data grâce à l’instruction
call symput(’nom-de-mvar’,valeur);
1.5 Le macro-langage SAS Cette instruction crée la macro-variable nom-de-mvar. Si valeur est le nom d’une variable
existant dans le tableau en cours, alors la valeur attribuée à la macro-variable nom-de-mvar
Les macros et les macro-variables sont des outils permettant d’étendre et de personnaliser est la valeur courante de cette variable ; si valeur est de la forme ’texte’, alors la valeur at-
le système SAS. Les macro-variables, qui peuvent comporter jusqu’à 32 000 caractères, per- tribuée à la macro-variable nom-de-mvar est la chaine de caractères texte.
mettent de modifier le texte d’un programme SAS par substitution symbolique. Elles peuvent Une macro-variable créée par une instruction call symput au sein d’une macro est locale
être définies soit par l’utilisateur, soit par le système SAS (macro variables automatiques), et s’il existe déja au moins une variable locale (par exemple, si la macro utilise des macro-
peuvent être globales ou locales selon la manière dont elles ont été définies. Les macros per- paramètres). Une macro-variable créée par une instruction call symput en dehors de macro
mettent quant à elles de réaliser des boucles, ou de définir des instructions conditionnelles. Un est globale.
programme SAS peut contenir n’importe quel nombre de macros (resp. de macro variables),
et chaque macro (resp. macro variable) peut être invoquée autant de fois que l’on veut au Autres
cours d’une même session. Les macros et macro-variables doivent être définies suivant un lan- Il existe d’autres fonctions ou instructions permettant de créer des macro-variables. Citons par
gage particulier, le macro-langage. Les symboles & et % permettent de distinguer les fonctions exemple %global, %local,%do itératif, %macro (qui permet de créer des macro-paramètres).
et instructions macro-langage des autres fonctions et instructions SAS : %nom fait référence à
une macro ou à une fonction de macro-langage, et &nom fait référence à une macro-variable.
1.5.2 Macro-variables automatiques
Lorsque le système SAS est invoqué, il crée des macro-variables dites automatiques qui
1.5.1 Macro-variables définies par l’utilisateur
fournissent des informations relatives à la session SAS en cours. Les macro-variables auto-
Il est possible de créer des macro-variables en tout point d’un programme, et de leur matiques, sauf exception, sont globales. En voici quelques exemples :
attribuer un nom en respectant les normes habituelles. Une fois créée, la valeur de cette
macro-variable information
macro-variable reste inchangée jusqu’à ce que l’utilisateur la modifie explicitement.
sysdate date à laquelle a commencé la session SAS en cours.
sysday jour de la semaine auquel a commencé la session SAS en cours.
L’instruction %let
sysindex nombre de macros exécutées au cours de cette session.
Le moyen le plus simple pour créer une macro-variable est d’utiliser l’instruction
%let nom-de-mvar=valeur; Ainsi, l’instruction
Si la macro-variable nom-de-mvar existait, alors l’instruction précédente modifie sa valeur et title " Date : &sysday, &sysdate ";
lui attribue la valeur valeur. Sinon, cette instruction crée une macro-variable nommée nom- définit le titre Date : Thuesday, 09Sep99 si le programme est exécuté le jeudi 9 septembre
de-mvar et prenant la valeur valeur. Le terme valeur peut comporter des macro-fonctions, 1999.
ou faire référence à des macros ou à des macro-variables. Dans ce cas, les macro-fonctions
et les références à des macros ou à des macro-variables sont d’abord évaluées, puis la valeur
1.5.3 Utilisation de macro-variables
valeur obtenue est attribuée à la macro-variable nom-de-mvar. Par contre, les expressions
logiques et arithmétiques ne sont pas évaluées (sauf si l’on utilise l’une des fonctions %eval On fait référence à une macro-variable en citant son nom précédé du symbole & : par
ou %sysevalf). Considérons les macro-variables définies par les instructions suivantes. exemple, &nom1. Ces citations produisent des substitutions symboliques, c’est-à-dire que &nom1
%let nom1=exemple; est remplacé par la valeur de la variable nom1. Par exemple, les instructions
%let nom2=ceci est un &nom1; %let nom=tab;
%let nom3=1+3; data tab2;
Les macro-variables nom1, nom2 et nom3 prennent respectivement les valeurs exemple, ceci set &nom; y=x&nom; z=&nom.x; run;
est un exemple et 1+3 (et non pas 4 !). Le terme valeur peut également comporter des créent le même tableau SAS tab2 que les instruction suivantes :
symboles réservés, comme %, &, ; (), sans que ceux-ci soient interprêtés comme éléments du data tab2;
langage SAS : il suffit d’utiliser une fonction comme %nrstr (c.f. ??). Dans tous les cas, la set tab; y=xtab; z=tabx; run;
valeur d’une macro-variable créée par un %let est une chaine de caractères. Si l’option symbolgen est utilisée (grâce à l’instruction options symbolgen;), la résolution
Les macro-variables créées par une instruction %let sont locales si l’instruction est placée au des macro-variables est décrite dans la fenêtre log à chacune des références. On peut alors
sein d’une macro, globale sinon. On peut forcer une macro-variable à être locale ou globale lire dans la fenêtre log des messages du type
grâce aux instructions %local et %global (c.f. 1.5.4). SYMBOLGEN : Macro variable nom resolves to tab
L’instruction %put permet également de vérifier la valeur d’une macro-variable : si la valeur
de la macro-variable mv est 3, alors l’instruction Le nom-de-macro spécifié dans l’instruction %macro doit être identique au nom-de-macro
%put valeur de mv : &mv; spécifié dans l’instruction %mend : il définit le nom de la macro créée par ces instructions. Les
fait apparaitre valeur de mv : 3 dans la fenêtre log. instructions ci-dessus ne font que définir une nouvelle macro, et n’entrainent pas l’exécution
des éventuelles instructions contenues dans la (ou les) ligne(s) instructions;. Pour qu’une
Exercice 1.37 macro soit exécutée, il faut invoquer cette macro par
Exécutez le programme suivant et expliquez la valeur obtenue pour y. %nom-de-macro
%let t=tab; Notez l’absence de symbole ;
%let n2=1+3; La (ou les) ligne(s) instructions; peut contenir soit une chaine de caractères soit une partie
title " Date : &sysday, &sysdate "; de programme SAS (si cette ligne contient une chaine de caractères, la macro ainsi définie
data &t; est comparable à une macro-variable). Lorsque %nom-de-macro apparait dans le programme,
y=&n2*2; %nom-de-macro est remplacé par SAS à cet endroit du programme par la (ou les) ligne(s)
proc print; run; instructions; avant que la partie de programme ne soit exécutée.
Exercice 1.38
1.5.4 Macro-variables locales ou globales Exécutez le programme suivant.
data tab;
Une macro-variable est dite globale si elle existe jusqu’à la fin de la session SAS. On peut
do x=1 to 18;
alors y faire référence et sa valeur peut être modifiée en tout point de la session (aussi bien en
y=0.4*x+rannor(5); output; end; run;
dehors qu’au sein des macros). Une macro-variable est dite locale si elle n’existe que pendant
%macro lieu;
l’éxécution de la macro au sein de laquelle elle est définie. Par exemple, les macro-paramètres
Nanterre
ou les macro-variables créés au sein d’une macro par un %let sont par défaut locales. Une
%mend lieu;
macro-variable est locale ou globale suivant la manière dont elle a été définie. Les instructions
%macro plot;
%local et %global forcent une macro-variable à être locale ou globale. La syntaxe est
proc gplot data=tab;
%global nom-de-mvar;
plot y*x;
%local nom-de-mvar;
run;
où nom-de-mvar est le nom d’une macro-variable, qui devient alors globale (ou locale). Si
%mend plot;
cette macro variable n’existait pas, les instructions %local et %global la créent (sa valeur est
title "le lieu est %lieu";
alors vide). Dans l’exemple suivant, les macros mac1 et mac2 créent les macro-variables var1
%plot
et var2 : var1 est locale tandis que var2 est globale.
%macro mac1;
%let var1=12; Macro-paramètres
%mend mac1; Il est possible de faire dépendre une macro de paramètres. Ces paramètres sont appelés macro-
%macro mac2; paramètres et sont déclarés entre parenthèses au cours de l’instruction %macro. Il peuvent être
%global var2; invoqués au sein de la macro par leur nom précédé du symbole & (puisque ce sont des macro-
%let var2=12; variables). Par exemple, les instructions
%mend mac2; %macro plot(vary=,varx=);
proc plot;
plot &vary*&varx;
1.5.5 Les macros
run;
Tout comme les macro-variables, les macros permettent de modifier le texte grâce à des %mend plot;
substitutions symboliques. Elles permettent en outre de réaliser des boucles ou des instruc- %plot(vary=y,varx=x)
tions conditionnelles. produisent le même graphe que les instructions
proc plot;
Syntaxe et utilisation plot y*x;
Une macro doit être définie en respectant la syntaxe suivante : run;
%macro nom-de-macro; Les macro-paramètres (ici varx et vary) sont des macro-variables locales, c’est-à-dire qu’ils
instructions; n’existent que durant l’éxécution de la macro plot.
%mend nom-de-macro ;
Commentaires %let d=%sysevalf(5/3);

Pour insérer un commentaire dans une macro, on peut utiliser au choix l’une des deux syntaxes Ces macro-variables prennent respectivement les valeurs 4, 2, 1 et 1.6666666667.
suivantes :
/* commentaire */ Instructions conditionnelles : %if %then / %else
%* commentaire ; Ces instructions ne peuvent être utilisées qu’au sein d’une macro. Elles définissent des ins-
La première syntaxe est également valable en dehors d’une macro, tandis que la seconde tructions conditionnelles. La syntaxe est
syntaxe est spécifique aux macros. %if expression-logique %then action;
< %else action2; >
1.5.6 Compléments sur le macro langage où action (resp. action2) est une instruction en macro-langage (comportant éventuellement
un %do ... %end) ou une chaine de caractères. Si expression-logique est vraie (i.e. di↵érente de
Titre zéro), alors action est réalisé. Si else est utilisé et que expression-logique est fausse (i.e. égale
Un titre peut comporter une ou plusieurs références à des macros ou macro-variables. Si l’on à zéro), alors action2 est réalisé : voici une macro qui peut au choix éditer un tableau SAS
souhaite que ces références soient résolues, il convient de définir le titre avec des doubles ou réaliser une représentation graphique :
quotes. Si de simples ’ sont utilisés, les symboles & et % sont interprêtés comme caractères, et %macro prinplot(info=,mydata=);
les éventuelles références ne sont pas résolues. Par exemple, si la macro-variable a a la valeur %if &info=print %then
2, alors %do;
title " macro-variable a : &a"; proc print data=&mydata; run;
définit le titre macro-variable a : 2 tandis que %end;
title ’ macro-variable a : &a’; %else %if &info=plot %then
définit le titre macro-variable a : &a. %do;
proc plot data=&mydata; plot y*x; run;
la fonction %nrstr %end
Dans certains cas, on souhaite qu’une expression comporte un symbole % ou & (ou tout autre %mend prinplot;
symbole réservé, tel que ; () or ’ and " ou un blanc) sans que ces symboles soient in- Attention : expression-logique est évaluée au moyen de la fonction %eval, qui ne travaille que
terprêtés comme éléments du langage SAS. On doit alors utiliser la fonction %nrstr. La sur les entiers. Si l’expression logique comporte des nombres décimaux, elle doit être donnée
syntaxe est %nrstr(expression). Si expression comporte l’un des symboles ’ " ( ou ), il faut sous la forme %sysevalf(expression-logique).
les faire précéder du symbole % pour qu’ils soient interprêtés commes simples caractères. L’ef-
fet de la fonction %nrstr est que expression est interprêté comme une chaine de caractères. Boucles : %do, %until, %while
Par exemple : L’instruction %do permet de définir des boucles. Elle ne peut être utilisée qu’au sein d’une
%let nom2=%nrstr(ceci est un &nom1); macro. La syntaxe est :
%let nom3=%nrstr(log%(12%)) ; %do mv=start %to stop < %by increment >;
créent deux macro-variables nom2 et nom3, qui prennent respectivement les valeurs ceci est texte-et-instructions-macro-langage
un &nom1 et log(12). %end;
où start, stop et increment sont des entiers, qui fixent le nombre d’itérations : l’indice d’itération
Les fonctions %eval et %sysevalf varie de start à stop par pas de increment. Par défaut, le pas est égal à 1. Pour chaque valeur
Elles forcent les expressions logiques et arithmétiques à être évaluée (le résultat d’une évaluation de l’indice d’itération, les instructions de la (des) ligne(s) texte-et-instructions-macro-langage
est du texte). Les syntaxes sont %eval(expression) et %sysevalf(expression), où expres- sont réalisées. mv définit une macro-variable, dont la valeur est un compteur (elle donne l’in-
sion est une expression arithmétique ou logique. La fonction %eval ne travaille que sur des dice d’itération). C’est une macro-variable locale, qui n’existe que durant l’éxécution de la
nombres entiers : les nombres apparaissant dans expression doivent être entiers, et le résultat boucle.
de l’évaluation est un entier. Si le résultat de l’expression logique ou arithmétique n’est pas
entier, alors l’évaluation fournie par %eval est la partie entière du résultat. Exercice 1.39
La fonction sysevalf travaille sur des nombres à virgule flottante, et le résultat d’une Exécutez le programme suivant.
évaluation avec sysevalf est un nombre à virgule flottante. Considérons par exemples les data tab1; x=11;
macro-variables a, b, c et d définies par data tab2; x=22;
%let a=%eval(1+3); data tab3; x=33; run;
%let b=%eval(4/2); %macro print(nom=,nombre=);
%let c=%eval(5/3); %do n=1 %to &nombre;
1.6. COMPLÉMENTS 41 42 CHAPITRE 1. INTRODUCTION À SAS
proc print data=&nom&n; depuis le 1er janvier 1960. Le chi↵re 0 correspond donc à cette date initiale. Pour pouvoir
run; entrer les dates et les lire de manière commode, il existe des formats (masque d’affichage des
%end; données) et informats (masque de saisie des donné) spécifiques : le format date7. correspond
%mend print; par exemple à 18may88, tandis que le format date9. correspond à 11mar1991, et les formats
%print (nom=tab, nombre=3) DDMMYY8. et DDMMYY10. permettent de lire des dates telles que 15/10/81 et 25/12/2005 res-
%print (nom=tab, nombre=4) pectivement. Dans une étape data comportant une instruction input, le nom d’une variable
comportant des dates doit être suivi du nom du format dans lequel elle a été saisie. Pour
Une autre façon de définir des boucles est d’utiliser les instructions %do%while ou %do%until.
pouvoir utiliser les formats de date avec le symbole @@ dans une instruction input, il faut
La syntaxe est alors
placer le symbole “ :” avant le format comme par exemple :
%do %until (expression-logique);
input date :date7. @@;
texte-et-instructions-macro-langage
(ici, la variable date doit être saisie au format date7.). L’affichage sur 4 chi↵res pour la date
%end;
se fera avec l’instruction format de la procédure print, dont on rappelle que la syntaxe est
ou bien
format nom var nom format. ; Par exemple :
%do %while (expression-logique);
proc print ; format date date9. ;
texte-et-instructions-macro-langage
%end; Exercice 1.40 Exécuter le programme suivant. Expliquer le résultat, puis renouveler avec
expression-logique (à noter entre parenthèses) est évaluée au début de chaque itération. Une un autre format de date.
boucle définie avec un %until (resp. %while) est réalisée jusqu’à ce que (resp. tant que ) la data tab; do i=1 to 36 by 2; j=i; output; end;
condition de expression-logiqe soit vraie. Attention : expression-logique est évaluée au moyen proc print; format i date7.; run;
de la fonction %eval, qui ne travaille que sur les entiers. Si l’expression logique comporte des
nombres décimaux, elle doit être donnée sous la forme %sysevalf(expression-logique). Exercice 1.41 Entrer le programme permettant de lire les dates suivantes puis de les afficher
au format date9.
8jan89 7feb54 22mar60 15apr73 29may75 28jun00 5jul23 7aug17 2sep4 19oct81
1.6 Compléments
Période de cent ans de référence pour les dates.
Dans toute cette partie, nous ne détaillons pas la syntaxe générale des procédures considérées
La période de cent ans couverte par les formats représentant les années par deux chi↵res est
mais fournissons seulement quelques exemples d’utilisation.
par défaut la période entre 1920 et 2019. L’option yearcutoff= précise l’année débutant cette
période de référence (qui est donc 1920 par défaut).
1.6.1 Valeurs manquantes
Exercice 1.42 Définir de nouvelles valeurs pour yearcutoff et les tester sur les exemples
Il est possible de distinguer plusieurs types de données manquantes. Par exemple une précédents. Par exemple :
valeur peut être manquante parcequ’elle n’existe pas dans la base de donnée, ou bien parceque option yearcutoff=1750;
nous ne souhaitons pas la rendre disponible pour des raisons de confidentialité. Nous notons A data tab; input x :date7.;cards;
et P ces deux types de valeurs manquantes. Pour pouvoir distinguer ces valeurs manquantes 8jan26
spécifiques, nous utilisons l’instruction missing avant l’étape data. Une fois cette commande ;
validée, elle le reste pour toute la session SAS. proc print; format x date9.; run;
missing A P;
data tab; Date, time et datetime
input x @@; Les dates sont enregistrées dans SAS comme le nombre de jour s’étant écoulé depuis le 1er
cards; janvier 1960, le moment de la journée (time) est le nombre de secondes écoulées depuis minuit,
3 A P C -8 et le datetime est le nombre de secondes écoulées depuis le 1er janvier 1960 à minuit. Par
; exemple, reprendre l’exercice 1.40 en remplaçant date7. par time. puis par datetime..
Dans cet exemple, la valeur C a été considérée comme manquante avec le simple point, car C
n’est pas déclarée dans la liste des données manquantes spéciales.
1.6.3 Exporter et importer ; connexion avec Excel
1.6.2 Les dates dans SAS
Le choix des types de fichiers importés ou exportés est plus ou moins riche selon que le
Les formats de date module sas/access to pc files est sous licence ou non.
SAS enregistre les dates par un nombre, qui indique le nombre de jours qui se sont écoulés
Au cours d’une étape data Avec la procédure Import

On a déjà vu comment importer ou exporter au cours d’une étape data. On peut dans ce cas Elle permet d’importer des données contenues dans un fichier texte, Excel, ou encore une
employer l’instruction filename, en dehors d’une étape data, pour manipuler plus facilement table de données Access. Par exemple soit le fichier C:\temp\delimiter.txt contenant les
les fichiers, par exemple en simplifiant les références multiples à un même fichier, ou encore lignes suivantes :
en changeant facilement le fichier source. Nous pouvons par exemple définir une référence à Region&State&Month&Expenses&Revenue
un fichier en utilisant Southern&GA&JAN2001&2000&8000
filename ventes ’C:\temp\ventes.txt’; Southern&GA&FEB2001&1200&6000
data tab; Nous pouvons le récupérer avec les instructions suivantes :
infile ventes; proc import datafile="C:\temp\delimiter.txt"
input nb @@; run; out=mydata dbms=dlm replace;
Pour exécuter ce code, il faut créer un fichier ’C:\temp\ventes.txt’ avec par exemple deux delimiter=’&’;
lignes de nombres. getnames=yes;
run;
Avec l’assistant d’importation proc print data=mydata; run;
— Pour importer un tableau Excel (ou autres : fichiers à séparateurs dans le cas général L’option out indique le nom du tableau SAS créé, replace indique que nous remplaçons le
*.*, fichiers *.csv ou *.txt), allez dans fichier->importer données puis suivez les tableau si celui-ci existait déjà. L’instruction getnames=yes; permet de récupérer les noms
indications des variables du fichier importé. Si l’on spécifie à la place getnames=no; ou si les entêtes ne
— Pour exporter un tableau SAS dans un fichier Excel, allez dans fichier->exporter sont pas des noms SAS valides, alors la procédure import crée automatiquement les variables
données, sélectionnez le tableau que vous souhaitez exporter puis continuez à suivre Var1, Var2, ...
les instructions.
Exercice 1.45
Avec la procédure export Créer le fichier C:\temp\delimiter.txt puis exécutez le programme ci-dessus. Essayez avec
Elle permet d’exporter un tableau SAS dans un fichier texte, excel ou autre. Par exemple l’instruction getnames=no.
pour exporter un tableau en délimitant les données avec le caractère ’&’, nous écrivons :
proc export data=sashelp.class La procédure import permet également d’importer une feuille d’un classeur Excel à l’aide
outfile=’c:\temp\class.txt’ dbms=dlm replace; de la commande sheet. Par défaut, la première feuille est récupérée. Pour récupérer une
delimiter=’&’; feuille dont le nom est Feuil, nous exécutons :
run; proc import datafile="C:\temp\liste.xls" out=liste;
L’option dbms indique quel type de sortie nous souhaitons, par exemple EXCEL (dans ce cas, sheet=’Feuil’;
l’extension attendue pour le fichier spécifié par outfile est .xls) ou XLSX (pour un fichier getnames=no; run;
.xslx) ou DLM (fichier à caractère délimiteur (blanc par défaut)). L’option replace permet
de ré-écrire sur un fichier existant (par défaut, la procédure export ne peut pas remplacer un
fichier existant). En combinant avec l’instruction filename, nous obtenons par exemple Exercice 1.46
filename class ’C:\temp\class.txt’; Nous travaillons avec le fichier C:\temp\class.xls de l’exercice 1.43. Exécutez le programme
proc export data=sashelp.class outfile=class... suivant.
proc import datafile="C:\temp\class.xls" out=mydata replace;
Exercice 1.43 Exécutez le programme suivant puis observez le fichier créé. Remarquez l’ex- proc print data=mydata; run;
tension du fichier ainsi que l’absence de la spécification du délimiteur.
proc export data=sashelp.class La procédure copy
outfile=’c:\temp\class.xls’ dbms=excel replace; Elle permet de sauvegarder ou de récupérer un tableau SAS. Pour sauvegarder un tableau,
nous exécutons par exemple
Libname disk ’C:\temp’;
Exercice 1.44 Essayez le programme suivant, puis enlevez l’option replace et allez voir la proc copy in=work out=disk;
note dans le journal. Renouvellez sans l’option dbms=dlm. select tab;
proc export data=sashelp.class quit;
outfile=’c:\temp\class.txt’ dbms=dlm replace; Pour récupérer, il suffit d’adapter l’exemple précédent en intervertissant work et disk.
delimiter=’:’; run;
Exporter/Importer un tableau en XML vations selon les modalités d’une variable.

libname myxml xml ’c:\temp\test.xml’;
data myxml.hh; Pour créer de nouvelles variables en employant des fonctions, des variables de la liste
set tab; suivant SELECT peuvent être remplacées par des éléments de la forme
run; fonction(variable) <AS nom>
La première ligne a↵ecte le fichier c:\temp\test.xml à la bibliothèque myxml. Nous spécifions où fonction est une fonction prédéfinie (fonction de groupe comme mean, max, var ...,
que nous utilisons le moteur XML pour cette bibliothèque. La bibliothèque myxml est ensuite ou opération arithmétique), variable est une variable du tableau courant, et nom est le nom
utilisée comme d’habitude, ici pour exporter en xml. Les bibliothèques de type XML peuvent attribué au résultat. Si ORDER BY est utilisé avec une fonction de groupe, alors la fonction
être utilisées pour créer des tableaux, les lire. Par contre on ne peut trier ces tableaux ni sera réalisée sur chaque groupe défini par cette clause.
réaliser de jointure.
Exercice 1.47 1. Créer le tableau d’étude suivant.
data tab;
1.6.4 Le langage de bases de données SQL
do i=1 to 40 by 1;
Acronyme de Structured Query Language, le langage SQL permet d’accéder rapidement nom=’A’; an=1930+i; output;
à une base de données. Ce langage est utilisé dans les programmes de bases de données tels end;
que Access, Oracle, Mysql, ou encore Postgresql. La procédure SQL permet d’obtenir un bon do j=1 to 40 by 1;
nombre de résultats similaires à ceux d’une étape data. La syntaxe générale est nom=’B’; an=1950+j; output;
proc SQL <options>; end; run;
instructions; 2. Exécuter le programme suivant (sans oublier la virgule entre an et nom).
quit; proc SQL;
Entre les deux instructions proc SQL et quit, le seul langage autorisé est le SQL. Les com- SELECT an, nom
mandes y sont organisées en blocs appelés requêtes, qui se terminent par un point-virgule, et FROM tab;
la virgule est maintenant le séparateur pour les listes de noms. L’instruction quit est faculta- 3. Exécuter ensuite
tive si la procédure est suivie d’autres étapes SAS. Tant que SAS ne rencontre pas de quit SELECT an, nom from tab WHERE nom=’A’;
ou d’étape SAS, la session SQL reste ouverte (message proc sql en cours d’éxécution en SELECT an, nom from tab order by an;
haut de le la fenêtre éditeur). Lors de cette session, il est possible de lancer individuellement SELECT an, nom, an-1900 AS annee from tab ;
chacune de des requêtes SQL. Notez qu’une requête SQL est lancée immédiatement après avoir
été lue par SAS (sans nécessiter d’instruction run) : la programmation SQL est une program- Exercice 1.48 Un gérant de stock considère les données suivantes :
mation par requête, à la di↵érence de SAS qui est une programmation étape.
Id prod Nom prod Id prod Quantite
1 bol 2 4
La commande select 2 verre 3 2
Elle permet de lire tout ou partie d’une table par sélection selon di↵érents critères. La syntaxe 3 couteau 4 2
est 4 fourchette
SELECT liste-de-noms-de-variables 5 assiette
FROM liste-de-noms-de-tables
<WHERE expression> 1. Créez deux tableaux produits et quantites contenant ces données, à l’aide de deux
<GROUP BY liste-de-noms-de-variables> étapes data.
<ORDER BY liste-de-noms-de-variables> ; 2. Fusionner les deux tableaux grâce aux commandes
Cette requête permet de sélectionner les variables citées après SELECT, dans l’ordre indiqué, Proc sql;
dans une table citée après FROM. Pour sélectionner toutes les variables d’une table, l’astérisque select produits.id prod, nom prod, quantite
* peut être utilisée à la place de la liste de variables. Rappelons que la virgule est maintenant from produits, quantites
le séparateur pour les listes de noms. Notons aussi que les variables peuvent être issues de WHERE produits.id prod=quantites.id prod;
plusieurs tables (citées après FROM), ce qui permet de fusionner des tables. La clause WHERE Remarquez que le résultat ne contient que les observations dont Id prod est présent
permet de spécifier un critère de sélection (appelé prédicat) sous forme d’une expression lo- dans les deux tableaux. Une telle fusion s’appelle “jointure interne”. Nous fusionnons
gique. La clause ORDER BY permet de trier le résultat de la requête selon une ou plusieurs les observations dont les valeurs de Id prod sont égales dans les deux tableaux. Dans
variables (par défaut, l’ordre est croissant, et on obtient un ordre décroissant en faisant suivre l’instruction SELECT, nous utilisons la syntaxe nom tableau.nom variable pour faire le
le nom de la variable concernée par DESC). La clause GROUP BY permet d’ordonner les obser- distinguo lorsque ce nom de variable est utilisé dans les deux tableaux.
3. Réalisez une jointure externe (fusion conservant toutes les observations) grâce aux par ALL dans l’instruction read. Inversement, pour créer une table SAS nom à partir des
commandes suivantes. colonnes d’une matrice X, la syntaxe est
Proc sql; proc IML ;
select produits.id prod, nom prod, quantite ...
from produits FULL JOIN quantites create nom from X ;
ON produits.id prod=quantites.id prod; append from X;
Ici, l’instruction FULL JOIN précise que nous gardons toutes les observations de tous close nom;
les tableaux. Elle remplace la virgule de la jointure interne. L’instruction ON vient quit;
remplacer l’instruction WHERE de la jointure externe.
Exercice 1.50 Exécutez l’exemple ci-dessous.
La commande CREATE TABLE Data tab1;
Le résultat d’une requête SELECT est par défaut affiché dans le fenêtre output, mais il peut input x y @@; cards;
l’être dans une table SAS si on utilise la syntaxe 8 7 1 3
CREATE TABLE nom-de-table ;
AS SELECT ... proc IML ;
Use tab1 ;
1.6.5 Le langage matriciel IML ; connexion avec R read all var {x y} into X ;
print X;
SAS IML (Interactive Matrix Language) est un module spécialisé interprétant un lan-
create tab10 from X ;
gage de calcul matriciel. L’objet de base de manipulation du langage est une matrice, un
append from X;
tableau bidimensionnel de valeurs numériques ou de caractères. SAS IML permet à l’utili-
close tab10;
sateur d’étendre les fonctionnalités de SAS en développant ses propres fonctions. Il permet
quit;
d’appeler les procédures SAS, mais aussi les fonctions R. Une table SAS peut être sauve-
proc print data=tab10; run;
gardée dans une matrice, ou inversement créée à partir d’une matrice. La syntaxe générale
Vérifiez en particulier que les variables de tab10 sont nommées COL1, COL2 ....
est
proc IML <options>; Quelques fonctions
instructions; Nous avons vu la fonction PRINT qui affiche le contenu de matrices, et X={ 1 2, 3 4 }, qui
quit; définit la matrice ✓ ◆
L’instruction proc IML ouvre une session IML tandis que quit la ferme. L’instruction quit est 12
facultative si la procédure est suivie d’autres étapes SAS. Le langage matriciel est employé au .
34
cours d’une session IML. En fin de session IML, toutes les matrices créées au cours de la session
De nombreuses autres fonctions de création de matrice sont disponibles (par exemple, pour
sont détruites (voir ci-dessous comment les sauvegarder). Il est donc souvent préférable de
créer une matrice diagonale d’éléments diagonaux donnés, ou une matrice dont toutes les
réaliser toutes les opérations matricielles souhaitées au cours d’une unique session IML.
composants sont identiques, ou matrice dont les éléments sont donnés dans un vecteur . . .).
Exercice 1.49 Exécutez l’exemple suivant. De nombreuses opérations matricielles sont disponibles (ajouter, multiplier terme à terme ou
proc IML; en produit matriciel, transposer, concaténer horizontalement ou verticalement, inverser, cal-
X={2 3, 1 4}; culer les valeurs ou vecteurs propres . . .). Il existe en outre des fonctions d’extraction (pour
Y=2*X; extraire un composant, ou une sous-matrice), des opérateurs de comparaison. On trouvera un
print X Y; descriptif de certaines fonctions sur la “Reference Card”
http://www.crest.fr/ckfinder/userfiles/files/Pageperso/raeberhardt/IML RefCard.pdf
Créer une matrice à partir d’une table SAS, ou inversement
Pour copier les variables v1 ; v2. . . vn d’une table SAS nom dans la matrice X, la syntaxe est Un exemple
proc IML ; Proc IML ;
use nom ; X={2 3, 1 4};
read all var {v1 v2 . . . vn} into X ; Y=2*X;
... print X Y;
quit; Z1=eigval(X) ; Z2=eigvec(X) ;
Si l’on souhaite copier toutes les variables de la table nom, on peut remplacer {v1 v2 . . . vn} Z3=X||Y ; Z4=normal(X) ;
print Z1 Z2 Z3 Z4; result <- median(&varName);

endsubmit;
Ici, normal(X) crée une matrice de même taille que X contenant des variables normales La commande de calcul est comprise par R comme result <- median(RInvoice).
(la matrice X n’intervient que par sa taille et non par ses valeurs). La matrice Z1 indique les
valeurs propres de X ; elle a deux colonnes, la première indiquant la partie réelle, la seconde la On peut transformer des tables SAS en data frame exploitables par R, ou inversement.
partie imaginaire des valeurs propres. Remarquez bien que l’on affiche des matrices, pas des
résultats de calculs. Par exemple on ne peut pas écrire print 3*X.
SAS et R
Pour éviter de ré-écrire ses propres fonctions SAS/IML, il est possible d’appeler les fonctions
R (langage matriciel, voir le chapitre 2 page 51). Pour soumettre des commandes R, la syntaxe
est
proc iml;
submit / R;
commandes-R
endsubmit;
On peut employer plusieurs blocs submit au cours d’une session SAS, et la session R persiste
alors d’un bloc submit à l’autre : une variable créée lors d’un bloc submit existera encore
dans un prochain bloc submit.
Il est souvent nécessaire de faire passer des matrices SAS en R, et inversement. Cela est
possible grâce aux fonction ExportMatrixToR et ImportMatrixToR. Voici un exemple tiré de
la vidéo
http://blogs.sas.com/content/iml/2011/10/31/video-calling-r-from-the-sasiml-language/
use sashelp.Cars;
read all var {Make Model Invoice};
close sashelp.Cars;
/* exporter une matrice vers R : creer dans R une */
/* matrice RInvoice a partir de la matrice IML Invoice */
run ExportMatrixToR(Invoice,"RInvoice");
/* faire des calculs R sur cette matrice */
submit / R;
result <- median(RInvoice);
endsubmit;
/* recuperer les resultats dans SAS/IML : creer dans SAS/IML */
/* une matrice median (ici, 1*1) a partir de l’objet R result */
run ImportMatrixFromR(median,"result");
/* editer dans SAS/IML */
print "dans IML: " median(format=dollar8.);
Il est également possible de passer des paramètres dans R par substitution symbolique,
avec une syntaxe comparable à celle employée pour les macro-variables. L’exemple suivant
est issu de la même vidéo.
/* passer des parametres dans R */
varName=‘‘RInvoice’’;
/* faire le calcul dans R */;
submit varName / R;
52 CHAPITRE 2. INTRODUCTION À R
N.B. Les exemples présentés dans cette partie comportent souvent plusieurs commandes
sur une même ligne, les commandes étant alors séparées par un point-virgule. En phase
d’apprentissage, il est recommandé de n’éxécuter qu’une commande à la fois, c’est-à-dire
de ne pas avoir recours au point-virgule. Il est également recommandé de décomposer les
commandes les plus complexes, pour bien en comprendre la signification, et d’afficher chacun
Chapitre 2 des objets que l’on crée.
La syntaxe des fonctions considérées dans ce document n’est pas détaillée : il convient (en
phase d’apprentissage mais aussi par la suite) de systématiquement consulter l’aide en ligne
Introduction à R des fonctions employées.
2.1 Introduction
R est un système (à la fois logiciel et langage de programmation) d’analyse statistique
Sommaire et graphique, disponible pour les systèmes d’exploitation Unix, Windows et MacOSX. Créé
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 par Ross Ihaka et Robert Gentleman, R est inspiré de S, un langage créé par AT&T Bell
2.2 Mise en route . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 Laboratories et disponible sous la forme du logiciel S-PLUS. C’est en particulier un outil
2.2.1 Installation de R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 efficace pour la manipulation et le stockage des données, les calculs matriciels, l’analyse de
2.2.2 Démarrer/quitter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 données, l’utilisation de méthodes statistiques et les représentations graphiques. De plus, R
2.2.3 Principes généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 est un langage de programmation objet performant et simple à utiliser.
2.2.4 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.2.5 Aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 R peut étendre ses fonctions de base par l’intermédiaire de packages (en français, mo-
2.3 Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 dules ou librairies) téléchargeables par l’intermédiaire du CRAN (Comprehensive R archive
2.3.1 Attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Network, ensemble de sites qui fournit ce qui est nécessaire à la distribution de R et se ses
2.3.2 Gestion des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 modules, sa documentation etc) ou l’un de ses sites miroirs, à l’adresse
2.3.3 Les vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 http://www.r-project.org/
2.3.4 Les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.3.5 Les tableaux (array) . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Le développement et la distribution de R sont assurés par des statisticiens regroupés dans la
2.3.6 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 “R Development Core Team”. Le logiciel R est libre, ce qui signifie que les utilisateurs ont
2.3.7 Les structures de données (data frame) . . . . . . . . . . . . . . . . 58 la liberté d’exécuter, de copier, de distribuer, d’étudier et d’améliorer ce logiciel. Son réseau
2.3.8 Les facteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 international de développement est en perpétuelle évolution. Il appartient donc aux utilisa-
2.3.9 Les expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 teurs de vérifier la validité des packages employés, en particulier des plus récents.
2.4 Lire et enregistrer des données . . . . . . . . . . . . . . . . . . . . 59
Documents et ouvrages d’initiation à R :
2.4.1 Lire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
— Consulter en priorité l’aide en ligne
2.4.2 Enregistrer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
— R pour les débutants, Emmanuel Paradis (2005)
2.5 Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
téléchargeable à http://cran.r-project.org/doc/contrib/Paradis-rdebuts fr.pdf
2.5.1 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 — Initiation à l’environnement R, Jérôme Huillet (2002)
2.5.2 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 téléchargeable à http://cict.fr/⇠stpierre/doc-R.pdf
2.5.3 Les expressions logiques . . . . . . . . . . . . . . . . . . . . . . . . . 61 — Statistiques avec R, Pierre-André Cornillon (2010), Presses universitaires de Rennes.
2.5.4 Elements de programmation . . . . . . . . . . . . . . . . . . . . . . . 61 — Site officiel de R à l’adresse http://www.r-project.org/ (liens CRAN, search, FaQs,
2.6 Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Books etc à gauche de la page)
2.6.1 Les principales fonctions. . . . . . . . . . . . . . . . . . . . . . . . . 62 Aides-mémoire R :
2.6.2 Exportation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 — http://math.univ-lille1.fr/⇠jacques/Download/Cours/Commandes-R.pdf (en fançais)
2.6.3 Plusieurs graphiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 — http://cran.r-project.org/doc/contrib/Short-refcard.pdf/ (en anglais, plus
complet)
51
2.2. MISE EN ROUTE 53 54 CHAPITRE 2. INTRODUCTION À R
2.2 Mise en route > setwd("nom du repertoire")

Le répertoire courant est donné par getwd()
2.2.1 Installation de R
Pour installer R, aller sur le site officiel de R (taper R dans un moteur de recherche)
à l’adresse http://www.r-project.org/ puis cliquer sur le lien CRAN à gauche de la page. 2.2.4 Packages
On obtient alors une liste de sites miroirs. Sélectionner le site de cette liste le plus proche
Plusieurs packages sont installés automatiquement en même temps que R. La gestion
géographiquement puis télécharger la version compatible avec le système d’exploitation utilisé.
des packages peut se faire grâce aux commandes appropriées dans la console et/ou grâce
Pour une interface plus conviviale, on peut installer RStudio (voir e.g. http://rstudio.org/).
au menu déroulant “packages”. Une fois R lancé, on peut obtenir la liste de l’ensemble des
packages installés dans l’environnement avec la commande library(). De nombreux packages
2.2.2 Démarrer/quitter supplémentaires sont disponibles sur le réseau CRAN. Pour installer un package supplémentaire,
on peut d’abord obtenir la liste des packages disponibles par la commande
Selon le système d’exploitation, on peut lancer R en tapant R dans une fenêtre de com-
> install.packages()
mandes et/ou en cliquant sur l’icone. On a alors accès à une fenêtre console et en utilisant
puis installer le package souhaité en le choisissant dans la liste obtenue, ou avec la commande
éventuellement les di↵érents menus déroulants, on a également accès à des fenêtres éditeur,
historique, graphique, gestionnaire de packages R, explorateur de l’espace de travail, etc. On > install.packages(nom du package).
quitte R avec la commande q() ou en fermant la console. On doit alors choisir de sauvegarder Les packages dont dépend le package souhaité sont également installés par défaut. Il est
ou non l’espace de travail (choisir non en général). Les objets courants sont alors sauvegardés également possible d’installer des packages en utilisant le menu déroulant (onglet packages).
dans le fichier .RData. On peut lancer R en batch sous unix par la commande R CMD BATCH La commande update.packages() est le moyen le plus simple d’assurer les mises à jour
fichier.R fichier.Rout des packages mais ne doit pas être employée lorsque les packages sont en cours d’utilisation.
L’ installation est à faire une seule fois, puis l’utilisateur doit charger à chaque session les
packages utiles via la commande library(nom du package), par exemple
2.2.3 Principes généraux
> library(stats)
R est un langage interprêté et non compilé. Il agit sur les objets (vecteurs, matrices La liste de toutes les fonctions disponibles dans un package s’obtient par la commande
etc) présents dans la mémoire vive de l’ordinateur (espace de travail ou workspace) avec des help(package=nom du package), par exemple
opérateurs et des fonctions. > help(package=stats)
L’utilisateur exécute des fonctions par l’intermédiaire de commandes, qu’il saisit après La suppression de packages est possible pas la commande remove.packages(nom du package).
l’invite de commande (prompt). Il existe deux invites de commandes di↵érentes : > indique
que R attend la prochaine commande, tandis que + indique que R attend que la commande
en cours soit terminée (on peut interrompre une commande avec ESC ou CTRL C selon le
système). Une ligne peut comporter plusieurs commandes, qui doivent alors être séparées par 2.2.5 Aide
un point-virgule. Les commandes de la ligne en cours sont exécutées au prochain passage à la
ligne. Toute commande exécutée est enregistrée dans un historique que l’on peut rappeler par L’aide en ligne de R est extrêmement utile pour l’utilisation des fonctions. Par exemple,
la commande history(). Le symbole # indique que le reste de la ligne ne sera pas interprêté les trois commandes
par R (commentaire). > ?mean ; help(mean) ; help("mean")
Une fonction, pour être exécutée, s’écrit toujours avec des parenthèses, qui contiennent donnent le même résultat et affichent la page d’aide de la fonction mean, qui fournit le nom
(ou non) une liste d’arguments et/ou d’options. Les résultats sont des objets, qui peuvent être du package où se trouve la fonction, une description, la liste des arguments par défaut, des
analysés à leur tour. Les fonctions disponibles sont contenues dans des packages (le package exemples d’utilisation etc. Pour les caractères spéciaux, il faut utiliser la syntaxe avec quotes,
nommé base est le coeur de R et contient les fonctions de base). L’utilisateur peut également par exemple help("⇤") pour l’aide en ligne de l’opérateur de multiplication. Par défaut, la
définir ses propres fonctions. Il peut exécuter des commandes à partir d’un fichier par la fonction help ne recherche que dans les packages chargés en mémoire. On peut ouvrir l’aide
commande en ligne au format html en tapant help.start(). Une recherche par mot-clé est possible
> source("nom du fichier.R") avec cette aide html ou depuis R par la commande help.search("mot-clef"). Par exemple,
le nom de fichier étant éventuellement précédé de son chemin d’accès s’il ne se trouve pas help.search("mean") affiche une liste de fonctions dont la page d’aide comporte le mot
dans le répertoire de travail. "mean". La fonction apropos trouve les fonctions chargées en mémoire dont le nom contient
Il est recommandé de créer un répertoire de travail dans lequel seront sauvegardés tous la chaı̂ne de caractères donnée en arguments, par exemple, apropos("help"). On peut aussi
les fichiers utiles. On peut lancer R directement de ce répertoire, ou changer de répertoire utiliser l’onglet de requète de la console. Il faut donc connaı̂tre le nom d’une fonction pour
grâce au menu déroulant (divers sous mac, fichier sous windows) ou la commande pouvoir rechercher l’aide correspondante. C’est pourquoi les aides-mémoire sont très utiles.
2.3. OBJETS 55 56 CHAPITRE 2. INTRODUCTION À R
2.3 Objets Création. Les principales fonctions permettant de créer des vecteurs comportent la
concaténation c() et la répétition rep(), par exemple :
2.3.1 Attributs > c(1,2,5) ; c(1,c(2,3,4),5+2i) ; c("Un","deux") ; rep(3,10)
L’opérateur : permet de créer une suite d’entiers croissante ou décroissante, par exemple
Tous les objets R sont caractérisés par des attributs. Les attributs intrinsèques (pour tous
2:11 ou 6:-2. La fonction seq() est similaire à l’opérateur : avec la possibilité de donner
les objets) sont
un pas à la séquence, par exemple, seq(1,25,by=2).
— Le mode, qui indique le type de base des composants : NULL (non défini), logical,
Les fonctions vector(), numeric(), logical(), character() permettent de créer des
numeric, complex, character.
vecteurs de mode et de longueur donnés (initialisation).
— La longueur, qui donne le nombre d’éléments.
Les commandes mode(nom) et length(nom) donnent respectivement le mode et la longueur
Opérations. Il est possible d’utiliser des opérations arithmétiques ou logiques sur un ou
de l’objet nom. La plupart des objets R ont également un attribut classe, qui en décrit
plusieurs vecteurs. Les opérations sont alors appliquées composante par composante. Si les
la structure : vector, matrix, array, factor, list, data.frame, ts (série chronologique),
vecteurs impliqués ne sont pas tous de même longueur, les plus courts sont réutilisés autant
function. La commande class(nom) donne la classe. La commande attributes(nom)
de fois que nécessaire pour avoir la même taille que le plus long. Ainsi, les commandes
donne une liste d’attributs (selon les objets : classe, dimension, nom des lignes et/ou colonnes
etc). La commande names permet d’attribuer un nom à chacune des composantes d’un objet. > x=1:5; y=1:7; z=x+y
On peut tester le mode et la classe par les fonctions is.null(nom), is.logical(nom), créent un vecteur x de longueur 5 et deux vecteurs y et z de longueur 7.
is.na(nom), is.matrix(nom) etc. On peut aussi modifier le mode ou la classe par les fonc-
tions as.null(nom), as.logical(nom), as.matrix(nom) etc. Attention : faire le passage Extraction d’éléments. Une partie des éléments d’un vecteur peut être sélectionnée en
de facteur à numérique en deux étapes, en passant par le mode caractère. Par exemple, ajoutant après le nom de ce vecteur un vecteur d’indices entre crochets, par exemple
>f=factor(c(1,1,3,3,3,4)); fn=as.numeric(f) > x=11:16; x[c(1,3,5)]; x[-3]; x[c(T,T,F,F,T,T)]; x[x > 15]; x[2:3]
> fc=as.character(f); fcn=as.numeric(fc) Si le vecteur considéré a un attribut names, i.e. chaque élément du vecteur a été associé à un
nom par la fonction names, alors on peut extraire selon ces noms, par exemple
> x=11:13; names(x)=c("x1","x2","x3"); x; x["x2"]
2.3.2 Gestion des objets
Les commandes ls() et objects() sont identiques et permettent d’afficher les objets
courants. L’option pattern permet d’afficher uniquement les objets dont le nom comporte 2.3.4 Les matrices
certains caractères, par exemple, ls(pattern="n"). Pour e↵acer les objets, on utilise la fonc-
tion rm ou remove, par exemple rm(n) e↵ace l’objet n et rm(list=objects()) e↵ace tous les Une matrice est un jeu de données, toutes du même mode, arrangées en lignes et en co-
objets courants. lonnes. Attention : sous R, un vecteur n’est pas une matrice. C’est au contraire une matrice
On peut créer des objets par a↵ectation avec l’un des opérateurs =, <- ou ->. Le nom d’un qui peut être vue comme un vecteur (obtenu en “dépliant” la matrice). En plus des attributs
objet doit commencer par une lettre et être constitué de chi↵res, lettres, points et espaces length et mode, une matrice a un attribut dimension qui est un vecteur à deux éléments
soulignés, les minuscules étant distinguées des majuscules. Toute valeur de type caractère donnant le nombre de lignes et le nombre de colonnes, et accessible par la fonction dim. La
(non numérique) doit être donnée entre quotes. Par exemple, fonction dimnames permet d’attribuer un nom aux lignes et colonnes.
> n=10; x<-2e+2; 12->y; t="caractère"
Si l’objet existe déjà, sa valeur précédente est écrasée. Noter qu’une instruction d’a↵ectation Création. La fonction diag(vecteur) permet de créer une matrice diagonale dont les
en donne lieu à aucune sortie. termes diagonaux sont donnés par vecteur. On utilise la fonction matrix() pour créer une
On affiche le contenu d’un objet en tapant son nom. Par exemple : matrice à partir d’un vecteur, par exemple
> n;x;y;t > vec <- 1:10; diag(vec); mat1=matrix(vec,ncol=2,byrow=T); dim(mat1)
R représente correctement des valeurs numériques qui ne sont pas finies (i.e. ±1) par > noms <- list(paste("row", 1:2), paste("col", 1:5, sep="-"))
Inf et -Inf, ou des valeurs qui ne sont pas des nombres par NaN (not a number). Une donnée > mat2=matrix(vec,nrow=2,byrow=F,dimnames = noms); dim(mat2)
manquante est notée NA (not available). On peut savoir où se trouvent les données manquantes L’option byrow=logique spécifie le mode de remplissage de la matrice (par défaut, le remplis-
d’un objet x par la commande is.na(x). sage se fait par colonnes, i.e. byrow=F). L’option dimnames permet d’attribuer un nom aux
lignes et colonnes (par défaut : pas de nom).
Si le vecteur employé dans la construction est trop court pour remplir entièrement la
2.3.3 Les vecteurs
matrice, alors il est réutilisé autant de fois que nécessaire. Par exemple,
Un vecteur est une suite ordonnée d’éléments tous du même mode. > matrix(1:3,nrow=5,ncol=3,byrow=T)
affiche une matrice à 5 lignes et 3 colonnes dont toutes les lignes sont identiques au vecteur
2.3. OBJETS 57 58 CHAPITRE 2. INTRODUCTION À R
1:3. La commande matrix(1:3,nrow=5,ncol=2,byrow=T) affiche une matrice à 5 lignes et 2.3.7 Les structures de données (data frame)
2 colonnes avec un message d’avis.
On peut créer une matrice en concaténant plusieurs matrices grâce à la fonction cbind Un data frame est une liste dont les composantes ont la même longueur. C’est un objet
(concaténation par colonnes) ou rbind (concaténation par lignes), par exemple très utilisé lors d’analyses d’individus caractérisés par des variables de nature di↵érente (qua-
litative, numérique, caractères, logique). On peut créer un data frame à partir de vecteurs
> mat3 <- rbind(mat1,t(mat2))
(numériques, caractères ou logiques) avec la fonction data.frame :
> dimnames(mat3) <- list(paste("row", 1:10), paste("col", c("A","B")))
> e1=1:10; e2=1:2; e3=3; x <- data.frame(nom1=e1,nom2=e2,e3)
Par défaut, les noms des colonnes sont les noms des objets e1 e2 e3. On peut aussi contraindre
Opérations. Il est possible d’utiliser des opérations arithmétiques ou logiques sur une
un objet (liste, matrice) à devenir un data.frame :
ou plusieurs matices. Les opérations sont alors appliquées composante par composante. Il
> mat1=matrix(1:10,ncol=2); B <- as.data.frame(mat1)
est également possible d’utiliser des opérations matricielles telles que %*% (produit), solve()
(inversion et résolution de systèmes linéaires), diag(mat) (extraction de la diagonale de la Les fonctions names(x) et row.names(x) permettent de spécifier les noms des colonnes et
matrice mat), t(mat1) (transpose la matrice mat1). La fonction apply permet d’appliquer des lignes d’un data frame.
fonctions ligne par ligne ou colonne par colonne : apply(mat1,1,sum) et apply(mat1,2,sum) Les fonction cbind et rbind s’utilisent comme pour les matrices ; la fonction summary
calculent la somme ligne par ligne et colonne par colonne respectivement. donne un résumé des données et permet d’identifier le mode de chaque composante ; on
extrait les informations d’un data frame soit de façon identique à une matrice, soit de façon
Extraction d’éléments. Comme pour les vecteurs, une partie des éléments d’une matrice identique à une liste, par exemple > B$V1. La notation $ n’étant pas toujours pratique, on
peut être sélectionnée en ajoutant après la matrice des indices entre crochets (indice de ligne peut utiliser la commande attach(B) pour rendre temporairement visibles les composantes
et indice de colonne séparés par une virgule) ou en ajoutant un seul indice entre crochets (si du data frame B. On accède alors aux composantes en tapant directement leur nom mais les
l’on voit la matrice sous sa forme vectorielle “dépliée”). Par exemple, éventuelles modifications ne sont pas prise en compte dans le data frame. Par exemple,
> mat1[3,2]; mat1[c(1,3,5),1]; mat1[1,]; mat1[,2]; mat1[3]; mat1[7] > attach(B); V1; V1=V1+1; V1; B$V1; B
2.3.5 Les tableaux (array) 2.3.8 Les facteurs
Il s’agit d’une généralisation des matrices, où le nombre de dimensions n’est pas nécessairement Un facteur est un vecteur utilisé pour identifier les composants d’autres vecteurs ayant la
deux. On peut les créer grâce à la fonction array. Par exemple, array(data=1:3,dim=c(2,4,3)) même longueur (variable qualitative). Un facteur a l’attribut supplémentaire levels, que l’on
crée un tableau à trois dimensions. peut afficher avec la fonction levels. R peut fournir des facteurs dont les niveaux sont or-
donnés ou non ordonnés. La fonction permettant de créer un facteur est factor, par exemple,
> factor(1:3,labels=c("a","b","c"))
2.3.6 Les listes > y=factor(c(rep("M",10),rep("F",10))); y; levels(y);length(y)
Une liste est un objet qui contient un ensemble ordonné d’objets appelés composants, La fonction table donne la table de contingence (e↵ectif de chaque niveau). Cette table peut
pas nécessairement de même mode. Les listes sont des objets récursifs, c’est-à-dire que les aussi être obtenue avec la fonction summary si le facteur est inclus dans un data.frame :
composants d’une liste peuvent eux-même être une liste. On peut créer une liste et nommer > e1=1:10; e2=1:2; e3=factor(c(rep(1,4),rep(2,6)),labels=c(’F’,’H’))
ses composants gâce à la fonction list() : > x <- data.frame(nom1=e1,nom2=e2,e3); x; summary(x)
> resultats <- list(nom.formation="SMIS", La fonction tapply applique une fonction à un vecteur par niveau d’un facteur, la fonction
+ nom.eleves=c("jean","moni","andr","hele","fran","gilles"), split crée une liste en séparant un vecteur suivant les niveaux d’un facteur. Par exemple,
+ notes=c(5,6,7,2,3,4),nb.etudiants=18) > table(y);f=1:length(y);tapply(f,y,sum)
> resultats > sp=split(f,y); sp; sp[1]; mode(sp); sp[1]; sp$F
On peut extraire les composants d’une liste par :
> resultats$nom.eleves; resultats$nom.eleves[1]
2.3.9 Les expressions
> resultats[[3]]; resultats[[3]][1]
et e↵ectuer les opérations suivantes Une expression est une suite de caractères qui ont un sens pour R (commandes). Pour
> resultats2 <- c(resultats,"UPS") # concatenation de listes construire une expression sans l’évaluer (par exemple pour inclure une équation sur un gra-
> names(resultats); names(resultats2) # noms des composants phique), on utilise la fonction expression() ; on évalue une expression par la fonction eval().
> resultats$responsable <- "Mathieu"; resultats # ajout de composants Par exemple,
On peut nommer les composants d’une liste ou les afficher par la fonction names. > x <- 3; y <- 2.5; expre <- expression(x/(y+exp(1))); eval(expre)
2.4. LIRE ET ENREGISTRER DES DONNÉES 59 60 CHAPITRE 2. INTRODUCTION À R
2.4 Lire et enregistrer des données > write(x) # cree un fichier data
La commande write.table exporte un data frame avec les noms de ligne et de colonne. On
2.4.1 Lire peut aussi enregistrer des objets de l’espace de travail avec
> save(x,y,file="mon fichier.RData")
La fonction read.table est le principal moyen pour lire des données stockées dans des
La fonction save.image() permet de sauvegarder l’espace de travail complet à tout mo-
fichiers texte (ASCII, avec typiquement l’extension .data, .csv ou .txt ; les fichiers xls
ment dans un fichier binaire, par défaut dans le fichier .RData. Ces données peuvent être
peuvent être préalablement convertis en csv). Elle a pour e↵et de créer un data frame. Une
ultérieurement chargées en mémoire par la commande
fois un jeu de données importé, la fonction fix permet de l’éditer dans un tableur (qu’il faut
> load("mon fichier.RData")
alors fermer avant de poursuivre). On peut vérifier le type de chacune des variables grâce à la
ou sous Mac, en cliquant sur le nom de fichier dans l’exploreur.
fonction summary. Il existe plusieurs variantes de cette fonction, qui di↵èrent de read.table
par la valeur des arguments par défaut. Par exemple,
> mes donnees <- read.table("mon fichier.data",header=F, 2.5 Programmation
+ skip=1,sep="\t", dec=",")
crée un tableau de données nommé mes donnees dont les variables sont nommées V1, V2 etc 2.5.1 Les fonctions
par défaut. L’option header=FALSE indique que la première ligne du fichier est la première
observation (la valeur par défaut header=TRUE indique que la première ligne donne le nom Une fonction est en fait un objet qui contient un ensemble de commandes. Il existe de
des variables) et l’option skip=1 indique que la lecture doit commencer seulement en seconde nombreuses fonctions prédéfinies sur R, et l’utilisateur peut définir ses propres fonctions, afin
ligne (e.g. si la première ligne du fichier comporte un commentaire). Les options sep="\t" d’utiliser R de façon plus confortable et productive. Ces commandes peuvent contenir des
et dec="," indiquent que dans le fichier, le séparateur de champ est une tabulation et que appels d’autres fonctions. Une fonction est crée de la manière suivante
les décimales sont notées avec une virgule. Un autre exemple (si vous avez conservé le fichier > nomfunction <- function (param1,param2,...,paramK)
class.xls et sauvegardé en class.csv) : {commande1
> x <- read.table("class.csv",header=T,sep=";") commande2
Les fonctions scan ou read.fwf permettent également de lire des données stockées dans ...}
des fichiers texte : scan permet de spécifier le mode des variables (” ” pour caractère, 0 pour Les paramètres après le mot function sont les paramètres entrants. Par défaut, la valeur de la
numérique , et i0 pour complexe), et read.fwf sert à lire des fichiers dans lesquels les données fonction est le résultat de la dernière expression évaluée (le plus souvent un data frame). On
sont dans un format à largeur fixée. Par exemple peut spécifier le résultat de la fonction par la fonction return. Les accolades sont facultatives
> mes donnees <- scan("mon fichier.data",what=list(" ",0,0)) dans le cas d’une seule commande. Par exemple,
lira dans le fichier mon fichier.data trois variables, la première de mode caractère et les > IMC <- function(taille,masse) masse/taille^2; t=1.60; m=50; IMC(t,m)
deux autres de mode numérique. L’appel de fonction fonctionne par recopie (t et m sont recopiés respectivement sous les noms
On peut également récupérer des données existantes sur R grâce à la fonction attach, taille et masse). Pour éviter les ambiguités, on peut appeler la fonction avec
par exemple, > IMC(taille=t,masse=m)
> fix(iris) Autre exemple :
> summary(iris) > sp=function(x,y)x+y;x*y; sp(2,3)
> Sepal.Length > sp=function(x,y)return(c(x+y,x*y)); sp(2,3)
> attach(iris); Sepal.Length
La commande data() donne la liste des jeux de données disponibles. La fonction help(nom) On peut définir des arguments par défaut (options)
donne des indications générales sur les données nom. > nomfunction <- function (param1,param2=0,...,paramK){commandes}
Enfin, le package Foreign fournit les moyens pour importer des données de fichiers pro- Dans ce cas, on peut appeler la fonction soit en omettant les paramètres possédant une valeur
duits pas des systèmes statistiques tels que S, SAS, SPSS etc. D’autres packages permettent par défaut, soit en leur attribuant une valeur. Il est nécessaire de donner tous les arguments
de faire le lien entre R et des systèmes de gestion de bases de données (par exemple, ROracle ne possédant pas de valeur par défaut. Les arguments doivent être donnés dans l’ordre ou
pour le SGBD Oracle) ou entre R et Excel. avec leur nom. On peut écrire ses propres fonctions en utilisant l’éditeur de texte qui travaille
avec R (obtenu si besoin par les menus déroulants) et les sauvegarder (extension .R). On les
appelle ensuite grâce à la commande source(nom de fichier.R).
2.4.2 Enregistrer
La commande write(x,file="nom.txt") crée le fichier texte nom.txt dans le répertoire Il existe sous R des fonctions génériques, qui s’appliquent à tous type d’objet mais qui
courant et y écrit l’objet x (quelle que soit sa classe). Par exemple, exécutent une tâche spécifique de la classe d’objet à laquelle elle s’applique. C’est le cas par
> x <- matrix(1:10, ncol = 5); write(x,sep = "\t",file="tab.txt") exemple des fonctions plot, print, summary. Les fonctions les plus courantes sont données
2.5. PROGRAMMATION 61 62 CHAPITRE 2. INTRODUCTION À R
dans les aides-mémoire. La fonction example donne des exemples de démonstration pour les final
fonction R : example(median) }
2.5.2 Portée des variables Il est préférable de la coder sans boucle :

> notes.finales <- function(notes,p){apply(t(notes)*p,2,sum)}
Lors de l’appel d’une fonction, une copie des arguments est transmise à la fonction, laissant > mat=matrix(1:6,ncol=2); p=c(.3,.7); notes.finales(mat,p)
les originaux intacts. Pour réaliser une a↵ectation globale, on utilise l’opérateur <<-
Plus généralement, une variable est d’abord cherchée au niveau dans lequel elle est utilisée ;
si elle n’y est pas trouvée, elle est cherchée au niveau supérieur et sa valeur est recopiée. La 2.6 Graphiques
modification d’une variable à un niveau inférieur ne modifie pas une variable de même nom
d’un niveau supérieur. On peut commencer par regarder quelques exemples de représentations graphiques grâce
à la commande demo(graphics). Les commandes graphiques e↵ectuent des tracés sur des
2.5.3 Les expressions logiques périphériques graphiques (devices : fenêtres ou fichiers), qui sont créés automatiquement si
besoin. Un seul device est actif à un moment donné ; la fonction x11(), quartz() sous mac
La valeur d’une expression logique est TRUE (ou simplement T, codé par 1) ou FALSE (ou ou windows() sous windows ouvre et active un tel périphérique.
simplement F, codé par 0). Pour définir des expressions logiques, on utilise les opérateurs
logiques tels que & (et), k (ou), >, <, == (égalité logique), ! (négation), != (di↵érence logique),
2.6.1 Les principales fonctions.
%in% (appartenance). Par exemple,
> 6:10 %in% 1:36; !(6:10 %in% 4:7); (6:10)>8 Les principales fonctions sont plot, hist, boxplot. Elles définissent le cadre de visuali-
> x=(-1):6; y=x*(x>0); sum(x>0) sation (axes, ...) en écrasant la figure en cours ou en superposant les ordres graphiques avec
l’ordre
2.5.4 Elements de programmation > par(new=TRUE) # utilisation de la figure en cours
L’utilisation classique de la fonction plot consiste à représenter un nuage de points d’une
Pour réaliser des sélections, on peut utiliser
variable y en fonction d’une variable x. Par exemple,
> if (expression logique){expression}
> x=1:6;y=x^2;plot(x,y)
> if (expression logique){expression 1} else {expression 2}
> grillex <- seq(0,1,length=50); fx <- sin(2*pi*grillex)
Par exemple
> plot(x=grillex,y=fx, xlab="x", ylab="sin(2*pi*x)", main="Representation
> va=function(x) {if (x<0) y=-x else y=x; y}; va(-4); va(5)
+ de la fonction sin(2*pi*grillex)", sub="Figure 1")
Pour répéter des commandes, on peut utiliser des boucles :
Les options main et sub permettent d’ajouter des titres ; les options xlab et ylab permettent
> while (expression logique,expression)
de nommer les axes. On peut choisir di↵érentes couleurs, types de lignes, types de points grâce
> for (ind in vecteur) {expression}
aux options col, type et pch respectivement. Les options xlim et ylim permettent d’imposer
Ici, ind est la variable boucle, vecteur est une expression vectorielle (souvent une séquence
les limites inférieures et supérieures des axes (utile lors de superposition de graphes). Si x est
du type 1:30). Par exemple,
une variables qualitative, la fonction plot fournit une représentation des données en boites à
> t=vector(); for (i in 1:6) {t[i]=va(i-3)}; t
moustaches (box-plot) (comme la fonction boxplot) :
> for(i in 1:5) print(1:i)
> y=1:30; x=factor(c(rep(1,15),rep(2,15))); plot(x,y)
L’usage des boucles est à éviter. Il est le plus souvent possible de s’en passer en utilisant des
écritures matricielles. Par exemple, la fonction suivante calcule des moyennes pondérées en Si les deux variables sont qualitatives, on obtient une représentation par un diagramme
utilisant des boucles : en bandes (comme avec la fonction spineplot). La commande plot(y) est un raccourci de
plot(1:length(y),y) si y est un vecteur et retourne un diagramme en barres si y est un
notes.finales <- function(notes,p) facteur (comme barplot).
{ netud <- nrow(notes) La fonction hist() permet d’e↵ectuer des histogrammes. Par défaut, les fréquences sont
neval <- ncol(notes) représentées mais l’option probability=TRUE permet d’obtenir un estimateur de densité (i.e.
final <- (1:netud) * 0 tel que l’aire totale sous la courbe soit égale à un).
for (i in 1:netud) Une fois le graphique tracé, il est possible de le compléter par d’autres informations (sans
{ for (j in 1:neval) modifier les axes) avec les fonctions lines(), text(), points(), legend() (ajout de lignes,
{ final[i] <- final[i] + notes[ i , j ] * p[ j] texte, points, légende respectivement), abline(v=10,lty=3), abline(h=10,lty=3) (ajout
} d’une ligne verticalle ou horizontale en pointillés), abline(c(1,2)) (ajoute une droite de
} pente 2 et d’ordonnée à l’origine 1).
2.6. GRAPHIQUES 63 64 CHAPITRE 2. INTRODUCTION À R
La commande lwd=3 des fonctions graphiques demande un grossissement des lignes par
un facteur 3. Les commandes col= et pch permettent de choisir la forme et la couleur des
points. Par exemple, Masters 1 ISEFAR, EA, MBFA
> plot(1:20,1:20,pch=1:20,col=1:20); abline(0,1,col=2) 2015-2016
> abline(0,1,col=2,lwd=3) Cours d’initiation à SAS et R
> plot(x,x,col=1, type=’l’); lines(x,sqrt(x),col=2,type=’l’) Cécile Durot et Olivier Couronné
> lines(x,x^2,col=3,type=’l’)
2.6.2 Exportation.
Les figures peuvent être sauvegardées à partir de la fenête graphique (Fichier ! Sauver
Initiation à R : Exercices
sous) dans un format compréhensible par un autre logiciel (jpeg, pdf, postcript, emf
sous window). On peut aussi ouvrir un device du format souhaité et y définir le graphique,
par exemple :
N.B. Certains exercices sont issus du livre de Pierre-André Cornillon, d’autres sont ins-
> pdf("essai.pdf")
pirés du cours d’initiation à R de Christine Kéribin en Master Ingénierie mathématique de
> plot(x=seq(1,20,by=0.01),y=cos(seq(1,20,by=0.01)),type="l")
l’université Paris Sud.
> dev.off()
Ici, dev.off() ferme le device pdf et finalise le fichier ”essai.pdf” contenant le graphique. On Exercice 2.1 1. Quel est l’utilité de la fonction set.seed ?
peut procéder de même en remplaçant par exemple pdf par jpeg.
2. Après avoir tapé la commande set.seed(45), utiliser la fonction mvrnorm du package
MASS pour générer trois vecteurs gaussiens de R2 d’espérance (0, 1) et de matrice de
2.6.3 Plusieurs graphiques. variance ✓ ◆
Si l’on souhaite faire figurer plusieurs graphiques sur la même fenêtre, on peut utiliser la 1 0.5
fonction layout(). Cette fonction découpe la fenêtre graphique en carreaux unitaires avant 0.5 1
de les regrouper. Elle admet ainsi comme arguments une matrice, qui donne le découpage en Exercice 2.2 1. Charger le jeu de données iris disponible sous R, et visualiser ses
carreaux. Les composants de la matrice donnant les numéros des graphiques qui doivent être premières lignes grâce à la fonction head.
dessinés dans chaque carreau. Par exemple, on fait précéder trois commandes plot de
> mat <- matrix(c(1,1,2,3),nrow=2); layout(mat) 2. Taper les commandes Species;iris$Species;attach(iris);Species et commenter.
Si l’on souhaite des graphiques tous de même taille, on peut utiliser plutôt par(mfrow=...) 3. Quels sont les attributs du jeu de données iris ?
ou par(mfcol=...). Par exemple, pour une fenêtre découpée en 2 lignes et 3 colonnes avec 4. Créer un sous-jeu de données iris2 comportant uniquement les données pour lesquelles
remplissage par ligne, exécutez la commande par(mfrow=c(2,3)) avant d’éxécuter les com- la modalité de la variable Species est versicolor.
mandes permettant de réaliser les six graphiques :
5. Trier par ordre décroissant les données de iris2 en fonction de la variable Sepal.Length
> par(mfrow=c(2,3))
(utiliser la fonction order)
> for(i in 1:3) plot (1:10,(1:10)^i)
> for(i in 1:3) plot (1:20,(1:20)^i) Exercice 2.3 1. Construire les vecteurs suivants avec la méthode la plus adaptée :
V 1 = ( 1, 3.2, 2.8), V 2 = ( 2, 1, 0, 1, 2, 3, 4, 5, 6), V 3 = (0.05, 0.1, 0.15, 0.2),
V 4 = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), V 5 = (OU I, N ON ).
2. Ordonner le vecteur V 1.
3. Quel est le résultat de l’opération V 6 = 2 ⇤ V 2 3 ? de l’opération V 3 + V 2 ? de
l’opération logique V 2 > V 4 ?
4. Créer le vecteur V 7 constitué des trois dernières composantes de V 6.
5. Afficher la longueur de V 6 et la somme de ses coefficients.
Exercice 2.4 1. Créer un vecteur age de composantes 4, 13, 16, 40, 66. Attribuer les
noms Julie, Coline, Cynthia, Ben, Christiane à ces composantes (dans cet ordre).
2. Afficher l’âge de Julie.
2.6. GRAPHIQUES 65 66 CHAPITRE 2. INTRODUCTION À R
3. Afficher le nom des individus mineurs (âgés de moins de 18 ans). 3. Créer un vecteur proba contenant les fréquences de chaque niveau sans les niveaux de
la question précédente.
Exercice 2.5 1. Construire un data frame à partir des deux variables suivantes :
4. Sélectionner les individus prenant la modalité de la question 2. Leur donner une valeur
> x parmi les modalités restantes, selon un tirage dont les probabilités sont calculées en
[1] 3.12 5.05 5.43 9.86 5.45 5.45 7.01 6.54 4.34 9.65 question 3 (utiliser la fonction sample). Ce procédé est appelé ventillation.
[11] 5.67 8.67 4.83 5.03 5.92 6.45 9.67 4.91 4.16 8.03
> y=rep(c("a","b"), c(10,10)) Exercice 2.10 1. Exporter les données du fichier ozone.txt (qui contient des mesures
climatiques et une variable de pollution à l’ozone mesurées durant l’été 2001 à Rennes)
2. Combien y a-t-il de lignes pour lesquelles 2<x<5 ? Afficher ces lignes.
par la commande
3. Enregistrer le tableau de données dans un fichier en utilisant la fonction write.table
ozone<-read.table("http://www.agrocampus-ouest.fr/math/livreR/ozone.txt")
puis en utilisant la fonction save. Que dire des fichiers générés ? Utiliser les fonctions
adéquates pour relire ces deux fichiers. 2. Extraire les variables T12, max03, vent, pluie et Vx12.
3. Quelles sont les données quantitatives et les facteurs ?
Exercice 2.6 Soit f la fonction définie par 4. Représenter l’évolution du maximum d’ozone (variable max03).
↵x 5. Représenter graphiquement max03 en fonction de T12, max03 en fonction de vent,
f (x) = ,
+ x + x2 pluie en fonction de vent.
où ↵, et sont des paramètres.
Exercice 2.11 1. Installer et charger le package Rcmdr.
1. Créer cette fonction, avec des valeurs par défaut de ↵, et égales à 1, 0 et 0
2. Utiliser le menu déroulant Données de la fenêtre R Commander pour créer un data
respectivement.
frame Decathlon à partir des données accessibles à l’URL
2. Comment appeler cette fonction avec les paramètres par défaut et l’argument x=c(1,10) ?
http://factomineR.free.fr/livre/decathlon.csv
3. Représenter sur un même graphe la fonction f avec des valeurs de ↵ et égales à 1, Notez que le séparateur de champs est le point-virgule, le séparateur décimal est le
et une valeur de de 1, puis 2 puis 3. point, et si le fichier comporte les noms des variables.
4. Placer les axes sur ce graphe ainsi que les tangentes à l’origine.
Exercice 2.12 Tracer sur un même graphe les fonctions sinus et cosinus pour une abscisse
Exercice 2.7 1. Calculer les statistiques de base (moyenne, min, etc) des trois variables variant entre 0 et 5 (utiliser des couleurs di↵érentes pour les deux courbes).
du jeu de données ethanol, disponible sous R dans la package lattice.
2. Calculer les quartiles de chacune de ces trois variables en utilisant les fonctions apply Exercice 2.13 (LGN)
et quantile. 1. Après avoir fixé la graine du générateur aléatoire à 123 (set.seed), simuler un échantillon
3. Toujours avec la fonction apply, calculer les déciles de chacune des trois variables en (x1 , . . . , x1000 ) de la loi de Bernoulli de paramètre 0.6 (fonction rbinom).
P
utilisant l’argument probs de la fonction quantile. 2. Calculer les moyennes successives Ml = li=1 xi /l grâce à la fonction cumsum. Tracer
Ml en fonction de l puis ajouter la droite horizontale d’équation y = 0.6.
Exercice 2.8 1. Télécharger les fichiers fusion1.xls et fusion2.xls à l’adresse
http://www.agrocampus-ouest.fr/math/livreR/fusion1.xls Exercice 2.14 (TLC)
Les ouvrir sous excel et les sauvegarder sous format texte, avec l’extension .csv. 1. Générer un échantillon (S1 , . . . , S1000 ) de la loi binomiale de paramètres n = 10 et
2. Conserver uniquement les variables yhat1, yhat3, Rhamnos, Arabinos et créer un data p = 0.5, et ranger dans un vecteur U1 les quantités
frame avec ces quatre variables.
S np
3. Ajouter à ce data frame les variables yres1 et yres2 qui retranchent, individu par p i .
np(1 p)
individu, les valeurs de yhat1 à celles de Rhamnos et les valeurs de yhat3 à celles de
Arabinos 2. Faire de même avec les valeurs n = 30 et n = 1000 pour obtenir deux nouveaux
vecteurs U30 et U1000 .
Exercice 2.9 Considérons la variable qualitative
Xqual <- factor(c(rep("a",60), rep("b",20), rep("c",17), rep("d",3))) 3. Représenter sur une même fenêtre les histogrammes de U10 , U30 et U1000 en superposant
à chaque fois la densité de la loi normale centrée réduite (dnorm).
1. Calculer la fréquence de chaque niveau de facteur.
2. Afficher l’intitulé des niveaux dont l’e↵ectif est inférieur à 5% de l’e↵ectif total.

POLY SASetR 2016

Transféré par

Informations du document

Titre original

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

POLY SASetR 2016

Transféré par

Droits d'auteur :

Formats disponibles

1 2

Masters 1 ISEFAR, EA, MBFA

Table des matières

1.6.4 Le langage de bases de données SQL . . . . . . . . . . . . . . . . . . 45

1.2.4 Mise en forme du listing (pages output)

autant de tableaux que d’instructions output sont alors créés. 0 8 1 18 2 17 3 9 4 3

Modèles linéaires gaussiens : procédure glm L’instruction call symput

Commentaires %let d=%sysevalf(5/3);

Au cours d’une étape data Avec la procédure Import

Exporter/Importer un tableau en XML vations selon les modalités d’une variable.

print Z1 Z2 Z3 Z4; result <- median(&varName);

Introduction à R des fonctions employées.

2.2 Mise en route > setwd("nom du repertoire")

2.3.5 Les tableaux (array) 2.3.8 Les facteurs

2.5.2 Portée des variables Il est préférable de la coder sans boucle :

Vous aimerez peut-être aussi