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.

Étiquettes (PROC FORMS)

La procédure FORMS permet d'imprimer les valeurs des variables sous forme d'étiquettes.

PROC FORMS DATA=nom_du_jeu_de_données <options1>;
LINE n nom_variable ... </ options2>;       {Identifie des variables dont les valeurs seront imprimées sur la \(\textit{n}^e\) ligne.} 
FREQ nom_variable;                          {Identifie une variable numérique dont les valeurs déterminent le nombre d'étiquettes 
                                            à imprimer pour chaque observation.} 
BY nom_variable ...;                        {Imprime les étiquettes de chaque groupe sur des pages différentes.} 
RUN;

<options1>:

FILE=nom_du_fichier	À utiliser avec l'instruction FILENAME, identifie un fichier dans lequel écrire les étiquettes.
WIDTH=nb_caractères	Identifie la largeur de l'étiquette. Par défaut c'est celle de la plus grande ligne.
LINES=n	Identifie le nombre (1 $\mathnormal{\le}$ n $\mathnormal{\le}$200) de lignes de l'étiquette.
DOWN=n	Identifie le nombre (0 $\mathnormal{\le}$ n $\mathnormal{\le}$200) de lignes à passer en haut de la page avant de commencer à imprimer les étiquettes.
ACROSS=n	Identifie le nombre (1 $\mathnormal{\le}$ n $\mathnormal{\le}$200) d'étiquettes à imprimer par ligne.
INDENT=n	Identifie le nombre (n) d'espaces à laisser libre avant la première colonne d'étiquet-tes.
SKIP=n	Identifie le nombre (1 $\mathnormal{\le}$ n $\mathnormal{\le}$200) de lignes à laisser libre entre les étiquettes.
NDOWN=n	Identifie le nombre (n) d'étiquettes à imprimer par colonnes.
BETWEEN=	Identifie le nombre (0 $\mathnormal{\le}$ n $\mathnormal{\le}$200) d'espaces entre chaque étiquette.
PAGESIZE=n	Identifie le nombre (n) de lignes d'une page.
COPIES=n	Identifie le nombre (n) d'étiquettes à imprimer pour chaque observation.
SETS=n	Identifie le nombre (n) de copies de l'ensemble des étiquettes à imprimer.

</ options2>:

INDENT=n	Identifie le nombre (n) d'espaces à laisser libre au début de la ligne.
LASTNAME	Imprime dans l'ordre inverse les mots d'une variable alphanumérique se trouvant avant et après une virgule.
PACK	Sur cette ligne, laisse un seul espace entre les valeurs.
REMOVE	Efface la ligne en entier si les valeurs des variables sont toutes des espaces ou des valeurs manquantes.

Les graphiques

Nuages de points (PROC PLOT)

La procédure PLOT permet de tracer le graphique d'une variable d'un jeu de données SAS en fonction d'une autre.

PROC PLOT DATA=nom_du_jeu_de_données <options1>;
BY nom_variable ...;              {Trace des nuages de points différents pour les observations de chaque groupe.} 
PLOT Y*X=`symbole' </ options2>;  {Trace le graphique de la variable Y en fonction de la variable X en représentant chaque observation par le symbole spécifié.} 
RUN;

<options1>:

UNIFORM	Uniformise les échelles des axes de tous les graphiques.
NOMISS	Exclut du calcul des axes les observations ayant des valeurs manquantes.
NOLEGEND	Supprime l'impression de la légende au haut de chaque graphique.
FORMCHAR=`onze_caractères'	- - - -|+|- - - .
HPERCENT=p ...	Identifie le pourcentage (1 $\mathnormal{\le}$ p $\mathnormal{\le}$100) de la largeur de la page à utiliser pour chaque graphique.
VPERCENT=p	Identifie le pourcentage (1 $\mathnormal{\le}$ p $\mathnormal{\le}$100) de la longueur de la page à utiliser pour chaque graphique.

</ options2>:

HAXIS (ou VAXIS)=a to b by p	Indique que la graduation de l'échelle sur l'axe des X (ou l'axe des Y) va de a à b par un pas p.
HZERO (ou VZERO)	Si les valeurs sont toutes positives et que l'option HAXIS (ou VAXIS) n'a pas été spécifiée, alors la graduation de l'échelle débutera à 0 pour l'axe des X (ou l'axe des Y).
HREVERSE (ou VREVERSE)	Renverse l'ordre des valeurs sur l'axe des X (ou l'axe des Y).
HEXPAND (ou VEXPAND)	Allonge l'axe des X (ou l'axe des Y) de façon à minimiser les marges de chaque côté du graphique et à maximiser la distance entre les graduations de l'échelle.
HSPACE (ou VSPACE)=nombre	Identifie le nombre de marques que l'on veut sur l'échelle entre les graduations pour l'axe des X (ou l'axe des Y).
HREF (ou VREF)=valeur ...	Trace des droites perpendiculaires à l'axe des X (ou à l'axe des Y) vis-à-vis les valeurs spécifiées.
HREFCHAR (ou VREFCHAR)=`caractère'	) (ou le tiret (-)).
HPOS (ou VPOS)=l	Indique la longueur (l) de l'axe des X (ou l'axe des Y). La valeur maximale pour l est celle de l'option LINESIZE (ou PAGESIZE) moins trois.
BOX	Trace une bordure tout autour du graphique.
OVERLAY	Supperpose tous les graphiques spécifiés dans l'instruction PLOT.
CONTOUR	Trace le graphique des courbes de niveaux à condition que l'instruction soit de la forme PLOT Y*X=Z; où Z est une variable numérique.

SAS Procedures Guide, p.397

Graphiques temporels (PROC TIMEPLOT)

La procédure TIMEPLOT permet de tracer des graphiques temporels d'une ou de plusieurs variables.

PROC TIMEPLOT DATA=nom_du_jeu_de_données <options1>;
PLOT nom_variable=`symbole' ... </ options2>;      {Trace le graphique temporel de ces variables en représentant les données par le symbole spécifié.} 
CLASS nom_de_variable ...;                         {Groupe les données selon les valeurs de ces variables. Sur une ligne différente pour chaque groupe, 
                                                   imprime les valeurs et les représente sur le graphique (sauf celles des variables déclarées dans CLASS).} 
BY nom_variable ...;                               {Trace un graphique différent pour les observations de chaque groupe.} 
ID nom_de_variable ...;                            {Imprime les valeurs de ces variables sans toutefois les représenter sur le graphique.}  
RUN;

<options1>:

MAXDEC=nb_décimales	Identifie le nombre maximal de décimales à imprimer.
UNIFORM	Uniformise les échelles de l'axe horizontal des graphiques de tous les groupes.

</ options2>:

AXIS=a to b by p	Indique que la graduation de l'échelle sur l'axe horizontal va de a à b par un pas p.
REVERSE	Renverse l'ordre des valeurs sur l'axe horizontal.
POS=nombre	Identifie le nombre de positions sur l'axe horizontal à utiliser pour représenter les valeurs des observations.
REF=valeur ...	Trace des droites verticales vis-à-vis les valeurs spécifiées de l'axe horizontal.
REFCHAR=`caractère'	).
JOINREF	Pour chaque ligne du graphique, joint le symbole le plus à gauche à celui le plus à droite par une ligne formée du tiret (-).
HILOC	Idem à JOINREF, mais s'applique uniquement aux symboles représentant des données. Cette option sera ignorée si l'option JOINREF est aussi spécifiée.
NOSYMNAME	À utiliser avec l'instruction CLASS, supprime l'impression du nom de la variable symbole dans les en-têtes des colonnes.
NPP	Supprime l'impression des valeurs des variables déclarées dans l'instruction PLOT.
OVERLAY	Superpose, en un seul, tous les graphiques spécifiés dans l'instruction PLOT.
OVPCHAR=`caractère'	Identifie le caractère à imprimer si deux symboles coïncides. Par défaut c'est @.

Histogrammes et diagrammes (PROC CHART)

La procédure CHART permet de tracer des histogrammes (BAR Charts) horizontaux, verticaux et à colonnes segmentées, ainsi que des diagrammes en bâtons (BLOCK Charts), circulaires (PIE Charts) et en étoiles (STAR Charts).

PROC CHART DATA=nom_du_jeu_de_données <options1>;
BY nom_variable ...;                           {Sur chaque diagramme, représente séparément les observations de chaque groupe.} 
HBAR nom_variable ... </ options2,3>;          {Liste des variables à représenter par un histogramme à barres horizontales.} 
VBAR nom_variable ... </ options2,3>;          {Liste des variables à représenter par un histogramme à barres verticales.} 
BLOCK nom_variable ... </ options2,3>;         {Liste des variables à représenter par un diagramme en bâtons (3D).} 
PIE nom_variable ... [NOHEADER] </ options2>;  {Liste des variables à représenter par un diagramme circulaire.} 
STAR nom_variable ... [NOHEADER] </ options2>; {Liste des variables à représenter par un diagramme en étoile.} 
RUN;

<options1>:

FORMCHAR (1,2,7,9,16,20)=`six_caractères'	-+-/* .
LPI=n	Identifie la proportion des diagrammes circulaires ou en étoiles. Ici, n = (nombre de lignes par pouce / nombre de colonnes par pouce)*10 à l'impression.

<options2>:

AXIS=min max	Identifie les valeurs minimale et maximale des axes.
DISCRETE	À utiliser lorsque la variable numérique à représenter est discrète.
FREQ=nom_variable	Identifie une variable numérique dont les valeurs représentent la fréquence de chaque observation.
LEVELS=nombre	Indique le nombre de barres ou de sections qui représenteront la variable continue.
MIDPOINTS=valeur ...	Pour des variables continues, identifie les valeurs formant les milieux des intervalles représentées par chaque barre ou section.
MISSING	Indique de tenir compte des valeurs manquantes des variables à représenter.
SUMVAR=nom_variable	Identifie une variable dont la somme de ses valeurs sera imprimée pour chaque barre ou section.
TYPE=	Indique parmi FREQ, CFREQ, PERCENT, CPERCENT, MEAN et SUM ce que les barres ou les sections représentent. Par défaut c'est FREQ.

<option3>:

Options	HBAR	VBAR	BLOCK
GROUP, SUBGROUP	$\mathnormal{\surd}$	$\mathnormal{\surd}$	$\mathnormal{\surd}$
NOSYMBOL, SYMBOL	$\mathnormal{\surd}$	$\mathnormal{\surd}$	$\mathnormal{\surd}$
NOSTATS	$\mathnormal{\surd}$
FREQ, CFREQ	$\mathnormal{\surd}$
PERCENT, CPERCENT	$\mathnormal{\surd}$
SUM, MEAN	$\mathnormal{\surd}$
ASCENDING, DESCENDING	$\mathnormal{\surd}$	$\mathnormal{\surd}$
NOZEROS, REF	$\mathnormal{\surd}$	$\mathnormal{\surd}$
NOSPACE		$\mathnormal{\surd}$
NOHEADER			$\mathnormal{\surd}$

GROUP=nom_variable	Trace les diagrammes de chaque groupe côte-à-côte.
SUBGROUP=nom_variable	Trace des diagrammes à colonnes segmentées selon chaque sous-groupe.
NOSYMBOL	À utiliser avec l'instuction SUBGROUP, supprime l'impression de l'identification des symboles.
SYMBOL=`caractère'	Identifie le (s) caractère(s) à utiliser pour dessiner les barres ou les bâtons. Par défaut c'est l'astérix (*).
NOSTATS	Supprime l'impression des fréquences, des fréquences cumulatives, des pourcentages et des pourcentages cumulatifs au bout de chaque barre.
FREQ (ou CFREQ)	Imprime seulement la fréquence (cumulative) au bout de chaque barre.
PERCENT (ou CPERCENT)	Imprime seulement le pourcentage (cumulatif) au bout de chaque barre.
SUM (ou MEAN)	Imprime le nombre total d'observations (ou la moyenne) que représente chaque barre.
ASCENDING (ou DESCENDING)	Imprime les barres en ordre croissant (ou décroissant) de grandeur à l'intérieur de chaque groupe.
NOZEROS	Supprime l'emplacement des barres de longueur nulle.
REF=valeur	Trace une droite perpendiculaire aux barres, vis-à-vis la valeur spécifiée de l'axe.
NOSPACE	Imprime un histogramme à barres verticales collées si l'espace est insuffisant pour les séparer.
NOHEADER	Supprime l'impression de l'en-tête par défaut.

SAS Procedures Guide, p.117

Stem-and-leaf, Boxplot et QQ-Plot (PROC UNIVARIATE)

La procédure UNIVARIATE permet d'obtenir des représentations arborescentes (stem-and-leaf), des diagrammes en boîtes (boxplots), des graphiques de quantile-normale (QQ-plot) ainsi que plusieurs statistiques descriptives et différents tests (voir la section 6.5).

PROC UNIVARIATE DATA=nom_du_jeu_de_données <options>;
VAR nom_variable ...;          {Liste des variables dont on veut des graphiques, des statistiques descriptives et des tests.} 
BY nom_variable ...;           {Effectue des analyses statistiques séparées pour les observations de chaque groupe.} 
FREQ nom_variable;             {Identifie une variables numérique dont les valeurs représentent la fréquence de chaque observation.} 
WEIGTH nom_variable;           {Identifie une variable numérique dont les valeurs serviront à balancer les observations.} 
ID nom_variable ...;           {Liste des variables qui serviront à identifier les cinq plus grandes ainsi que les cinq plus petites observations.} 
OUTPUT OUT=nom <statistiques>; {À utiliser avec l'instruction VAR, nomme un nouveau jeu de données qui contiendra les variables en plus des statistiques spécifiées.} 
RUN;

<options>:

FREQ	Imprime la table des fréquence.
NOPRINT	Supprime toutes les impressions.
NORMAL	Teste l'hypothèse que les données proviennent d'une distribution normale.
PLOT	Imprime les représentations arborescentes, les diagrammes en boîtes et les graphiques de quantile-normale.
ROUND=unité ...	Identifie les unités ($\ge$ 0) selon lesquelles arrondir les valeurs de chaque variable.
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 et de covariances.

<statistiques>:

N, NMISS, NOBS, MEAN, STDMEAN, SUM, STD, VAR, CV, USS, CSS, SKEWNESS, KURTOSIS, SUMWGT, MAX, MIN, RANGE, Q3, MEDIAN, Q1, QRANGE, P1, P5, P10, P90, P95, P99, MODE, T, PROBT, MSIGN, PROBM, SIGNRANK, PROBS, NORMAL et PROBN.

Voir la section 6.5 pour connaître une brève description de ces mots-clés.

SAS Procedures Guide, p.617