DS2 would be the king!) Years ago I made up a piece of SAS code to demonstrate the basic idea of Map-Reduce. Now this idea can be best implemented by this piece of workable program with PROC DS2 (tested in SAS 9.4 TS1M2, Win7):

PROC DS2; /* create some data –*/
data input_data / overwrite = yes;
dcl double d;
method init();
   dcl int i;
   do i = 1 to 10000000;
      /*– create some money values –*/
      d = round( (ranuni(123) * 10 ), .01 );
      output;
   end;
end;
enddata;
run; /*– count the rows in multiple threads –*/
thread map / overwrite = yes;
dcl double c s;
keep c s;
method run();
   set input_data;
   /*– the more compuation here, the more benefit –*/
   c + 1;
   s + d;
end;
method term();
   output;
   put s= c=;
end;
endthread;
run; /*– blend the results into one total –*/
data reduce / overwrite = yes;
dcl thread map m;
dcl double totc tots;
keep totc tots;
method run();
   set from m threads=4;
   totc + c;
   tots + s;
end;
method term();
   output;
end;
enddata;
run;
quit; proc print data=reduce; run;

Robert Ray of SAS Institute to kindly allow me to post his code.

data a;
    input i a $ b $;
    datalines;
    1 a1A b1
    1 a1A b1
    2 a2 b2
    ;
run; data b;
    input i a $ c $;
    datalines;
    1 a1C c1
    2 .   c2
    3 .  c3
    ;
run; data mrge;
    merge a b;
    by i;
run; proc ds2;
    data ds2;
       method run();
          merge a b;
        by i;
       end;
     enddata;
    run;
quit;

data null;
n = 5;
r = 2;

   *the factorial of a number;
fact=fact(n);

   *for positive integers, fact(n) = gamma(n+1);
gamm=gamma(n + 1);

   *C(n,r): number of combinations of n objects selected r ;
*n! / [r!(n-r)!];
comb1 = comb(n,r);
comb2 = fact(n) / (fact(r) * fact(n-r));
comb3 = gamma(n+1) / (gamma(r+1) * gamma(n-r+1));
comb4 = exp(lcomb(n,r));
comb5 = exp(lgamma(n+1)-lgamma(r+1)-lgamma(n-r+1));

   *A(n,r): number of permutation (ordered arrangements);
*n! / (n-r)!;
perm1 = perm(n,r);
perm2 = fact(n) /  fact(n-r);
perm3 = gamma(n+1) /  gamma(n-r+1);
perm4 = exp(lperm(n,r));
perm5 = exp(lgamma(n+1)-lgamma(n-r+1));

   put (all) (= / );
run;

Note functions fact() and gamm() can quickly reach out their limitations(try n=171 and check the overflow notes in Log window).

2. Generate Unique Pairs

Question see here.

data null;
array x[5] $1 (“A” “C” “D” “B” “E”);
n = dim(x);
r = 2;
ncomb = comb(n, r);
do j = 1 to ncomb+1;
rc = allcomb(j, r, of x[*]);
if rc < 0 then leave;
put j 5. +3 x1 “- ” x2 +3;
end;
run;

The output in Log:

1   A – C
2   A – E
3   A – B
4   A – D
5   C – D
6   C – E
7   C – B
8   D – B
9   D – E
10   B – E

Or if you like alphabetical sorted pairs:

data null;
array x[5] $1 (“A” “C” “D” “B” “E”);
n = dim(x);
r = 2;
ncomb = comb(n, r);
do j = 1 to ncomb+1;
rc = lexcomb(j, r, of x[*]);
if rc < 0 then leave;
put j 5. +3 x1 “- ” x2 +3;
end;
run;

The output:

1   A – B
2   A – C
3   A – D
4   A – E
5   B – C
6   B – D
7   B – E
8   C – D
9   C – E
10   D – E

I checked Rick Wicklin’s blog and found  PROC IML offers a much more intuitive approach to this problem:

proc iml;
n = 5;
r = 2;
idx = allcomb(n, r);
print idx;
quit;

The output:

1 2
2 3
1 3
3 4
2 4
1 4
4 5
3 5
2 5
1 5

or make the output more readable:

proc iml;
n = 5;
r = 2;
idx = allcomb(n, r);
print idx;

    Items = {“A” “C” “D” “B” “E”};
S = Items[ ,idx];
S = shape(S, 0, r);
print S[r=(char(1:nrow(S)))];
quit;

the output:

1  A C
2  C D
3  A D
4  D B
5  C B
6  A B
7  B E
8  D E
9  C E
10 A E

3. Generate Unique Pairs: A Macro

Years ago when the build-in functions above might not be available in SAS, a macro %combo did the same job:

%combo(2,a,c,d,b,e)

The output:

1  a c
2  a d
3  a b
4  a e
5  c d
6  c b
7  c e
8  d b
9  d e
10 b e

It’s fun to check out the macro how to implement it by arrays.

Statistical Notes (3): Confidence Intervals for Binomial Proportion Using SAS which I will extend as a SESUG 2015 paper. Basically I added a new Blaker method to my CI_Single_Proportion.sas file and found more CIs from SAS PROC FREQ.

filename CI url “https://raw.github.com/Jiangtang/Programming-SAS/master/CI_Single_Proportion.sas” ;
%include CI; %CI_Single_Proportion(r=81,n=263);

data test;
input grp outcome $ count;
datalines;
1 f 81
1 u 182
; ods select BinomialCLs;
proc freq data=test;
    tables outcome / binomial (CL=
                               WALD
                               WILSON
                               CLOPPERPEARSON
                               MIDP
                               LIKELIHOODRATIO
                               JEFFREYS
                               AGRESTICOULL
                               LOGIT
                               BLAKER 
                              );
    weight Count;
run; ods select BinomialCLs;
proc freq data=test;
    tables outcome / binomial (CL =
                              WILSON(CORRECT)
                              WALD(CORRECT)
                              );
    weight Count;
run;

The following is a quick-and-dirty way to get a function like %COV:

%macro COV(data, var1,var2);
    %local _cov;
    %let rc = %sysfunc(dosubl(%str(     ods select none ;
    ods output cov=_cov;     proc corr data=&data  cov ;
    var &var1 &var2 ;
    run;     ods select all;         proc sql noprint;
    select &var2 into :_cov
    from _cov  (obs=1)
    ;
    drop table  _cov;
    quit
    )));
    &_cov
%mend COV;

You can use it in macro variable assignment:

%let cov = %COV(sashelp.iris,SepalLength,SepalWidth);

or in a data step:

data iris;
    set sashelp.iris;
    cov = %COV(sashelp.iris,SepalLength,SepalWidth);
run;

or in PROC SQL:

proc sql;
    create table iris2 as
    select *,
    %COV(sashelp.iris,SepalLength,SepalWidth) as cov
    from sashelp.iris;
quit;

One line conclusion: I LOVE Dosubl and hope this Dosubl also inspires your programming!

Technically, .Rdata is not a data format. It’s rather a big container to hold bunch of R objects:

In this example, when a .Rdata is loaded, 3 objects are included where ‘data’(the ‘real’ data) and ‘desc’ (data description portion) are of our interests.

SAS/IML offers a nice interface to call R command which can be used to read the R format data:

proc iml;
submit / R;
load(“C:/data/w5/R data sets for 5e/GPA1.RData”)
endsubmit;

    call ImportDataSetFromR(“work.GPA1”, “data“);
call ImportDataSetFromR(“work.GPA1desc”, “desc“);

quit;

data null;
set GPA1desc end = eof ;
i+1;
II=left(put(i,3.));
call symputx(‘var’||II,variable);
call symputx(‘label’||II,label);
if eof then call symputx(‘n’,II);
run;

%macro labelit;
data gpa1;
set gpa1;

    label
%do i=1 %to &n;
&&var&i = &&label&i
%end;
;
run;
%mend;

%labelit

Years ago I wrote several posts on this topic:

Statistical Notes (3): Confidence Intervals for Binomial Proportion Using SAS

Statistical Notes (5): Confidence Intervals for Difference Between Independent Binomial Proportions Using SAS

Confidence Intervals for Binomial Proportion: A SAS 9.4/STAT 12.3 Update

Confidence Intervals for Difference Between Independent Binomial Proportions: A SAS 9.4/STAT 12.3 Update

I’m not a statistician and I might get some time later to dig these new methods in Wu’s paper (I modified his codes little bit to fit my post):

/*0 input data*/
data jeff;
    n=263;
    r=81;
run; /*1 Random Walk Metropolis*/
%let nmc=1010000;
%let c=0.08; data PosteriorSample;
    call streaminit(123);
    set jeff;
    p0=0.5;
    retain p0;     do i = 1 to &nmc.;
        p1=p0+rand(‘normal’,0,&c.);         do while(p1 lt 0 or p1 gt 1);
            p1=p0+rand(‘normal’,0,&c.);
        end;         logratio=(1/2-1)*log(p1)+(1/2-1)*log(1-p1)+r*log(p1)+(n-r)*log(1-p1)
        – (1/2-1)*log(p0)-(1/2-1)*log(1-p0)-r*log(p0)-(n-r)*log(1-p0);         if log(rand(‘uniform’)) <= logratio then do;
            p0=p1;
        end;         if i gt 10000 and floor(i/20)*20 eq i then do;
            output;
        end;
    end;
    keep i p0;
run; title "Jeffreys Interval by Random Walk Metropolis Algorithm";
proc univariate data=PosteriorSample noprint;
    var p0;
    output out=PP pctlpts = 2.5 97.5 pctlpre = pct;
run; proc print data=pp noobs;
    format pct2_5 pct97_5 6.4;
run;
title; /*2 MCMC*/
title "Jeffreys Credible Interval by PROC MCMC";
ods select PostIntervals;
proc mcmc data=jeff
    seed=123
    outpost=PosteriorSample2
    nbi=10000
    nthin=20
    nmc=1000000
    statistics=(summary interval) diagnostics=none plots=none;
    parms prb 0.5;
    prior prb ~ beta(1/2,1/2);
    model r ~ binomial(n,prb);
run;
title;

SAS list manipulations needs bunch of SAS I/O functions which are not necessarily well known to all SAS programmers. The new DOSUBL function makes this technique much more easier and little bit of ugly I must admit:

%MACRO ExpandVarList(data=_LAST_, var=_ALL_);
    %if %upcase(%superq(data)) = _LAST_
    %then %let data = &SYSLAST;
    %let rc = %sysfunc(dosubl(%str(
    proc transpose data=&DATA(obs=0) out=ExpandVarList_temp;
        var &VAR;
    run;
    proc sql noprint;
        select _name_ into :temp_varnames separated by ‘ ‘
        from ExpandVarList_temp
        ;
    drop table ExpandVarList_temp;
    quit
    )));
    &temp_varnames
%MEND ExpandVarList; %put %ExpandVarList(data=sashelp.class);

this version, but does have huge advantage of utilizing traditional SAS programming elements like data steps, procedures and such.

 /* — Method no. 2 :using a Data Step + Array launched by DOSUBL– */
%macro VarList(data=);
    %local varlist;     /* DOSUBL required for executing the Data Step in a distinct session */
    %let rc = %sysfunc(dosubl(%str(
    Data _null_;
    length varlist $32167.;
        set &data(obs=1);
        array avarn[*] _NUMERIC_;
        array avarc[*] _CHARACTER_;
        do i=1 to dim(avarn);
            varlist=CATX(‘ ‘,varlist, vname(avarn[i]));
        end;
        do i=1 to dim(avarc);
        *no self-reference allowed!;
            if vname(avarc[i]) NE ‘varlist’ then
                varlist=CATX(‘ ‘,varlist, vname(avarc[i]));
        end;
         call symputx(‘varlist’,varlist);
    run;
    )));
   
    &varlist
%mend VarList;
%put %VarList(data=sashelp.class); /* — Method no. 3:  using Dictionary View COLUMNS launched by DOSUBL –*/
%macro VarlistDIC(data=);
    %local libname memname varlist;     /* Test : if . separator exists in DataSet name then extracts Libname & Memname strings accordingly */
    %let libname=%UPCASE( %sysfunc( IFC( %index(&data, .) EQ 0, WORK, %scan(&data,
                1) )));
            %let memname=%UPCASE( %sysfunc( IFC( %index(&data, .) EQ 0, &data,
                %scan(&data, 2) )));
            %let rc = %sysfunc(dosubl(%str(     proc sql noprint;
        select name into :varlist separated by ‘ ‘
        from DICTIONARY.COLUMNS
        where libname EQ "&libname" and memname EQ "&memname"
        ;
    quit;
    )));     &varlist
%mend VarlistDIC;
%put %VarListDIC(data=sashelp.class);

/* — Method no. 4 : using SCL function with iterative FETCHOB + DICTIONARY VIEW — */
%macro ListVar(libname=, memname=);
    /* local var initialisation */
    %let listvar=;
    %let i=0;      
    /* open dictionary view with WHERE clause*/
    %let id=%sysfunc(open(sashelp.vcolumn (where=( libname = "%upcase(&libname)" AND memname= "%upcase(&memname)"))));
    /* load variable names into macro-variables (beware macro var collision !) */
    /* Cf.

http://www.notecolon.info/2013/01/note-open-function-reading-data-sets-in.html */
    %syscall set(id);
    %let rc=0;
    /* loop into each line and accumulate the variable names into a list*/
    %do %until(&rc LT 0);
        %let i=&i+1;
        %let rc=%sysfunc(fetchobs(&id, &i));

        /* force loop exit once last variable has been stored into the list */
        %let listvar= %sysfunc( IFC ( &rc GE 0, &listvar &Name, &listvar ));
    %end;
    %let id=%sysfunc(close(&id));    /* expands the list */
  &listvar
%mend;
%put %ListVar(libname=sashelp, memname=class);

Honors belonged to Mike Molter and Lex Jansen for their hardcore talks on XML and CDISC Dataset-XML respectively. Dataset-XML is basically ODM based replacement of currently wildly used SAS Version 5 Transport File. It’s an emerging technology and it’s nice to check it out:

CDISC Dataset-XML Resources @CDISC

Support for Dataset-XML v1.0 @SAS

/*#1 if branch*/
%macro tragedy_of_life1(ds);
    %if %sysfunc(exist(&ds)) %then %do;
        proc print data=&ds noobs;
        run;
    %end;
    %else %do;
        %put ERROR: Dataset &ds not exist.;
    %end;
%mend; /*#2 abort*/
%macro tragedy_of_life2(ds);
    %if %sysfunc(exist(&ds)) ^= 1 %then %do;
        %put ERROR: Dataset &ds not exist.;
        %abort cancel;   
    %end;     proc print data=&ds noobs;
    run;
%mend; /*#3 goto*/
%macro tragedy_of_life3(ds);
    %if %sysfunc(exist(&ds)) ^= 1 %then %do;
        %put ERROR: Dataset &ds not exist.;
        %goto iExit;   
    %end;     proc print data=&ds noobs;
    run;     %iExit:
%mend;