Posts Tagged ‘langage’

h1

La fonction CATQ pour concaténer tout en ajoutant des guillemets avec SAS 9.3 et plus

février 23, 2019

La fonction catq est disponible depuis SAS 9.3. La particularité de cette fonction est de pouvoir ajouter des guillemets simples (single quotes) ou des guillemets doubles (double quotes) autour des différentes valeurs à concaténer.

Un des avantages de la fonction catq est de pouvoir travailler autant avec les valeurs numériques qu’avec les valeurs caractères. On fera néanmoins attention aux valeurs infinies comme 1/3.

Exemple 1

data catq;
    x=catq('1' ,'ABC ',2," EFG",' ');
    put x=;

    x=catq('2' ,'ABC ',2," EFG",' ');
    put x=;
run;

Dans ce premier exemple, on voit que le 1 permet d’ajouter des guillemets simples alors que le deux permet d’ajouter des guillemets doubles. Dans le cas présent, seules les valeurs caractères ont des guillemets.

x='ABC ' 2 ' EFG' ' '
 x="ABC " 2 " EFG" " "

Exemple 2

data catq;
   x=catq('1'     ,'ABC ',2," EFG",' '); 
   put x=;

   x=catq('1a'    ,'ABC ',2," EFG",' '); 
   put x=;
 
   x=catq('1c'    ,'ABC ',2," EFG",' '); 
   put x=;
   
   x=catq('1ac'    ,'ABC ',2," EFG",' '); 
   put x=;
run;

Dans ce second exemple, on voit que la lettre a pour que toutes les valeurs soient entre guillemets, y compris les valeurs numériques.

Si on souhaite ajouter la virgule (comma) entre les différentes valeurs à concaténer avec la lettre c, il faudra impérativement garder la lettre a.

 x='ABC ' 2 ' EFG' ' '
 x='ABC ' '2' ' EFG' ' '
 x=ABC ,2, EFG,
 x='ABC ','2',' EFG',' '

Exemple 3

Une autre manière d’ajouter la virgule comme séparateur entre les valeurs est d’utiliser la lettre d (delimiter) et de préciser le séparateur dans le second argument de la fonction ; cet argument est optionnel et ne servira qu’avec la lettre d.

data catq;
   x=catq('c','ABC ',2," EFG",' '); 
   put x=;

   x=catq('d',',','ABC ',2," EFG",' '); 
   put x= /;
  
   x=catq('1ac','ABC ',2," EFG",' '); 
   put x=;

   x=catq('1ad',',','ABC ',2," EFG",' '); 
   put x=;
run;

Nous obtenons le même résultat qu’on utilise c ou d avec l’argument optionnel. La lettre d offre juste plus de possibilités.

 x=ABC ,2, EFG,
 x=ABC ,2, EFG,
 x='ABC ','2',' EFG',' '
 x='ABC ','2',' EFG',' '

Exemple 4

Lorsqu’on n’a pas besoin des guillemets autour des différentes valeurs à concaténer, la fonction catq se rapproche de la fonction catx.

data catq;  
   x=catq('d',',','ABC ',2," EFG",' '); 
   put x=/;
   
   x=catq('ds',',','ABC ',2," EFG",' '); 
   put x=;
   
   x=catx(',','ABC ',2," EFG",' ');
   put x=/;
   
   x=catq('dt',',','ABC ',2," EFG",' '); 
   put x=;
run;

Pour enlever les leading et trailing blanks avec la fonction catq, on ajoutera la lettre s (strip).
Pour uniquement enlever les trailing blanks avec la fonction catq, on ajoutera la lettre t (trim).

 x=ABC ,2, EFG,
 x=ABC,2,EFG
 x=ABC,2,EFG
 x=ABC,2, EFG

Aller plus loin

La fonction dispose d’autres arguments pour travailler avec les literals (lettre n), pour afficher les valeurs en hexadecimal (lettre x), pour utiliser une tabulation horizontale comme séparateur (lettre h), etc.
Toutes les informations sont disponibles dans la documentation en ligne : http://support.sas.com/documentation/cdl/en/lefunctionsref/63354/HTML/default/viewer.htm

 

À lire aussi


				
h1

SAS : obtenez des couleurs sympas dans vos rapports en 5 minutes

août 20, 2018

h1

Une petite histoire de macro : compter le nombre de mots dans un paramètre de macro

avril 11, 2010

Il est courant de devoir compter le nombre de mots dans un paramètre de macro. Il est par exemple possible de vouloir créer une boucle pour travailler chacun des termes contenu dans cette macro de manière séparée.

Voici donc l’histoire d’une mini macro qu’on nommera CNT_WRD qui crée une macro variable TOT_WRD renvoyant le nombre de mots contenu dans le paramètre TXT.

Ceci est pour vous l’occasion de voir ou revoir un raisonnement possible dans la construction d’une macro sous SAS.

1. Préciser ses besoins, une rapide « spécification »

La macro CNT_WRD composée d’un seul paramètre retournera dans une macro variable TOT_WRD le nombre de mots contenus dans le texte donné dans le paramètre de macro.

Ici on considérera comme mot, tout terme séparé par au moins un blanc.

Si le paramètre de macro est vide, la macro ne devra pas afficher de message d’erreur et la macro variable TOT_WRD sera égale à 1. Par défaut, aucune valeur ne sera entrée dans le paramètre TXT.

La macro variable doit pouvoir être utilisable à l’extérieur de la macro (macro variable globale).

2. Tester la fonction COUNT dans une étape data

La fonction COUNT permet de comptabiliser certains caractères et donc de répondre à ce type de besoin. En fait, cette fonction ne compte pas le nombre de mots mais compte le nombre de caractères définis par le second élément dans la fonction; dans notre cas, elle comptera le nombre de blancs. Il faut donc ajouter 1 au total.

Voici un exemple dans une étape data.

data _null_;
tot_wrd=1+count(‘mot1 mot2’,‘ ‘);
put tot_wrd=;
run;

Dans la log, vous pouvez voir que cnt_wrd=2.

Mais cela ne suffit pas pour gérer les blancs multiples et les blancs aux extrémités. Car si vous avez plus d’un blanc entre chaque mot, chacun sera compté. Il faut donc les enlever au préalable (avec la fonction COMPBL ici). Les blancs de début et fin peuvent s’enlever au moyen de la fonction STRIP.

data _null_;
tot_wrd=1+count(strip(compbl(‘ mot1 mot2 ‘)),‘ ‘);
put tot_wrd=;
run;

Mais que ce passe t-il si notre texte à compter est vide ? TOT_WRD sera égal à 1. Il faut donc ajouter le 1 au total que si le texte à analyser n’est pas vide.

data _null_;
length txt $200;
txt=;
if txt ne ‘ ‘ then tot_wrd=1+count(strip(compbl(txt)),‘ ‘);
put tot_wrd=;
run;

3. Créer la macro

Comme indiqué dans le dernier point, on travaille ici de manière conditionnelle. Si le paramètre de macro TXT est vide, la macro variable CNT_WRD nouvellement créée prend la valeur zéro. Sinon, On passe par la fonction COUNT.

Comme il n’existe pas d’équivalent aux fonctions COUNT et COMPBL en langage macro, il faut encadrer chacune d’elle dans une fonction macro SYSFUNC.

Ici on notera que la fonction STRIP n’apparaît pas. Les blancs de début et de fin en langage macro n’ont aucun impact.

%macro cnt_wrd(txt=);

%global tot_word;

%if &txt.= %then %let tot_wrd=0;
%else %let tot_wrd=%eval(1+%sysfunc(count(%sysfunc(compbl(&txt.)),%str( ))));

%mend cnt_wrd;

Pour représenter un blanc dans une étape data, il suffit d’utiliser des guillemets. En langage macro, on fait appel à la fonction %STR(). Il faudra ne pas oublier d’ajouter un blanc entre les parenthèses.

Afin d’ajouter 1 au résultat de la fonction COUNT, il faut utiliser la macro fonction %EVAL. Le contenu des macro variables sont sinon tous interprétés comme du texte, qu’il s’agisse de nombres ou pas.

Enfin, pour que cette macro variable TOT_WRD soit utilisable en dehors de la macro, il faut qu’elle soit globale. Hors par défaut, une macro variable créée dans une macro est locale, c’est-à-dire n’existe que le temps de la macro. L’instruction %GLOBAL TOT_WRD; résouds le problème.

4. Tester la macro dans le cadre de sa validation

Que se passe t-il quand on ne change pas la valeur par défaut du paramètre de macro ?

%cnt_wrd;
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand le paramètre de macro TXT est vide de texte ?
%put Valeur de TOT_WRD: &tot_wrd;

%cnt_wrd(txt=);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il lorsqu’il n’y a qu’un mot?

%cnt_wrd(txt=mot1);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand il y a plusieurs mots ?

%cnt_wrd(txt=mot1 mot2 mot3);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand il y a des blancs multiples entre les mots, en début et à la fin ?

%cnt_wrd(txt= mot1 mot2 mot3 );
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand il y a des blancs multiples entre les mots, en début et à la fin ?

%cnt_wrd(txt=mot1 mot2);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand la macro est appelée plusieurs fois ?

%cnt_wrd(txt=mot1 mot2);
%put Valeur de TOT_WRD: &tot_wrd;
%cnt_wrd(txt=mot1);
%put Valeur de TOT_WRD: &tot_wrd;

Lecture complémentaire

h1

Protégé : Newsletter Juin : Exercice

juin 1, 2009

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

h1

Sauvegarder une résolution de macro dans un fichier externe (l’option MFILE)

février 2, 2009

Le programme SAS généré par un appel de macro peut être sauvegardé dans un fichier externe grâce à l’option globale MFILE. Quel est l’intérêt ? Comment concrètement cela se programme t-il ?A quoi ressemble le résultat ? C’est ce que je vous propose de découvrir dans cet article.

1. Quel est l’intérêt de sauvegarder le code généré par une macro?

  • La résolution d’une macro dans la log avec l’option globale MPRINT est agrémenté d’information cachant le cœur du programme. Un accès au programme seul facilite la lisibilité.
  • Extraire le code permet de l’exécuter morceau par morceau afin de s’assurer que la demande faite à SAS correspond à ses attentes et éventuellement trouver la cause d’un problème (to debug).

Le même type d’approche est possible avec un programme généré dans un DATA _NULL_.

2. Un exemple pour créer une étape data avec six instructions similaires

Dans cet exemple, le langage macro est utilisé pour générer six instructions dans une étape data au moyen d’une boucle.

A chaque nouvelle instruction une nouvelle variable est créée.

  • Elle contient un nombre aléatoire extrait au moyen de la fonction RANUNI et sa racine variant de 1 à 6.
  • Cette valeur est multipliée par 49 dans un premier temps.
  • La valeur entière inférieure est gardée dans un second temps au moyen de la fonction FLOOR.
options mprint mfile;
filename mprint 'C:/sasref/eg_mfile.sas';
%macro eg_mfile;
   data test;
      %do i=1 %to 6;
      var&i. = floor(ranuni(&i.)*49);
      %end;
   run;
%mend eg_mfile;
%eg_mfile;

2 points à respecter : On prendra bien soin de garder l’option MPRINT dans l’instruction OPTIONS et d’utiliser MPRINT comme nom de FILENAME.

3. Visualiser le contenu du fichier EG_MFILE.SAS

Le fichier EG_MFILE.SAS contient le contenu suivant :

data test;
var1 = floor(ranuni(1)*49);
var2 = floor(ranuni(2)*49);
var3 = floor(ranuni(3)*49);
var4 = floor(ranuni(4)*49);
var5 = floor(ranuni(5)*49);
var6 = floor(ranuni(6)*49);
run;

 Alors que la log, elle, contient des informations supplémentaires exploitables beaucoup moins rapidement.

MPRINT(EG_MFILE):   data test;
MPRINT(EG_MFILE):   var1 = floor(ranuni(1)*49);
MPRINT(EG_MFILE):   var2 = floor(ranuni(2)*49);
MPRINT(EG_MFILE):   var3 = floor(ranuni(3)*49);
MPRINT(EG_MFILE):   var4 = floor(ranuni(4)*49);
MPRINT(EG_MFILE):   var5 = floor(ranuni(5)*49);
MPRINT(EG_MFILE):   var6 = floor(ranuni(6)*49);
MPRINT(EG_MFILE):   run;

Source : redscope.info/node/584 (ce site n’existe plus)

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;