Archive for the ‘put’ Category

h1

La 3ème méthode qui fait la différence pour sélectionner en se basant sur une second data set

février 16, 2009

Suite au précieux conseil d’Arnaud Gaborit (A.I.D.), je vous propose de compléter l’article du 26 janvier dernier intitulé « Deux méthodes pour sélectionner en se basant sur une second data set« . Les personnes travaillant sur de grosses bases de données apprécieront.

Lectures complémentaires :

1. Rappel : les données et le résultat attendu

D’un côté, on a un data set contenant la liste des effets secondaires observés. Il y a une ligne par effet secondaire. Seuls les patients ayant eu un effet secondaire sont enregistrés.

data ae_multi;
   input patref ae_id;
   datalines;
1 1
1 2
2 1
4 1
4 2
5 1
;
run;

De l’autre côté, on a la liste des patients correspondant à la population qui nous intéresse. Une ligne correspond à un patient.

data pat_uniq;
   input patref;
   datalines;
2
3
4
;
run;

Le but est de garder uniquement les effets secondaires des patients présents dans notre population.

patref ae_id

   2     1
   4     1
   4     2

2. Créer un format à partir d’un data set

Dans une premier temps, un format numérique (TYPE=N est la valeur par défaut) appelé PATREF (FMTNAME=’PATREF’) est créé à partir du data set sur les patients. La variable PATREF sert de valeur START. Pour toutes les valeurs de START, on applique le même libellé (LABEL=’retenir’).

Si le data set contient plusieurs variables (ce qui sera généralement le case), l’option KEEP servira à limiter la sélection à la variable servant à définir START.

data pat (keep=start fmtname label);
   set pat_uniq (rename=(patref=start)); *(keep=patref);
   fmtname='PATREF';
   label='retenir';
run;

Si plusieurs valeurs identiques pour la variable START sont présentes dans votre fichier, vous devrez supprimer les doublons. L’étape suivante ne marchera pas sinon.

*proc sort data=pat nodupkey;
*by start;
*run;

Le data set est à présent convertit en format au moyen de l’option CNTLIN. Ce format est sauvegardé par défaut dans le catalogue FORMATS de la bibliothèque WORK.

proc format cntlin=pat;
run;

3. Sélectionner les observations de son choix

Ici, l’option WHERE est privilégiée à l’instruction IF pour des raisons de performance.

Ensuite, grâce à la fonction PUT, les valeurs de PATREF sont converties en RETENIR si elles sont présentes dans le data set PAT_UNIQ. Seules ces valeurs RETENIR sont gardées.

data ae_multi;
   set ae_multi (where=(put(patref,patref.) = 'retenir'));
run;

Voir le résultat :

proc print data=ae_multi;
run;
h1

Afficher 7h30 du matin sous la forme 07:30

octobre 24, 2008

Les heures, minutes et secondes sont enregistrables sous SAS sous la forme d’un seul chiffre exprimant cette durée en seconde. On parle d’heure SAS (SAS time). A l’affichage, il y a le format TIME5. pour représenter les heures et les minutes uniquement à partir de 5 caractères au maximum. Mais ce format omet le zéro de début pour les heures à un chiffre comme 9h00. Voici donc dans cet article plusieurs solutions pour contourner le problème allant d’un format avec PICTURE, en passant par les fonctions RIGHT et TRANWORD.

1. Le data set servant d’exemple

Pour présenter les variantes, un data set NEWTIME est créé. Il contient une variable SEC avec 4 valeurs exprimant le temps en secondes et une valeur manquante.

  • 7h30 : prenons 7h30m00s ou 27000 secondes (7x60x60*60) pour exprimer 7h30 du matin
  • 15h : prenons maintenant 15h00m00s ou 54000 secondes pour obtenir 15h
  • 14h59 : pour désigner 14h59, des valeurs entre 14h59m00s (53940 sec) et 14h59m59s (53999 sec) sont possibles. Dans l’exemple, ces deux extrêmités sont choisies.
data newtime;
   input sec;
   datalines;
27000
54000
53940
53999
.
;
run;

2. Un format créé avec l’instruction PICTURE

La solution la plus flexible est probablement de créer un nouveau format. De cette manière, la valeur d’origine en seconde est encore disponible. Ce format peut aussi servir à convertir une variable caractère en heure SAS.

L’instruction PICTURE : Le format SASREF est construit à partir de l’instruction PICTURE dans une procédure PROC FORMAT. Le symbole %H réfère à des heures allant de 0h à 23h. Le symbole %M désigne des minutes allant de 0min à 59min. Le zéro intercalé ajoutera un zéro pour les valeurs inférieures à 10.

Documentation : Vous pouvez consulter la documentation en ligne pour connaître tous les symbole comme %M, %H disponible avec l’instruction PICTURE : PICTURE Statement.

proc format;
   picture sasref other='%0H:%0M' (datatype=time);
run;

Dans cet exemple, une variable caractère TIME_C est créée à partir de la fonction PUT et du format SASREF affichant 5 caractères.

Vous pouvez aussi exécuter l’instruction FORMAT pour appliquer le format SASREF5. à la variable SEC.

data newtime;
   set newtime;
   time_c=put(sec,sasref5.);
   *format sec sasref5.;
run;

3. Ajouter une condition pour traiter les valeurs manquantes

Une seconde variable TIME_C2 applique une contrainte particulière pour les valeurs manquantes. En effet, le format SASREF renvoie le mot ERROR si la valeur d’origine est manquante.

data newtime;
   set newtime;
   if not missing (sec) then time_c2=put(t1,sasref5.);
run;

4. Passer d’une valeur texte 7:30 à une valeur 07:30 avec les fonctions RIGHT et TRANWRD

Une troisième variable TIME_C3 est construite en deux étapes. Voyons donc l’interprétation faite pour une heure comme 7:30.

  • Fonction PUT et format TIME5 pour créer une valeur 7:30 : Tout d’abord, la fonction PUT combinée au format TIME5. crée une variable caractère de la forme 7:30 avec une longueur de 5. Par défaut, le texte est aligné à gauche. Le blanc est donc situé en 5ème position.
  • Fonctions RIGHT et TRANWORD pour ajouter un blanc en tête : Ensuite, une variable caractère 7:30 est convertie en 07:30, etc. Dans un premier temps, la fonction RIGHT aligne le texte à droite. Le blanc est en première position. Dans un second temps, la fonction TRANWRD remplace le blanc par un zéro.
data newtime;
   set newtime;
   if not missing (sec) 
   then time_c3=tranwrd(right(put(sec,time5.),' ','0');
run;

LA documentation en ligne propose une page sur les fonctions TRANWORD et RIGHT.

  • TRANWORD Function
  • RIGHT Function

Vous pouvez aussi consultez l’article sur la fonction PUT :

5. Aperçu des données

Voici un aperçu des différentes variables après :

sec     time_c time_c2 time_c3

27000   07:30   07:30   07:30
53940   14:59   14:59   14:59
53999   14:59   14:59   14:59
54000   15:00   15:00   15:00
    .   ERROR
h1

Ajouter des indentations dans un tableau

octobre 20, 2008

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 :

h1

Quand compilation et exécution font la différence, un exemple

août 21, 2008

SAS effectue plusieurs lectures d’un programme. A la première lecture, c’est la compilation. A la seconde, c’est l’exécution. Connaître ces notions vous aidera à comprendre les exemples ci-dessous : pourquoi le premier code proposé ne fonctionne pas alors que les autres passent. Les fonctions PUT, VVALUE, le dictionnaire DICTIONARY.COLUMNS et le DATA _NULL_ serviront dans les exemples.

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.

h1

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

août 13, 2008

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;

h1

Convertir une variable caractère en numérique et inversement

avril 21, 2008

Cet article est maintenant réécrit. Vous le retrouvez sur www.programmeur-pro.com.

Passer d’une variable numérique à une variable caractère ou inversement est fréquent en langage de programmation SAS. Les fonctions INPUT et PUT permettent de changer ainsi le type de la variable. Dans un premier temps, je vous propose deux exemples pour illustrer les deux situations. Dans un second temps, on verra deux emplois supplémentaires de la fonction PUT : ajouter des zéros avant et après le nombre, et passer d’une valeur caractère à une autre valeur caractère.

Exemples d’application : dans la vie courante, il est fréquent de créer une variable texte à partir de plusieurs autres. Dans le lot, il y a souvent une variable numérique. Celle-ci doit être convertie en texte avant la concaténation. A l’inverse, on peut vouloir extraire le chiffre d’une chaîne de caractère et le sauvegarder dans une variable numérique.

Note : Dans un data step, on est obligé de créer de donner un nom différent à la variable d’origine et à la nouvelle variable. Il est alors courant de renommer au préalable la variable d’origine pour pouvoir utiliser son nom pour la nouvelle variable. Ensuite, la variable d’origine est supprimée. Dans une procédure SQL, le même nom peut être utilisé.

1. Du caractère au numérique et inversement

La fonction INPUT est composée de deux paramètres : la variable texte ou directement la chaîne de caractère d’un côté, l’informat de l’autre.

Du caractère au numérique : ici, on indique à la machine qu’il faut lire la variable d’origine comme une variable texte pouvant atteindre une longueur de 16 caractères. Pour cela on utilise l’informat $16. On peut aussi choisir un informat $CHAR. : ici $CHAR16. (SAS Online Doc. : INPUT Function, Informats by Category)

data char_to_num;
  x_char = ‘123456789.123456’;
  x_num = input(x_char,$16.);
*x_num = 123456789.123456;
run;

Note : Pensez à ajouter un format sur la variable numérique si vous ne la lisez pas intégralement dans votre output.

Du numérique au caractère : dans l’exemple ci-dessous, on indique que la valeur à créer sera numérique avec 16 chiffres/point dont 6 après la virgule. C’est l’information donnée par le format numérique 16.6. Bien sûr, on peut avoir la longueur nombre à convertir peut-être plus petit sans risquer d’affecter la valeur. Une autre possibilité est d’utiliser le format BEST16. Si aucun nombre n’est précisé (BEST.) cela revient à BEST8. SAS cherche alors la meilleure réponse possible permettant d’entrer 8 chiffres/point. Les décimales pourront être tronquées s’il n’y a pas assez de place, voir les entiers.

data num_to_char;
  y_num = 123456789.123456;
  y_char = put(y_num,16.6);
*y_char = ‘123456789.123456’;
run;

2. Les plus de la fonction PUT

Ajouter des zéros aux extrémités du nouveau texte : le format z. permet de remplacer les espaces vides par des zéros. Dans l’exemple ci-dessous, la nouvelle variable aura une longueur de 8 caractères. Les deux derniers seront les chiffres après la virgule. Comme il n’y en a qu’un seul dans la variable d’origine, un zéro sera ajouté à la fin. Il reste deux espaces en début à remplir avec des zéros.

data num_char_zero;
   z_num = 123.1;
   z_char = put(z_num,z8.2);
  *z_char = ‘00123.10’;
run;

Passer d’une valeur caractère à une autre : la valeur caractère d’origine peut aussi être du texte et non des chiffres. Dans cette situation, la nouvelle variable prend la valeur d’un format caractère souvent défini par le programmeur.

proc format;
  value $cntry
  FR = ‘France’
  LU = ‘Luxembourg’
  CH = ‘Suisse’;
run;

data char_to_char;
  a1_char=’LU’;
  a2_char=put(a1_char,$cntry.);
  *a2_char=’Luxembourg’;
run;

h1

Arrondir ses chiffres avant d’appliquer un format

mars 31, 2008

Gérer l’affichage des pourcentages et des décimales avec SAS : tel est la thématique de cet article. Les formats permettent de présenter les données d’une manière un peu plus élégante et parlante. On peut ainsi n’afficher que les deux derniers chiffres après la virgule, ajouter un symbole pourcentage. Mais les formats vont couper le chiffre plutôt que l’arrondir si PICTURE avec l’option ROUND n’est pas utilisé.

1. Arrondir un nombre avec la fonction ROUND : la fonction ROUND permet d’arrondir les nombres soit à la décimale près soit à l’entier (ou son multiple) près. La fonction dispose de deux paramètres : la variable d’origine et la précision de l’arrondi.

Arrondir à deux chiffres après la virgule :

x1= round (orig,0.01);

Arrondir tous les 10 :

x1= round (orig,10);

Ainsi dans le premier exemple, si ORIG=17.016, l’arrondi au centième (X1) est égal à 17.02. Dans le second cas, l’arrondi (X2) = 20.

2. Créer un PICTURE format : l’instruction PICTURE est très pratique pour afficher les formats dans un rapport.

Dans l’exemple qui suit, le nombre aura au maximum trois chiffres pour la partie entière et deux chiffres pour la partie décimale. Si la partie entière n’a qu’un chiffre, seul celui-ci apparaîtra. Remplacez le 0 des dizaines par un 9 et le chiffre zéro précédera le pourcentage s’il est inférieur à 10 %.

proc format;
picture pct
low-high=‘009.99 %’;
run;

Cette syntaxe dispose de l’option ROUND. C’est très pratique pour à la fois arrondir un chiffre, apposer un symbole % et avoir un zéro pour les chiffres après la virgule quand le chiffre n’est pas entre 1 et 9.

proc format;
picture pct_rd (round)
low-high=‘009.99 %’;
run;

3. Créer un texte avec un pourcentage arrondi à deux décimales : le code qui suit utilise 4 valeurs pour illustrer la différence entre la fonction ROUND, le FORMAT.

orig     fmt     rnd   solution1 solution2

21.200  21.20 %  21.20   21.20 %   21.20 %
6.333   6.33 %   6.33    6.33 %    6.33 %
84.367  84.36 % 84.37   84.37 %   84.37 %
13.362  13.36 %  13.36   13.36 %   13.36 %

data rnd_fmt;
set rnd_fmt;
fmt       = put(orig,pct.);
rnd       = round(orig,0.01);
solution1 = put(round(orig,0.01),pct.);
solution2 = put(orig,pct_rd.);
run;

Annexe :

data rnd_fmt;
input orig;
datalines;
21.200
6.333
84.367
13.362
;
run;