Guide SAS

De WikiDMS
Aller à : navigation, rechercher

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 <m>\textit{n}^e</m> 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 - <m>{\infty}</m> . 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 [</math>] [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 applicables 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 </math> 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 [</math>] ...;

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 [</math>] 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 [</math>] [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 [</math>] [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 <m>{\le} x</m>) 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 ( <m>{\alpha}</m>) GAMINV(p, <m>{\alpha}</m>) PROBGAM(x, <m>{\alpha}</m>) RANGAM(s, <m>{\alpha}</m>)
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 ( <m>{\lambda}</m>) POISSON( <m>{\lambda}</m>,y) RANPOI(s, <m>{\lambda}</m>)
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 <m>{\ge} x</m> LOG(x) ln(x) TAN(x)
FLOOR(x) Plus grand entier <m>{\le} x</m> 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 [</math>] [début-fin] [.déc] ...;
MISSING lettre ...;
ATTRIB nom_variable LABEL=`étiquette'
FORMAT=nom_format
INFORMAT=nom_format
LENGTH=[</math>]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 (</math>), 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 </math> 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 <m>(\sum_i w_i)-1</m> et WEIGHT <m>(\sum_i w_i)</m> 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 <m>( \(\Phi^{-1}(rang_i-\frac{3}{8})/(n+\frac{1}{4})\))</m>, TUKEY <m>( \(\Phi^{-1}(rang_i-\frac{1}{3})/(n+\frac{1}{3})\))</m> et VW <m>( \(\Phi^{-1}(rang_i)/(n+1)\))</m> la variable Yi, normalement distribuée, à calculer.
PERCENT Idem à FRACTION, mais multiplie le résultat par 100.
SAVAGE Calcule <m>\(Y_i=[\sum_{j=n-rang_i+1}^n(1/j)]-1\)</m> .
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 </math> 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 <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
MAX, MIN <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
FUZZ <m>{\surd}</m>
JUST <m>{\surd}</m>
UPCASE <m>{\surd}</m>
DEFAULT=l Identifie la largeur par défaut (l) des formats.
MAX (ou MIN)=n Identifie la largeur maximale (ou minimale) 1 <m>{\le}</m> n <m>{\le}</m>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 à <m>{\pm}</m> 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 <m>{\le}</m> n <m>{\le}</m>200) de lignes de l'étiquette.
DOWN=n Identifie le nombre (0 <m>{\le}</m> n <m>{\le}</m>200) de lignes à passer en haut de la page avant de commencer à imprimer les étiquettes.
ACROSS=n Identifie le nombre (1 <m>{\le}</m> n <m>{\le}</m>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 <m>{\le}</m> n <m>{\le}</m>200) de lignes à laisser libre entre les étiquettes.
NDOWN=n Identifie le nombre (n) d'étiquettes à imprimer par colonnes.
BETWEEN= Identifie le nombre (0 <m>{\le}</m> n <m>{\le}</m>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 <m>{\le}</m> p <m>{\le}</m>100) de la largeur de la page à utiliser pour chaque graphique.
VPERCENT=p Identifie le pourcentage (1 <m>{\le}</m> p <m>{\le}</m>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 <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
NOSYMBOL, SYMBOL <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
NOSTATS <m>{\surd}</m>
FREQ, CFREQ <m>{\surd}</m>
PERCENT, CPERCENT <m>{\surd}</m>
SUM, MEAN <m>{\surd}</m>
ASCENDING, DESCENDING <m>{\surd}</m> <m>{\surd}</m>
NOZEROS, REF <m>{\surd}</m> <m>{\surd}</m>
NOSPACE <m>{\surd}</m>
NOHEADER <m>{\surd}</m>


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 (<m>\ge</m> 0) selon lesquelles arrondir les valeurs de chaque variable.
VARDEF= Indique parmi DF (n-1), N (n), WDF <m>( \( (\sum_i w_i)-1 \))</m> et WEIGHT <m>( \( \sum_i w_i \))</m> 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

Les statistiques descriptives et les tests

Tables de fréquences et tableaux de contingences (PROC FREQ)

La procédure FREQ permet d'obtenir des tables de fréquences et des tableaux de contingences ainsi que plusieurs statistiques descriptives et différents tests (voir la section 5 plus bas).

PROC FREQ DATA=nom_du_jeu_de_données <options1>;
BY nom_variable ...;                          {Imprime des tables ou des tableaux différents pour les observations de chaque groupe.} 
TABLES ligne_var[*col_var] ... </ options2>;  {Produit les tables de fréquences et les tableaux de contingences demandés.} 
WEIGHT nom_variable;                          {Identifie une variable dont les valeurs doivent être des entiers qui représentent le nombre de sujets 
                                              correspondants à chaque observation. Par défaut, chaque observation vaut un dans le compte des fréquences.} 
RUN;


<options1>:

FORMCHAR (1,2,7)=`trois_caractères' -+ .
ORDER= Indique parmi DATA, FORMATTED, FREQ et INTERNAL l'ordre selon lequel apparaîtront les variables. Par défaut c'est INTERNAL.
PAGE Imprime une seule table ou un seul tableau par page.

</ options2>:

ALL Idem à CHISQ, MEASURES et CMH.
ALPHA= <m>{\alpha}</m> Identifie le niveau <m>100(1- {\alpha})%</m> de l'intervalle de confiance. Par défaut <m>{\alpha}=0,05</m>.
CHISQ Imprime la valeur et la "p-value" des khi-deux de Pearson, du maximum de vraisemblance et de Mantel-Haenszel, ainsi que le test de Fisher, le coefficient de Phi, celui de contingence et la statistique V de Cramer.
CMH Imprime la valeur et la "p-value" des trois statistiques (corrélation, ANOVA et association générale) de Cochran-Mantel-Hanszel.
CMH1 Idem à CMH, mais imprime seulement la statistique de corrélation.
CMH2 Idem à CMH, mais n'imprime pas la statistique d'association générale.
EXACT Test de Ficher pour les tableaux plus grands que 2x2.
MEASURES Imprime la valeur et l'erreur standard asymptotique des statistiques Gamma, Tau-b de Kendall, tau-c de Stuart, D de Somers, corrélation de Pearson, corrélation de Spearman, lambda asymétrique et symétrique ainsi que le coefficient d'incertitude, la taille de l'échantillon et, pour les tableaux 2x2, les risques relatifs.
CELLCHI2 Imprime pour chaque cellule sa contribution à la statistique <m>{\chi}^2</m>.
CUMCOL Imprime pour chaque cellule les pourcentages cumulatifs des colonnes.
DEVIATION Imprime pour chaque cellule la différence entre sa fréquence et sa valeur espérée.
EXPECTED Imprime les fréquences espérées sous l'hypothèse de l'indépendance.
MISSPRINT Pour les tableaux, imprime les fréquences des valeurs manquantes sans toutefois les utiliser dans les calculs de statistiques.
MISSING Inclut les valeurs manquantes dans les calculs.
OUT=nom Nomme le jeu de données qui contiendra les valeurs et les fréquences des variables de la dernière table ou du dernier tableau.
LIST Imprime les données en une liste plutôt que sous forme de table.
NOCOL Supprime l'impression des pourcentages des colonnes.
NOCUM Supprime l'impression des fréquences cumulatives et des pourcentages cumulatifs.
NOFREQ Supprime l'impression des fréquences.
NOPERCENT Supprime l'impression des pourcentages.
NOPRINT Supprime l'impression des tables, mais imprime les statistiques demandées.
NOROW Supprime l'impression des pourcentages de lignes.

SAS Procedures Guide, p.325


Tables de statistiques descriptives (PROC TABULATE)

La procédure TABULATE permet d'obtenir diverses statistiques descriptives disposées en une table.

PROC TABULATE DATA=nom_du_jeu_de_données <options1>;
CLASS nom_variable nom_variable nom_variable;       {Liste des variables qui serviront de titres pour les lignes, la page et les colonnes de la table.} 
VAR nom_variable ...;                               {Liste des variables numériques à analyser.} 
TABLE page, colonnes, lignes </ options2>;          {Identifie, selon une des trois formes suivantes: var*var (croiser), var var (concatener), (var var) (grouper), 
                                                    les variables définissant les pages, les lignes et les colonnes des tables à imprimer. } 
BY [NOTSORTED][DESCENDING] nom_variable format ...; {Imprime des tables différentes pour les observations de chaque groupe.} 
FORMAT nom_variable nom_format ...;                 {À utiliser avec l'instruction CLASS, imprime les valeurs des variables selon le format d'écriture spécifié.} 
FREQ nom_variable;                                  {Identifie une variable numérique dont les valeurs représentent la fréquence de chaque observation.} 
KEYLABEL statistique=`étiquette' ...;               {Liste des statistiques dont le mot clé sera remplacé par une étiquette dans l'impression des tables.} 
LABEL nom_variable=`étiquette' ...;                 {Liste des variables dont le nom sera remplacé par une étiquette dans l'impression des tables.} 
WEIGHT nom_variable;                                {Identifie une variable numérique dont les valeurs serviront à balancer les observations.} 
RUN;


<options1>:

FORMAT=format Identifie un format selon lequel imprimer les données dans chaque cellule de la table.
FORMCHAR=`onze_caractères' - - - -|+|- - - .
NOSEPS= Supprime l'impression des lignes horizontales.
ORDER= À utiliser avec l'instruction CLASS, indique parmi DATA, FORMATTED, FREQ et INTERNAL l'ordre selon lequel imprimer les valeurs des variables. Par défaut c'est INTERNAL.
MISSING Indique de tenir compte des valeurs manquantes.
VARDEF= Indique parmi DF <m>(n-1)</m>, N (n), WDF <m>( \( (\sum_i w_i)-1 \))</m> et WEIGHT <m>( \( \sum_i w_i \))</m> le diviseur à utiliser lors des calculs de variances.


</ options2>:


BOX Identifie parmi _PAGE_, `texte' et `nom_variable' le(s) mot(s) à écrire dans la cellule vide du coin supérieur gauche de la table.
CONDENSE Imprime plusieurs tables sur une même page.
MISSTEXT=`texte' Identifie un maximum de 20 caractères qui seront imprimés dans les cellules contenant une valeur manquante.
PRINTMISS Imprime toutes les combinaisons de valeurs possibles des variables de la table même s'il s'agit, par exemple, d'une colonne ne comportant que des valeurs manquantes.
FUZZ=nombre Utilise 0 à la place des données (autre que les fréquences) dont la valeur absolue est plus petite que ce nombre dans les calculs et pour l'impression.

SAS Procedures Guide, p.561

Coefficients de corrélations (PROC CORR)

La procédure CORR permet d'obtenir des coefficients de corrélations entre des variables ainsi que plusieurs statistiques descriptives et différents tests (voir la section 5 plus bas).

PROC CORR DATA=nom_du_jeu_de_données <options>;
BY nom_variable ...;                            {Effectue des analyses statistiques séparées pour les observations de chaque groupe.} 
FREQ nom_variable;                              {Identifie une variable numérique dont les valeurs représentent la fréquence de chaque observation.} 
PARTIAL nom_variable ...;                       {Liste des variables à être fixées dans les calculs des corrélations partielles de Pearson, de Spearman et de Kendall.} 
VAR nom_variable ...;                           {Liste des variables dont on veut les corrélations.} 
WEIGHT nom_variable;                            {Identifie une variable dont les valeurs représentent le poids de chaque observation pour le 
                                                calcul des coefficients de corrélation pondérés.} 
WITH nom_variable ...;                          {Évalue les corrélations entre ces variables et celles déclarées dans l'instruction VAR. Les lignes 
                                                de la matrice de corrélation sont définies par les variables déclarées dans cette instruction, tandis 
                                                que les colonnes sont définies par les variables déclarées dans l'instruction VAR.} 
RUN;


<options>:

OUTP=nom Nomme un nouveau jeu de données qui contiendra les coefficients de corrélation de Pearson.
OUTH=nom Nomme un nouveau jeu de données qui contiendra les statistiques de Hoeffding.
OUTK=nom Nomme un nouveau jeu de données qui contiendra les coefficients de corrélation de Kendall.
OUTS=nom Nomme un nouveau jeu de données qui contiendra les coefficients de corrélation de Spearman.
HOEFFDING Imprime la statistique D de Hoeffding.
KENDALL Imprime les coefficients tau-b de Kendall à condition que l`instruction WEIGHT ne soit pas utilisée.
PEARSON À utiliser avec les options HOEFFDING, KENDALL et SPEARMAN, imprime aussi les coefficients de corrélation de Pearson.
SPEARMAN Imprime les coefficients de Spearman.
NOMISS Dans les calculs, ne tient pas compte des observations ayant des valeurs manquantes.
VARDEF= Indique parmi DF (n-1), N (n), WDF <m>( \( (\sum_i w_i)-1 \))</m> et WEIGHT <m>( \( \sum_i w_i \))</m> le diviseur à utiliser lors des calculs de variances et de covariances.
SINGULAR=p À utiliser avec l'instruction PARTIAL, identifie le critère (p) de détermination de la singularité des variables.
ALPHA Imprime le coefficient alpha de Cronbach.
COV Imprime la matrice des covariances.
CSSCP Imprime la matrice des sommes de carrés corrigées et des produits croisés.
NOCORR Supprime l'impression des corrélations de Pearson.
SSCP Imprime la matrice des sommes de carrés et les produits croisés.
BEST=n Imprime n corrélations des variables ayant les plus grandes valeurs absolues. Imprime les coefficients en ordre décroissant.
NOPRINT Supprime toutes les impressions.
NOPROB Supprime l'impression des niveaux de significations associés aux corrélations.
NOSIMPLE Supprime l'impression des statistiques descriptives pour chaque variable.
RANK Imprime les coefficients de correlations pour chaque variable en ordre décroissant de valeur absolue.

SAS Procedures Guide, p.209

Statistiques descriptives (PROC MEANS et PROC SUMMARY)

Les procédures MEANS et SUMMARY permettent d'obtenir plusieurs statistiques descriptives (voir la section suivante). Elles sont très similaires. Leur différence majeure vient du fait que PROC MEANS imprime automatiquement les statistiques descriptives à moins de spécifier l'option NOPRINT contrairement à PROC SUMMARY qui ne les imprime pas à moins de spécifier l'option PRINT.

PROC MEANS [ou SUMMARY] DATA=nom_du_jeu_de_données <options><statistiques>;
VAR nom_variable ...;          {Liste des variables numériques pour lesquelles on veut les statistiques.} 
   [
   CLASS nom_variable ...;     {Liste des variables qui serviront à former des sous-groupes.} 
   FREQ nom_variable;          {Identifie une variable numérique dont les valeurs représentent la fréquence de chaque observation.} 
   WEIGHT nom_variable;        {Identifie une variable numérique dont les valeurs serviront à balancer les observations.} 
   ID nom_variable ...;        {Liste des variables qui serviront à identifier les valeurs maximales.} 
   BY nom_variable ...;        {Effectue des analyses statistiques séparées pour les observations de chaque groupe.}
   OUTPUT OUT=nom <statistiques>;        {Nomme un nouveau jeu de données qui contiendra les statistiques spécifiées.} 
RUN;


<options>:

ORDER= À utiliser avec l'instruction CLASS, indique parmi DATA, FORMATTED, FREQ et INTERNAL l'ordre selon lequel imprimer les valeurs des variables. Par défaut c'est INTERNAL.
DESCENDING Imprime d'abord les sous-groupes, puis les groupes et finalement l'ensemble des données.
FW=l Identifie la largeur (l) des champs à utiliser pour l'impression de chaque statistique. Par défaut c'est 12.
MAXDEC=n Identifie le nombre (0 <m>{\le}</m> n <m>{\le}</m>8) maximal de décimales à imprimer pour les résultats.
NOPRINT À utiliser avec PROC MEANS, supprime l'impression de toutes les statistiques descriptives.
PRINT À utiliser avec PROC SUMMARY, imprime toutes les statistiques descriptives.
IDMIN À utiliser avec l'instruction ID, les variables serviront plutôt à identifier les valeurs minimales.
MISSING À utiliser avec l'instruction CLASS, indique de tenir compte des valeurs manquantes pour former les sous-groupes.
NWAY Indique d'imprimer les statistiques que pour les sous-groupes (sinon les groupes), mais pas pour l'ensemble des données.
VARDEF= Indique parmi DF <m>(n-1)</m>, N (n), WDF <m>( \( (\sum_i w_i)-1 \))</m> et WEIGHT <m>( \( \sum_i w_i \))</m> le diviseur à utiliser lors des calculs de variances et de covariances.

<statistiques>:

N, NMISS, NOBS, MIN, MAX, RANGE, SUM, SUMWGT, MEAN, CSS, USS, VAR, STD, STDERR, CV, SKEWNESS, KURTOSIS, T et PRT.

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

SAS Procedures Guide, p.365 et 559

Classement des statistiques et des tests

Statistiques et tests Procédures
Mots-clés Descriptions FREQ TABULATE UNIVARIATE CORR MEANS, SUMMARY
Table de fréquences <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
PCTN Pourcentage qu'une fréquence (somme) <m>{\surd}</m>
PCTSUM représente d'une autre fréquence (somme) <m>{\surd}</m>
N Nombre de valeurs non manquantes <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
NMISS Nombre de valeurs manquantes <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
NOBS Nombre d'observations <m>{\surd}</m> <m>{\surd}</m>
SUM Somme, <m>\(\sum_i w_ix_i\)</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
SUMWGT Somme des poids, <m>\( \sum_i w_i \)</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
MIN, MAX Minimum et maximum <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
RANGE Étendue (MAX-MIN) <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
MEDIAN Médiane <m>{\surd}</m> <m>{\surd}</m>
Q1 et Q3 Premier et troisième quartiles <m>{\surd}</m>
QRANGE Étendue interquartile (Q3-Q1) <m>{\surd}</m>
P1,P5,P10 Les percentiles <m>{\surd}</m>
P90,P95,P99 <m>{\surd}</m>
MODE Mode <m>{\surd}</m>
MEAN Moyenne, <m>{\overline{x}}= \(\sum_i w_ix_i/\sum_iw_i\)</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
STDMEAN Écart-type de la moyenne <m>{\surd}</m>
STDERR <m>STD/\(\sqrt{N}\)</m> <m>{\surd}</m> <m>{\surd}</m>
STD Écart-type \(\sqrt{VAR}\) <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
VAR Variance <m>\(\sum_i w_i(x_i-\overline{x})^2/N\)</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
CV Coefficient de variation, <m>100*STD/{\overline{x}}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
COV Matrice des covariances <m>{\surd}</m>
CORR Matrice des corrélations <m>{\surd}</m>
USS Somme des carrés <m>\(\sum_i w_ix_i^2\)</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
SSCP et produits croisés <m>{\surd}</m>
CSS Somme des carrés corrigée <m>\(\sum_iw_i(x_i-\overline{x})^2\)</m> <m>{\surd}</m> <m>{\surd}</m> <m>{\surd}</m>
CSSCP et produits croisés <m>{\surd}</m>
SKEWNESS <m>\(\frac{N\sum_iz_i^3}{(N-1)(N-2)}\)</m> <m>{\surd}</m> <m>{\surd}</m>
KURTOSIS <m>\(\frac{N(N-1)\sum_iz_i^4}{(N-1)(N-2)(N-3)}-\frac{3(N-1)^2}{(N-2)(N-3)}\)</m> <m>{\surd}</m> <m>{\surd}</m>
Statistiques et tests Procédures
Mots-clés Descriptions FREQ TABULATE UNIVARIATE!CORR MEANS, SUMMARY
ALPHA Coefficient Alpha de Cronbach <m>{\surd}</m>
PEARSON Coefficients de corrélations <m>{\surd}</m> <m>{\surd}</m>
SPEARMAN Coefficients de corrélations <m>{\surd}</m> <m>{\surd}</m>
KENDALL Coefficient tau-b de Kendall <m>{\surd}</m> <m>{\surd}</m>
Coefficient tau-c de Stuart <m>{\surd}</m>
D de Somers, V de Cramer <m>{\surd}</m>
Coefficients Phi et de contingence {\surd}
Coefficient d'incertitude {\surd}
Lambda, Gamma, Khi-deux et Fisher {\surd}
HOEFFDING Statistique D de Hoeffding {\surd}
R| {\surd}
T Valeur de la t de Student {\surd} {\surd} {\surd}
PROBT,PRT t|, (test H0: <m>{\mu}</m>=0) {\surd} {\surd} {\surd}
MSIGN Valeur de la statistique des signes {\surd}
PROBM Test des signes pour H0: <m>{\mu}=0</m> <m>{\surd}</m>
SIGNRANK Valeur de la statistique et test des {\surd}
PROBS rangs de Wilcoxon pour <m>H0: {\mu}</m>=0 <m>{\surd}</m>
NORMAL Statistiques W:Normal et D:Normal <m>{\surd}</m>
PROBN Prob<W et Prob>D <m>{\surd}</m>


La régression (PROC REG)

La procédure REG permet d'obtenir le meilleur modèle de régression linéaire par la méthode des moindres carrés.

PROC REG DATA=nom_du_jeu_de_données <options1>;
MODEL variables_dépendantes = variables_explicatives ... <options2>;   {Identifie les variables numériques du jeu de données qui forment le modèle.} 
BY nom_variable ...;                                                   {Effectue une régression différente pour les observations de chaque groupe.} 
FREQ nom_variable;                                                     {Identifie une variable numérique dont les valeurs représentent la fréquence de chaque observation.} 
ID nom_variable;                                                       {Avec CLI, CLM, P, R ou INFLUENCE, identifie les observations par les 
                                                                       valeurs de cette variable plutôt que de les numéroter. } 
VAR nom_variable ...;                                                  {Identifie les variables numériques, qui ne font pas parti du modèle, à inclure 
                                                                       dans la matrice des produits croisés.} 
WEIGHT nom_variable;                                                   {Identifie une variable numérique dont les valeurs serviront à balancer les observations.} 
ADD nom_variable ...;                                                  {Ajoute des variables indépendantes au modèle de régression. Ces variables 
                                                                       doivent apparaître dans les instructions MODEL ou VAR.} 
DELETE nom_variable ...;                                               {Enlève des variables indépendantes du modèle de régression.} 
MTEST nom_variable, ...; <options3>                                    {Dans le cas d'un modèle de régression multiple avec plusieurs variables dépendantes,
                                                                       teste l'hypothèse que les variables sont égales à zéro. Si on remplace 
                                                                       la première variable par une soustraction de variables dépendantes, teste 
                                                                       l'hypothèse que les autres variables sont les mêmes pour chaque variable dépendante.
                                                                       Si aucune variable n'est spécifiée, teste l'hypothèse que les paramètres
                                                                       estimés sont tous égal à zéro.} 
OUTPUT OUT=nom <statistique>=nom_variable ...;                         {Nomme un nouveau jeu de données qui contiendra les statistiques spécifiées.}  
PLOT                                                                   {Semblable à la procédure PLOT (voir section 5.1)} 
RUN;


<options1>:

OUTEST=nom Nomme le fichier de données qui contiendra les estimations des paramètres.
COVOUT Écrit la matrice des covariances des paramètres estimés dans le fichier de données spécifié à l'instruction OUTEST.
OUTSSCP=nom Nomme le jeu de données qui contiendra les sommes de carrés corrigées et la matrice des produits croisés.
SIMPLE Imprime la somme, la moyenne, la variance, l'écart-type et la somme des carrés de chaque variable.
CORR Imprime la matrice des corrélations de toutes les variables déclarées dans l'instruction MODEL ou VAR.
USSCP Imprime les sommes de carrés et la matrice des produits croisés de toutes les variables.
ALL Idem à SIMPLE, SSCP, CORR et à spécifier ALL dans tous les modèles.
NOPRINT Supprime toutes les impressions. Idem à spécifier NOPRINT dans tous les modèles.

<options2>:

SELECTION= Identifie parmi FORWARD, BACKWARD, STEPWISE, MAXR, MINR, RSQUARE, ADJRSQ, CP et NONE la méthode à utiliser.
BEST=n Avec CP ou ADJRSQ, indentifie le nombre maximal (n) de sous-ensembles à imprimer. Avec RSQUARE, identifie le nombre maximal (n) de sous-ensembles de chaque taille.
DETAILS Imprime les statistiques de chaque entrée et sortie d'une variable dans le modèle pour les méthodes FORWARD, BACKWARD et STEPWISE.
GROUPNAMES=nom... Nomme les groupes de variables.
INCLUDE=n Inclut les n premières variables explicatives de l'instruction MODEL dans chaque modèle.
NOINT Enlève bêta 0 du modèle.
SLE= <m>{\alpha}</m> Identifie le niveau de signification des entrées dans le modèle pour les méthodes FORWARD et STEPWISE. Par défaut <m>{\alpha} = 0.50</m> et <m>{\alpha} = 0.15</m> respectivement.
SLS= {\alpha} Identifie le niveau de signification des sorties dans le modèle pour les méthodes BACKWARD et STEPWISE. Par défaut <m>{\alpha} = 0.10</m> et <m>{\alpha} = 0.15</m> respectivement.
ADJRSQ Calcule les R2 ajustés.
AIC Calcule le critère de Akaike pour chaque modèle.
B Avec RSQUARE, ADJRSQ et CP calcule les r2.
BIC Calcule le critère de Sawa pour chaque modèle.
CP Calcule les statistiques Cp de Mallow pour chaque modèle.
GMSEP Avec RSQUARE, ADJRSQ et CP estime les CME des prévisions en supposant que les variables indépendantes et explicatives sont multinormales.
JP Avec RSQUARE, ADJRSQ et CP estime les CME des prévisions pour chaque modèle (statistiques Jp) en supposant que les valeurs des variables explicatives sont fixées et que le modèle est correct.
MSE Avec RSQUARE, ADJRSQ et CP calcule les CME de chaque modèle.
PC Avec RSQUARE, ADJRSQ et CP calcule le critère de prévision de Amemiya.
RMSE Avec RSQUARE, ADJRSQ et CP imprime la racine des CME de chaque modèle.
SBC Avec RSQUARE, ADJRSQ et CP calcule la statistique SBC pour chaque modèle.
SIGMA=valeur Identifie la vraie valeur de l'écart-type du terme d'erreur à utiliser dans les calculs de CP et BIC.
SP Avec RSQUARE, ADJRSQ et CP calcule la statistique Sp pour chaque modèle.
SSE Avec RSQUARE, ADJRSQ et CP calcule SCE pour chaque modèle.
I Imprime la matrice (X'X)-1.
XPX Imprime la matrice X'X des produits croisés.
ACOV Imprime la matrice des covariances asymptotiques estimées des estimations sous l'hypo-thèse de l'hétéroscédasticité.
COLLIN Analyse détaillée de la colinéarité des variables explicatives.
COLLINOINT Idem à COLLIN, mais sans bêta 0.
CORRB Imprime la matrice de corrélations du vecteur bêta.
COVB Imprime la matrice <m>(X'X)-1*s2</m> des covariances du vecteur bêta.
STB Imprime les coefficients de régression normalisés.
CLI Intervalles de confiance à 95% pour une prédiction individuelle.
CLM Intervalles de confiance à 95% pour l'espérance...
DW Calcule les statistiques de Durbin-Watson.
INFLUENCE Analyse détaillée de l'influence de chaque observation sur le vecteur bêta et sur les valeurs prédites.
P Calcul des prévisions.
R Analyse des résidus.
ALL Idem à ACOV, CLI, CLM, CORRB, COVB, I, P, PCORR1, PCORR2, R, SCORR1, SCORR2, SEQB, SPEC, SS1, SS2, STB, TOL, VIF et XPX.
NOPRINT Supprime l'impression des résultats de la régression.

<options3>:

CANPRINT Imprime les corrélations canoniques.
DETAILS Imprime la matrice M.
PRINT Imprime les matirces H et E.

<statistique>:

COOKD, COVRATIO, DFFITS, H, L95, L95M, P, PRESS, R, RSTUDENT, STDI, STDP, STDR, STUDENT, U95, U95M.

SAS/STAT User's Guide Volume 2, p.1351

Voir aussi

Articles connexes

Références externes