Guide SAS

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 0<p<1	Fonction de répartition P(X <= $x)	Génération d'une valeur aléatoire 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)

Arithmétique		Mathématique		Trigonométrie
ABS(x)	Valeur absolue de x	DIGAMMA(x)	G'(x)/G(x)	COS(x)
DIM(t)	Dimension du tableau t	ERF(x)		ARCOS(x)
MOD(n,d)	Reste de la division n/d	ERFC(x)	1-ERF(x)	COSH(x)
SIGN(x)	Signe de x (-1, 0, ou 1)	EXP(x)	ex	SIN(x)
SQRT(x)	Racine carrée de x	GAMMA(n)	(n-1)!	ARSIN(x)
Troncation		LGAMMA(x)	ln(GAMMA(x))	SINH(x)
CEIL(x)	Plus petit entier >= x	LOG(x)	ln(x)	TAN(x)
FLOOR(x)	Plus grand entier <= x	LOG10(x)	log(x)	ATAN(x)
INT(x)	Partie entière de x	LOG2(x)	log2(x)	TANH(x)
ROUND(x,u)	Arrondit x à l'unité u	TRIGAMMA(x)	DIGAMMA'(x)

Pour terminer, les fonctions suivantes permettent le calcul de statistiques descriptives: N, NMISS, SUM, MIN, MAX, RANGE, MEAN, STD, STDERR, VAR, CV, USS, CSS, SKEWNESS et KURTOSIS .

Chacune prend en argument une liste de nombre séparés par des virgules ou une liste de variables précédée du mot "OF". Afin de connaître leur définition, voir la section 6.5.

Instructions optionnelles

Tout au long de ce document, nous allons parcourir différentes procédures qui, comme nous l'avons déjà mentionné, regroupent plusieurs instructions. Toutefois, il en existe d'autres qui, sans être spécifique à une procédure, peuvent être utilisées au besoin. Mais d'abord, voyons quelques instructions pouvant être ajoutées à l'étape DATA:

DATA nom_du_jeu_de_données;
INPUT nom_variable [$] [début-fin] [.déc] ...;
MISSING lettre ...;
ATTRIB nom_variable LABEL=`étiquette'
FORMAT=nom_format
INFORMAT=nom_format
LENGTH=[$]nombre_d'octets;
RUN;

D'abord, l'instruction MISSING identifie une lettre représentant des valeurs manquantes. Ensuite, l'instruction ATTRIB permet d'attribuer à une variable une étiquette pouvant contenir jusqu'à 40 caractères (LABEL), un format d'écriture (FORMAT) ou de lecture (INFORMAT) ainsi qu'un nombre d'octets (LENGTH), variant de 2 à 8 pour les variables numériques et de 1 à 200 pour les variables alphanumériques ($), différent de ceux par défaut qui sont respectivement 8 et 12.

En outre, notons que SAS est un logiciel admettant la programmation. Il existe un certain nombre d'instructions telles DO, IF-THEN/ELSE, WHERE et END indispensables pour bâtir de petits programmes. Non seulement elles peuvent être utilisées à l'intérieur de l'étape DATA pour créer ou modifier certaines variables, mais leur emploi peut également servir dans diverses procédures. Enfin, en ajoutant encore d'autres instructions comme DELETE qui enlève certaines données et OUTPUT nom_du_jeu_de_données ... qui écrit l'observation dans le jeu de données, on est en mesure d'obtenir toutes les variantes imaginables.

Combiner des jeux de données

À l'intérieur de l'étape DATA, il existe différentes méthodes pour combiner les données de deux ou de plusieurs jeux temporaires ou permanents. Mais peu importe celle que nous utilisons, on recommande de vérifier le résultat en portant une attention particulière aux NOTES et aux avertissements (WARNINGS), et en imprimant les données du nouveau jeu obtenu.

Premièrement, la concatenation nous permet de copier un sous l'autre et en un seul des jeux de données selon l'ordre où ils sont déclarés dans l'instruction SET. La forme la plus simple pour concatener les données est donc:

DATA nom_du_jeu_de_données;
SET nom_du_jeu_à_concatener ...;
RUN;

Le nombre d'observation du nouveau jeu ainsi créé doit correspondre à la somme des observations de tous les jeux combinés. Notons que SAS considère les variable ayant le même nom comme étant la même variable. S'il existe des variables différentes d'un jeu à un autre, il y aura alors des valeurs manquantes pour les observations correspondantes au(x) jeu(x) ne contenant pas ces variables. Aussi, pour concatener, une variable doit être du même type dans tous les jeux de données. Si ce n'est pas les cas, voici, par exemple, comment changer une variable numérique en une variable alphanumérique pour un certain jeu de données:

DATA nom_du_jeu_de_données (drop=tempvar);
length variable $ 12;
SET ancien_jeu (rename=(variable=tempvar));
variable=tempvar;
RUN;

Deuxièmement, on peut combiner les observations de n jeux de données triés individuellement en un seul jeu aussi trié, en ajoutant l'instruction BY au modèle précédent comme suit:

DATA nom_du_jeu_de_données;
SET nom_du_jeu_à_concatener ...;
BY nom_variable ...;
RUN;

La seule restriction est que les variables déclarées dans l'instruction BY appartiennent à chacun des jeux et que ceux-ci doivent auparavant être triés selon l'ordre croissant des valeurs de ces variables communes. Puis, dans le nouveau jeu, apparaissent dans l'ordre les observations des jeux à concatener, pour chaque groupe contenant toutes les observations ayant la même combinaison de valeurs des variables communes.

Troisièmement, il est possible de fusionner les observations correspondantes de deux ou de plusieurs jeux de données en une seule observation dans le nouveau jeu.

D'abord, on peut simplement joindre côte-à-côte les observations selon la position qu'elles occupent dans les jeux de données à l'aide de l'instruction MERGE comme suit:

DATA nom_du_jeu_de_données;
MERGE nom_du_jeu_à_combiner ...;
RUN;

Ici, le nombre d'observations du nouveau jeu de données est égal au nombre d'observations du plus grand jeu combiné. Le cas le plus simple est lorsque toutes les variables sont différentes et que tous les jeux de données ont le même nombre d'observations. Cependant, si une variable existe dans plus d'un jeu de données, alors c'est la valeur du dernier jeu lu qui est retenue dans le nouveau jeu et ce, même s'il s'agit d'une valeur manquante.

Puis, si au préalable tous les jeux de données sont triés selon des variables communes, alors l'ajout de l'instruction BY permet de combiner les observations par groupes formés d'une même combinaison des valeurs de ces variables:

DATA nom_du_jeu_de_données;
MERGE nom_du_jeu_à_combiner ...;
BY nom_variable ...;
RUN;

Le nombre d'observations du nouveau jeu est maintenant la somme du plus grand nombre d'observations de chaque groupe parmi tous les jeux. Lorsque nécessaire, à l'intérieur de chaque groupe, la dernière valeur d'une variable sera répétée pour compléter à ce nombre d'observations dans le nouveau jeu. Donc, aucune valeur manquante n'est crée. Aussi, si une certaine combinaison des valeurs des variables déclarées dans l'instruction BY existe dans un jeu et non dans un autre, alors le nouveau jeu contiendra quand même les observations de ce groupe, mais avec des valeurs manquantes pour les autres variables des jeux ne la contenant pas.

Quatrièmement, on peut remplacer les valeurs des variables d'un jeu de données par les valeurs correspondantes d'un autre jeu. Pour ce faire, on travaille avec deux jeux de données auparavant triés selon des variables communes qui ne pourront être mise à jour. Dans le premier, les combinaisons des valeurs de ces variables formant chaque groupe doivent être uniques. Celui-ci contient les informations originales tandis que dans le deuxième on trouve les nouvelles informations. Le nombre d'observations du nouveau jeu est la somme du nombre d'observations du premier jeu et du nombre d'observations qui diffèrent dans le deuxième. On utilise la syntaxe suivante:

DATA nom_du_jeu_de_données;
UPDATE jeu_1 jeu_2;
BY var_1 var_2 ... var_m;
RUN;

Toutefois, si le premier jeu contient plus d'une observation dans un même groupe, alors la première est remplacée et les autres demeurent inchangées. Si, par contre, c'est le deuxième jeu qui contient des valeurs répétées, alors SAS effectue tous les changements un à la suite de l'autre.

Aussi, si une observation du premier jeu n'a pas de correspondante dans le deuxième, alors elle demeure inchangée. Dans le cas contraire, l'observation du deuxième jeu peut être modifiée et sera ajoutée au nouveau jeu.

De plus, notons que SAS ne remplacera pas une valeur existante dans le premier jeu par une valeur manquante dans le deuxième, à moins qu'elle soit indiquée par un caractère spécifié dans l'instruction MISSING autre que le point ou l'espace.

En dernier lieu, le deuxième jeu peut contenir de nouvelles variables qui seront ajoutées à toutes les observations dans le nouveau jeu.

Finalement, notons que les nouveaux jeux crées par l'instruction UPDATE contiendrons toutes les variables de tous les jeux combinés. Mais pour en préciser le contraire, dans l'étape DATA ainsi que dans toutes autres procédures, on peut toujours utiliser, entre parenthèses, après le nom d'un jeu de données différentes options dont en voici les principales:

KEEP= nom_variable ... Identifie les variables à inclure dans le jeu de données.

DROP=nom_variable ... Indique à SAS de ne pas tenir compte de ces variables.

IN=nom_variable S'utilise uniquement dans les instructions SET, MERGE et UPDATE. Crée une variable temporaire qui vaut 1 si l'observation appartient au jeu de données et 0 sinon.

RENAME= (ancien_nom = nouveau_nom) ... Change le nom d'une ou de plusieurs variables.

SAS Language: Reference, chapitre 15.

En conclusion, il nous est maintenant possible d'associer toutes les notions vues dans ce chapitre afin de créer maints jeux de données. Donc, nous sommes prêts pour l'analyse statistique des données à l'aide de procédures dont plusieurs sont présentées dans les chapitres à venir.

La transformation des jeux de données

Concatener deux jeux de données (PROC APPEND)

La procédure APPEND permet d'ajouter les observations d'un jeu de données SAS (DATA=) à la fin des observations d'un autre jeu (BASE=). Aucun nouveau jeu n'est créé à moins que celui déclaré dans l'instruction BASE n'existe pas déjà.

PROC APPEND BASE=nom_du_jeu_de_données DATA=nom_du_jeu_de_données [FORCE];
RUN;

L'instruction FORCE oblige la procédure APPEND à concatener les jeux de données lorsque les variables du jeu déclaré dans l'instruction DATA sont différentes, pas du même type ou plus longues que celles du jeu de données déclaré dans l'instruction BASE.

Trier les observations (PROC SORT)

La procédure SORT permet de trier les observations d'un jeu de données selon l'ordre croissant (ou décroissant) des valeurs des variables spécifiées dans l'instruction BY.

PROC SORT DATA=nom_du_jeu_de_données_à_trier <options>;
BY [DESCENDING] nom_variable ... [DESCENDING] nom_variable;
RUN;

<options>:

OUT=nom	Donne un nom différent au jeu de données qui contiendra les observations une fois triées.
NODUPLICATES	Élimine toutes les observations qui sont identiques à une autre.
NODUPKEY	Comme NODUPLICATES, mais à l'intérieur de chacun des groupes formés par l'instruction BY.
EQUALS	Les observations ayant la même combinaison de valeurs pour les variables déclarées dans l'instructions BY conservent leur position.
SORTSEQ=	Indique parmi ASCII, DANISH, EBCDIC, FINNISH, NATIONAL, NORVEGIAN et SWEDISH la méthode de trie à utiliser. Par défaut c'est ASCII ou EBCDIC.

SAS Procedures Guide, p.505

Changer les observations en variables et vice-versa (PROC TRANSPOSE)

La procédure TRANSPOSE permet de transposer la table d'observation et de variables d'un jeu de données.

PROC TRANSPOSE DATA=nom_du_jeu_de_données <options>;
VAR nom_variable ...;       {Liste des variables à transposer} 
ID nom_variable;            {Identifie une variable dont les valeurs deviendront les noms des nouvelles variables} 
IDLABEL nom_variable;       {Avec l'utilisation de l'instruction ID, identifie une variable dont les valeurs deviendront 
                            les étiquettes des nouvelles variables.} 
COPY nom_variable ...;      {Copie ces variables sans les transposer} 
BY nom_variable ...;        {Effectue la transposition à l'intérieur de chaque groupe} 
RUN;

<options>:

OUT=nom	Donne un nom différent au jeu de données une fois transposé.
PREFIX=nom	Donne un nom qui servira de préfix pour les noms des nouvelles variables.
NAME=nom_variable	Nomme une variable qui contiendra les noms des nouvelles observations.
LABEL=nom	Nomme une variable qui contiendra les étiquettes des nouvelles observations.
LET	Permet d'avoir des valeurs identiques pour les variables déclarées dans l'instruction ID ou à l'intérieur d'un même groupe de l'instruction BY.

SAS Procedures Guide, p.595

Normaliser les données (PROC STANDARD)

La procédure STANDARD permet de normaliser les valeurs de quelques-unes ou de toutes les variables d'un jeu de données SAS.

PROC STANDARD DATA=nom_du_jeu_de_données <options>;
BY nom_variable ...;    {Normalise selon la moyenne et l'écart-type respectifs à chaque groupe d'observations.} 
FREQ nom_variable;      {Identifie une variable numérique dont les valeurs représentent la fréquence de chaque observation. 
                         Les observations ayant une fréquence valant moins que un ou étant une valeur manquante ne seront
                           pas utilisées lors du calcul de la moyenne et de l'écart-type.} 
VAR nom_variable ...;    {Liste des variables à normaliser.} 
WEIGTH nom_variable;     {Identifie une variable numérique dont les valeurs représentent le nombre de sujets que vaut chaque observation.} 
RUN;

<options>:

OUT=nom	Donne un nom différent au jeu de données contenant les variables normalisées.
MEAN=moyenne	Normalise les variables selon cette moyenne.
STD=écart-type	Normalise les variables selon cet écart-type.
REPLACE	Remplace les valeurs manquantes par la valeur de la moyenne.
VARDEF=	Indique parmi DF (n-1), N (n), WDF ( \( (\sum_i w_i)-1 \)) et WEIGHT ( \( \sum_i w_i \)) le diviseur à utiliser lors des calculs de variances.
PRINT	Imprime la fréquence, la moyenne et l'écart-type de chaque variable normalisée.

SAS Procedures Guide, p.551

Calculer des rangs (PROC RANK)

La procédure RANK permet d'obtenir le rang, pour une ou plusieurs variables, de chaque observation.

PROC RANK DATA=nom_du_jeu_de_données <options>;
BY nom_variable ...;         {Calcul les rangs à l'intérieur de chaque groupe.} 
RANKS nouvelle_variable ...; {Nomme les nouvelles variables qui contiendront les rangs.} 
VAR nom_variable ...;        {Liste des variables dont on veut les rangs.}  
RUN;

<options>:

OUT=nom	Nomme le jeu de données qui contiendra les rangs.
FRACTION	Divise chaque rang par le nombre total d'observations n'ayant pas de valeurs manquantes et l'exprime sous forme de fraction.
NPLUS1	Idem à FRACTION, mais divise le rang par n+1 plutôt que par n.
GROUPS=nb_groupes	Identifie le nombre de groupes, dont les observations recevront le même rang, à former selon les valeurs de la variable.
NORMAL=	Indique parmi BLOM ( \(\Phi^{-1}(rang_i-\frac{3}{8})/(n+\frac{1}{4})\)), TUKEY ( \(\Phi^{-1}(rang_i-\frac{1}{3})/(n+\frac{1}{3})\)) et VW ( \(\Phi^{-1}(rang_i)/(n+1)\)) la variable Yi, normalement distribuée, à calculer.
PERCENT	Idem à FRACTION, mais multiplie le résultat par 100.
SAVAGE	Calcule \(Y_i=[\sum_{j=n-rang_i+1}^n(1/j)]-1\) .
DESCENDING	Donne à la plus grande valeur le rang 1, à la suivante le rang 2 et ainsi de suite.
TIES=	Indique parmi MEAN, HIGH et LOW le rang à attribuer aux observations de valeurs égales. Par défaut c'est MEAN.

SAS Procedures Guide, p.493

La représentation des données

Impression des données (PROC PRINT)

La procédure PRINT permet d'imprimer un jeu de données et d'obtenir la somme des valeurs de variables numériques.

PROC PRINT DATA=nom_du_jeu_de_données <options>;
VAR nom_variable ...;        {Liste des variables à imprimer.} 
ID nom_variable ...;         {Identifie les observations par les valeurs de ces variables plutôt que de les numéroter.} 
BY nom_variable ...;         {Imprime les données séparément pour chaque groupe.} 
PAGEBY nom_variable;         {À utiliser avec l'instruction BY, imprime les données de chaque groupe sur des pages différentes.} 
SUM nom_variable ...;        {Liste des variables dont on veut le total de leurs valeurs. Utilisé avec l'instruction BY, 
                             imprime aussi le sous-total de chaque groupe contenant plus d'une observation.} 
SUMBY nom_variable;          {À utiliser avec l'instruction BY, imprime le sous-total des valeurs de cette variable pour tous les groupes.} 
RUN;

<options>:

DOUBLE	Imprime les observations à interligne double.
NOOBS	Supprime l'impression des numéros des observations.
UNIFORM	Imprime le même nombre d'observations sur chaque page.
LABEL	Utilise les étiquettes des variables plutôt que leur nom pour identifier les colonnes.
SPLIT=`caractère'	Identifie un caractère qui, à l'intérieur d'une étiquette, indique d'en continuer l'impression sur la ligne au-dessous.
N	Imprime à la fin le nombre total d'observations. Utilisé avec l'instruction BY, imprime le nombre d'observations de chaque groupe.
ROUND	Arrondit les valeurs à deux décimales.

Formats de lecture et d'écriture (PROC FORMAT)

La procédure FORMAT, permet de définir nos propres formats pour la lecture et pour l'écriture des valeurs de variables. Elle est la seule procédure qui doit précéder l'étape DATA.

PROC FORMS <options1>;
VALUE nom_format <(options2)> rang=`valeur' ...; {Définit un format qui écrit différemment les valeurs des variables. 
                                                 Le rang peut aussi être OTHER. Si les valeurs et les rangs sont tous des caractères,
                                                 précéder le nom du format du signe $ et mettre entre apostrophes les deux côtés de l'égalité.} 
INVALUE nom_format <(options2)> `rang'=valeur ...; {Définit un format de lecture. La valeur peut aussi être _SAME_ ou _ERROR_ .} 
PICTURE nom_format <(options2)> rang=`patron' <(options3)> ...; {Définit un patron pour l'impression de nombres. 
                                                                Un exemple du patron serait 000 009.99 .} 
SELECT lettres[:][-lettres] ...;                 {Imprime le format dont le nom correspond aux lettres. Avec l'emploi des deux-points (:), 
                                                 imprime tous les formats commençant par ces lettres. Aussi, imprime tous 
                                                 les formats dont le nom, selon l'ordre alphabétique, est compris entre 
                                                 ces lettres (lettres-lettres).} 
EXCLUDE lettres[:][-lettres] ...;                {Contraire de SELECT. Une seule de ces deux instructions peut être employée.} 
RUN;

<options1>:

LIBRARY=nom_librairie	Identifie une librairie qui contiendra les définitions des formats.
FMTLIB	Imprime le contenu de la librairie.
PAGE	Imprime chaque format sur une page différente dans la librairie.
CNTLIN=nom_du_jeu_de_données	Identifie un jeu de données pouvant aider à créer des formats. Par exemple, ce peut être un fichier associant des valeurs à des chaînes de caractères.
CNTLOUT=nom_du_jeu_de_données	Identifie un jeu de données contenant des informations sur les formats que l'on crée.

<(options2)>:

Options	VALUE	INVALUE	PICTURE
DEFAULT	$\mathnormal{\surd}$	$\mathnormal{\surd}$	$\mathnormal{\surd}$
MAX, MIN	$\mathnormal{\surd}$	$\mathnormal{\surd}$	$\mathnormal{\surd}$
FUZZ	$\mathnormal{\surd}$
JUST		$\mathnormal{\surd}$
UPCASE		$\mathnormal{\surd}$

DEFAULT=l	Identifie la largeur par défaut (l) des formats.
MAX (ou MIN)=n	Identifie la largeur maximale (ou minimale) 1 $\mathnormal{\le}$ n $\mathnormal{\le}$40 des formats. Par défaut c'est la largeur de la plus longue étiquette.
FUZZ=écart	Indique d'associer à un rang toute valeur qui est à $\mathnormal{\pm}$ l'écart de la valeur spécifiée dans l'instruction VALUE.
JUST	Justifie à gauche toutes les chaînes de caractères avant de les comparer aux rangs.
UPCASE	Transforme toutes les chaînes de caractères en lettres majuscules avant de les comparer aux rangs.

<(options3)>:

PREFIX=`caractère(s)'	Identifie un ou deux caractères qui précéderont la valeur.
FILL='caractère'	Identifie un caractère qui remplacera les espaces libres à gauche des valeurs.
MULTIPLIER=facteur	Multiplie par ce facteur toutes les valeurs des données avant d'appliquer le format à la partie entière du résultat.
NOEDIT	Imprime les nombres du patron tel qu'ils apparaissent.