Introduction

Introduction à SAS

Tout d'abord, examinons le concept général d'un programme SAS. En somme, un tel programme va lire des données, créer un jeu de données, puis exécuter des transformations, calculs et analyses.

Ce que nous appellerons le code d'un programme contient autant d'étapes DATA et de procédures PROC nécessaires à l'obtention de tous les résultats souhaités. Toutefois, on doit respecter un certain ordre logique quoiqu'il ne soit pas formellement défini. Par exemple, on ne pourrait pas se servir d'une procédure faisant appel à un jeu de données qui ne serait pas préalablement conçu.

En second lieu, remarquons que chaque étape ou procédure est composée de plusieurs instructions habituellement représentées par des mots signifiant leur fonction et dont la dernière est toujours RUN. Cette instruction met fin aux étapes et aux procédures et, lors de la compilation, signale de les faire rouler.

Bien que nous étudierons plus tard différentes procédures séparément, notons maintenant quelques règles communes aux instructions:

Elles se terminent toujours par un point-virgule.
Elles peuvent commencer sur n'importe quelle colonne, mais par convention les étapes et procédures commenceront sur la première colonne et les instructions sur la deuxième.
Plusieurs instructions peuvent apparaître sur une même ligne.
Une instruction peut être poursuivie d'une ligne à la suivante, en autant qu'aucun mot ne soit scindé.
Les mots dans une instruction sont séparés par un espace ou un caractère comme la barre oblique. On verra plus loin les syntaxes spécifiques à chacune.

Par conséquent, pour utiliser SAS, il suffit d'écrire (et de sauvegarder!) le code d'un programme dans une fenêtre d'un éditeur tel "asedit" ou "emacs" puis, sous Unix, de le compiler avec la commande:

sas nom_du_fichier

Par la suite, un premier fichier nommé nom_du_fichier.log sera automatiquement généré. Il contient le code du programme ainsi que des messages d'erreurs, s'il y a lieu. Il inclut également des avertissements (WARNINGS) qui nous informent de problèmes potentiels ainsi que des NOTES, messages informatifs ou explications, à propos de la mémoire utilisée, la provenance des données, la taille du jeu de données construit, etc. Dans le cas d'une erreur, on verra le mot ERROR imprimé environ à l'endroit où elle se trouve dans le code et une brève explication pas toujours très claire! SAS détecte trois catégories d'erreurs. Premièrement, dans les instructions, il peut survenir des erreurs de syntaxe comme un mot mal orthographié ou un point-virgule manquant. Deuxièmement, s'il y a une absurdité telle une référence a des variables non existantes ou une division par zéro à l'intérieur d'une étape ou d'une procédure, alors son exécution est arrêtée et un message d'erreur apparaît avant de poursuivre avec la prochaine. Finalement, on peut retrouver une incompatibilité entre les données brutes et les variables déclarées dans l'instruction INPUT (voir chapitre 2).

En conclusion, on est toujours mieux d'examiner d'abord le fichier .log puis, si nécessaire, d'effectuer des corrections au code et de recompiler le programme afin de s'assurer qu'il ne contienne aucune erreur et qu'il roule avec succès. Par prévention, avant de compiler, il est bon de vérifier l'ordre logique des instructions, l'exactitude de la syntaxe et de l'orthographe des mots clés, la correspondance entre les données et les variables déclarées dans l'INPUT, ainsi que la présence du point-virgule là où il est requis. Pour terminer, il ne reste plus qu'à visionner le second fichier produit qui se nomme nom_du_fichier.lst dans lequel se trouve toutes les sorties du programme et donc, tous les résultats désirés.

Options

Bien que facultatives, les options forment habituellement la première ligne de code d'un programme. Il s'agit ici de changer les valeurs par défaut de quelques paramètres de spécifications. La formule la plus courante est sans doute la ligne suivante:

OPTIONS LINESIZE=80 NODATE NONUMBER FORMDLIM='-';

Effectivement, avec l'impression des résultats sur des feuilles de format 8"1/2 x 11", la valeur par défaut de l'option PAGESIZE valant 60, qui indique le nombre de lignes par page, est correcte. Par contre, quant à la longueur de chaque ligne, il est préférable de changer la valeur par défaut de l'option LINESIZE valant 132 par 80.

De plus, les options NODATE et NONUMBER indiquent respectivement de supprimer l'impression de la date dans les titres de même que celle du numéro de chaque page. Finalement, l'option FORMDLIM permet d'imprimer plus d'une page sur une même feuille, l'une à la suite de l'autre, en les délimitant par une ligne formée du tiret.

À toutes fins utiles, on peut connaître la liste de toutes les valeurs par défaut des différentes spécifications ainsi qu'une brève description de ces dernières dans le fichier .log disponible après avoir exécuté le petit programme suivant:

PROC OPTIONS;
RUN;

Titres, pieds de page et commentaires

Encore une fois, bien que facultatifs, les titres, pieds de page et commentaires sont fortement recommandés. En effet, ils peuvent êtres placés n'importe où dans le programme et seront ainsi ajoutés à l'impression des résultats pour plus de clarté et de précision. La syntaxe à utiliser est la suivante:

TITLEn "titre";
FOOTNOTEn "pied_de_page";
/*texte_en_commentaire*/

ou

*texte_en_commentaire;

Notes: 1. Lorsque le titre comprend déjà des guillemets, on doit remplacer ceux de la syntaxe par l'apostrophe. 2. Le caractère n, placé immédiatement après l'instruction TITLE, peut prendre les valeurs 1 à 10 . Il désigne le numéro des différentes lignes de texte qui apparaîtront dans l'ordre croissant, de haut en bas. S'il est omis, on assumera qu'il vaut 1. Ainsi, TITLE est équivalent à TITLE1. On peut aussi obtenir une ligne blanche en sautant une valeur de n. Une fois un TITLEi précisé, il sera présent dans toutes les impressions suivantes jusqu'à ce qu'il soit annulé ou redéfini. 3. Généralement, on va placer ces instructions à l'intérieur d'une procédure. De cette façon, on pourra facilement redéfinir un TITLEi dans les procédures suivantes afin de remplacer le précédent et d'annuler tous les TITLEn tels que n est supérieur à i. Donc, de procédure en procédure, on aura tous les titres désirés. 4. L'utilisation de TITLE annule tous les titres, tandis que celle de TITLEn annule le $\textit{n}^e$ titre ainsi que les précédents. 5. Toutes ces remarques s'appliquent également à FOOTNOTE.

L'étape DATA

Présentation

De prime abord, l'étape DATA, de même que toute autre procédure, consiste en un groupe d'instructions décrivant des tâches spécifiques. À la compilation, elles seront automatiquement traduites en langage machine. Puis, uniquement si la syntaxe est correcte, elles seront exécutées. D'où l'avantage d'examiner avant tout le fichier .log .

Au départ, on possède ce que l'on appelle des données brutes, soit une collection de données qui n'ont pas encore été traitées par SAS. Mais avant de pouvoir les analyser, on devra les organiser en un jeu de données afin que SAS puisse les reconnaître et les utiliser. En conséquence, l'étape DATA nous permettra, entre autres, de lire les données, de créer différents jeux de données et des nouvelles variables ainsi que de modifier certaines variables déjà existantes.

D'ailleurs, un jeu de données SAS peut être vu comme une structure rectangulaire qui identifie et conserve des valeurs. Les données sont donc enregistrées dans un fichier sous la forme d'une table de lignes et de colonnes. Chaque ligne représente une observation, i.e. un ensemble de valeurs qui nous informe sur un même "individu". Et chaque colonne est appelée une variable, i.e. un ensemble de valeurs décrivant une mesure ou une caractéristique spécifique et ce pour la totalité des "individus".

Finalement, une fois créé, un jeu de données contiendra non seulement des valeurs, mais aussi des informations descriptives telles le nom des variables, le nombre d'observations et le moment exact où il a été construit.

Lire les données

En premier lieu, voyons comment il est possible de se procurer des données déjà existantes dans un fichier Unix, à condition qu'elles soient disposées en une table d'observations et de variables (voir ci-haut). De plus, si on n'a pas toutes les données sur une observation, les valeurs manquantes doivent être représentées par un point ou un espace. SAS les considérera comme valant - $\mathnormal{\infty}$ . Alors, on n'a qu'à imiter le modèle suivant:

FILENAME nom_du_fichier "location_du_fichier_Unix";
DATA nom_du_jeu_de_données;
INFILE nom_du_fichier;
INPUT [#no] nom_variable [$] [début-fin] [.déc] ...;
RUN;

La première instruction de cette étape est toujours DATA. Celle-ci débute la construction du jeu de données en le nommant. Cependant, dans ce cas-ci, on doit auparavant localiser le fichier qui contient les données brutes avec l'instruction FILENAME puis, à l'aide de l'instruction INFILE, on pourra l'intégrer au programme SAS. Un exemple de la location du fichier Unix serait /home/malo/SAS/programme.

Mais avant d'aller plus loin, on doit connaître quelques règles appliquables aux noms. En effet, qu'il s'agisse de jeux de données, de variables ou autres, un nom se compose toujours de un à huit caractères alphanumériques, soient des chiffres, des lettres et le souligné (_). Le premier caractère ne peut pas être un chiffre et l'espace est illicite. En général, on voudra qu'un nom soit représentatif de son contenu.

Par la suite, l'instruction INPUT indique à SAS la disposition des données brutes et donc, comment les lire. On commence par définir les variables et indiquer leur type. Par défaut, il est numérique, mais si on place le signe $ après le nom d'une variable, il sera alphanumérique.

Et puis, comme dans le fichier de données les variables sont alignées, on indique après leur nom le numéro de la colonne où débutent les valeurs (début) ainsi qu'un tiret et la position de son dernier caractère (-fin) s'il y en a plus qu'un.

Pour terminer, on peut aussi indiquer à SAS le numéro de la ligne (#no) sur laquelle il doit lire les variables qui suivent et le nombre (.déc) de décimales qu'elles comportent. Cela est utile pour commencer à lire les données sur une ligne autre que la première si, par exemple, il y a du texte au début du fichier de données; et pour indiquer quelles variables sont sur chaque ligne s'il y a plusieurs lignes pour une même observation. On peut aussi clore l'instruction par #n pour dire qu'il y a au total n lignes par observation, mais qu'on ne veut lire que les variables déclarées précédemment.

De plus, si le fichier de données satisfait à toutes les conditions suivantes:

les valeurs contiennent au plus huit caractères;
sur chaque ligne, les valeurs sont séparées entre elles par au moins un espace;
les valeurs manquantes sont représentées par un point (et non par un espace);
les valeurs numériques incluent le nombre nécessaire de décimales;

alors, on pourra simplement lister les noms des variables, sans avoir à spécifier le numéro des colonnes (début-fin), comme suit:

INPUT [#no] nom_variable [$] ...;

Finalement, on peut aussi attribuer des formats particuliers aux valeurs des variables. Par FORMAT (ou INFORMAT) on entend une façon précise d'écrire (ou de lire) les données. SAS en comprend plusieurs déjà définis (pour une descriptions de ceux-ci, voir le manuel SAS Language: Reference aux pages 60 à 71). Aussi, on peut créer des formats personnels à l'aide de la procédure FORMAT (voir la section 4.2). Pour lire des données selon un format de lecture, la syntaxe est la suivante:

INPUT [/] [@col] nom_variable [$] nom_format. ...;

La barre oblique indique de lire les variables suivantes à partir de la prochaine ligne d'une même observation. Puis, avant son nom et son type, on indique le numéro de la colonne (@col) où débute les valeurs de la variable. Pour terminer, on nomme le format à attribuer suivi d'un point. Mais, pour affecter un format d'écriture à certaines variables, on ajoute simplement, après l'INPUT, la ligne suivante:

FORMAT nom_variable ... nom_format.;

Entrer les données

Deuxièmement, si les données n'existent pas déjà, on peut soit créer son propre fichier de données et procéder comme on vient de le voir, soit entrer les données à même le programme en employant l'instruction CARDS comme suit:

DATA nom_du_jeu_de_données;
INPUT nom_variable [$] [début-fin] [.déc] ...;
CARDS;
<entrer ici la table des données>
;
RUN;

De cette façon, les instructions FILENAME et INFILE sont remplacées par CARDS qui indique que les données brutes vont suivre. Puis, un point-virgule vient marquer la fin de l'entrée de ces données. Néanmoins, juste avant l'INPUT, on peut ajouter:

INFILE CARDS <options>;

dans le but d'accéder aux options de cette instruction dont en voici quelques-unes:

DLM=caractère Indique le caractère qui va remplacer l'espace pour séparer les valeurs.
FIRSTOBS=numéro Indique le numéro de la première valeur à être lue.
MISSOVER Indique à SAS de considérer manquantes les dernières valeurs absentes d'une observation et de lire la prochaine observation à partir de la ligne suivante.
OBS=nombre Indique le nombre total d'observations à lire à partir de la première.

SAS Language: Reference, p.379

De plus, l'ajout de @@ à la fin de l'instruction INPUT juste avant le point-virgule permet de lire plusieurs observations une à la suite de l'autre sur une même ligne.

Fichiers SAS permanents

Antérieurement, tous les jeux de données dont on a parlé étaient temporaires. Leur existance se limitait à la durée du programme. Cependant, un jeu de données peut être permanent. Celui-ci est avantageux puisqu'il demeure prêt à être réutilisé par SAS. Aussi, il est efficient et il occupe moins d'espace que le fichier de données brutes. Pour créer un fichier SAS permanent, on emprunte la syntaxe suivante:

LIBNAME librairie "location_du_fichier_SAS";
DATA librairie.nom_du_jeu_de_données_permanent;
INPUT nom_variable [$] [début-fin] [.déc] ...;
RUN;

Pour commencer, l'instruction LIBNAME, située avant l'étape DATA, indique à SAS dans quel répertoire enregistrer le fichier. La librairie à laquelle on fait référence pour accéder au jeu de données permanent doit satisfaire les règles pour les noms décrites précédemment et ne peut pas s'appeler WORK, car il s'agit de celle utilisée par SAS dans le cas de jeux de données temporaires.

Puis, semblablement, on accéde à un fichier SAS permanent comme suit:

LIBNAME librairie "location_du_fichier_SAS";
DATA nom_du_jeu_de_données;
SET librairie.nom_du_jeu_de_données_permanent;
RUN;

Ici, c'est l'instruction SET qui nous permet de réutiliser le jeu de données permanent en préfixant son nom de celui de la librairie. L'instruction LIBNAME demeure nécessaire tandis que l'instruction INPUT ne l'est plus étant donné que son information est déjà contenue dans le fichier permanent.

Opérateurs et fonctions

Notons d'abord que les opérateurs sont des symboles ayant une définition précise et connue. Ils nous permettent de créer et de modifier des variables numériques. Donc, après l'INPUT, on peut ajouter, autant de fois que nécessaire, la formule suivante:

nom_variable = cte_ou_variable opérateur cte_ou_variable ...;

Ainsi, la variable à gauche de l'égalité reçoit la valeur calculée de l'expression de droite. Évidemment, l'emploi des parenthèses est permis. Les opérateurs sont évalués selon l'ordre habituel et ils se classifient en quatre groupes.

Tout d'abord, les opérateurs arithmétiques sont +, -, *, /, ** soient l'addition, la soustraction, la multiplication, la division et l'exponentiation. Puis, on a les opérateurs de comparaison =, =, >, >=, <, <= soient égal, différent, plus grand, plus grand ou égal, plus petit et plus petit ou égal. Ensuite, viennent les deux opérateurs logiques & (et), | (ou). Finalement, l'opérateur de concatenation, ||, combine des valeurs alphanumériques en une plus longue en les plaçant une après l'autre.

De plus, SAS contient plusieurs fonctions prédéfinies pouvant être fort utiles pour la création ou la modification de variables numériques. En voici les principales:

Distribution	Percentile	Fonction de	Génération d'une
	0<p<1	répartition	valeur aléatoire
		P(X <= $x)	avec germe s
Bêta (a>0, b>0)	BETAIN(p,a,b)	PROBBETA(x,a,b)
Binomiale (n,p)		PROBBNML(p,n,x)	RANBIN(s,n,p)
Binomiale Négative(n,p)		PROBNEGB(p,n,x)
Cauchy			RANCAU(s)
Exponentielle			RANEXP(s)
Fisher (n1,n2)	FINV(p,n1,n2)	PROBF(x,n1,n2)
Gamma ( $\mathnormal{\alpha}$)	GAMINV(p, $\mathnormal{\alpha}$)	PROBGAM(x, $\mathnormal{\alpha}$)	RANGAM(s, $\mathnormal{\alpha}$)
Hypergéométrique		PROBHYPR(N,K,n,x)
Khi-carré (dl)	CINV(p,dl)	PROBCHI(x,dl)
Normale (0,1)	PROBIT(p)	PROBNORM(x)	RANNOR(s)
Poisson ( $\mathnormal{\lambda}$)		POISSON( $\mathnormal{\lambda}$,y)	RANPOI(s, $\mathnormal{\lambda}$)
T de Student (dl)	TINV(p,dl)	PROBT(x,dl)		Triangulaire (h)	RANTRI(s,h)
Uniforme (0,1)			RANUNI(s)
Fonction de masse définie par p1 à pn		RANTBL(s, p1,...,pn)

Guide SAS

Sommaire