Supongamos que tenemos un linux, que está ejecutando una bbdd Oracle. Oracle arranca unos cuantos procesos: para escribir los logs, listener, escribir datos a datafile, monitorizar otros procesos ...

[root@box /]# ps aux | grep -i oracle
oracle 3920 0.0 0.1 65304 9876 ? Ssl Jul18 0:00 /opt/oracle/product/10.2.0/db/bin/tnslsnr LISTENER -inherit
oracle 3978 0.0 0.2 1641684 17144 ? Ss Jul18 0:00 ora_pmon_SID
oracle 3980 0.0 0.1 1640508 15408 ? Ss Jul18 0:00 ora_psp0_SID
oracle 3982 0.0 0.4 1640508 40768 ? Ss Jul18 0:00 ora_mman_SID
oracle 3984 0.0 6.5 1665924 535984 ? Ss Jul18 0:11 ora_dbw0_SID
oracle 3986 0.0 0.3 1656068 31744 ? Ss Jul18 0:41 ora_lgwr_SID
oracle 3988 0.0 0.6 1642116 49300 ? Ss Jul18 0:54 ora_ckpt_SID
oracle 3990 0.0 2.1 1643228 177576 ? Ss Jul18 0:22 ora_smon_SID
oracle 3992 0.0 0.2 1640564 22420 ? Ss Jul18 0:00 ora_reco_SID
oracle 3994 0.0 0.7 1642200 63436 ? Ss Jul18 0:10 ora_cjq0_SID
oracle 3996 0.0 0.9 1643352 76596 ? Ss Jul18 0:04 ora_mmon_SID
oracle 3998 0.0 0.3 1640552 25452 ? Ss Jul18 0:00 ora_mmnl_SID
oracle 4000 0.0 0.1 1641388 15560 ? Ss Jul18 0:00 ora_d000_SID
oracle 4002 0.0 0.1 1641560 14792 ? Ss Jul18 0:00 ora_s000_SID
oracle 4006 0.0 0.2 1640516 16692 ? Ss Jul18 0:00 ora_qmnc_SID
oracle 4949 0.0 0.2 1640560 18436 ? Ss Jul18 0:00 ora_q000_SID
oracle 4951 0.0 0.1 1640540 16048 ? Ss Jul18 0:00 ora_q001_SID
oracle 5052 0.0 0.3 1641228 28808 ? Ss Jul18 0:06 oracleSID (LOCAL=NO)
oracle 10251 0.0 0.3 1640704 27508 ? Ss 11:56 0:00 oracleSID (LOCAL=NO)
root 10358 0.0 0.0 52160 808 pts/0 R+ 12:53 0:00 grep -i oracle
[root@box /]#

¿Realmente oracle necesita todos esos procesos? Vamos a fijarnos en uno, el listener.

[root@box /]# pidof tnslsnr
3920

Asi que tiene PID 3920 ... vamos al directorio /proc.


[root@box ~]# cd /proc/
[root@box proc]# ls
t1 11981 140 6397 6909 dri misc
10 11983 1893 6404 6910 driver modules
10081 11984 2 6439 7 execdomains mounts
1126 11990 3 6448 7124 fb mtrr
11421 11994 3313 6469 781 filesystems net
11794 12005 3459 6470 807 fs partitions
11862 12021 4 6471 9 ide scsi
11876 12030 4025 6472 95 interrupts self
11892 12038 4559 6473 9890 iomem slabinfo
11894 12066 5 6474 acpi ioports stat
11900 12677 5428 6489 asound irq swaps
11926 12679 5648 6491 buddyinfo kallsyms sys
11929 1293 5654 6531 bus kcore sysrq-trigger
11930 13147 5983 6552 cmdline keys sysvipc
(...)
3920
(...)

Parece que hay un subdirectorio por cada proceso. Veamos qué podemos averiguar de nuestro listener.

[root@box proc]# cd 3920/
[root@box 3920]# pwd
/proc/3920
[root@box 3920]# ls
attr cwd loginuid mountstats seccomp status
auxv environ maps oom_adj smaps task
cmdline exe mem oom_score stat wchan
cpuset fd mounts root statm

Hay bastante información relativa al proceso del listener, por ejemplo:

• "cmdline" representa la línea de comandos con la que se ha arrancado el proceso. En /proc hay otro cmdline, pero ese representa las opciones que se han pasado al kernel para arrancar.
• "cwd" es el directorio en el que está el proceso.
• "environ" las variables del entorno de ese proceso. Lo mismo que veríamos con la opción "-e" de ps
• "exe" el ejecutable del proceso, en este caso es un enlace simblico a /opt/oracle/product/10.2.0/db/bin/tnslsnr
• "root" sería el directorio raíz según ese proceso. Puede ser útil para comprobar si un servicio que hemos instalado se está ejecutando en chroot o no.
• "fd" son los descriptores de archivo que está accediendo el proceso. Como en Unix todo son archivos esto significa que podemos ver qué ficheros está leyendo/escribiendo, sockets, pipes. sería algo parecido a lo que hace el comando "lsof"

Además de estos valores de procesos, dentro de proc hay más archivos para ver o consultar otras cosas como:

• si las interfaces de red han de hacer "forwarding"
• particiones montadas
• sistemas de archivos reconocidos por el kernel
• tiempo arrancado (uptime)

Vale la pena explorar un poco por /proc, es bastante posible que algunas funciones que necesitamos incluir en un script se puedan hacer accediendo directamente a /proc en vez de ejecutar y parsear la salida de algun comando.

Takže já sem Pepa a tyhle stránky jsem vytvořil proto, abych publikoval své názory, nápady a zážitky :-)

Kdo to chce číst ať to čte a kdo ne tak ať čte třeba Hulána :-D

Despite what the detractors say, China has redeemed itself. Beijing was a tremendous, astounding success. The opening that was a panorama of colors, a touch of history and more than a pinch of drama. Thousands of athletes, hundreds of games, a little faux pas here and there, but all in all Beijing's reclaimed fame! Preparations for the games by China's athletes was rigorous and had paid off well. The Sinos got most of the gold. China is trying to prove her mettle as a responsible power, or so it seems. It is hoped that in as many other respects, such as giving what is due to its distinct peoples China might also shine some day. I rest my case, Your Honors.

1. Un premier exemple avec la fonction PUT

Rappel sur la fonction PUT : Une fonction PUT permet de convertir une variable numérique en variable texte ou une variable texte en une autre variable texte. Elle est composée de deux paramètres. D'un côté, il y a la variable d'origine. De l'autre côté, il y a le format à appliquer sur cette variable d'origine. C'est donc la valeur sous forme formatée qui devient une valeur texte. Reportez vous à l'article "Convertir une variable caractère en numérique et inversement" pour plus de détails.

La phase de compilation : A la compilation, SAS  vérifie que la variable d'origine et le format associé sont tous les deux du même type. Il faut qu'une variable numérique est un format qui s'applique à une variable numérique. De manière identique, il faut un format caractère pour une variable texte.

La phase d'exécution : Si on ne connaît pas à l'avance le type de la variable, on peut avoir envie de définir une condition : si la variable est numérique applique tel format, sinon applique tel autre format. Hors une condition IF/THEN n'est visible par SAS qu'à la phase d'exécution.

En d'autres termes, SAS tentera d'appliquer un format numérique à une variable numérique avant de regarder si la fonction PUT est définie dans une condition.

data import_excel;
   retain type 'CHAR';
   study = '999';
   output;
   study = '888';
   output;
run;

data study_new;
   set import_excel;
   if type='NUM' then study_new=put(study,best.);
   else study_new=study;
run;

Le résultat : Dans l'exemple, un format numérique (BEST.) est appliqué à une variable texte (STUDY). La première partie de la condition ne s'applique pas car le type de la variable n'est pas égal à NUM. Mais SAS cherche un format $BEST. qui n'existe pas. Il est obligé de s'arrêter là.

28 data study_new;
29 set ref;
30 if upcase(type)='NUM' then study_new=put(study,best.);
                                                  -----
                                                  48
ERROR 48-59: The format $BEST was not found or could not be loaded.

31 else study_new=study;
32 run;

NOTE: The SAS System stopped processing this step because of errors.
WARNING: The data set WORK.STUDY_NEW may be incomplete.
When this step was stopped there were 0 observations and 3 variables.

Un exemple où le type de la variable est inconnu : en important un fichier EXCEL (PROC IMPORT/MIXED=YES), le type de la variable sous SAS peut-être inconnu. La variable sera caractère si une cellule contient du texte. Sinon, elle sera numérique.

2. Une solution rapide

Une fonction Vxxx: la fonction VVALUE retourne une valeur texte. Elle utilise le format associé à la variable en interne pour construire la valeur sous forme formatée. La nouvelle variable aura une longueur de 200.

data study_new;
   set ref;
   if type='NUM' then study_new=vvalue(study);
   else study_new=study;
run;

3. Une solution plus lourde mais pouvant s'appliquer à plusieurs variables

Une autre solution est de générer le code à exécuter. Si la variable est numérique, c'est l'instruction avec PUT qui apparaîtra, sinon c'est l'autre instruction. Cette approche fait appel à la notion de dictionnaire et de DATA _NULL_.

3.1 Créer un data set contenant le nom des variables et leur type à partir du dictionnaire (dictionary) appelé COLUMNS

La première étape consiste à créer un data set, nommé DICT_REF, contenant la variable STUDY et son type.

Choix du dictionnaire : Le dictionnaire (dictionary) COLUMNS est un data set de référence, créé de manière automatique par SAS. Il répertorie toutes les variables contenues dans tous les data sets de toutes les bibliothèques actives. Il contient donc une ligne par variable.

Chaque ligne du dictionnaire contient plusieurs informations caractérisant cette variable dont :

• la bibliothèque d'origine (variable LIBNAME)
• le data set d'origine (variable MEMNAME)
• le nom de la variable (variable NAME)
• le type de la variable (variable TYPE).

Prendre un sous-ensemble du dictionnaire : Ici seule la variable STUDY est utile. Elle provient du data set EXCEL_IMPORT sauvegardé de manière temporaire dans la bibliothèque WORK.

Mettre en majuscule : Le type de la variable est soit "num" soit "char", toujours en minuscule. Le nom de la variable peut avoir un mélange de majuscules et minuscules selon la manière dont est saisi le nom lors de sa création. Pour éviter des surprises, le nom de la variable et le type sont mis en majuscule grâce à la fonction UPCASE. L'avantage des dictionnaires, c'est qu'ils peuvent lister plus d'une variable.

proc sql;
   create table dict_ref as
      select upcase(name) as name,
             upcase(type) as type
      from dictionary.columns
      where upcase(libname) = 'WORK' and
            upcase(memname) = 'EXCEL_IMPORT' and
            upcase(name)    = 'STUDY';
quit;

3.2 Ecrire le code et l'appeler

La deuxième étape consiste à créer un programme nommé TMP_STUD.SAS donc le nom et l'emplacement est défini dans l'instruction FILENAME. Pour écrire dans ce fichier, l'instruction FILE est ajoutée dans le DATA _NULL_. Pour plus de précisions sur l'instruction PUT, reportez-vous à l'article "Ecrire un texte avec l'instruction PUT".

filename stud 'C:/sasref/tmp_stud.sas';

data _null_;
   set dict_ref;
   file stud;
   put 'data study_new;';
   put @3 'set excel_import;';
   if type='NUM' then put @3 'study_new=put(' name ',9.);';
   else put @3 'study_new=' name ';';
   put 'run;';
run;

%include stud;
filename stud;

L'écriture du programme est fonction des informations contenues dans le DICT_REF. Si plus d'une variable est sélectionnée, il faudrait préciser deux choses :

• Les instructions DATA et SET ne sont à écrire qu'une fois. Elles sont ajoutées lors de la première boucle fait en interne autour de l'étape DATA via "if _N_=1".
• L'instruction RUN apparaît une fois en fin de programme. Il faut donc l'ajouter une fois le dernier record du fichier de référence atteint. L'option END= de l'instruction SET crée une variable interne prenant la valeur 0 pour tous les records sauf le dernier où elle prend la valeur 1. La condition est donc basée sur cette variable.

filename stud 'C:/sasref/tmp_stud.sas';

data _null_;
   set dict_ref end=eof;
   file stud;
   if _N_=1 then
      do;
         put 'data study_new;';
         put @3 'set excel_import;';
      end;
   if type='NUM' then put @3 'study_new=put(' name ',9.);';
   else put @3 'study_new=' name ';';
   if eof then put 'run;';
run;

%include stud;
filename stud;

Le code sauvegardé dans le fichier TMP_STUD.SAS se présente donc ainsi, vu que la variable STUDY est de type caractère.

data study_new;
   set excel_import;
   study_new=STUDY ;
run;

L'instruction %INCLUDE permet l'exécution de ce code.

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;

• ODS TRACE pour identifier une sortie,
• ODS OUTPUT pour rediriger une sortie vers un data set,
• ODS SELECT and ODS EXCLUDE pour choisir les sorties apparaissant dans la fenêtre OUTPUT.

Pour illustrer ce sujet, la procédure PROC MEANS sera utilisée.

Remise dans le contexte :

• Changer l'éditeur pour une présentation plus fine : rediriger vers un document RTF avec ODS RTF s'applique une fois que la formulation nous convient.
• Changer la formulation des informations : le TEMPLATE peut préalablement être modifié pour n'afficher qu'un sous ensemble du résultat par exemple.
• Faire de gros travaux : pivoter un tableau, combiner des résultats entre eux ou encore calculer une valeur à partir des résultats existant fait partie des gros travaux qui nécessitent de passer par un dataset SAS.

1. Identifier le nom des résultats

Pour voir le nom des différentes outputs, entourez votre procédure des instructions ODS TRACE ON/LISTING et ODS TRACE OFF.

• La première instruction demande l'affichage de chacune des noms des sorties.
• L'option LISTING permet d'afficher cette information dans la fenêtre OUTPUT. La destination par défaut est la LOG.
• Enfin, la seconde instruction désactive le traçage.

Premier exemple

ods trace on/listing;

*Exemple 1 : Proc Means;
proc means data=sashelp.class;
   var height weight;
run;

ods trace off;

On obtient la sortie de PROC MEANS appelée SUMMARY.

Output Added:
-------------
Name: Summary
Label: Summary statistics
Template: base.summary
Path: Means.Summary
-------------

Second exemple avec une instruction BY : il est toujours possible d'ajouter une instruction BY dans PROC MEANS.

proc sort data=sashelp.class out=class;
   by sex;
run;

ods trace on/listing;

*Exemple 2 : Proc MEANS et l'instruction BY;
proc means data=class;
   by sex;
   var height weight;
run;

ods trace off;

Il y a plusieurs outputs pour une seule procédure. Les deux sorties ont le même nom (NAME) mais le chemin d'accès (PATH) est différent. On parle de BYGROUP1 et BYGROUP2 pour les distinguer.

Output Added:
-------------
Name: Summary
Label: Summary statistics
Template: base.summary
Path: Means.ByGroup1.Summary
-------------

Output Added:
-------------
Name: Summary
Label: Summary statistics
Template: base.summary
Path: Means.ByGroup2.Summary
-------------

2. ODS OUTPUT et PROC MEANS

Dans le premier exemple, un data set EXEMPLE1 est créé à partir de la sortie ONEWAYFREQ de la PROC MEANS appliquée au fichier SASHELP.CLASS.

J'ai choisi d'écrire l'instruction ODS OUTPUT à l'intérieur de la procédure puisqu'elle s'applique uniquement à la procédure mais elle peut être aussi affichée avant la procédure.

Une seule instruction pour plusieurs data sets à créer : Ecrire l'instruction ODS OUTPUT avant la procédure est intéressant si vous générez plusieurs sorties de procédures différentes et voulez lister tous les data sets SAS à créer en une seul instruction ODS OUTPUT.

*Exemple 1 : Proc Means;
proc means data=sashelp.class;
   var height weight;
   ods output summary=exemple1;
run;
 
Un fichier brut peu lisible : Après un PROC PRINT sur le data set EXEMPLE1, on découvre un fichier peu lisible dès qu'il y a plus d'une variable.

   VName_          
   Height      Height_N    Height_Mean  
   Height        19        62.336842105  

   Height_
   StdDev      Height_Min  Height_Max
5.1270752466     51.3          72

   VName_
   Weight      Weight_N    Weight_Mean
   Weight        19        100.02631579

  Weight_
   StdDev      Height_Min  Height_Max
22.773933494     50.5          150

Solution, étape 1 : Une solution est de faire un PROC TRANSPOSE pour un résultat sous la forme ci-dessous.

   _NAME_     _LABEL_     COL1

Height_N      N          19.000
Height_Mean   Mean       62.337
Height_StdDev Std Dev     5.127
Height_Min    Minimum    51.300
Height_Max    Maximum    72.000
Weight_N      N          19.000
Weight_Mean   Mean      100.026
Weight_StdDev Std Dev    22.774
Weight_Min    Minimum    50.500
Weight_Max    Maximum   150.000

Dans la sortie brute de l'ODS OUTPUT, les variables commencent soit par HEIGHT, soit par WEIGHT (soit par VNAME ne m'intéresse pas ici). Il s'agit de transposer toutes ces variables. Il faut donc toutes les lister. Par soucis de clarté et de simplicité, on peut faire appel à une version abrégée : la racine commune des variables suivie de deux points.

proc transpose data=exemple1 out=exemple1;
   var height: weight:;
run;

Solution, étape 2 : Pour retrouver une présentation semblable à celle d'un PROC MEANS envoyé dans la fenêtre OUTPUT, il faut transposer de nouveau. Auparavant, il faut créer une variable distinguant la variable HEIGHT de la variable WEIGHT.

var_name  N   Mean   Std_Dev Minimum Maximum

 Height  19  62.337  5.1271    51.3     72
 Weight  19 100.026 22.7739    50.5    150

Créer une variable nommée VAR_NAME prenant soit la valeur HEIGHT soit la valeur WEIGHT.

• La fonction SCAN récupérera, dans une variable nommée VAR_NAME, le premier mot de la variable _NAME_ après avoir précisé que chaque mot est séparé par un trait bas (underscore).
• La longueur de la variable est définie explicitement au cas où certains noms de variables seraient supérieurs à 8 et donc tronqués.
• Cette longueur est définie avant l'instruction SET pour que la variable VAR_NAME apparaisse en premier.

data exemple1 (drop=_name_);
   length var_name $12;
   set exemple1;
   var_name=scan(_name_,1,'_');
run;

Il est alors possible de faire pivoter le data set. Une ligne est créée pour HEIGHT et une autre pour WEIGHT, c'est-à-dire pour chaque nouvelle valeur de VAR_NAME. Chaque colonne prend le nom contenu dans la variable _LABEL_.

proc transpose data=exemple1 out=exemple1 (drop=_name_);
   by var_name;
   id _label_;
run;

L'instruction BY : Dans le cas du PROC MEANS, on ne rencontre pas de difficulté particulière liée à l'instruction BY. Au lieu d'avoir une ligne dans le fichier de sortie, on a autant de lignes que de valeurs dans la variable de l'instruction BY. Dans notre exemple, on a donc deux lignes avec une instruction BY SEX. Vous pouvez retrouver le code pour la transposition en fin d'article pour obtenir la sortie suivante :

Sex=F

var_name  N   Mean  Std_Dev Minimum Maximum

 Height   9 60.5889  5.0183   51.3    66.5
 Weight   9 90.1111 19.3839   50.5   112.5

Sex=M

var_name  N  Mean  Std_Dev Minimum Maximum

 Height  10  63.91  4.9379    57.3    72
 Weight  10 108.95 22.7272    83.0   150

3. Sélectionner ou exclure certaines sorties ou toute les sorties (ODS EXCLUDE, SELECT, LISTING)

L'instruction ODS LISTING CLOSE suspend l'envoie de toutes les sorties dans la fenêtre OUTPUT. L'ODS EXCLUDE interrompt un sous-ensemble ou toutes les sorties générées par la procédure. A l'inverse, l'ODS SELECT retient les sorties. A vous de voir si vous avez plus vite fait de lister les sorties à garder ou celles à exclure.

Quelques sorties : Pour sélectionner ou exclure quelques sorties en particulier, il suffit d'ajouter leur nom, trouvés au préalable avec ODS TRACE ON, séparé par un espace dans l'instruction. Cela est pratique pour des procédures générant beaucoup de sorties comme PROC UNIVARIATE. 

Toutes les sorties : Pour faire la même chose sur toutes les sorties, on utilise ALL et NONE avec ODS EXCLUDE et ODS SELECT.

*Exemple 1 : Proc Means;

ods exclude all; *ods select none; *ods listing close;
proc means data=sashelp.class;
   var height weight;
   ods output summary=exemple1;
run;
ods exclude none; *ods select all; *ods listing;

Note : Toutes les explications couvertes dans cet article s'appliquent aussi à la procédure PROC SUMMARY.

Annexe : Détails du programme s'appliquant au second exemple

*Exemple 2 : Proc MEANS et l'instruction BY;

proc sort data=sashelp.class out=class;
   by sex;
run;

proc means data=class;
   by sex;
   var height weight;
   ods output summary=exemple2;
run;

proc transpose data=exemple2 out=exemple2;
   by sex;
   var height: weight:;
run;

data exemple2 (drop=_name_);
   length var_name $12;
   set exemple2;
   var_name=scan(_name_,1,'_');
run;

proc transpose data=exemple2 out=exemple2 (drop=_name_);
   by sex var_name;
   id _label_;
run;

proc print data=exemple2 noobs;
   by sex;
run;

Pour illustrer le propos un data set liste plusieurs actions pour un patient à une visite donnée. Il s'agit de regrouper ces actions par patient et visite dans un seul record.

Le data set avant

pat_id  visit_dt rec_id action

   1   02APR2007    1   RAYON X
   1   02APR2007    2   ULTRASON
   1   02APR2007    3   SCANNER
   2   15NOV2007    2   RAYON X
   2   15NOV2007    1   ULTRASON

Le data set après : une nouvelle variable caractère est créée ACTION_LST. On lui donnera une longueur de 200. Chaque action y est séparée par une barre. Les variables REC_ID (identifiant du record) et ACTION sont supprimées.

pat_id  visit_dt action_lst

   1   02APR2007 RAYON X | ULTRASON | SCANNER
   2   15NOV2007 ULTRASON | RAYON X

1. La force du RETAIN

Pour débuter une variable ACTION_LST de longueur 200 est créée. Elle ne contient à la base aucune valeur.

data final; *(drop = rec_id action);
   set orig;
   by pat_id visit_dt;
   length action_lst $200;
   retain action_lst ' ';
   if first.visit_dt then action_lst=action;
   else action_lst=catx(' | ',action_lst,action);
   *if last.visit_dt then output;
run;

Pour chaque nouvelle visite de chaque patient, ACTION_LST est initialisée. Elle prend la valeur de la variable ACTION.

Du fait de la présence de l'instruction RETAIN, cette première valeur est maintenue pour tous les records d'une même visite. A chaque nouvelle lecture d'un record, une nouvelle action est ajoutée.

La fonction CATX permet de concaténer les valeurs d'ACTION_LST et ACTION, et d'ajouter la barre comme délimiteur.

Voici donc le résultat intermédiaire, avant l'activation du code mis en commentaires.

pat_id  visit_dt action_lst

   1   02APR2007 RAYON X
   1   02APR2007 RAYON X | ULTRASON
   1   02APR2007 RAYON X | ULTRASON | SCANNER
   2   15NOV2007 ULTRASON
   2   15NOV2007 ULTRASON | RAYON X

A présent, il s'agit de garder seulement le dernier record de chaque visite par patient avec LAST.VISIT_DT et à supprimer les variables REC_ID et ACTION.

2. Rotation de données (PROC TRANSPOSE) et lecture en boucle (ARRAY)

Avec cette seconde approche, le travail est découpé en deux étapes à commencer.

Dans un premier temps, un PROC TRANSPOSE pour faire pivoter les données. Le data set n'a alors plus qu'une ligne par visite de patient. Chaque action apparaît dans une colonne donnée.

proc transpose data=orig out=final2 (drop=_name_);
   by pat_id visit_dt;
   var action;
run;

pat_id  visit_dt  COL1      COL2      COL3

   1   02APR2007  RAYON X   ULTRASON  SCANNER
   2   15NOV2007  ULTRASON  RAYON X

Dans un second temps un ARRAY nommé _ACTION est défini. Il contient toutes les variables commençant par COL. A chaque nouvelle lecture d'une variable COL, sa valeur est ajoutée à celle de la variable ACTION_LST.

data final2 (drop=i col:);
   set final2;
   length action_lst $200;
   array _action {*} col:;
   do i=1 to dim(_action);
      action_lst = catx(' | ',action_lst,_action{i});
   end;
run;

Annexe : Création du data set utilisé pour l'exemple.

data orig;
   input pat_id visit_dt date9. rec_id action $15.;
   format visit_dt date9.;
   datalines;
1 02APR2007 1 RAYON X
1 02APR2007 2 ULTRASON
1 02APR2007 3 SCANNER
2 15NOV2007 2 RAYON X
2 15NOV2007 1 ULTRASON
;
run;

proc sort data=orig;
   by pat_id visit_dt;
run;

Blocks are really easy and very usefull part of ruby.

There are two ways of constracting blocks in Ruby.  The first is to use {} and place the code between the curly braces, like this "  { code block  }".  We use this if the code is one line long.  The second is to use the do/end keywords placing the ruby code between the keywords.  This way of creating block is useful when the code is in multiple lines.  Whereas the previous, is used when the code is in a single line.

 A Ruby method, which takes a block as argument.

This snippet demonstrate how to pass implicitely a ruby block as a parameter of the method.  Implecitly because, I am not converting the block into a proc object (more on this later).

IRB certified code ;-)

irb(main):030:0>   def name(&blk)
irb(main):031:1>     sleep 3
irb(main):032:1>     puts "I am inside the method . . "
irb(main):033:1>     sleep 3
irb(main):034:1>     blk.call
irb(main):035:1>     sleep 3
irb(main):036:1>     puts "and back to the method"
irb(main):037:1>     sleep 3
irb(main):038:1>   end
=> nil
irb(main):039:0>
irb(main):040:0* name { puts "from the block"}
=>  I am inside the method . .
=>  from the block
=>  and back to the method

Identifier et supprimer les doublons dans un data set fait partie des compétences de base du programmeur SAS. Trois approches sont envisageables : PROC SQL, PROC SORT et un compteur dans un data step.

Qu'appelle-t-on doublon ? des lignes complètement identiques ou seulement des lignes ayant quelques variables communes ? Il est important de savoir si deux records ayant des observations communes sont considérés comme doublons ou s'il faut que toutes les observations soient identiques. Si seules quelques variables sont considérées, il faut savoir quelle ligne est conservée et lesquelles sont supprimées.

Le data set utilisé pour l'exemple est composé de trois variables CNTRY (country), PAT_ID (patient ID) et VAL (value). Le patient 2 de Chine a trois lignes d'observations dont deux strictement identiques.

cntry    pat_id    val

 CN        1        A
 CN        2        B
 CN        2        C
 CN        2        C
 HK        3        E 

1. PROC SQL

Avec la procédure SQL, il est possible de faire des calculs et de baser sa sélection d'observations sur ce calcul. En d'autres termes, il est possible de compter le nombre de fois qu'une valeur apparaît. Pour identifier les records avec doublons, on prend ceux comptés plus d'une fois.

Première présentation : Voici, tout d'abord, une présentation de PROC SQL décomposable en deux étapes.

proc sql;
   create table two (where=(cnt_pat > 1)) as
      select cntry, pat_id, val, count(*) as cnt_pat
      from one
      group by cntry, pat_id;
quit;

Dans un premier temps, une variable donne le nombre de records par patient dans un pays donné (CNT_PAT) grâce à la syntaxe GROUP BY et la fonction COUNT. A ce stade, on obtient le data set suivant :

cntry pat_id val cnt_pat

  CN     1    A     1
  CN     2    C     3
  CN     2    B     3
  CN     2    C     3
  HK     3    E     1

Dans un second temps, seules les observations ayant des doublons sont gardées, une fois le nouveau data set créé, grâce à l'option WHERE=.

Deuxième présentation : Au lieu de créer la variable CNT_PAT et de faire une sélection ultérieure, la fonction COUNT peut être  ajoutée dans une condition introduite par le mot HAVING et faisant toujours appel à la fonction COUNT.

Pour ne voir qu'une des lignes multiples, il suffit d'ajouter DISTINCT.

proc sql;
   create table two_bis as
   select /*distinct*/ cntry, pat_id, val
   from one
   group by cntry, pat_id
   having count(*) > 1;
quit;

A l'inverse, pour ne sélectionner que les observations n'apparaissant qu'une fois, ">1" sera remplacé par "=1". Seules les observations ayant exactement une occurrence sont sélectionnées.

Le DISTINCT s'applique à l'intégralité des observations. Cela permet de ne garder que des lignes uniques.

Il n'est pas possible de garder la première ligne parmi les doublons définis par des variables précises (CNTRY et PAT_ID dans l'exemple) avec cette méthode.

2. Les options de la procédure PROC SORT (NODUP/NODUPRECS, NODUPKEY)

Il existe deux options dans la procédure PROC SORT pour supprimer les doublons selon qu'ils s'appliquent

• à toute une ligne d'observation (NODUPRECS dont l'alias est NODUP) ou
• à une liste de variables précises données dans l'instruction BY (NODUPKEY).

Au choix, le nouveau data set sans doublons remplace l'ancien ou est sauvegardé dans un dataset différent introduit par OUT=.

Les observations ayant été exclues peuvent être sauvegardées dans un nouveau data set dont le nom est défini par DUPOUT=.

proc sort data=one out=three nodupkey dupout=three_bis;
   by cntry pat_id;
run;

proc sort data=one out=four noduprecs /*nodup*/ dupout=four_bis;
   by cntry pat_id;
run;

3. Appliquer une variable compteur

Enfin, après PROC SQL et PROC SORT, une troisième possibilité pour identifier et supprimer les doublons, est d'ajouter une variable compteur.

Dans l'exemple ci-dessous, la variable compteur est nommée CNT. Pour la première observation d'un patient d'un pays donné, le compteur est initialisé à 1. Pour chaque nouveau record du patient, le compteur est incrémenté de 1. Quand la variable CNT est égale à 1, le record est ajouté dans le data set FIVE. Sinon il est ajouté dans le data set FIVE_BIS. A la fin, la variable compteur est supprimée.

Ainsi le data set FIVE contient les records sans doublons. Dans le cas du patient doublonné (patient 2), c'est la première observation qui est conservée.

Dans le data set FIVE_BIS, les records exclus de la première sélection sont conservés.

data five (drop=cnt) five_bis (drop=cnt);
   set one;
   by cntry pat_id val;
   if first.pat_id then cnt=1;
   else cnt+1;
   if cnt = 1 then output five;
   else output five_bis;
run;

Annexe :

data one;
   input cntry $ pat_id $ val $;
   datalines;
CN 1 A
CN 2 B
CN 2 C
CN 2 C
HK 3 E
;
run;

La transposition de jeux de données sous SAS est une étape fréquente dans le processus de programmation. Voici pour débuter un premier exemple pour se familiariser avec la syntaxe de base.

1. Les données d'origine

Le data set illustrant le sujet est composé de trois variables :

• le numéro du patient (PAT_ID)
• le numéro de la visite (VISIT) prenant les valeurs 18 pour début de visite, 50 pour fin de visite et 70 pour suivi
• la date de cette visite (VISIT_DT).

En fin d'article, vous trouverez le code pour créer ce data set.

pat_id visit visit_dt

   1     18  25MAR2007
   1     70  15OCT2007
   1     50  01JUL2007
   2     18  14APR2007
   2     50  08AUG2007
   3     50  16OCT2007

2. Le minimum

Pour afficher une ligne par patient, il faut faire appel à la procédure PROC TRANSPOSE.

Dans le cas présent, on a choisi d'afficher la date de la visite (VAR VISIT_DT) pour chaque patient (BY PAT_ID). Le numéro de la visite est perdu dans cette transposition.

Le minimum de la syntaxe requiert la création d'un nouveau data set introduit par le mot-clé OUT=. Ce data set peut avoir le même nom que le data set d'origine. Il faut au moins lister une variable.

proc transpose data=one out=two;
   by pat_id;
   var visit_dt;
run;

pat_id  _NAME_    COL1      COL2      COL3

   1   visit_dt 25MAR2007 15OCT2007 01JUL2007
   2   visit_dt 14APR2007 08AUG2007         .
   3   visit_dt 16OCT2007         .         .

3. Les options et instructions supplémentaires

3.1 Des variables automatiques supprimées avec l'option DROP= : Le nom de la variable utilisée pour créer les colonnes COL1-COL3 est donné de manière automatique par SAS. Cette information est sauvegardée dans la variable _NAME_. Elle peut dont être supprimée avec l'option DROP attachée au data set de sortie nommé TWO.

proc transpose data=one out=two (drop=_name_);
   by pat_id;
   var visit_dt;
run;

pat_id         COL1         COL2         COL3

   1      25MAR2007    15OCT2007    01JUL2007
   2      14APR2007    08AUG2007            .
   3      16OCT2007            .            .

3.2 Une colonne propre à une visite donnée grâce à l'instruction ID : On remarque que pour le premier patient, la visite du 15 octobre est citée avant celle du 1er juillet. En d'autres termes, une colonne donnée ne correspond pas à une visite donnée mais à l'ordre des données dans le fichier source. De la même manière, la deuxième visite du troisième patient apparaît dans la première colonne.

Pour que chaque colonne corresponde à un numéro de visite donné, on fait appel à l'instruction ID suivie du nom de la variable définissant la colonne. Dans notre cas, il s'agit de la variable VISIT.

proc transpose data=one out=two (drop=_name_);
   by pat_id;
   var visit_dt;
   id visit;
run;

pat_id          _18          _70          _50

   1      25MAR2007    15OCT2007    01JUL2007
   2      14APR2007            .    08AUG2007
   3              .            .    16OCT2007

3.3 Des noms de colonnes personnalisés grâce à PREFIX = : Maintenant chaque colonne correspond à une visite en particulier. Comme les numéros de visites sont des nombres et que les variables de SAS ne peuvent commencer par un chiffre, SAS ajoute automatiquement un tiret bas devant. Pour donner un nom un peu plus parlant, on peut ajouter un préfixe à ces noms de colonne.

proc transpose data=one out=two (drop=_name_) prefix=VISIT;
   by pat_id;
   var visit_dt;
   id visit;
run;

pat_id      VISIT18      VISIT70      VISIT50

   1      25MAR2007    15OCT2007    01JUL2007
   2      14APR2007            .    08AUG2007
   3              .            .    16OCT2007 

3.4 Lister toutes les variables commençant par un nom donné

Avoir une série de variables commençant par le même préfixe présente des avantages car SAS permet d'y référer très simplement.

La syntaxe SAS : Pour lister toutes ces variables, il suffit de faire suivre le préfixe de deux points. Dans notre exemple, toutes les variables commençant par le mot VISIT sont listées avec VISIT:.

Voici quelques exemples d'applications de cette syntaxe :

• un PROC TRANSPOSE : lister les variables à transposer
• une option KEEP/DROP : lister les variables à garder ou à supprimer
• un ARRAY : lister les variables définissant l'array.

Annexe :

data one;
   input pat_id visit visit_dt date9.;
   format visit_dt date9.;
   datalines;
1 18 25MAR2007
1 70 15OCT2007
1 50 01JUL2007
2 18 14APR2007
2 50 08AUG2007
3 18 16OCT2007
;
run;

Après avoir présenté les deux alternatives sous SAS dans un data step pour définir des conditions (La base du IF et SELECT), partons voir la syntaxe de PROC SQL pour définir une nouvelle variable.

1. Différences et ressemblances avec les IF et SELECT

Différences : A la différence des deux syntaxes du data step,...

• ... une seule action est possible pour une condition donnée : à savoir définir une et une seule nouvelle variable ou macro variable. Les conditions ne peuvent dont pas servir pour créer de nouveaux data sets ou imbriquer des conditions dans d'autres conditions.
• ... le nom de la nouvelle variable n'est donné qu'une seule fois.

Ressemblances :

• Comme dans SELECT WHEN et ELSE IF,  seuls les records non déjà valides pour les cas listés précédemment sont relus.
• Comme IF THEN, une dernière condition ELSE liste tous les cas non sélectionnés auparavant.

Un des avantages de la procédure SQL est de pouvoir définir une nouvelle variable à partir d'une ancienne variable portant le même nom. Alors que dans un data step, cela se passe en plusieurs étapes : 

• Tout d'abord, la variable est renommée pour pouvoir se servir de son nom d'origine pour la nouvelle variable.
• Ensuite la variable d'origine portant le nom créé uniquement pour l'occasion est supprimée.

Un autre avantage est l'usage des fonctions et du mot-clé DISTINCT.

2. La syntaxe CASE WHEN en exemple

2.1 Définir une variable à partir de plusieurs variables

Dans cet exemple, la variable POP prend au maximum 4 valeurs :

• 1 si la variable AGE est supérieure à 13 et la variable SEX est égale à F ;
• 2 si l'AGE est entre 0 et 13 et qu'il s'agit d'une femme ;
• 3 si il s'agit d'un homme et que l'âge est une valeur positive ;
• valeur manquante enfin pour les autres cas.

proc sql;
   /*create table class as*/
   select *, case
               when age > 13 and sex='F' then 1
               when age >= 0 and sex='F' then 2
               when age < 0 or sex not in ('F','M') then .
               else 3
           end as pop
   from sashelp.class;
quit;

2.2 Utiliser les fonctions

Dans l'exemple ci-dessous, le critère est appliqué par groupe de valeurs définies dans la variable SEX. En regardant les données, deux groupes de valeurs apparaissent : 'F' pour les femmes et 'M' pour les hommes. La variable MAX_AGE1 est égale à '13' si, pour un groupe donné, la valeur maximale observée parmi les valeurs non manquantes de la variable AGE est 13. Sinon, MAX_AGE1 prend la valeur 'N/A'.

proc sql;
   select sex, case
                 when max(age) = 13 then '13'
                 else 'N/A'
               end as max_age1
   from sashelp.class
   group by sex;
quit;

A présent, vu qu'il n'y a qu'un critère définissant la condition et qu'une seule valeur n'est attendue, ce critère peut être donné en début.

proc sql;
   select sex, case max(age)
                 when (13) then '13'
                 else 'N/A'
               end as max_age2
   from sashelp.class
   group by sex;
quit;

Mais, il est bon de se demander si un format ne serait pas plus adapté dans ce cas.

proc format;
  value max_age
   13    = '13'
   other = 'N/A';
run;

proc sql;
   select sex, put(max(age),max_age.) as max_age2
   from sashelp.class
   group by sex;
quit; 

2.3 Créer une macro variable

Voici pour terminer un petit exemple où une macro variable POP est crée. Sa valeur dépend de l'âge maximum observé dans le data set.

proc sql; *noprint;
   select case
            when max(age) > 13 then '>13'
            when max(age) >= 0 then '[0-13]'
            else 'N/A'
          end into :pop
   from sashelp.class;
quit;

Selon que des variables aient certaines valeurs ou non, le programmeur peut décider de créer une nouvelle variable, extraire une ligne d'observation, etc.

SAS propose plusieurs syntaxes pour exprimer ces conditions.

• Dans le data step et la procédure SQL, pour extraire un sous ensemble de records sans autre action le WHERE est probablement le plus adapté. De plus, dans d'autres cas que le data step et la PROC SQL l'option WHERE est aussi utilisable (PROC SORT, PROC FREQ, ODS OUTPUT...).
• Sinon, dans un data step, on rencontre le IF et le SELECT et dans une procédure SQL, CASE WHEN est disponible. 

Ce sujet sera divisé en 3 articles à commencer par la syntaxe du IF. Dans huit jours, le prochain rendez-vous sera consacré au SELECT. Enfin le dernier article de la série s'intéressera au CASE WHEN.

1. Le minimum ou presque

"S'il pleut, alors je prend mon parapluie, sinon, je le laisse au bureau." Dans cette phrase, on repère trois mots : si, alors, sinon. Traduisez par IF, THEN, ELSE. C'est trois mots, version anglaise, forme la syntaxe de base.

Dans l'exemple suivant, on considère les variables AGE et SEX pour créer la variable PP_NY (per protocol population, no/yes) : "Si ma variable âge est supérieure à 13 et qu'il s'agit d'hommes alors ma variable pp_ny=1, sinon pp_ny=0."

data class;
   set sashelp.class;
   if age > 13 and sex='M' then pp_ny=1;
   else pp_ny=0;
run;

On remarquera l'usage de l'instruction finale ELSE pour incluse tous les cas non pris en compte précédemment.

2. Multiplier les combinaisons

Dans ce second exemple, une instruction ELSE IF a été ajoutée. Ainsi tous les hommes de 13 ans ou moins pour lesquels on connaît l'âge sont sélectionnée dans cette seconde instruction. Enfin, les valeurs restantes correspondent aux lignes d'observations où l'âge est manquant ou concernant les femmes.

data class;
   set sashelp.class;
   if age > 13 and sex='M' then pp_ny=1;
   else if age > .z and sex='M' then pp_ny=0;
   else pp_ny=.;
run;

ELSE IF : il est préférable d'utiliser le ELSE IF, plutôt que le IF pour des raisons de performance et pour éviter des erreurs d'étourderie.

• Par performance j'entends : seules les observations qui ne sont pas valides dans la première condition sont lues pour évaluer la condition suivante. C'est un temps très précieux quand on traite une grosse base de données. 
• Par erreur j'entends : en aucun cas, des observations peuvent-être sélectionnées par deux instructions. Ainsi si PP_NY=1, il n'y a aucune chance qu'il devienne PP_NY=0 après exécution de la seconde instruction.

Important : dans l'exemple précédent, j'ai volontairement choisi de lister plus d'une variable pour définir ma condition. En effet, si vous avez une seule variable en entrée et une seule variable en sortie, un informat suffit. Plusieurs avantages se cachent derrière :

• le programme est allégé
• l'accès aux valeurs est plus évident puisque les formats font partie des informations données en début de programme.

Voici ce que cela donnerait si on ne considérerait que la variable AGE pour définir la variable PP_NY.

proc format;
   invalue age_pp
   ._-.z    = .
   low-13   = 0
   13<-high = 1;
run;

data class;
   set sashelp.class;
   pp_ny=input(age,age_pp.);
run;

3. Parenthèse sur les valeurs manquantes 

On a fait très attention de ne pas inclure les âges manquants pour définir PP_NY=1/0. La valeur .z est une valeur manquante spéciale "special missing". SAS en compte 27.

L'intérêt des valeurs manquantes spéciales : le but des special missings est d'offrir d'un éventail de valeurs pour distinguer les valeurs manquantes. Prenez le cas d'une variable indiquant le contraceptif médicamenteux pris par le patient. S'il s'agit d'une femme et que l'information n'est pas fournie, on mettra manquant (un point). Par contre, s'il s'agit d'un homme, on marquera .A pour "non applicable". Un format permettra ensuite de représenter . par MISSING et .A par N/A.

L'ordre des valeurs manquantes : l'ordre des missings et special missings est important à connaître. Cela vous expliquera pourquoi j'ai utiliser .z et non . dans l'exemple précédent. Vous pouvez vous reporter à la Online Doc : Missing Values. En résumé cela donne :

• ._ pour le plus petit,
• . juste après,
• .A
• ...
• .Z pour le plus grand des special missings
• valeurs négatives
• valeurs positives

Alternative avec la fonction MISSING : sachez qu'une autre solution pour exclure tous les valeurs manquantes (missing et special missing), c'est d'utiliser la fonction MISSING quia pour autre avantage de s'appliquer autant aux valeurs textes qu'aux valeurs numériques. C'est très pratique quand on ne connaît pas à l'avance le type de la variable. Dans la PROC SQL, WHERE... il y a aussi "WHERE x IS MISSING".

4. Plusieurs actions quand une condition est remplie (DO-END)

Si une condition est remplie, il peut s'avérer nécessaire de faire plusieurs choses. Par exemple, on peut à la fois créer une nouvelle variable et sortir la ligne d'observation.

Dans l'exemple ci-dessous, la variable SEX ne prend que les valeurs 'M' et 'F'. Dans ce cas précis, au final, il y a plus de records à la fin. Tout d'abord, tous les records sont extraits et POP est défini comme étant égal à 1. Ensuite, pour les records masculins, les records sont sortis une deuxième fois et notre variable POP est alors égale à 2.

data class;
   set sashelp.class;
   pop=1;
   output;
   if sex='M' then
     do;
        pop=2;
        output;
     end;
run;

1. Des variables continues

La moyenne et l'écart-type sont des outils s'appliquant uniquement aux données numériques, suivant un ordre donné où l'écart entre chacune des valeurs potentielles est toujours le même. On peut donc parler de valeurs continues au sens large du terme.

Ainsi, l'âge d'une personne est une donnée continue qu'elle soit arrondie en années, en mois, en jours, en heure. La moyenne et l'écart-type auront une précision similaire.

2. Définition l'écart-type d'une population

L'écart-type ayant pour but de chiffrer l'écart entre les valeurs  et la moyenne. Il est donc logique de calculer la différence entre chaque valeur et la moyenne. Dans un premier temps, on a autant de différences que de valeurs. Dans un second temps, une valeur moyenne est extraite de ces différences.

1. Mettre au carré les différences : qui dit moyenne, dit somme des valeurs divisé par le nombre de valeur. Hors, la somme de valeurs positives et négatives s'annulent. Et dans notre cas, on a bien des valeurs inférieures et des valeurs supérieures à la moyenne. Dans le cas de l'écart-type, toutes les différences sont rendues positives en les multipliant par elles-mêmes (mises au carré).

C'est probablement pour des faciliter la résolution de calculs mathématiques que la mise au carré est préféré à la prise des valeurs absolu. Si vous avez une autre hypothèse, n'hésitez pas à en faire part.

2. Extraire la moyenne : on souhaite une moyenne. Donc la somme des différences (mises au carré) sont divisées par le nombre de différences. Si on s'arrête là, la statistique s'appelle la variance.

3. Exprimer la dispersion dans la même unité que la moyenne : A présent la somme des différences n'est plus dans la même unité que la moyenne. Pour parler dans la même unité, on prend la racine de l'ensemble du calcul.

3. Estimer l'écart-type d'une population à partir d'un échantillon

Contexte : il est fréquent de ne pas travailler sur la population qui nous intéresse mais sur un échantillon. Par exemple, si on mesure la pression artérielle systolique des patients d'une étude clinique pour savoir si la drogue a permis de la réduire, le statisticien n'est pas intéressé par la moyenne de ces patients mais bien celle de tous les personnes pouvant à l'avenir faire appel à cette drogue.

Le problème : De plus, les recherches statistiques ont permis de démontrer qu'en moyenne, la moyenne de tous les échantillons possibles est la même que celle de la population. Pour l'écart-type, c'est un peu moins simple, puisqu'il la moyenne des écarts-types de tous les échantillons n'est pas exactement égale à celle de la population.

La solution : Mais les chercheurs en statistique sont là ! Ils ont réussi à montrer qu'en enlevant 1 au nombre total de valeurs dans chacun des échantillons, on pouvait retrouver l'écart-type de la population (cf. des cours d'inférence qui semble si théorique au prime abord mais qui permettent d'accéder à l'arrière de la scène).

Vocabulaire : Et pour enrichir votre vocabulaire et surtout comprendre ces spécialistes sachez que si l'écart-type sera appelé un estimateur biaisé si le 1 n'est pas enlevé.

L'écart-type le plus utilisé est donc le second, celui où on divise les différences non pas par le nombre de différences mais le nombre de différences moins 1.

4. Comprendre la différence entre l'écart-type et l'erreur-type

Pour ceux qui auront une formation à composante statistique, vous pourrez être amené à expliquer en entretien ou à vos collègues la différence entre l'écart-type (standard deviation) et l'erreur-type (standard error). 

La première différence, c'est que l'écart-type s'applique à des données, alors que l'erreur-type s'applique à la statistique de la moyenne. 

A chaque fois, qu'un échantillon est pris, sa moyenne va servir à estimer la moyenne de la population. Bien-sûr, toutes les moyennes des échantillons ne sont pas identiques. Il existe une variabilité. Certains sont plus proches de la réalité que d'autre. Cette variabilité des résultats entre les échantillons est donnée par l'erreur-type. Ainsi un intervalle à l'intérieur duquel la moyenne de la population se tient pourra être estimé.

5. En langage mathématique, l'écart-type donne quoi ?

Pour désigner nos valeurs, le mathématicien utilise la lettre X.

• Xi représente la ième valeur de l'échantillon. Si on a 15 valeurs alors i prend les valeurs de 1 à 15 ou plus généralement les valeurs de 1 à n.
• La moyenne de ces Xi est symbolisée par un X avec une barre au dessus.

Pour calculer l'écart-type, on a parlé de trois étapes :

1. sum(Xi-Xbar)2 Tout d'abord la différence entre chaque Xi et la moyenne X barre est calculée. Elles sont mises au carré. Puis, la somme de ces valeurs en est faite. On en profite pour préciser que les valeurs de i vont de 1 à n.
2. sum(Xi-Xbar)2 / (n-1) Après, il s'agit de calculer la moyenne de ces valeurs
3. racine(sum(Xi-Xbar)2 / (n-1)) Enfin, la statistique est convertie en une unité comparable à celle de la moyenne via la racine carré.

6. Et en langage SAS, comment trouver la valeur d'un écart-type ?

Dans tous les cas suivant, le dénominateur est n-1.

6.1 Fonction STD : La fonction STD (standard deviation) retourne la valeur de l'écart-type.

proc sql;
   select std(age) as std_age
   from sashelp.class;
quit;

6.2 Calcul manuel : dans un premier temps, la différence avec l'âge moyen est calculée pour chaque record. Chaque différence est mise au carré. Dans un deuxième temps, la somme de ces différences est divisée par le nombre de records moins 1. Enfin, la racine carrée du tout est prise.

proc sql;
   create table step1 as
      select (age-mean(age))**2 as step1
      from sashelp.class;
   select sqrt(sum(step1)/(count(*)-1)) as step2_3
      from step1;
quit;

6.3 Les procédures PROC MEANS et PROC SUMMARY : dans les exemples ci-dessous, j'ai volontairement choisi l'instruction ODS OUTPUT pour extraire les statistiques dans un data set.

proc means data=sashelp.class;
var age;
ods output Summary=proc_means;
run;

proc summary data=sashelp.class print;
   var age;
   ods output Summary=proc_summary;
run;

6.4 La procédure PROC UNIVARIATE : deux sorties fournies par la procédure UNIVARIATE sont indifféremment disponible.

proc univariate data=sashelp.class;
   var age;
   ods output Moments=proc_univ_opt1;
   ods output BasicMeasures=proc_univ_opt2;
run;

Pour développer une variable compteur, il faut maîtriser la notion de FIRST. Vous pouvez vous reporter à l'article "Repérer les 1ers/derniers records (FIRST/LAST)".

En outre, il faut comprendre la notion de RETAIN. Celle-ci sera abordée dans cet article.

Quatre exemples serviront à illustrer le sujet. Ils sont basés sur un data set nommé LAB ayant 9 lignes observations. Il est donné en fin d'article dans le paragraphe "Annexe". On y trouve trois patients (PAT_ID), deux types de tests médicaux (TEST) et une date pour chaque test (variable TEST_DT). La variable compteur s'appelle à chaque fois CNT.

 1. La notion de RETAIN

Un RETAIN permet d'assigner une valeur à toutes les observations d'une variable. On préfèrera donc un RETAIN à "variable=valeur;" pour assigner une valeur unique pour toutes les records d'une variable données. 

Si entre temps, la valeur d'une observation est modifiée, tous les valeurs suivantes prennent cette nouvelle valeur. Cette seconde fonctionnalité sert pour créer une variable compteur.

Un RETAIN se définit le plus souvent dans une instruction RETAIN. Dans le cas des compteurs, on peut créer un RETAIN implicite prenant une valeur d'origine de zéro.

2. Pour chaque nouvelle observation incrémenter le compteur : dans ce premier exemple, à chaque nouvelle observation identifiée de manière unique par PAT_ID, TEST_DT et TEST, le compteur est incrémenté par 1. Le compteur va alors de 1 à 9 (le total d'observations). Les données sont préalablement triées par ces trois variables.

  test_dt    pat_id    test    cnt

28MAR2006      101     DBP      1
28MAR2006      101     SBP      2
29APR2006      101     DBP      3
27MAY2006      101     SBP      4
23JUN2006      101     SBP      5
13JAN2006      301     DBP      6
14FEB2006      301     SBP      7
15MAR2006      301     DBP      8
05MAR2006      401     DBP      9

Il faut donc dans un premier temps trier les données et rappeler cet ordre dans l'instruction BY du data step.

proc sort data=lab;
   by pat_id test_dt test;
run;

Puis la variable CNT prend une valeur de 0 pour chaque record.

Enfin les records sont lus les uns après les autres. A chaque nouvelle TEST pour un PAT_ID et TEST_DT donné, le compteur est incrémenté de 1.

data lab;
   retain cnt 0;
   set lab;
   by pat_id test_dt test;
   if first.test then cnt=cnt+1;
run;

Un RETAIN implicite : l'instruction RETAIN peut-être omise si un RETAIN implicite est utilisé. C'est le cas ici quand "cnt=cnt+1" est remplacé par "cnt+1".

data lab;
   set lab;
   by pat_id test_dt test;
   if first.test then cnt+1;
run;

3. Pour chaque nouvelle date, incrémenter le compteur : dans le second exemple, pour chaque nouvelle date indépendamment du patient ou de type de test, le compteur est incrémenté par 1. Le compteur va de 1 à 8 (les 8 différentes dates). Les données sont triées par date au préalable.

  test_dt    pat_id    test    cnt

13JAN2006      301     DBP      1
14FEB2006      301     SBP      2
05MAR2006      401     DBP      3
15MAR2006      301     DBP      4
28MAR2006      101     SBP      5
28MAR2006      101     DBP      5
29APR2006      101     DBP      6
27MAY2006      101     SBP      7
23JUN2006      101     SBP      8

proc sort data=lab;
   by test_dt;
run;

data lab;
   set lab;
   by test_dt;
   if first.test_dt then cnt+1;
run;

4. Pour chaque nouveau patient, incrémenter le compteur : dans ce troisième exemple, chaque patient reçoit un numéro unique allant de 1 à 3 ; trois étant le nombre total de patients. Les données sont donc triées par PAT_ID.

   test_dt    pat_id    test    cnt

28MAR2006      101     SBP      1
28MAR2006      101     DBP      1
27MAY2006      101     SBP      1
23JUN2006      101     SBP      1
29APR2006      101     DBP      1
14FEB2006      301     SBP      2
13JAN2006      301     DBP      2
15MAR2006      301     DBP      2
05MAR2006      401     DBP      3

proc sort data=lab;
   by pat_id;
run;

data lab;
   set lab;
   by pat_id;
   if first.pat_id then cnt+1;
run;

5. Pour chaque nouveau date d'un patient donné, incrémenter le compteur : dans ce dernier exemple, à chaque nouvelle date, le compteur est incrémenté par un. Le premier patient ayant 4 dates différentes et 5 observations, le compteur va de 1 à 4 pour lui. Une des valeurs est doublée pour la date identique. Le second patient ayant trois dates uniques, le compteur va de 1 à 3 pour lui. Le compteur est donc réinitialisé à 1 pour chaque nouveau patient.

  test_dt    pat_id    test    cnt

28MAR2006      101     SBP      1
28MAR2006      101     DBP      1
29APR2006      101     DBP      2
27MAY2006      101     SBP      3
23JUN2006      101     SBP      4
13JAN2006      301     DBP      1
14FEB2006      301     SBP      2
15MAR2006      301     DBP      3
05MAR2006      401     DBP      1

proc sort data=lab;
   by pat_id test_dt;
run;

data one;
   set orig;
   by pat_id test_dt;
   if first.pat_id then cnt=1;
   else if first.test_dt then cnt+1;
run;

Annexe :

data orig;
   format test_dt date9.;
   input pat_id test_dt date9. test_type $;
   datalines;
101 28MAR2006 SBP
101 28MAR2006 DBP
101 27MAY2006 SBP
101 23JUN2006 SBP
301 14FEB2006 SBP
101 29APR2006 DBP
301 13JAN2006 DBP
301 15MAR2006 DBP
401 05MAR2006 DBP
;
run;

• /bin (binarios): Los binarios son los ejecutables de Linux. Aquí tendremos los ejecutables de los programas propios del sistema operativo, entre ellos comandos como cp, mv, cat, chown, etc. No es el único directorio que contiene ejecutables como veremos más adelante.

• /boot (arranque): Aquí nos encontramos los archivos necesarios para el inicio del sistema, desde los archivos de configuración de Grub Lilo, hasta el propio kernel del sistema.

• /dev (dispositivos): Linux se basa en la simpleza y en el tratamiento homogéneo de la información. Linux trata los dispositivos como si fueran un fichero más para facilitar el flujo de la información. En esta carpeta tenéis los dispositivos del sistema, por ejemplo los usb, sda (o hda) con sus respectivos números que indican las particiones, etc.

• /etc (etcétera): Aquí se guardan los ficheros de configuración de los programas instalados, así como ciertos scripts que se ejecutan en el inicio del sistema. Los valores de estos ficheros de configuración pueden ser complementados o sustituidos por los ficheros de configuración de usuario que cada uno tiene en su respectivo “home” (carpeta personal).

• /home (hogar): Este hogar no es más que un directorio que a su vez contiene otros, uno por cada usuario dado de alta en el sistema. Dentro de dichos directorios es donde el usuario tiene su carpeta personal, donde están los ficheros de configuración de usuario, así como los archivos personales del mismo que puede crear, modificar y eliminar bajo su propio criterio.

• /lib (bibliotecas): Contiene las bibliotecas (tambien mal conocidas como librerías) del sistema, así como módulos y controladores (drivers).

• /lost+found (perdido y encontrado): Es una carpeta que nos podemos encontrar en todas las particiones. Cuando por cualquier circunstancia se cierra mal el sistema (un apagón por ejemplo), cuando éste se reinicie comprobaréis que se llamará al programa fsck para restaurar la integridad del sistema de ficheros. En esta carpeta encontraremos la información que se mal-guardó debido a la incidencia.

• /media (media/medios): Es donde se montan las unidades extraíbles como los dispositivos USB, disqueteras, unidades de CD/DVD y en algunas distros, como Ubuntu, las particiones adicionales.

• /mnt (montajes): Es un directorio que se suele usar para montajes temporales de unidades.

• /opt (opcionales): Destinado para guardar paquetes adicionales de aplicaciones.

• /proc: Información para la virtualización del sistema de ficheros de Linux.

• /root: Es el /home del administrador. Es el único /home que no está incluido -por defecto- en el directorio anteriormente mencionado.

• /sbin (binarios de sistema): Son los ejecutables de administración, tales como mount, umount, shutdown…

• /srv (servicios): Información del sistema sobre ciertos servicios que ofrece (FTP, HTTP…).

• /sys (sistema): Información sobre los dispositivos tal y como los ve el kernel Linux.

• /tmp (temporales): Es un directorio donde se almacenan ficheros temporales. Cada vez que se inicia el sistema este directorio se limpia.

• /usr: Es el directorio padre de otros subdirectorios de importancia:
  • /usr/bin: Conjunto de ejecutables de la mayoría de aplicaciones de escritorio entre otras (por ejemplo firefox).
  • /usr/include: Los ficheros cabeceras para C y C++.
  • /usr/lib: Las bibliotecas para C y C++.
  • /usr/local: Es otro nivel dentro que ofrece una jerarquía parecida al propio diretorio /usr.
  • /usr/sbin: Otra serie de comandos administrativos para el sistema.
  • /usr/share: Archivos compartidos como ficheros de configuración, imágenes, iconos, etc.
  • /usr/src: Tiene en su interior el código fuente para el kernel LInux.

• var: Ficheros de sistema como el buffer de impresión, logs…
  • /var/cache: Se almacenan datos cacheados para las aplicaciones.
  • /var/lib: Información sobre el estado actual de las aplicaciones, modificable por las propias aplicaciones.
  • /var/lock: Ficheros que se encargan de que un recurso sólo sea usado por una aplicación determinada que ha pedido su exclusividad, hasta que ésta lo libere.
  • /var/log: Es uno de los subdirectorios más importantes ya que aquí se guardan todo tipo de logs del sistema.
  • /var/mail: Los correos de los usuarios.
  • /var/opt: Datos usados por los paquetes almacenados en /opt.
  • /var/run: Información sobre el sistema desde que se inició.
  • /var/spool: Datos esperando a que sean tratados por algún tipo de proceso.
  • /var/tmp: Otro fichero temporal.

1. Passer par un data step pour ajouter une ou plusieurs observations

L'instruction SET dispose de l'option END=. Celle-ci permet de définir une nouvelle variable. On peut s'imaginer cette variable comme une variable binaire prenant une valeur zéro pour toutes les observations sauf la dernière. Il est courant de nommer cette variable EOF, acronyme pour END OF FILE (fin de fichier).

Dans un premier temps, toutes les observations sont lues et envoyées dans le data set de sortie avec OUTPUT.

Dans un second temps, on précise à SAS que si notre variable binaire a une valeur de 1, l'observation va être de nouveau envoyée dans le data set final après avoir changé les valeurs de son choix.

Lorsque la valeur prise par la variable binaire n'est pas précisée (if eof then...), SAS assume 'if eof=1 then...' ou en d'autres termes 'si la condition est vraie alors...'. Pour information, l'inverse est 'if not eof then...' ou 'if eof=0 then...'.

data class;
   set sashelp.class end=eof;
   output;
   if eof then
      do;
         name='SASREF';
         sex='F';
         age=18;
         height=.;
         weight=100;
         output;
         name='SASREF';
         sex='M';
         age=.;
         height=.;
         weight=.;
         output;
      end;
run;

Cette méthode reste très contraignante. Car il faut redéfinir tous les champs au risque sinon d'avoir une valeur de l'ancienne observation. La procédure SQL est véritablement conçue pour répondre à notre besoin.

2. L'instruction INSERT de la procédure PROC SQL

Deux syntaxes sont disponibles avec l'instruction INSERT selon qu'on liste seulement les valeurs, mais pour toutes les variables ou qu'on liste à la fois les variables et leur valeurs mais seulement celles qui nous intéresse.

Ma préférence va à la seconde solution, car elle évite des erreurs dans l'ordre d'affichage des valeurs. De plus, lorsqu'on relit un programme, il est facile de faire le lien entre une valeur et la variable à laquelle elle réfère.

 2.1 Lister toutes les va