Protégé : Deux exemples d’usage de la syntaxe de l’ODS : PROC PRINT et PROC REPORT

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Mot de passe :

Protégé : Répéter la valeur d’une variable sur chaque page avec ODS RTF

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Mot de passe :

Protégé : Une option SAS 9.2 pour ODS PDF : répéter une valeur groupée sur plusieurs pages

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

Mot de passe :

Passer par un format pour changer les couleurs d’une cellule dans un tableau (PROC REPORT et ODS)

Dans de précédents articles, je vous ai parlé de la possibilité de changer le style des cellules d’un tableau. Je vous invite ici à découvrir comment un format peut vous éviter de passer par un COMPUTE/ENDCOMP de PROC REPORT pour changer le style selon les valeurs prises par une variable donnée.

1. Créer les formats pour l’exemple

Pour mettre en gras (bold) ou non, il faut passer par le style FONT_WEIGHT. Dans notre exemple, ce style prendra la valeur BOLD quand la variable AGE aura des valeurs entre 14 et 16 ans et un LIGHT pour un style non gras. Vous avez aussi à disposition la valeur MEDIUM pour un ton légèrement plus prononcé.

Pour changer la couleur du texte, c’est le style FOREGROUND qu’il faut utiliser. Dans notre cas, le texte aura la couleur bleu si la variable AGE est comprise entre 14 et 16 ans inclus.

proc format;
value age_font 11–13=‘light’
14–16=‘bold’;
value age_color 14–16=‘blue’;
run;

2. Utiliser le format dans PROC REPORT

Pour changer le style d’une colonne en particulier, il suffit d’ajouter style(column)=[…] dans l’instruction DEFINE.

Ici au lieu de donner une couleur à toutes les valeurs avec FOREGROUND= suivi du nom de la couleur, on donne le format AGE_COLOR. qui prendra la valeur BLUE pour les AGE des 14-16 ans.

De manière similaire, l’épaisseur du trait est changée avec FONT_WEIGHT et le format AGE_FONT. défini auparavant.

ods listing close;
ods pdf file=‘C:/sasref/zebre.pdf’;
proc report data=sashelp.class nowd;
columns name age;
define name / display ;
define age / display style(column)=[font_weight=age_font. foreground=age_color.];
run;
ods pdf close;
ods listing;

3. Voir le résultat

Lectures complémentaires

• Alterner les couleurs de fond dans un tableau : une ligne sur deux (PROC REPORT et ODS)
• Changer la couleur d’une ligne ou d’une colonne grâce à PROC REPORT et ODS
• Un moyen simple de changer les couleurs en fonction des valeurs prises par des variables dans un fichier .xls
• Choisir ses couleurs sous SAS

Des questions ? Envoyez votre message sur le forum du blog.

Alterner les couleurs de fond dans un tableau : une ligne sur deux (ODS et PROC REPORT)

Ces semaines passées, je vous ai proposé une syntaxe pour changer le style des cellules d’un tableau généré sous SAS avec PROC REPORT. Aujourd’hui, je vous propose une variante permettant de changer la couleur de fond une ligne sur deux. L’exemple utilise une sortie PDF. Le programme peut s’appliquer aux sorties RTF et TAGSETS.EXCELXP.

1. Le programme

Dans PROC REPORT, l’instruction CALL DEFINE contenu entre les instructions COMPUTE et ENDCOMP permet de modifier le style des lignes dans un tableau.

La notion de RETAIN : Dans l’exemple qui suit une variable nommée CNT est créée avec un RETAIN implicite. Le changement de couleur de fond est fonction de la valeur prise par cette variable. Vous pouvez également utilisée une variable déjà existante dans le data set lu.

La foncton MOD() : Le modulo est le résidu d’une division. La fonction MOD() avec un modulo 2 permet de distinguer les valeurs pairs des valeurs impaires. Ici à chaque fois que la valeur CNT a une valeur pair, le fond est mis en gris.

ods listing close;
ods pdf file=‘C:/sasref/zebre.pdf’;
proc report data=sashelp.class nowd;
columns name age;
define name / display;
define age / display;
compute name;
cnt+1;
if mod(cnt,2) then call define (_row_,‘style’,‘style=[background=lightgrey]’);
endcomp;
run;
ods pdf close;
ods listing;

2. Le résultat

Lectures complémentaires

• Jongler avec les records grâce aux compteurs (retain)
  Changer la couleur d’une ligne ou d’une colonne grâce à PROC REPORT et ODS
  Un moyen simple de changer les couleurs en fonction des valeurs prises par des variables dans un fichier .xls
  Choisir ses couleurs sous SAS

Changer la couleur d’une ligne ou d’une colonne via PROC REPORT et ODS

Après vous avoir présenter comment changer la couleur d’une cellule dans un fichier .xls, je vous propose de voir comment changer la couleur de toute une colonne ou de toute une ligne avec PROC REPORT et ODS TAGSETS.EXCELXP. Cela est intéressant pour distinguer votre ligne/colonne TOTAL du reste de vos données. Notez que la syntaxe s’applique également avec ODS RTF et ODS PDF par exemple.

1. Changer le style de couleur pour une colonne

Pour changer la couleur d’une colonne, on utilisera STYLE(COLUMN)=[] dans l’instruction DEFINE de son choix.

Pour changer la couleur d’une ligne, il faudra passer par COMPUTE/ENDCOMP et CALL DEFINE. Pour changer la couleur d’une celulle, nous avions dans le précédent article utiliser _COL_ comme premier argument. Pour appliquer la couleur à toute la ligne, il suffira de remplacer ce premier argument par _ROW_.

ods listing close;
ods tagsets.excelxp file=‘C:/sasref/col_row_color.xls’;

proc report data=sashelp.class nowd;
column name age;
define name / ‘Nom’ display style(column)=[background=lightblue];
define age / ‘Age’ display;
compute age;
if age=15 then call define (_ROW_,‘style’,‘style=[background=lightblue foreground=red ]’);
endcomp;
run;

ods tagsets.excelxp close;
ods listing;

Dans l’exemple ci-dessus la colonne Nom est mise en bleu clair. Les lignes où l’âge est égal à 15 ans sont mises en bleu clair également et le texte est mis en rouge.

2. Voir le résultat

Lectures complémentaires

• Un moyen simple de changer les couleurs en fonction des valeurs prises par des variables dans un fichier .xls
• Choisir ses couleurs sous SAS
• Mes premiers pas avec ODS TAGSETX.EXCELXP (1/3)
• Mes premiers pas avec ODS TAGSETX.EXCELXP (2/3)
• Mes premiers pas avec ODS TAGSETS.EXCELXP (3/3)
• 6 notions pour débuter avec PROC REPORT
• Améliorer l’habillage de vos tableaux (débuter avec PROC TEMPLATE via PROC REPORT)

Un moyen simple de changer les couleurs en fonction des valeurs prises par des variables dans un fichier .xls

Suite à la question de Pierre, je vous invite à découvrir comment changer la couleur de données selon leur valeurs dans un fichier .xls généré au moyen d’ODS TAGSETS.EXCELXP et PROC REPORT.

1. Le code de base à améliorer

ODS TAGSETS.EXCELXP FILE=’…xls ‘ / ODS TAGSET.EXCELXP CLOSE : Pour l’exemple, un fichier CLASS_COLOR.XLS est créé.

PROC REPORT : Il contient les données de la variable AGE disponibles dans la table SASHELP.CLASS.

ODS LISTING CLOSE/ODS LISTING : Aucune sortie n’est envoyée vers la destination traditionnelle LISTING le temps de la création du fichier .xls.

ods listing close;
ods tagsets.excelxp file=‘C:/sasref/class_color.xls’;
proc report data=sashelp.class nowd;
column age;
define age / ‘Age’ display;
run;
ods tagsets.excelxp close;
ods listing;

2. L’ajout de COMPUTE dans PROC REPORT

A présent les intructions COMPUTE et ENDCOMP englobe une condition. Si la variable AGE est égale à 15 alors tous la valeur 15 est mise en rouge (foreground=) et la couleur de fond de la cellule est bleu clair (background=).

Pour cela, on utilise CALL DEFINE si et seulement si AGE=15. CALL DEFINE est composé de trois paramètres :

• _COL_
• ‘style’
• ‘style=[à compléter]’

ods listing close;
ods tagsets.excelxp file=‘C:/sasref/class_color.xls’;
proc report data=sashelp.class nowd;
column age;
define age / ‘Age’ display;
compute age;
if age=15 then call define (_COL_,‘style’,‘style=[background=lightblue foreground=red]’);
endcomp;
run;
ods tagsets.excelxp close;
ods listing;

3. Voir le résultat

4. Quelques styles supplémentaires

Pour compléter la liste des styles, vous avez par exemple:

• Changer la taille des caractères : font_size=14pt (mettre en taille 14 points)
• Changer l’inclinaison des caractères : font_style=italic (mettre en italique)
• Changer l’épaisseur des traits formant les caractères : font_weight=bold  (mettre en gras)
• Changer la police de caractères : font_face= »Courier New, Arial » (utiliser Courier New si disponible, sinon utiliser Arial).

Lectures complémentaires :

• Choisir ses couleurs sous SAS
• Mes premiers pas avec ODS TAGSETX.EXCELXP (1/3)
• Mes premiers pas avec ODS TAGSETX.EXCELXP (2/3)
• Mes premiers pas avec ODS TAGSETS.EXCELXP (3/3)
• 6 notions pour débuter avec PROC REPORT

Ajouter des indentations dans un tableau

Avec PROC REPORT et PROC TABULATE, SAS crée des tableaux à partir d’un jeu de donnée (SAS data set). Dans certains cas, la lisibilité de ces tableaux est améliorée en ajoutant des indentations au texte (to indent). Nous verrons donc ici deux approches possibles : l’option INDENT de PROC TABULATE et le caractère hexadécimal pour les blancs dans PROC REPORT.

1. Un exemple pour illustrer la syntaxe sur les indentations

Dans les essais cliniques, trois types de tableaux/listings sont produits :

• Démographie (demography) : descriptif des patients en terme d’âge, de sexe, de pays, etc.
• Efficacité (efficacy) : l’efficacité du médicament par rapport à un autre ou par rapport à un effet placebo (le patient prend en médicament en pensant qu’il est actif alors qu’il ne l’est pas).
• Sécurité (safety) : ces tableaux permettent l’analyse des effets secondaires d’un médicament.

Je vais prendre la cas d’un tableau démographique version réduite (trois colonnes) pour présenter la syntaxe sur les indentations.

• La première colonne contient les caractéristiques démographiques (sexe et pays),
• la seconde colonne compte le nombre de patients (N) pour chaque caractéristique
• la troisième colonne donnera la répartition des patients en pourcentage (%).

---------------------------------
|                   |  N  |  %  |
|-------------------------------|
|Gender             |           |
|   Male            |   12| 48 %|
|   Female          |   13| 52 %|
|Country            |           |
|   France          |    6| 24 %|
|   Belgium         |   10| 40 %|
|   Luxemburg       |    9| 36 %|
---------------------------------

Des variables numériques pour ordonner les valeurs : Pour faciliter le tri des données, j’ai choisi d’avoir des variables numériques dans mon data set SAS sur lesquelles j’applique des formats.

• Ainsi la premier variable (GRP) réfère à l’intitulé des caractéristiques démographiques : Gender (1) Country (2).
• La seconde variable (SUBGRP) est l’ordre pour chaque caractéristique. J’aurais pu choisir des valeurs de 1 à 5 mais j’ai préféré que chaque chiffre des décimal corresponde à la variable GRP.

data patient_info;
   input grp subgrp cnt_n pct_n;
   datalines;
1 11 12 0.48
1 12 13 0.52
2 21  6 0.24
2 22 10 0.40
2 23  9 0.36
;
run;

Je choisi de créer des formats du même nom (GRP et SUBGRP) :

proc format;
   value grp     1='Gender'
                 2='Country';
   value subgrp 11='Male'
                12='Female'
                21='France'
                22='Belgium'
                23='Luxemburg';
run;

En outre, je crée un format avec PICTURE pour l’affichage des pourcentages. La raison est la suivante : par défaut, deux chiffres après la virgules apparaissent avec PROC TABULATE. De plus, je souhaite voir le symbole % s’afficher pour chaque pourcentage.

Un format BEST5. est ajouté pour des fréquences composées jusqu’à 5 chiffres sans décimale. De plus, il remplace les points par des blancs. Cela servira pour PROC REPORT.

proc format;
   picture pct (round) .     = ''
                       other = '099 %' (multiplier=100);
   value cnt           .     = ' '
                       other = [best5.];
run;

Dans les deux exemples qui suivent une indentation est formée de trois blancs.

2. L’option INDENT de PROC TABULATE

Dans l’exemple suivant, les deux variables GRP et SUBGRP sont traitées comme des variables textuelles.

L’instruction TABLE contient l’option INDENT= et précise ainsi le nombre de blancs pour décaler les valeurs de la variable SUBGRP vers la droite. Le résultat a été donné en début d’article.

proc tabulate data=patient_info noseps;
   class grp subgrp;
   table grp=''*subgrp='', cnt_n='N'*sum=' '*f=5.
                           pct_n='%'*sum=' '*f=pct.
         / rts=20 indent=3;
   format grp grp. subgrp subgrp.;
run;

Les options NO=SEPS et RTS= sont là pour personnaliser la mise en forme. Pour plus de précisions sur ces options, vous pouvez consulter la documentation en ligne :

• NOSEPS sur la page « PROC TABULATE Statement »
• RTS= sur la page « TABLE Statement »

3. Créer des variables alphanumériques (caractères) avec PROC REPORT

Ajouter une ligne pour chacune des caractéristiques : Toutes les informations sont créées manuellement. Ainsi, il y a en plus une ligne pour chaque groupe dans le data set SAS. Au lieu d’avoir 5 lignes, on en aura 7. Pour chaque nouveau GRP, la variable SUBGRP prendre la valeur du GRP + un zero afin d’apparaître en premier dans le rapport après un tri.

proc sort data = patient_info 
          out  = patient_report;
   by grp subgrp;
run;

data patient_report;
   set patient_report;
   by grp subgrp;
   output;
   if first.grp then
      do;
         subgrp=grp*10;
         cnt_n=.;
         pct_n=.;
      end;
run;

Trier par SUBGRP pour afficher les données dans l’ordre voulu.

proc sort data=patient_report;
   by grp subgrp;
run;

Une fois triées les données sont toujours numériques.

grp subgrp cnt_n pct_n

  1    10     .     .
  1    11    12  0.48
  1    12    13  0.52
  2    20     .     .
  2    21     6  0.24
  2    22    10  0.40
  2    23     9  0.36

Créer des variables caractères : la variable DSPLAY nouvellement créée peut contenir jusqu’à 15 caractères. Elle est composée des variables GRP et SUBGRP converties avec la fonction PUT.

Des hexadécimales pour créer des blancs : Les espaces sont créés à partir de valeurs hexadécimales. On répète ici trois fois A0 entre guillemets pour créer trois espaces. La lettre x qui suit précise à SAS qu’il s’agit d’hexadécimales. Ces trois blancs sont concaténés au résultat de la fonction PUT grâce aux deux barres.

data patient_report;
   length dsplay $15;
   set patient_report;
   if subgrp=0 then dsplay=put(grp,grp.);
   else dsplay='A0A0A0'x || put (subgrp,subgrp.);
   cnt_c=put(cnt_n,cnt.);
   pct_c=put(pct_n,pct.);
run;

Trier les données : La variable SUBGRP sert uniquement à définir l’ordre d’affichage des données mais n’apparaît pas dans le tableau final (option NOPRINT dans l’instruction DEFINE).

Enlever le titre de la colonne : La variable DSPLAY contient les caractéristiques démographiques. Aucun nom n’apparaîtra dans le titre de la colonne. Si les guillemets vides ne sont pas précisés, le nom de la variable est affiché.

Aligner à droite : Les variables caractères CNT_C et PCT_C sont affichées en tant que texte (DISPLAY) et leurs observations sont alignées à droite plutôt que d’être centrées (option RIGHT).

proc report data=patient_report;
   columns subgrp dsplay cnt_c pct_c;
   define subgrp / noprint order order=data;
   define dsplay / ' ' display;
   define cnt_c  / 'N' display right;
   define pct_c  / '%' display right;
run;

Dans ce cas, la sortie se présente sans ligne autour du cadre :

                     N      %
Gender
   Male             12   48 %
   Female           13   52 %
Country
   France            6   24 %
   Belgium          10   40 %
   Luxemburg         9   36 %

Sur le blog, vous trouverez d’autres articles sur les notions abordées ici :

• Vous découvrez PROC REPORT ? Cet article vous offre une introduction sur la procédure : 6 notions pour débuter avec PROC REPORT
• L’instruction OUTPUT a servi pour ajouter de nouveaux records dans le data set. Voici un article plus complet sur le sujet : Faire des petits avec l’instruction OUTPUT
• La fonction PUT a permis de créer notre variable caractère DSPLAY à partir de variables numériques et de formats. L’article Convertir une variable caractère en numérique et inversement se consacre à se sujet.
  
• La syntaxe PICTURE est discutée dans l’article Arrondir ses chiffres avant d’apppliquer un format.

Je garde ou je jette? les variables

Pour garder ou supprimer sous SAS des variables, il y a les mots-clés KEEP (garder) et DROP (enlever). Sélectionner les variables nécessaires par la suite et seulement celles-ci est très important. Cela fait partie des outils pour améliorer la performance d’un programme tant en terme de temps d’exécution que le volume demandé pour stocker les data sets. Voici plus en détails, et avec des exemples, l’utilisation de ce vocabulaire qui s’applique au data step, aux procédures et à la syntaxe de l’ODS OUTPUT.

1. L’option dans un data step

Les mots KEEP et DROP servent principalement en tant qu’option appliquée à un data set donné. Elles sont alors listées juste après le nom du data set entre parenthèses et sont suivies du signe égal :

• Keep= Data Set Option : nom_du_dataset (keep=nom_var1 nom_var2 etc)
• Drop= Data Set Option : nom_du_dataset (drop=nom_var1 nom_var2 etc)

Exemple 1 : une instruction SET

data class (drop=weight: height:);
   set sashelp.class (keep=name weight height);
   weight_kg = weight*0.45359237;
   height_m  = height*0.0254;
   bmi       = weight_kg/height_m**2;
run;

Dans le cas présent, les variables NAME (nom), WEIGHT (poids) et HEIGHT (taille) sont lues dans le fichier d’origine SASHELP.CLASS et gardées. De nouvelles variables sont calculées pour avoir un poids en kilogramme (WIEGHT_KG) et une taille en mètres (HEIGHT_M). A partir du poids et de la taille, l’indicateur de masse corporelle (BMI) est calculé. Les variables, dont le nom commence par WEIGHT et HEIGHT, ne sont plus nécessaires par la suite. Elles sont donc supprimée dans le data set final appelé CLASS.

Soit le mot KEEP, soit le mot DROP est donné en option mais pas les deux afin d’éviter les confusions. Le choix entre KEEP et DROP dépend souvent du nombre de variables à lister par la suite. C’est donc un choix purement pratique.

Note, Indice de masse corporelle : L’indice de masse corporel (Body Mass Index, BMI) est égal au poids divisé par la taille au carré (poids/taille²). Le site de l’Organisation Mondiale de la Santé (World Health Organisation, WHO) donne des précisions sur le sujet.

Note, Conversion des unités de mesures (source Wikipedia) : je suppose que la taille donnée dans le fichier SASHELP.CLASS est exprimée en pouces (inches) et que le poids est exprimé en livres (pounds). Sachant qu’un pouce est égal à 2,54 cm et qu’une livre est égale à 0,45359237 kg, les tailles et poids du premier exemple ont pu être convertis en mètres et kilos.

Exemple 2 : une instruction MERGE

data age_ae;
   merge ae      (in=ref keep=name ae_id ae_sev)
         patient (keep=name age);
   by name;
   if ref;
run;

Dans ce second exemple, les patients ayant eu un effet secondaire (adverse event, AE) sont enregistrés dans le data set AE. Chaque effet secondaire est identifié de manière unique par les variables NAME et AE_ID. La sévérité de l’effet secondaire nous intéresse dans le data set AE.

A cette information, est ajouté l’âge du patient disponible dans la variable AGE du data set PATIENT.

La variable commune aux deux data sets est NAME. Il faut donc qu’elle reste dans les deux data sets. Seuls les patients ayant eu un effet secondaire sont sélectionnés grâce à l’option IN.

Pour tester l’exemple, vous trouverez en fin d’article un code créant les fichiers PATIENT et AE.

NOTE : Une variable utilisée par une autre option du data set comme RENAME ou WHERE ne pourra pas être supprimée au même moment.

2. Quelques exemples de procédures

Dans une procédure, elles suivent le nom du data set d’entrée et/ou du data set de sortie. Aucun autre mot ne doit être inséré entre le nom du data set et les options entre parenthèses.

• proc sort data=… () out=…();
• proc print data=… () width=min;
• proc transpose data=…() out=…() prefix=visit;
• proc freq data=…();
• proc report data=…() split=’#’;
• proc tabulate data=…()
• proc gplot data=…()
• proc boxplot data=…()
• proc univariate data=…()
• proc ttest data=…()
• etc.

La procédure SQL liste les variables à garder après le mot SELECT. Il n’y a pas à ce stade d’option pour supprimer les variables. Par contre, on peut affiner la sélection après que le data set final soit créé. Bien sûr, le temps de lecture est augmenté puisque toutes les variables sont lues pour créer le data set et non un sous-ensemble.

proc sql;
   create table test (drop=ae_sdt ae_edt) as
      select a.*, age
      from ae a
      left join
           patient b
      on a.name=b.name;
quit;

NOTE : L’option WHERE est très pratique lorsqu’on en peut faire une sélection que sur le résultat de la fusion.

proc sql;
   create table test (where=(ae_sev=1 or age=12)) as
      select a.*, age
      from (select name, ae_id, ae_sev
            from ae) a
      left join
           (select name, age
            from patient) b
      on a.name=b.name;
quit;

3. L’option dans l’ODS OUTPUT

Les sorties générées par une procédure sont redirigeables vers un data set via l’instruction ODS OUTPUT. Le nom de la sortie est alors suivi du signe égal et du nom du data set de destination. Après ce nom les options sont ajoutables.

ods exclude all;
ods output onewayfreqs=exemple_ods (keep=age frequency percent);
proc freq data=sashelp.class;
   table age;
run;
ods output clear;
ods exclude none;

Deux articles sur l’ODS OUTPUT sont déjà à votre disposition

• Un tableau à une dimension avec PROC FREQ et l’ODS OUTPUT
• Diriger les sorties d’un PROC MEANS dans un data set SAS

4. Les instructions KEEP et DROP dans un data step

En plus des options KEEP et DROP, il existe les instructions KEEP (KEEP Statement) et DROP (Drop Statement) pouvant être exécutées dans un data step. L’important ici est de se souvenir que l’instruction s’applique à la fin du data step, une fois que le data set final est créé. Ainsi il n’est pas possible de supprimer une variable en milieu de programme pour ensuite créer une autre variable du même nom.

data class (drop=i);
   do i=0 to 3;
      output;
   end;
   do i=10 to 12;
      output;
   end;
run;

data class;
   do i=0 to 3;
      output;
   end;
   drop i;
   do i=10 to 12;
      output;
   end;
run;

Les deux exemples ci-dessus font le même travail. La variable I n’apparaîtra pas dans le data set final car elle est supprimée en fin de programme.

Lectures complémentaires : Outre les options KEEP et DROP, le programmeur utilisera souvent les options RENAME et WHERE et de temps en temps les options FIRSTOBS et OBS. Pour une liste complète des options, consultez la documentation en ligne : SAS Data Set Option.

Après savoir comment supprimer les variables et donc les colonnes d’un data set SAS, vous serez peut-être intéressé de savoir comment supprimer ou garder certaines lignes d’un data set avec les mots-clés DELETE (DELETE Statement) et OUTPUT (OUTPUT Statement).

Annexe : Créer les data sets PATIENT et AE pour tester l’exemple avec MERGE.

data patient;
   set sashelp.class;
run;

data ae;
   set sashelp.class (keep=name);
   if name=‘Thomas’ then
      do;
         ae_id  = 1;
         ae_sdt = ’21MAR2007’d;
         ae_edt = ’28APR2007’d;
         ae_sev = 3;
         output;
         ae_id  = 2;
         ae_sdt = ’03JUN2007’d;
         ae_edt = ’19JUN2007’d;
         ae_sev = 1;
         output;
      end;
run;

Répéter une action sur plusieurs variables avec le langage macro

Sous SAS, deux possibilités sont envisageables pour répéter une action sur plusieurs variables. Dans le cas d’un data step, la syntaxe de l’ARRAY est tout à fait appropriée. Dans d’autres cas, le langage macro peut s’avérer plus pertinent. Voici donc une présentation de l’approche via le langage macro.

1. L’exemple

Pour illustrer le propos, le programme aura pour but de définir un PROC REPORT contenant toutes les variables du data set SASHELP.CLASS. Si on connaît le nom des variables, la syntaxe se résume de la manière suivante.

proc report data=sashelp.class;
   columns name age sex weight height;
   define name   / display;
   define age    / display;
   define sex    / display;
   define weight / display;
   define height / display;
run;

Mais si on ne connaît pas le nom des variables par avance, il faut automatiser la tâche.

2. Remplacer le nom des variables par des macros variables

Dans l’exemple suivant, le nom de chaque variable est sauvegardé dans une macro variable. Ces macros variables ont une structure particulière :

un préfixe commun + un nombre

%let class1 = name;
%let class2 = age;
%let class3 = sex;
%let class4 = weight;
%let class5 = height;

proc report data=sashelp.class;
   columns name age sex weight height;
   define &class1. / display;
   define &class2. / display;
   define &class3. / display;
   define &class4. / display;
   define &class5. / display;
run;

3. Répéter l’instruction DEFINE grâce à une boucle

Grâce à cette structure particulière, une boucle peut être envisagée. L’instruction DEFINE est alors répétée autant de fois qu’il y a de variables. La boucle est définie par une macro variable « I » qui prend des valeurs allant de 1 à 5. La partie nombre de la macro variable est donc remplacée par la valeur de la macro variable « I ».

NOTE : Pour résoudre la macro variable lors de la première boucle, SAS effectue deux lectures. A la première lecture, les deux perluètes (ampersand) && se transforment en un seul ; &i. se transforme en 1. On a donc &CLASS1. A la deuxième lecture, SAS résout la macro variable &CLASS1. comme précédemment.

%macro test;
   proc report data=sashelp.class;
   columns name age sex weight height;
   %do i=1 %to 5
      define &&class&i. / display;
   %end;
   run;
%mend test;
%test;

4. Créer les macros variables de manière automatique

Pour créer les macros variables automatiquement, il faut agir en deux étapes.

1. Enregistrer chacune des noms de variables du data set choisi dans PROC REPORT (SASHELP.CLASS) dans un nouveau data set (LST_VAR) et plus particulière dans une variable (NAME).
2. Associer un numéro à chaque nom de variable (compteur) et convertir l’information en macro variable (CALL SYMPUT).

proc sql;
   create table lst_var as
      select name
      from dictionary.columns
      where upcase(libname)=‘SASHELP’ and
            upcase(memname)=‘CLASS’;
quit;

data _null_;
   set lst_var;
   cnt+1;
   call symput (cats(‘CLASS’,put(cnt,best.)),name);
run;

5. Compter le nombre de variables de manière automatique

Si le nombre de variable dans le data set n’est pas connu à l’avance, il faut le retrouver. Cette information est ensuite sauvegardée dans une macro variable, disons MAX_VAR, et remplacera notre nombre 5. L’article « 3 méthodes pour construire des macro variables sans macro » vous donnera plus de précisions concernant la création d’une macro variable.

Obtenir rapidement le nombre de variables dans un data set : Un moyen pour trouver le nombre de variables est de faire appel au dictionnaire de SAS intitulé TABLES.

proc sql noprint;
   select nvar into : max_var
   from dictionary.tables
   where upcase(libname)=‘SASHELP’ and
         upcase(memname)=‘CLASS’;
quit;

Plus de flexibilité sur la liste des variables concernées : Un autre moyen pour compter le nombre de variables est d’agir en deux étapes.

• Enregistrer dans un variable d’un nouveau data set chacune des noms de variables de SASHELP.CLASS.
• Compter le nombre d’observations dans ce data set. Vous pouvez vous reporter à l’article « Combien d’observations dans mon data set » pour plus de précisions sur les différentes alternatives.

Dans notre exemple, il s’agit de créer le data set LST_VAR pour la première étape. Le code de la section 4 est tout à fait suffisant pour cela. Ensuite, CALL SYMPUTX peut servir à sauvegarder l’information dans une macro variable.

data _null_ ;
   call symputx(‘max_var’,_N_-1);
   set lst_var;
run;

Pourquoi vous ai-je proposé cette alternative ?  Ici, toutes les variables sont sélectionnées. Mais si seulement quelques une sont choisies, seule la seconde alternative marche. Voici quelques sous-sélections possibles.

• Sélectionner toutes les variables numériques,
• Sélectionner toutes les variables finissant pas _X,
• etc.

En résumé : En résumé, le code se décompose en 2 étapes : créer les macros variables et utiliser ces macros variables pour définir une boucle.

*1. Créer les macros variables CLASS1 à CLASS5, MAX_VAR.;

*1.1 Créer le data set LST_VAR servant de fichier de référence.;

proc sql;
   create table lst_var as
      select name
      from dictionary.columns
      where upcase(libname)=‘SASHELP’ and
            upcase(memname)=‘CLASS’;
quit;

*1.2 Créer les macro variables CLASS1-CLASS5 en se basant sur le data set LST_VAR créé précédemment.;

data _null_;
   set lst_var;
   cnt+1;
   call symput (cats(‘CLASS’,put(cnt,best.)),name);
run;

*1.3 Créer la macro variable VAR_MAX en se basant sur le data set LST_VAR créé précédemment.;

data _null_ ;
   call symputx(‘max_var’,_N_-1);
   set lst_var;
run;

*2. Reporting : appeler les différentes macro variables pour créer la boucle autour de l’instruction DEFINE.;

%macro test;
proc report data=sashelp.class;
   columns name age sex weight height;
   %do i=1 %to &max_var.;
      define &&class&i. / display;
   %end;
run;
%mend test;
%test;

Il était une fois la LOG

La fenêtre LOG (ou JOURNAL pour la version française de SAS) contient des informations plus ou moins détaillées sur le travail effectué par SAS. Ces informations peuvent être sauvegardées dans un fichier externe ou être supprimées lors de l’exécution du programme.

1. Une LOG plus ou moins détaillée

Deux situations se présentent :

• lire les détails de l’exécution d’une macro
• accéder aux détails d’un fichier .sas inclus dans un autre programme (%INCLUDE…)

Changer les options par défauts : les options MPRINT, MLOGIC et SYMBOLGEN s’adresse à la macro et SOURCE2 au programme inclus. Par défaut, ces options sont désactivées. Elles ont pour but d’aider le programmeur au stade du développement.

Voir le statut actuel des options : pour connaître l’état actuel d’une de ces options, il faut consulter la log après avoir exécuté la procédure options.

proc options;
run;

Remettre les options dans leur état initial : pour désactiver ces options, on utilise NOMPRINT, NOMLOGIC, NOSYMBOLGEN et NOSOURCE2.

Exemple, partie 1 : Le fichier main_include.sas contient l’instruction OPTIONS, le format AGE et la macro RAPPORT.

options source2 mprint mlogic symbolgen;

proc format;
   value age
   11-13 = ’11-13′
   14-16 = ’14-16′
   other = ‘Autre’;
run;

%macro rapport (dsn=);
proc report data=&dsn;
   columns name age sex;
   define name /‘Nom’ display;
   define age  /‘Age’ display ;
   define sex  /‘Sexe’ display;
   format age age.;
run;
%mend rapport;

Exemple, partie 2 : Dans un second programme, le premier programme et la macro RAPPORT sont appelés.

%include ‘C:/sasref/main_include.sas’;
%rapport (dsn=sashelp.class);

2. Commander la suppression du contenu de la LOG

Sous Windows, par défaut, à chaque nouvelle exécution d’un programme, la log grossie. Pour la vider, il y a deux possibilités : une manuelle et une automatique.

Après avoir activé la fenêtre log en la sélectionnant, il y a trois choix possibles :

• Combiner les touches clavier Ctrl et E (raccourci clavier CTRL+E)
• Sélectionner menu Edit/Clear All.
• Taper la commande log;clear; dans le cadre en haut à gauche de l’écran

Cela marche aussi avec les fenêtres OUTPUT et EDITOR. Remplacez seulement le mot LOG par OUTPUT ou EDITOR pour la commande.

Pour une action automatique, l’instruction DM permet d’inclure dans le programme les mots-clés donné jusqu’à présent dans le cadre pour les commandes.

proc print data=sashelp.class;
run;

dm ‘log;clear;’;

3. Sauvegarder le contenu de la LOG dans un fichier externe

Rediriger le contenu de la log : la procédure PROC PRINTTO permet de rediriger le contenu de la log dans un fichier externe. Pour cela, le nom du fichier à créer et son chemin d’accès sont définis dans LOG=. Au choix, l’extension du fichier est .log ou .txt.

Rediriger le listing : le contenu de la fenêtre OUTPUT peut-être aussi redirigé. Cette fois-ci, il faut utiliser FILE=.

Ecraser les anciens fichiers : pour effacer le contenu d’un précédent fichier, il y a l’option NEW dans l’instruction PROC PRINTTO.

Réinitialisation : pour réactiver les destinations par défaut, la procédure sans argument est soumise à SAS.

proc printto log=‘C:/sasref/class.log’ new;
run;

proc printto file=‘C:/sasref/class.txt’ new;
run;

proc print data=sashelp.class;
run;

proc printto;
run;

Mes 1ers pas avec ODS TAGSETS.EXCELXP (3/3)

L’ODS TAGSETS.EXCELXP, alternative au PROC EXPORT, permet de créer des fichiers Excel à partir de données SAS. Afin de personnaliser ce fichier, nous avons vu dans un premier article la syntaxe de PROC REPORT. Puis dans un second article, le PROC TEMPLATE a permis de modifier des couleurs, polices et marges du document à imprimer. Pour ce dernier article sur « Mes premiers pas avec l’ODS TAGSETS.EXCELXP », il s’agit de voir les options de l’instruction ODS.

ods tagsets.excelxp file = ‘C:/excel/mon_nouveau_fichier.xls’
style = vero_xls
options (…);

1. Personaliser la feuille de calcul

1.1 Donner un nom à une feuille : pour personnaliser le nom de la feuille de calcul, il faut ajouter l’option SHEET_NAME=’Mon nom de feuille’.

ods tagsets.excelxp options (sheet_name=‘Mon nom de feuille’);

1.2 Figer la première ligne contenant les titres de colonnes : sous Excel, on peut figer les x premières lignes de sorte que quelque soit la ligne consultée, la ligne figée reste visible. Sur le même principe, la première ligne contenant le nom des colonnes peut être figé grâce à l’option FROZEN_HEADER=.

ods tagsets.excelxp options (frozen_headers = ‘Yes’);

1.3 Ajouter un filtre aux colonnes : sous Excel, un filtre est une petite flèche qui apparaît dans la première ligne d’une colonne donnée. En cliquant dessus, on voit apparaître toutes les valeurs prises par la colonne. L’utilisateur peut ainsi choisir de ne faire apparaître que les lignes ayant une valeur ou un groupe de valeurs données. Pour ajouter ce type de filtre à toutes les colonnes du fichier Excel avec ODS, il y a l’option AUTOFILTER=.

ods tagsets.excelxp options (autofilter = ‘All’);

1.4 Créer plusieurs feuilles dans un seul fichier Excel

Pour créer plusieurs feuilles dans un fichier Excel unique, il faut dans un premier temps, définir les données communes aux multiples feuilles : nom du fichier Excel et Style.

ods tagsets.excelxp file = ‘C:/excel/mon_nouveau_fichier.xls’
style = vero_xls;

Dans un deuxième temps, on actualise cette information pour chaque feuille en précisant les options SHEET_NAME .

ods tagsets.excelxp options (sheet_name = ‘Feuille 1’);
proc report…;
run;
ods tagsets.excelxp options (sheet_name = ‘Feuille 2’);
proc report…;
run;
ods tagsets.excelxp close;

2. Agir sur le document à imprimer

2.1 Faire les titres de colonnes sur toutes les pages : l’option ROW_REPEAT= va permettre de répéter le titre des colonnes sur chacune des pages à imprimer.

ods tagsets.excelxp options (row_repeat = ‘header’);

2.2 Modifier l’orientation de la page : par défaut l’orientation de la page à imprimer est orientée portrait (portrait). Pour changer en Paysage (landscape), il faut le préciser avec l’option ORIENTATION=.

ods tagsets.excelxp options (orientation = ‘landscape’);

Cette liste des options est loin d’être exhaustive. Vous pouvez vous reporter à la page du support SAS pour avoir la liste complète de options.

Références : la documentation sur les ODS TAGSETS.EXCELXP reste encore très limitée. Voici néanmoins quelques liens :

• Liste des options : Quick Reference for the TAGSETS.EXCELXP Tagset (.html)
• Try this Demo : The ExcelXP Tagset and Microsoft Excel (.html)
• Proc Template : http://www.tek-tips.com/viewthread.cfm?qid=1178234&page=1

Mes 1ers pas avec ODS TAGSETS.EXCELXP (2/3)

Sous SAS, l’ODS TAGSETS.EXCELXP est une alternative au PROC EXPORT. Dans une première partie, vous avez vu comment modifier la largeur d’une colonne, gérer l’alignement des valeurs textes et former une cellule unique servant de titre à plusieurs colonnes, le tout avec la syntaxe de proc report. Maintenant vous allez découvrir comment modifier les couleurs, polices de caractères, etc. en créant un nouveau template.

1. La structure de base de PROC TEMPLATE

Une autre particularité que l’on rencontrera dans le fichier Excel, c’est la présence de la couleur grise pour le fond ces cellules ayant des données, une couleur bleuté pour le texte des cellules contenant le nom des variables, etc.

Pour altérer ces couleurs, disons remettre du blanc en fond et du texte en noir, on va créer un nouveau template à partir d’un existant. Il suffira alors de modifier les quelques paramètres qui nous intéresse.

La structure de base du PROC TEMPLATE est la suivante :

proc template;
   define style styles.vero_xls;
   parent=style.default;
   *style x from x /…;
run;

J’ai donné le nom vero_xls à ce nouveau STYLE. Vous pouvez choisir le nom qui vous plaira. L’important est de se référer au même nom par la suite. 

2. Les instructions STYLE de PROC TEMPLATE

Il existe plusieurs instructions STYLE, selon qu’il s’agisse :

• de la partie non couverte par les données : style Table from Table
• de la partie couverte par les noms de colonnes : style Header from Header
• de la partie couverte par le nom des lignes (dans un proc print, les valeurs de la variable obs) : style RowHeader from RowHeader
• de la partie couverte par les données : style Data from Data
• de l’apparence de la page A4 d’impression : style Body from Body

Voicic trois autres styles :

•    style SystemTitle from SystemTitle /…;
•    style SystemFooter from SystemFooter /…;
•    style SysTitleAndFooterContainer from SysTitleAndFooterContainer /…;

3. Les options des instructions STYLE

Les options sont situées après la barre inclinée (slash /). Les valeurs prises par ces options sont notées entre guillemets.

 Les options les plus courantes sont :

• FOREGROUND = (couleur du texte). Ici, on choisira le mot ‘black’ entre guillemets.
• BACKGROUND = (couleur des cellules). Ici, on choisira ‘white’.
• FONT_SIZE = (la taille du texte). Ici, on choisira 1.5 par exemple.
• FONT_FACE = (la ou les polices de caractères). Ici, on choisi ‘Courier’. Mais on peut aussi opter pour ‘Courier,Arial’. Ainsi si la police Courier n’est pas disponible, Arial sera le second choix.

Deux autres options du langage courant

• FONT_WEIGHT= (mette en gras). La valeur BOLD sert à mettre en gras
• FONT_STYLE= (mettre en italique ou non). La valeur ITALIC met en italique tandis que ROMAN fait l’inverse.

Agir dur les bordures des cellules :

• BORDER_COLOR= (couleur de la bordure)
• BORDER_WIDTH= (largeur de la bordure)

Agir sur les marges du document A4.

• LEFTMARGIN = (marge de gauche)
• RIGHTMARGIN = (marge de droite)
• TOPMARGIN = (marge du haut)
• BOTTOMMARGIN = (marge du bas)

Note : Une liste des différents styles est disponible sur ce forum : http://www.tek-tips.com/viewthread.cfm?qid=1178234&page=1.

4. Faire référence au nouveau template

Pour que ce template soit lu à la place de celui par défaut, on ajoutera STYLE=nom_du_nouveau_template dans l’instruction ODS TAGSETS.EXCELXP de début.

ods tagsets.excelxp file  = ‘C:/excel/mon_nouveau_fichier.xls’
                    style = vero_xls;
proc report …;
run;
ods tagsets.excelxp close;

Après avoir vu les actions menées au niveau du PROC REPORT et du PROC TEMPLATE pour personnaliser son fichier Excel, vous verrez dans le troisième et dernier article sur « Mes premiers pas avec ODS TAGSETS.EXCELXP », lundi prochain, les options disponibles dans l’instruction ODS.

Mes 1ers pas avec ODS TAGSETS.EXCELXP (1/3)

SAS propose une alternative au PROC EXPORT pour créer un fichier Excel à partir de données SAS. Il s’agit de l’ODS TAGSETS.EXCELXP. Celle-ci fait preuve de flexibilité tant pour ajouter les labels des variables, définir la largeur des colonnes qu’ajouter les filtres aux colonnes ou encore créer plusieurs feuilles par fichier Excel. Voici donc le premier des articles consacrées à mes découvertes de ces derniers jours sur le sujet : « syntaxe de base et options changeables au niveau de la procédure Proc Report ».

1. La syntaxe de base : tout d’abord, il s’agit d’encadrer la proc report, proc print, ou autre entre deux instructions ODS TAGSETS.EXCELXP. La première instruction servira en premier lieu à définir le nom et la destination du nouveau fichier Excel. La seconde instruction fermera le processus de création du fichier Excel.

ods tagsets.excelxp file=‘C:/excel/mon_nouveau_fichier.xls’;
   proc report data=resultats;
      columns pop grp subgrp check;
      define pop    / display ‘Pop’;
      define grp    / display ‘Pays’;
      define subgrp / display ‘Ville’;
      define check  / display ‘Check’;
      run;
ods tagsets.excelxp close;

Un premier essai au résultat et on se rendra compte de plusieurs « imperfections » que l’on souhaitera changer à commencer par la largeur des colonnes.

2. Changer la largeur des colonnes : avec un PROC REPORT, il est possible d’affiner l’apparence (le STYLE) des colonnes et notamment celui de la largeur des colonnes. Si on veut que toutes les colonnes soient de la même largeur, l’option STYLE(COLUMN) sera ajoutée dans l’instruction PROC REPORT, sinon elle sera ajoutée dans chaque instruction DEFINE. Si un grand nombre de colonnes doit avoir la même largeur, il est possible de combiner les deux méthodes. Tout d’abord, la largeur la plus fréquente dans l’instruction PROC REPORT est définie. Ensuite, les colonnes devant avoir une valeur différente sont actualisées dans leur instruction DEFINE.

proc report data=resultats style(column)=[cellwidth=3cm];
   columns pop grp subgrp check;
   define pop    / display ‘Pop’
                   style(column)=[cellwidth=5cm];
   define grp    / display ‘Pays’;
   define subgrp / display ‘Ville’;
   define check  / display ‘Check’;
run;

Note : Les options WIDTH= et FLOW des instructions DEFINE perdent ici leur utilisé puisque le texte n’est pas coupé.

3. Centrer ou aligner à gauche, à droite : de la même manière que définir la largeur des colonnes, changer l’alignement du texte (pas des nombres) est possible avec JUST=center (left ou right). Par défaut, les textes sont alignés à gauche et les nombres sont alignés à droite. On peut choisir de changer l’alignement :

• soit au niveau des valeurs (style(column)),
• soit au niveau du nom des variable (style(header)).

Gérer certains formatage avec TAGATTR= est un autre attribut possible de STYLE(COLUMN). Voici deux exemples d’application :

• Sur le même principe que le format Zw., les zéros situées en entête d’une variable numérique sont conservés. On ajoutera autant de zéro que nécessaire.
• Les variables numériques sont affichées comme du texte, si l’arobas @ est utilisé.
• Mais il ne semble pas possible de combiner les deux notations. Mais corrigez-moi si je me trompe.

proc report …;
   define check    / display ‘Check’
                     style(column)=[tagattr=’format:000′];
   define check    / display ‘Check’
                     style(column)=[tagattr=’format:@’];
run;

4. Un nom de colonne commun à plusieurs colonnes : sous Excel, il est très simple de sélectionner deux cellules et de demander à ce qu’elles n’en forment plus qu’une seule. Pour faire la même chose en SAS, on fait appel à la syntaxe de PROC REPORT.

   columns pop (‘Zone géographique’) grp subgrp check;

Si on choisi de combiner des cellules, l’ajout d’un filtre sur les colonnes concernées peut paraître inapproprié. En effet, le filtre n’utilisera que les valeurs de la première colonne.

Dans la seconde partie (lundi prochain) sur ODS TAGSETS.EXCELXP, vous verrez comment modifier les couleurs, la police de caractère, etc. en créant un template.

Annexe : data set servant d’exemple

data resultats;
   input pop grp $2. subgrp $5. check $4.;
   datalines;
1 AL Alger 001A
1 AL Oran  003
1 MO Rabat 002
2 CH Bern  001A
2 NO Oslo  004
;
run;

5 options courantes de PROC REPORT

Après avoir vu les notions de bases de PROC report, je vous propose 5 points de syntaxe que j’utilise régulièrement pour un résultat un peu plus personnalisé.

• Les points 1 et 2 sont des options de l’instruction PROC REPORT.
• Le point 3 concerne l’instruction COLUMN.
• Les points 4 à 5 servent dans les instructions DEFINE.

En fin d’article, vous avez un exemple de syntaxe pour mieux cerner le tout.

1. Changer le symbole coupant les mots pour l’utiliser comme du texte : par défaut, la barre inclinée (/) est le symbole pour les sauts à la ligne dans le titre des colonnes et les valeurs textes. Du coup, si on veut considérer celui-ci comme du texte à part entière, il faut définir un autre caractère pour couper le texte. Par exemple, on peut utiliser le symbole dièse # dans l’option SPLIT=’…’ de l’instruction PROC REPORT

2. Affichez les valeurs manquantes : lorsque des valeurs sont groupées, SAS ignore par défaut les valeurs manquantes (missing et special missing). Pour changer cela, il faut précisez l’option MISSING dans l’instruction PROC REPORT, avec GROUP, ORDER ou ACROSS. Un exemple de la documentation en ligne illustre ce sujet. How PROC REPORT Handle Missing Values. Les valeurs manquantes d’ANALYSIS et DISPLAY restent affichées.

3. Un titre pour plusieurs colonnes : il est possible d’ajouter un titre commun à plusieurs colonnes. Pour cela, il faut agir sur l’instruction COLUMN. Les variables concernées sont listées entre parenthèses. Le nom commun est donné entre guillemets en premier dans les parenthèses.

4. Définir la largeur des colonnes : pour définir la largeur de la colonne, il existe l’option WIDTH=. Cette largeur peut ne pas être suffisante pour afficher tout le texte. Mais, heureusement, il y a l’option FLOW. Celle-ci fait apparaître le texte sur plusieurs lignes, s’il n’y a pas assez de place sur une seule. Cela évite à celui-ci d’être coupé.

Même si, a priori, le texte est contenu dans la largeur défini, il est donc conseillé d’utiliser l’option FLOW pour éviter des coupures involontaires ou repérer plus facilement des textes plus longs que prévus.

5. Et les formats ? : Les formats s’utilisent indifféremment en option dans les instructions DEFINE avec un signe égal ou dans une instruction FORMAT.

Exemple :

proc report data=mesresultats nowd
split=‘#’
missing;
column pays patient_id
(‘Statistiques’ cnt pct);
define pays / display ‘Pays’
format=$cntry.;
define patient_id / display ‘ID’;
define cnt / display ‘N’;
define pct / display ‘%’;
*format pays $cntry.;
run;

NOTE 1 : Les options HEADLINE, HEADSKIP et les tirets bas pour entourer un titre commun à plusieurs colonnes n’ont pas été mentionnés ici car ils perdent leur intérêt avec un ODS RTF.

NOTE 2 : La modification de l’apparence peut-être amélioré en changer le « style » au niveau local c’est-à-dire dans la procédure REPORT ou au niveau global, en créant ou actualisant le Template de la procédure REPORT. Cela pourrait faire l’objet de plusieurs articles tant le sujet est vaste.

6 notions pour débuter avec PROC REPORT

 

Pour créer un tableau et le publier, la procédure REPORT est disponible. Je vous propose de voir sa structure de base.

1. Lister vos variables avec l’instruction COLUMN : la procédure REPORT doit contenir au minimum une instruction COLUMN listant les variables à publier dans l’ordre d’apparition souhaité.

Pour les utilisateurs de SAS pour Windows, on ajoutera l’option NOWD dans l’instruction PROC REPORT, pour éviter l’ouverture d’une fenêtre indépendante.

2 Personnalisez les colonnes : par défaut, les colonnes auront pour nom celui de la variable. Pour les personnalisez, on ajoute une instruction DEFINE par colonne.

proc report data=result_pat nowd;
   column pays pays_txt patient_id cnt pct;
   define pays       / display ‘ ‘;
   define pays_txt   / display ‘Pays’;
   define patient_id / display ‘ID’;
   define cnt        / display ‘N’;
   define pct        / display ‘%’;
run;

3. Privilégiez l’affiche en mode DISPLAY : par défaut les variables textes seront en mode DISPLAY tandis que les variables numériques seront en mode ANALYSIS. En d’autres termes, SAS peut potentiellement regrouper et additionner des valeurs numériques. Je pense notamment lorsqu’on utilise l’option GROUP sur d’autres variables. De plus, les valeurs textes seront alignées à gauche et les valeurs numériques seront alignées à droite.

Mon choix est donc de convertir toutes mes variables à afficher en texte avant et de n’utiliser PROC REPORT que comme un outil de publication. Vous pouvez, de plus, explicitement indiquer le mode DISPLAY dans les instructions DEFINE.

4. Trier les données et ne pas afficher certaines colonnes : en plus des affichages par défaut DISPLAY et ANALYSIS, vous avez l’affichage ORDER. Il est vivement conseillé de noter explicitement l’option ORDER= (formated, data, freq ou internal) car la valeur par défaut risque d’évoluer dans les prochaines versions de SAS. On peut également utiliser le mot-clé DESCENDING pour un tri par ordre décroissant.

Il est souvent plus facile de trier les données si elles sont numériques. Par exemple, imaginez que vous vouliez trier vos données par pays avec en premier des pays d’Europe par ordre alphabétique (Allemagne, France, Royaume-Uni) puis des pays d’Asie par ordre alphabétique (Indonésie, Malaisie, Singapour, Thaïlande). Vous pouvez créer un format numérique avec des valeurs allant de 1 à 7 (1 pour Allemagne, 7 pour Thaïlande).

Pour être cohérent avec mon propos précédent, je vous conseille d’avoir deux variables :

• d’un côté la variable numérique qui sert pour le tri mais que ne sera pas affichées. Pour cela, il y a l’option NOPRINT de l’instruction DEFINE ;
• et de l’autre, la variable texte créée préalablement à partir de la variable numérique et du format avec une fonction PUT.

5. Grouper les données et créer des breaks : imaginez que vous ayez plusieurs patients du même pays. Vous aurez autant de fois le nom de pays qu’il y a de patients. Pour alléger le tableau, vous pouvez n’afficher le pays que la première fois. Au lieu de DISPLAY, ANALYSIS, ORDER, etc. vous utilisez alors l’option GROUP dans l’instruction DEFINE.

Notez que toutes les colonnes à gauche devront donc être également groupées.

Il est possible d’utiliser ORDER=… avec GROUP comme pour l’option ORDER.

Un des avantages de GROUP est de définir entre les groupes des séparations. Pour cela, il y l’instruction BREAK AFTER appelle la variable groupée en question. Le type de séparation est défini par l’option. SKIP par exemple permet de sauter une ligne entre les groupes. Mais cette instruction ne fonctionne pas avec ODS RTF. Il faut alors utiliser la syntaxe COMPUTE/ENDCOMP.

proc report data=result_pat nowd;
   column pays pays_txt patient_id cnt pct;
   define pays       / group order=data noprint;
   define pays_txt   / group ‘Pays’;
   define patient_id / display ‘ID’;
   define cnt        / display ‘N’;
   define pct        / display ‘%’;
   *break after pays / skip;
   compute before;
      line ‘ ‘;
   endcomp;
   compute after pays_num;
      line ‘ ‘;
   endcomp;
run;

6. Les faiblesses de l’instruction ACROSS : imaginez que vous ayez les fréquences et pourcentages pour deux drogues. Cela vous donne 4 colonnes dans votre tableau finale. Mais, dans votre tableau d’origine, vous avez 3 colonnes : le type de drogue, les fréquences et les pourcentages. L’instruction ACROSS permet de « transposer » l’information. Mais si, en plus, vous voulez rajouter une colonne à droite, vous rencontrerez de réelles difficultés.

Comme précédemment, je choisi d’agencer mes données comme il me convient avant la procédure. Je n’utilise PROC REPORT que pour l’affichage. Cela implique souvent l’usage d’un PROC TRANSPOSE et d’un MERGE (where=() rename=()).

proc sort data=result_drug;
   by pays;
run;

proc transpose data   = result_drug
               out    = result_drug_across
               prefix = drug_;
   by pays;
   var cnt pct;
   id drug;
run;

data result_drug_across (drop=_NAME_);
   merge result_drug_across
          (where=(lowcase(_name_)=‘cnt’)
           rename=(drug_1=cnt_1 drug_2=cnt2))
         result_drug_across
          (where=(lowcase(_name_)=‘pct’)
           rename=(drug_1=pct_1 drug_2=pct2));
   by pays;
run;

Pour une information plus détaillées sur DISPLAY, ANALYSIS, GROUP, ORDER, ACROSS vous trouverez la page « Concept: REPORT procedure ». Notez que je n’ai pas parlé de COMPUTED, dans la même veine que GROUP, DISPLAY, ACROSS, ANALYSIS, mais que celle-ci permet de faire des calculs simples (sommation, etc).

Conclusion

En conclusion, la procédure REPORT est un outil qui, certes très puissant, peut vite devenir très compliqué. De mon expérience, il apparaît plus judicieux de restreindre l’usage de PROC REPORT à la diffusion de résultats préalablement agencés en triant les données avec des variables numériques non affichées et ne montrant que les variables textes.

Pour plus de détails sur la procédure REPORT, vous pouvez consulter le prochain article intitulé « 6 subtilités de PROC REPORT » et le chapitre PROC REPORT de la documentation en ligne.

Annexe:

data result_pat;
   length pays_txt $10;
   input pays pays_txt $ patient_id cnt pct;
   datalines;
1 Maroc      1 10  20
1 Maroc      2 25  50
1 Maroc      3 15  30
2 Luxembourg 1 18  36
2 Luxembourg 2 32  64
3 Canada     1  5 100
;
run;

data result_drug;
   input pays drug cnt pct;
   datalines;
1 1 10 20
2 1 18 36
1 2 40 80
2 2 32 64
3 1 5 100
;
run;

Faire des petits avec l’instruction OUTPUT

 

Imaginez devoir créer plusieurs fois le même tableau avec des fréquences, des tests statistiques, etc. Pourquoi plusieurs fois ? Parce que chaque tableau inclus une population différente.

1. Une observation par tableau

Dans le cas le plus simple, chaque observation n’apparaît que dans un seul des tableaux à produire. Une variable identifie le tableau auquel l’observation est allouée et l’instruction BY utilise cette variable avec la procédure report ou autre.

Voici un exemple où les données sont publiées par pays dans des tableaux distincts. L’utilisation d’une valeur numérique pour le pays est optionnelle mais ajoute de la flexibilité pour trier les données.

proc format;
value cntry
1=’Chine’
2=’Malaisie’;
run;

proc report data=lab;
by cntry;
columns test cnt;
…

format cntry cntry.;

run;

2. Plusieurs tableaux pour une observation

Exemple : maintenant voici deux exemples des essais cliniques pour lesquels une observation peut servir à plusieurs tableaux.

• Construire un tableau pour la population ‘per protocol’, un pour ‘intent-to-treat’ et un pour ‘safety’ : un patient valide par protocole est aussi pour l’analyse de sûreté mais tous les patients valides pour la sûreté ne répondent pas forcément aux critères du protocole.
• créer un tableau par zone géographique : un tableau pour tous les pays couverts par l’étude clinique, un tableau par pays et un par centre dans un pays donné.

Dans ces deux cas, une observation peut être utilisée par plusieurs tableaux. La méthode précédente n’est plus suffisante. Voici la solution que je vous propose :

• 1er tableau : extraire les observations correspondant au premier tableau en utilisant une condition listant le critère de sélection si besoin.
• rendre ces observations uniques en ajoutant une nouvelle variable avec un numéro unique
• sauvegarder ces observations dans un jeu de données
• 2ème tableau : extraire les observations pour le second tableau
• donner un numéro différent à ces observations
• ajouter ces observations à celles précédemment sélectionnées
• 3ème tableau : etc.

Dans l’exemple qui suit, quatre tableaux différents sont à produits. On intercalera le code suivant entre les procédures format et report mentionnées précédemment.

data lab;
set lab;
grp=1;
output;
if cntry=’CN’ then
do;
grp=2;
output;
end;
else if cntry=’MY’ then
do;
grp=3;
output;
end;
if cntr=1 and cntry=’CN’ then
do;
grp=4;
output;
end;
run;

3. Créer plusieurs jeux de données

L’instruction OUTPUT dirige, par défaut, les données vers le jeu de données nommé dans l’instruction DATA. Parfois, il faut créer plusieurs data sets à partir à partir d’un seul jeu de données. Par exemple, on créera un data set contenant les patients inclus dans l’étude et un autre ceux exclus. Pour cela, il suffit de nommer les nouveaux jeux de données dans l’instruction DATA et de rappeler leur nom dans chaque instruction OUTPUT.

data incl excl;
set pat_lst;
if missing (randomno) then output excl;
else output incl;
run;

4. Créer une variable numérique avec des valeurs continues

En combinaison avec une boucle, l’instruction OUTPUT permet de générer des nombres. Par exemple, j’ai eu besoin de tester une macro via un data set listant toutes les valeurs ASCII imprimables. Ces valeurs ont un numéro allant de 32 à 126. La fonction BYTE retrouve la valeur ASCII avec ces numéros.

data ascii (drop=i);
do i=31 to 126;
ascii=byte(i);
output;
end;
run;

Autres lectures : vous pouvez étendre votre lecture sur l’instruction DO et DELETE. L’instruction DO dispose d’un mot-clé BY. L’instruction DELETE est, quant à elle, l’inverse de l’OUTPUT.