Archive for the ‘Conditions’ Category

h1

Enlever les balises HTML d’un texte (do while et do until)

mai 18, 2009

Les balises HTML sont des mots entourés de < et > servant à la mise en forme de pages Internet. Dans l’exemple qui suit le but est d’enlever avec SAS des balises HTML contenues dans une variable appelée DESCRIP au moyen d’une boucle.  Cet exemple, basé sur un cas réel, permettra d’illustrer la syntaxe de DO UNTIL et de DO WHILE.

1. La fonction SUBSTR pour enlever un symbole <…>

Pour enlever une balise, je choisis ici de remplacer la chaîne commencant par < et se terminannat par > au moyen de la fonction SUBSTR. Pour ce faire,

  • paramètre 1 : donner le nom de la variable en premier
  • paramètre 2 : préciser la position du symbole < en second 
  • paramètre 3 : donner la longueur du texte en calculant le nombre de caractères entre ce symbole de début de balise et celui de fin (position de su symbole de fin > – position du symbole de début < + 1).

data no_tag (drop=tag:);
   descrip=‘<p>my text</p>’;
   tag_start = index(descrip,‘<‘);
   tag_end   = index(descrip,‘>’);
   substr(descrip,tag_start,tag_end-tag_start+1)=‘ ‘;
run;

Ici le texte à mettre à jour est <p>my text</p>. Cette première étape data remplace la première balise et seulement la première. Pour des raisons de lisibilité, j’ai choisi de créer deux variables intermédiaires qui retourne la position de < (variable TAG_START) et de > (TAG_END) au moyen de la fonction INDEX.

En fin d’étape data, toutes les variables dont le nom commence par TAG sont supprimée grâce à l’option DROP.

2. Répéter l’opération au moyen d’une boucle DO UNTIL

A chaque exécution de la boucle la variable DESCRIP est mise à jour : une balise <…> est enlevée.

La boucle sera exécutée jusqu’à ce qu’aucun symbole < ne soit identifié. En d’autres termes, la boucle sera exécutée jusqu’à ce que la fonction INDEX retourne la valeur zéro.

data no_tag (drop=tag:);
   descrip=‘<p>my text</p>’;
   do until(index(descrip,‘<‘)=0);
      tag_start = index(descrip,‘<‘);
      tag_end   = index(descrip,‘>’);
      substr(descrip,tag_start,tag_end-tag_start+1)=’ ‘;
   end;
run;

3. Répéter l’opération au moyen d’une boucle DO WHILE

A chaque exécution de la boucle la variable DESCRIP est mise à jour : une balise <…> est enlevée.

La boucle sera exécutée tant qu’un symbole < sera identifié. En d’autres termes, la boucle sera exécutée tant que la fonction INDEX ne retournera pas la valeur zéro.

data no_tag (drop=tag:);
   descrip=‘<p>my text</p>’;
   do while(index(descrip,‘<‘) ne 0);
      tag_start = index(descrip,‘<‘);
      tag_end = index(descrip,‘>’);
      substr(descrip,tag_start,tag_end-tag_start+1)=‘ ‘;
   end;
run;

Avec DO UNTIL et DO WHILE, il faut faire attention aux boucles infinies. Si la condition pour sortir de la boucle n’est jamais obtenue. L’exécution continue sans fin.

Lectures complémentaires

Sur le blog www.sasreference.fr

Online Doc

  • DO WHILE Statement
  • DO UNTIL Statement
h1

Les anniversaires, cela se fête avec SAS

avril 2, 2009

Aujourd’hui étant mon anniversaire, je fais la paresseuse et vous communique un petit fichier SAS, reçu ce jour (merci Alex), à faire tourner sous Windows, écouteurs en place, pour la prochaine fois qu’un collègue ou pote qui connaît SAS soufflera ses bougies. Amusez-vous bien !

%let pc=1;

%macro sasreference_fr(note,octave,length);

select(&note.);
when (‘A’) call sound (55*(2**&octave.),&length.*160*&pc.);
when (‘A#’) call sound (58*(2**&octave.),&length.*160*&pc.);
when (‘Bb’) call sound (58*(2**&octave.),&length.*160*&pc.);
when (‘B’) call sound (62*(2**&octave.),&length.*160*&pc.);
when (‘C’) call sound (65*(2**&octave.),&length.*160*&pc.);
when (‘C#’) call sound (69*(2**&octave.),&length.*160*&pc.);
when (‘Db’) call sound (69*(2**&octave.),&length.*160*&pc.);
when (‘D’) call sound (73.5*(2**&octave.),&length.*160*&pc.);
when (‘D#’) call sound (73.5*(2**&octave.),&length.*160*&pc.);
when (‘Eb’) call sound (78*(2**&octave.),&length.*160*&pc.);
when (‘E’) call sound (82*(2**&octave.),&length.*160*&pc.);
when (‘F’) call sound (87*(2**&octave.),&length.*160*&pc.);
when (‘F#’) call sound (92.5*(2**&octave.),&length.*160*&pc.);
when (‘Gb’) call sound (92.5*(2**&octave.),&length.*160*&pc.);
when (‘G’) call sound (98*(2**&octave.),&length.*160*&pc.);
when (‘G#’) call sound (104*(2**&octave.),&length.*160*&pc.);
when (‘Ab’) call sound (104*(2**&octave.),&length.*160*&pc.);
when (‘R’) call sleep((&length./3)*&pc.,1);
otherwise;
end;
%mend sasreference_fr;

data _null_;
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘D’,3,2);
%sasreference_fr(‘C’,3,2);
%sasreference_fr(‘F’,3,2);
%sasreference_fr(‘E’,3,4);

%sasreference_fr(‘R’,3,2);

%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘D’,3,2);
%sasreference_fr(‘C’,3,2);
%sasreference_fr(‘G’,3,2);
%sasreference_fr(‘F’,3,4);

%sasreference_fr(‘R’,3,2);

%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,4,2);
%sasreference_fr(‘A’,4,2);
%sasreference_fr(‘F’,3,1);
%sasreference_fr(‘F’,3,1);
%sasreference_fr(‘E’,3,2);
%sasreference_fr(‘D’,3,4);

%sasreference_fr(‘R’,3,2);

%sasreference_fr(‘Bb’,4,1);
%sasreference_fr(‘Bb’,4,1);
%sasreference_fr(‘A’,4,2);
%sasreference_fr(‘F’,3,2);
%sasreference_fr(‘G’,3,2);
%sasreference_fr(‘F’,3,4);
run;

Pour les curieux, je vous invite à consulter les programmes des chansons suivantes suggérées sur le forum de developpez.com :

Les plus téméraires s’intéresserons à la publication « Making Music in SAS« . Vos créations pourront être publiées sur le blog.

A lire aussi www.sasreference.fr :

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

5 points à retenir sur l’opérateur logique LIKE

décembre 14, 2008

Comment dire à SAS de sélectionner toutes les observations pour lesquelles une variable donnée contient le mot CASTS ? L’opérateur logique LIKE, utilisable uniquement une condition exprimée par WHERE est fait pour ce travail. Voici donc 5 points à retenir sur LIKE que vous pourrez vous même vérifier à l’aide du data set founi en bas d’article dans la rubrique « Annexe » et des exemples de la section 2.

1. Les 5 points à retenir sur LIKE

1. Trouver un texte ayant une structure donnée : Le but de LIKE est de trouver, pour une variable donnée, toutes les observations ayant une structure particulière.

2. Traiter des chaînes de caractères : LIKE s’applique à une chaîne de caractères et non à des valeurs numériques.

3. Autoriser un caractère libre : Le tiret bas (underscore : _) désigne qu’il faut absolutement un caractère à l’endroit où il est utilisé : ni plus ni moins.

4. Autoriser une chaîne de caractère libre : Le pourcentage (percent : %) accepte toute chaîne de caractère, quelque soit sa longueur, à l’endroit où le symbole apparaît. L’absence de caractère est aussi valide.

5. Appliquer LIKE dans un WHERE : LIKE s’utilise uniquement avec WHERE dans une étape data ou dans la procédure SQL. Il ne fonctionnera pas avec IF.

2. Quelques exemples

Un exemple avec les pourcentages : Dans ce premier exemple, on sélectionne toutes les lignes d’observations où la variable TEST_LAB contient le mot CASTS en majuscule. Il est possible de prendre une observation contenant du texte ou des blancs avant le mot CASTS et/ou après le mot CASTS.

data casts;
   set lab (where=(test_lab like '%CASTS%'));
run;

Pour prendre toutes les observations indépendamment de la case ajouter la fonction UPCASE autour du nom de la variable UPCASE(TEST_LAB) like…

Un exemple avec le tiret bas : imaginons que vous vouliez repérer toutes les tests en rapport avec « Leukocyte esterase » mais vous envisagerez une mauvaise saisie au niveau du k, c et y. Vous demandez alors toutes les observations ressemblant au mot « Leukocyte esterase » en acceptant n’importe quelle autre valeur pour k, c et y.

data check_leuk;
   set lab (where=(test_lab like 'LEU_O__TE ESTERAS'));
run;

Un exemple combinant pourcentage et tiret bas : dans ce troisième et dernier exemple, on cherche à trouver toutes les observations contenant le mot CAST tout en assumant que la lettre A peut être erronnée dans les données du data set LAB. N’importe quel caractère à l’emplacement du A est autorisé.

data check_casts;
   set lab (where=(test_lab like '%C_ST%'));
run;

La même chose avec PROC SQL

proc sql;
   create table check_casts as
       select *
       from lab
       where test_lab like '%C_ST%';
quit;

Annexe : CASTS réfère à des tests de laboratoires sur les urines (urinal test).

data lab;
   length test_label $100;
   input test_label $;
   datalines;
FATTY CASTS
GRANULAR CASTS
HYALINE CASTS
RED BLOOD CELL COSTS
LEUKOCYTE ESTERASE
RENAL TUBULAR EPITHELIAL CASTS
WAXY CASTS
WHISTE BLOOD CELL CASTS
KETONE
;
run;
h1

Penser conditionnel (3/3) : CASE WHEN

juillet 3, 2008

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;

h1

Penser conditionnel (2/3) : SELECT

juin 26, 2008

Pour dire à SAS quelles actions sont à mener si des critères sont remplis, nous avons vu la syntaxe IF/THEN/ELSE (voir article). Dans un data step, l’alternative à cette syntaxe, SELECT WHEN, fait l’objet du présent article.

1. La syntaxe de base

Toutes les conditions sont englobées entre l’instruction SELECT et l’instruction END.  Chaque condition est introduite par l’instruction WHEN. Les observations non sélectionnées avant la fin sont traités par l’instruction OTHERWISE.

A la différence de la syntaxe IF/THEN :

  • Les conditions sont listées entre parenthèses et aucun mot-clé n’introduit l’action.
  • Si toutes les conditions se basent sur une seule variable, celle-ci peut-être citée une seule fois et ce en tout début dans l’instruction SELECT. Mais il faut aussi que les valeurs prises par la variable soient toutes listées. Ainsi <5 ne marche pas mais 0,1,2,3,4 marche.

De la même manière que IF/THEN :

  • Seuls les records non sélectionnés pas un précédent WHEN sont considérées par les conditions suivantes. C’est le même principe que le ELSE IF.
  • Si plusieurs actions sont planifiées, celles-ci sont listées entre un DO et un END.

select  <nom_variable, optionnel> ;
when (<condition>)
do;
<action 1>;
<action 2>;
*etc;
end;
when (<condition>)  <action>;
otherwise <action>;
end;

2. Le caractère unique du SELECT WHEN

Pas d’action s’il vous plaît : Lorsqu’il n’y a aucune action pour une condition donnée, il est possible d’écrire une instruction WHEN sans donner de détails après la parenthèse. On parle d’instruction nulle.

OTHERWISE est parfois obligatoire : Si aucune condition n’est rempli pour un data set donné, il est important d’avoir une instruction OTHERWISE. Celle-ci peut rester vide d’action.

3. Illustration par un exemple

Premier exemple : les trois caractéristiques de ce premier exemple sont les suivantes.

  • La condition est basée sur une seule variable. On choisit dont de nommer une seule fois cette variable dans l’instruction SELECT.
  • Il y a plusieurs actions (DO/END) pour certaines conditions.
  • Dans le cas où aucune des conditions précédentes ne serait remplie, l’instruction OTHERWISE est ajoutée.

Les records incluant un âge manquant sont sauvegardées dans le data set nommé MISS_AGE et la  date de création d’une requête (query) pour clarifier le record est ajoutée dans une variable QUERY_SDT (Query Starting Date). Les autres records, traitant des moins de 5 ans, sont sauvegardés dans le data set YOUNG.

data miss_age young ;
set sashelp.class;
select (age);
when (.)
do;
query_sdt=mdy(3,26,2008);
output miss_age;
end;
when (0,1,2,3,4) output young;
otherwise;
end;
run;

Second exemple : cet exemple se distingue sur trois aspects.

  • La condition est basée sur plusieurs variables. Il faut dont les lister à chaque nouvelle instruction WHEN.
  • Une seule action n’est donnée à chaque fois voir moins. L’action porte sur la valeur de la variable POP. Il n’y a pas d’action quand l’âge n’est pas une valeur connue ou que le sexe n’est pas défini par les lettres majuscules F (female) ou M (male).
  • Les valeurs restantes se rapportent aux hommes ayant une valeur pour leur âge. C’est notre troisième population.

data pop;
set sashelp.class;
select;
when (age > 13 and sex=‘F’) pop = 1;
when (age >= 0 and sex=‘F’) pop = 2;
when (age < 0 or sex not in (‘F’,‘M’));
otherwise pop = 3;
end;
run;

A dans huit jours pour une présentation du CASE WHEN de la procédure SQL.

h1

Penser conditionnel (1/3) : La base du IF

juin 19, 2008

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 inclure 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és 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 toutes les valeurs manquantes (missing et special missing), c’est d’utiliser la fonction MISSING qui a 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’observations.

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;

h1

Repérer les 1ers/derniers records (FIRST/LAST)

mai 6, 2008

Repérer la première et/ou la dernière observation d’un jeu de données ou d’un sous-ensemble de ce jeu, c’est possible sous SAS avec les mots-clés FIRST et LAST dans un data step. On se sert de cette information sous forme de condition. Si la première observation est rencontrée, on fait ceci, sinon on fait cela. Cela sert pour créer une variable compteur ou pour générer plusieurs programmes via un DATA _NULL_, programmes variant par quelques valeurs listées dans un fichier de référence.

1. Le raisonnement FIRST/LAST en langage humain

Dans l’exemple ci-dessous, on a tout d’abord deux variables MEMNAME et NAME qui sont triées. Ensuite sont ajoutées plusieurs variables.

Les variables FRST_DSN/LST_DSN

  • S’il s’agit de la première fois que l’on lit la valeur de la variable MEMNAME, alors on donne une value de 1 à FRST_DSN, sinon on donne une valeur de 0.
  • Si au contraire, il s’agit de la dernière valeur avant de changer, LST_DSN prend la valeur 1, sinon il prend la valeur 0.

Dans l’exemple, on remarque que FRST_DSN et LST_DSN sont toutes les deux égale à 1 quand MEMNAME=DSN2, car il n’y a qu’une observation pour ce MEMNAME. La première observation est donc également la dernière,

memname  name  frst_dsn lst_dsn frst_var lst_var
    dsn1       var1          1          0           1          0
    dsn1       var1          0          0           0          0
    dsn1       var1          0          0           0          1
    dsn1       var2          0          0           1          1
    dsn1       var3          0          1           1          1    
    dsn2       var1          1          1           1          1    

    dsn3       var1          1          0           1          1
    dsn3       var2          0          0           1          1
    dsn3       var3          0          0           1          1
    dsn3       var4          0          1           1          1    
    dsn4       var1          1          0           1          1
    dsn4       var2          0          1           1          1       

FRST_VAR/LST_VAR : une fois dans un groupe (DSN1, DSN2, DSN3 ou DSN4), on regarde la seconde variable NAME.

  • Si on a la première fois la valeur dans ce groupe, FRST_VAR=1 sinon FRST_VAR=0.
  • Si au contraire, il s’agit de la dernière fois qu’on l’observe dans ce group, LST_VAR=1, 0 autrement.

Dans l’exemple, seul le DSN1 a plusieurs fois une VAR1 associée. C’est donc le seul moment où FRST_VAR n’est pas égal à LST_VAR.

NOTE, choix de l’auteur : entendez FRST pour rappeler le mot FIRST (premier), LST le mot LAST (dernier) et DSN le mot DATA SET NAME (nom du jeu de données).

2. Le raisonnement FIRST/LAST en langage SAS

SAS lie les données d’un jeu de données ligne par ligne. On rassemble les données par groupe en les triant. On rappelle cet ordre avec une instruction BY.

Ici les variables MEMNAME et NAME sont extraites de la bibliothèque SASHELP grâce au dictionnaire COLUMN.

proc sql;
   create table lst_dsn_var as
   select memname, name
   from dictionary.columns
   where upcase(libname)=’SASHELP’;
quit;

Puis, chacune des variables FRST_DSN, LST_DSN, FRST_VAR et LST_VAR sont crées. Ces variables prennent une valeur de 1, si la condition est vrai (s’il s’agit bien de la première ou de la dernière observation), 0 sinon. Bien sûr, on peut choisir de leur donner la valeur que l’on veut.

data _null_;
   set lst_dsn_var;
   by memname name;
   if first.memname then frst_dsn=1;
   else frst_dsn=0;
   if last.memname then lst_dsn=1;
   else lst_dsn=0;
   if first.name then frst_var=1;
   else frst_var=0;
   if last.name then lst_var=1;
   else lst_var=0;
run;

NOTE : SAS se base sur les données d’origine pour dire si oui ou non, il s’agit de la première/dernière observation. Dès lors, si le jeu d’origine est altéré (suppression de lignes), SAS ne redéfinira pas une première/dernière observation parmi celles restantes. On peut donc ne plus avoir l’observation considérée par SAS comme première/dernière. Il choisira si besoin de faire les deux opérations dans des data steps distincts.

3. La première et la dernière observation d’un data set

Vous n’aurez pas toujours une variable prenant la même valeur pour toutes les observations et ainsi retrouver la première et la dernière observation. On peut soit en créer une avec un RETAIN par exemple ou plus simplement utiliser

  • la variable automatique _N_ pour la première observation et
  • la variable assignée avec l’option END= dans l’instruction SET pour la dernière observation.

data _null_;
   set lst_dsn_var end=eof;
   if _N_=1 then …;
   if eof then…;
run;

NOTE : Par habitude, on donne ici le nom EOF (End Of File) comme nom à la variable qui prend une valeur 1 s’il s’agit de la dernière observation, 0 autrement. Comme la variable automatique _N_, EOF n’apparaît pas dans le data set final, s’il est créé.

h1

Oh attention danger avec MERGE et IF

mars 11, 2008

Attention

Oh attention danger ! Cela me fait penser à une chanson de Sardou. Mais c’est aussi la phrase qu’il faut avoir à l’esprit quand on veut combiner par un MERGE deux jeux de données et en même temps mettre à jour une variable avec une condition IF.

Lorsque MERGE et IF sont utilisés dans un seul data step pour actualiser une variable, le programmeur a souvent en tête un MERGE puis un IF. C’est à dire d’équivalent de deux data steps, un pour le MERGE et un pour IF. Hors dans les faits, SAS agit différemment.

Il est donc essentiel de savoir repérer la situation pour utiliser deux steps au lieu d’un. Pour cela je vous propose de passer par un exemple.

1. Les données d’origine : je vous propose en exemple deux jeux de données appelés ONE et TWO ayant une variable commune ID et une variable unique, X dans le premier cas, Y dans le second. On compte plusieurs ID identiques dans ONE. Chaque ID est unique dans TWO. On fait donc un merge MANY-TO-ONE.

—ONE—
id     x   
 1    999
 1    888
 1    777
 2    66

—TWO—
id     y
 1    10
 2    12

2. La méthode claire en deux étapes : quand x est égal à 999, l’observation de Y est mise à jour. Dans l’exemple, seule la première observation de Y est concernée.

Dans un premier temps, les données sont combinées.

data safe;
   merge one two;
   by id;
run;

id     x      y
 1    999    10
 1    888    10
 1    777    10
 2    666    12 

Dans un second temps, la variable Y est mise à jour.

data safe;
   set safe;
   if x=999 then y=999;
run;

id     x      y
 1    999    999
 1    888     10
 1    777     10
 2    666     12 

3. La méthode risquée : en regardant le résultat, on remarque la  mise à jour de la variable Y ne concerne plus seulement la première observation mais est étendue à l’ensemble des observations de l’ID concerné (ID=1)-

data danger;
   merge one two;
   by id;
   if x=999 then y=999;
run;

id     x      y
 1    999    999
 1    888
    999
 1    777   
999
 2    666     12

En conclusion, les deux notations sont correctes. Il est seulement important de savoir clairement le résultat qu’on recherche. Le premier cas reste le plus fréquent. Lorsqu’il s’agit de mettre à jour une variable une fois un MERGE terminé via une IF condition, il faut le faire en deux étapes pour éviter des sorties différentes de ses attentes.