Here is an example. hth %put %eval( 1.0 eq 1); %*-- returns 0 for false -- *; ... View more

Here is one way. hth   /* test data */   proc plan seed=12345678;      factors obs=50 ordered rep=100 ordered x=1 of 1000 random;      output out=sim;   run;   /* mean of x over 100 reps for each obs */   proc means data=sim;      var x;      by obs;   run;   /* on lst   obs=1   The MEANS Procedure                          Analysis Variable : x      N            Mean         Std Dev         Minimum         Maximum   --------------------------------------------------------------------    100     503.3600000     311.3526864      14.0000000         1000.00   --------------------------------------------------------------------   obs=2                          Analysis Variable : x      N            Mean         Std Dev         Minimum         Maximum   --------------------------------------------------------------------    100     483.4900000     290.8708796       8.0000000     979.0000000   --------------------------------------------------------------------   ...   obs=50                          Analysis Variable : x      N            Mean         Std Dev         Minimum         Maximum   --------------------------------------------------------------------    100     467.2800000     273.5758747       2.0000000     999.0000000   --------------------------------------------------------------------   */ ... View more

Your path is not to be resolved by an explicit or implicit %eval(). Thus you don't need to macro quote the singleton ampersand character at all. The ampersand has to be hidden from the cmd.exe shell though, since it is a command separator to the interpreter (see msdn article). The following worked fine on my sas running on a windows 7:    %let drive = c:;    %let path = /temp/a & b;    x "&drive & cd ""&path"" & dir *.csv > list.txt"; ... View more

I am partial to separating out the part that is repeated from the part that loops. This makes it simple to test the repeated part. I am also for making the macro arguments formal and declaring all local macro variables explicitly. One good side effect of using the formal arguments is that this makes it clear who is responsible for quoting what. For instance, if the macro caller does not quote the comma that is within the names parameter value, then even the macro invocation will fail; the macro author cannot do anything about it; thus the quoting responsibility naturally falls on to the macro user. Within the macro, however, the macro author should have used %qscan function, instead of %scan, when certain characters are expected, because %scan function returns an unquoted text. hth    %macro report(name, ccy);       %put ***&name***&ccy***;    %mend  report;    %macro e5(names=, ccys=, dlm=#);       %if %superq(names) = %then %return;       %if %superq(ccys) = %then %return;       %local i j name ccy;       %let i = 1;       %let name = %qscan(&names, &i, &dlm);       %do %while (&name ^=);          %let j = 1;          %let ccy = %qscan(&ccys, &j, &dlm);          %do %while (&ccy ^=);             %report(&name, &ccy)             %let j = %eval(&j + 1);             %let ccy = %qscan(&ccys, &j, &dlm);          %end;          %let i = %eval(&i + 1);          %let name = %qscan(&names, &i, &dlm);       %end;    %mend  e5;    %let names = a#b, b#c;    %let ccys = 1#2#3;    %e5(names=%superq(names), ccys=&ccys)    %*-- on log    ***a***1***    ***a***2***    ***a***3***    ***b, b***1***    ***b, b***2***    ***b, b***3***    ***c***1***    ***c***2***    ***c***3***    --*; ... View more

See if an old sas-l posting of mine helps. ... View more

Since there are only 200 or so 5-digit (perfect) square numbers, even the exhaustive search does not take a long time to run -- about 5-6 seconds on my 32bit windows box. hth.    /* 5-digit (perfect) square numbers only */    data one;       do i = 1e2 to 1e3;          j = i**2;          if j < 1e4 then continue;          if j > 1e5 - 1 then stop;          v = put(j, 5.0);          keep v;          output;       end;    run;    proc fcmp outlib=work.func.quiz;       /* returns > 1000 if any condition is not met */       function usedOnceDigit(v1 $, v2 $, v3 $);          length v $15 nDigits usedOnceDigit nUsedOnceDigits i j 8 c $1;          array freq[10] (0 0 0 0 0 0 0 0 0 0);          v = cat(v1, v2, v3);          nDigits = 0;          usedOnceDigit = .;          nUsedOnceDigits = 0;          do i = 1 to 10;             c = substr("1234567890", i, 1);             freq = 15 - length(compress(v, c));             if freq > 0 then do;                  if i = freq then return(1005);                if freq >= 10 then return(1004);                if index(v, substr("1234567890", freq, 1)) = 0 then return(1004);                nDigits + 1;                if nDigits > 5 then return(1002);                do j = 1 to i-1;                   if freq > 0 and freq = freq then return( 1003);                end;                if freq = 1 then do;                   usedOnceDigit = i;                   nUsedOnceDigits + 1;                end;             end;          end;          if nDigits < 5 then return(1002);          if nUsedOnceDigits ^= 1 then return(1006);          return(usedOnceDigit);       endsub;    quit;    %let cmplib = %sysfunc(getoption(cmplib));    options cmplib = (work.func &cmplib);       proc sql;          select "answer is: ", v1, v2, v3          from (             select o1.v as v1, o2.v as v2, o3.v as v3                  , usedOnceDigit(o1.v, o2.v, o3.v) as usedOnce             from   one as o1, one as o2, one as o3             where  o1.v < o2.v and o2.v < o3.v                and calculated usedOnce < 1000          )          group by usedOnce          having count(*) = 1;       quit;       /* on lst                    v1     v2     v3       --------------------------------       answer is:   12321  33124  34225       */    options cmplib=(&cmplib); ... View more

The OP's problem is one of finding (connected) components given a graph, once we convert the given data into one. Below is my try that implements the depth-first search(DFS) based component finding algorithm running on the graph represented as an edgelist stored in a hash-of-hashes. This runs pretty fast. On my desktop with 32bit windows, it usually takes 10 to 20 seconds or so given N=10000. But it consumes an enormous amount of memory. The code asked for 910M at peak and used 512M while running for N=10000, most of which seems to be overhead for hash objects. Enjoy.   options nocenter mprint fullstimer;   /* test data */   %let N=10000;   %let seed=20110921;   data one;       length id 4 v1-v4 $3;       array arr v1-v4;       alpha = "abcdefghijklmnopqrstuvwxyz";       alphaLen = vlength(alpha);       vlen = vlength(v1);       do id = 1 to &N;         call missing(of v1-v4);         do i = 1 to 4;             do j = 1 to vlen;               p = ceil(alphaLen*ranuni(&seed));               substr(arr,j,1) = substr(alpha,p,1);             end;         end;         output;         keep id v1-v4;       end;    run;   /* a tiny test dataset -- uncomment to use this one   data one;       input id (v1 v2 v3 v4) ($);   cards;   1 a b c d    the graph has four (connected) components,   2 a e f g    including two singletons, like so:   3 . . . .                          4 i j k l          1 - 2 - 6 - 9   5 . . m .                \ |   6 . n f o                  8   7 . . m .          3   8 . n . g              5 - 7   9 . . . o          4   ;   run;            */   /* step one: convert it to a graph represented as an edge list. */   %macro matches;       %local i j k;       %let k = 1;       %do i = 1 %to 4;         %do j = &i %to 4;             %let k = %eval(&k + 1);             union all             select m&k..id as tail, n&k..id as head             from one as m&k., one as n&k.             where m&k..v&i = n&k..v&j and not missing(m&k..v&i)         %end;       %end;   %mend  matches;   proc sql _method;       drop index id on one;       create index id on one (id);       drop index v1 on one;       create index v1 on one (v1);       drop index v2 on one;       create index v2 on one (v2);       drop index v3 on one;       create index v3 on one (v3);       drop index v4 on one;       create index v4 on one (v4);       create table g as       select distinct mn.tail, mn.head from (         select m1.id as tail, n1.id as head from one as m1, one as n1 where m1.id=n1.id         %matches       ) as mn       order by mn.tail, mn.head;   quit;   /* Step Two: to find connected components and singletons.       depth-first search(DFS) of a hash-of-hash representation of the graph.       the limit on the depth of recursive link blocks is 11 by default         but can be changed by the stack= data statement option. */   data c(rename=(tail=vertex cid=component)) /stack=&N;       retain OK top component 0;       dcl hash tails();       dcl hash heads();       dcl hash stack();       dcl hiter ti;       dcl hiter hi;       link main;       main:         link loadData;         do rc = ti.first() by 0 while (rc = OK);             tails.find();             if missing(cid) then do;               component + 1;               cid = component;               tails.replace();               link connect;             end;             rc = ti.next();         end;         link doOutput;       stop;       return;       connect:         link pushStack;         hi = _new_ hiter('heads');         do rc = hi.first() by 0 while (rc = OK);             tail = head;             tails.find();             if missing(cid) then do;               cid = component;               tails.replace();               link connect;             end;             rc = hi.next();         end;         link popStack;       return;       loadData:         /* load data into a hash of hashes */         tails = _new_ hash(ordered:'a');         tails.defineKey('tail');         tails.defineData('tail', 'cid', 'heads');         tails.defineDone();         do until (end);             set g end=end;             by tail;             call missing(cid);             if first.tail then do;               heads = _new_ hash(ordered:'a');               heads.defineKey('head');               heads.defineData('head');               heads.defineDone();               tails.replace();             end;             heads.replace();         end;         put "NOTE: done loading data into memory hash-of-hashes.";         ti = _new_ hiter('tails');                 /* a call stack */         stack = _new_ hash(ordered:'a');         stack.defineKey('top');         stack.defineData('tail', 'cid', 'heads', 'head', 'rc', 'hi');         stack.defineDone();       return;       popStack:         if stack.find() ^= OK then return;         stack.remove();         top + (-1);       return;        pushStack:         top + 1;         stack.add();       return;       doOutput:         do rc = ti.first() by 0 while (rc = OK);             keep tail cid;             output c;             rc = ti.next();         end;       return;   run;   /* check -- how many clusters? */   proc sql;     select size as 'component size'n,             count(*) as 'number of components'n     from (         select component as componentID, count(*) as size         from  c         group by component     )     group by size     order by size desc;   quit;   /* on lst: for the small dataset       component  number of           size  components       ---------------------               5          1               2          1               1          2       for the larger one       component  number of           size  components       ---------------------           9964          1               2          3               1          30   */ ... View more

Here is one way. HTH.    /* test data */    data one;      input gvkey execid year ceo cfo other;    cards;    103     6  1992  0  0  1    103    6  1993  1  0  0    103     6  1994  1  0  0    259     6  1996  0  0  1    259     6  1997  0  0  1    259     6  1998  1  0  0    259     6  1999  1  0  0    259     6  2000  1  0  0    1990   6  2003  0  0  1    1990   6  2004  0  0  1    1990   6  2005  0  1  0    1990    6  2006  0  1  0    34     19  1994  0  0  1    34     19  1995  0  0  1    34     19  1996  0  0  1    34     19  1997  0  0  1    2503  19  1998  0  0  1    2503  19  1999  1  0  0    2503  19  2000  1  0  0    2503  19  2001  1  0  0    2503  19  2002  1  0  0    ;    run;    /* compress into exec-company */    %let vars = gvkey execid from to ceo cfo other;    %let varsc = %sysfunc(translate(&vars,%str(,), %str( )));    data two;       call missing(&varsc);      do until (last.gvkey);         set one;         by execid gvkey notsorted;         if first.gvkey then from = year;         if last.gvkey then to = year;         ceos = sum(ceos, ceo);         cfos = sum(cfos, cfo);         others = sum(others, other);      end;      ceo = ceos > 0;      cfo = cfos > 0;      other = others > 0;      keep &vars;    run;    /* pair previous exec-co observation with current */    data three;      set two;      by execid notsorted;      exceo = ifn(first.execid, ., lag(ceo));      excfo = ifn(first.execid, ., lag(cfo));      exother = ifn(first.execid, ., lag(other));    run;    /* summarize */    data _null_;      set three end=end;      array count[1:9] _temporary_ (9*0);      if exceo then do;        if ceo then count[1] + 1;        if cfo then count[2] + 1;        if other then count[3] + 1;      end;      if excfo then do;        if ceo then count[4] + 1;        if cfo then count[5] + 1;        if other then count[6] + 1;      end;      if exother then do;        if ceo then count[7] + 1;        if cfo then count[8] + 1;        if other then count[9] + 1;      end;      if end then do;        put @1 "ex" @10 "current";        put @1 " "   @10 "CEO" @20 "CFO" @30 "Other";        put @1 "CEO" @10 count[1] @20 count[2] @30 count[3];        put @1 "CFO" @10 count[4] @20 count[5] @30 count[6];        put @1 "Other" @10 count[7] @20 count[8] @30 count[9];      end;    run;    /* on log    ex       current             CEO       CFO       Other    CEO      1         1         2    CFO      0         0         0    Other    2         1         3    */ ... View more