.ipynb .pdf

Binder Colab

Contents

11. Data Manipulation

In this section, we will cover three main topics

1. Reshaping data frome wide (fat) to long (tall) formats

2. Reshaping data from long (tall) to wide (fat) formats

3. Merging datasets

To reshape datasets, we will cover two methods

• PROC TRANSPOSE

• Using a DATA step with arrays

In order to understand the second more general method, we will first need to learn about a few SAS programming keywords and structures, such as

• The OUTPUT and RETAIN statements

• Loops in SAS

• SAS Arrays

• FIRST. and LAST. SAS variables

11.1. The OUTPUT and RETAIN Statements

When processing any DATA step, SAS follows two default procedures:

1. When SAS reads the DATA statement at the beginning of each iteration of the DATA step, SAS places missing values in the program data vector for variables that were assigned by either an INPUT statement or an assignment statement within the DATA step. (SAS does not reset variables to missing if they were created by a SUM statement, or if the values came from a SAS data set via a SET or MERGE statement.)

2. At the end of the DATA step after completing an iteration of the DATA step, SAS outputs the values of the variables in the program data vector to the SAS data set being created.

In this lesson, we’ll learn how to modify these default processes by using the OUTPUT and RETAIN statements:

• The OUTPUT statement allows you to control when and to which data set you want an observation written.

• The RETAIN statement causes a variable created in the DATA step to retain its value from the current observation into the next observation rather than it being set to missing at the beginning of each iteration of the DATA step.

11.1.1. The OUTPUT Statement

An OUTPUT statement overrides the default process by telling SAS to output the current observation when the OUTPUT statement is processed — not at the end of the DATA step. The OUTPUT statement takes the form:

OUTPUT dataset1 dataset2 ... datasetn;;

where you may name as few or as many data sets as you like. If you use an OUTPUT statement without specifying a data set name, SAS writes the current observation to each of the data sets named in the DATA step. Any data set name appearing in the OUTPUT statement must also appear in the DATA statement.

The OUTPUT statement is pretty powerful in that, among other things, it gives us a way:

• to write observations to multiple data sets

• to control output of observations to data sets based on certain conditions

• to transpose datasets using the OUTPUT statement in conjunction with the RETAIN statement, BY group processing and the LAST.variable statement

Throughout the rest of this section, we’ll look at examples that illustrate how to use OUTPUT statements correctly. We’ll work with the following subset of the ICDB Study’s log data set (see the course website for icdblog.sas7bdat):

LIBNAME PHC6089 "/folders/myfolders/SAS_Notes/data";

PROC PRINT data = phc6089.icdblog (obs=5);
RUN;

SAS Connection established. Subprocess id is 2262

The SAS System

Obs	SUBJ	V_TYPE	V_DATE	FORM
1	210006	12	05/06/94	cmed
2	210006	12	05/06/94	diet
3	210006	12	05/06/94	med
4	210006	12	05/06/94	phytrt
5	210006	12	05/06/94	purg

As you can see, this log data set contains four variables:

• subj: the subject’s identification number

• v_type: the type of clinic visit, which means the number of months since the subject was first seen in the clinic

• v_date: the date of the clinic visit

• form: codes that indicate the data forms that were completed during the subject’s clinic visit

The log data set is a rather typical data set that arises from large national clinical studies in which there are a number of sites around the country where data are collected. Typically, the clinical sites collect the data on data forms and then “ship” the data forms either electronically or by mail to a centralized location called a Data Coordinating Center (DCC). As you can well imagine, keeping track of the data forms at the DCC is a monumental task. For the ICDB Study, for example, the DCC received more than 68,000 data forms over the course of the study.

In order to keep track of the data forms that arrive at the DCC, they are “logged” into a data base and subsequently tracked as they are processed at the DCC. In reality, a log data base will contain many more variables than we have in our subset, such as dates the data on the forms were entered into the data base, who entered the data, the dates the entered data were verified, who verified the data, and so on. To keep our life simple, we’ll just use the four variables described above.

Example

This example uses the OUTPUT statement to tell SAS to write observations to data sets based on certain conditions. Specifically, the following program uses the OUTPUT statement to create three SAS data sets — s210006, s310032, and s410010 — based on whether the subject identification numbers in the icdblog data set meet a certain condition:

LIBNAME PHC6089 "/folders/myfolders/SAS_Notes/data";

DATA s210006 s310032 s410010;
    set phc6089.icdblog;
        if (subj = 210006) then output s210006;
    else if (subj = 310032) then output s310032;
    else if (subj = 410010) then output s410010;
RUN;
 
PROC PRINT data = s210006 (obs=5) NOOBS;
    title 'The s210006 data set';
RUN;
 
PROC PRINT data = s310032 (obs=5) NOOBS;
    title 'The s310032 data set';
RUN;
 
PROC PRINT data = s410010 (obs=5) NOOBS;
    title 'The s410010 data set';
RUN;

The s210006 data set

SUBJ	V_TYPE	V_DATE	FORM
210006	12	05/06/94	cmed
210006	12	05/06/94	diet
210006	12	05/06/94	med
210006	12	05/06/94	phytrt
210006	12	05/06/94	purg

---

The s310032 data set

SUBJ	V_TYPE	V_DATE	FORM
310032	24	09/19/95	backf
310032	24	09/19/95	cmed
310032	24	09/19/95	diet
310032	24	09/19/95	med
310032	24	09/19/95	medhxf

---

The s410010 data set

SUBJ	V_TYPE	V_DATE	FORM
410010	6	05/12/94	cmed
410010	6	05/12/94	diet
410010	6	05/12/94	med
410010	6	05/12/94	phytrt
410010	6	05/12/94	purg

As you can see, the DATA statement contains three data set names — s210006, s310032, and s410010. That tells SAS that we want to create three data sets with the given names. The SET statement, of course, tells SAS to read observations from the permanent data set called stat481.icdblog. Then comes the IF-THEN-ELSE and OUTPUT statements that make it all work. The first IF-THEN tells SAS to output any observations pertaining to subject 210006 to the s210006 data set; the second IF-THEN tells SAS to output any observations pertaining to subject 310032 to the s310032 data set; and, the third IF-THEN statement tells SAS to output any observations pertaining to subject 410010 to the s410010 data set. SAS will hiccup if you have a data set name that appears in an OUTPUT statement without it also appearing in the DATA statement.

The PRINT procedures, of course, tell SAS to print the three newly created data sets. Note that the last PRINT procedure does not have a DATA= option. That's because when you name more than one data set in a single DATA statement, the last name on the DATA statement is the most recently created data set, and the one that subsequent procedures use by default. Therefore, the last PRINT procedure will print the s410010 data set by default.

Note that the IF-THEN-ELSE construct used here in conjunction with the OUTPUT statement is comparable to attaching the WHERE= option to each of the data sets appearing in the DATA statement.

Before running the code be sure that you have saved the icdblog dataset and changed the LIBNAME statement to the folder where you saved it.

Example

Using an OUTPUT statement suppresses the automatic output of observations at the end of the DATA step. Therefore, if you plan to use any OUTPUT statements in a DATA step, you must use OUTPUT statements to program all of the output for that step. The following SAS program illustrates what happens if you fail to direct all of the observations to output:

DATA subj210006 subj310032;
    set phc6089.icdblog;
    if (subj = 210006) then output subj210006;
RUN;
 
PROC PRINT data = subj210006 NOOBS;
    title 'The subj210006 data set';
RUN;

The subj210006 data set

SUBJ	V_TYPE	V_DATE	FORM
210006	12	05/06/94	cmed
210006	12	05/06/94	diet
210006	12	05/06/94	med
210006	12	05/06/94	phytrt
210006	12	05/06/94	purg
210006	12	05/06/94	qul
210006	12	05/06/94	sympts
210006	12	05/06/94	urn
210006	12	05/06/94	void

PROC PRINT data = subj310032 NOOBS;
    title 'The subj310032 data set';
RUN;

198  ods listing close;ods html5 (id=saspy_internal) file=stdout options(bitmap_mode='inline') device=svg style=HTMLBlue; ods
198! graphics on / outputfmt=png;
NOTE: Writing HTML5(SASPY_INTERNAL) Body file: STDOUT
199  
200  PROC PRINT data = subj310032 NOOBS;
201      title 'The subj310032 data set';
202  RUN;
NOTE: No observations in data set WORK.SUBJ310032.
NOTE: PROCEDURE PRINT used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      
203  
204  ods html5 (id=saspy_internal) close;ods listing;

205  

The DATA statement contains two data set names, subj210006 and subj310032, telling SAS that we intend to create two data sets. However, as you can see, the IF statement contains an OUTPUT statement that directs output to the subj210006 data set, but no OUTPUT statement directs output to the subj310032 data set. Launch and run the SAS program to convince yourself that the subj210006 data set contains data for subject 210006, while the subj310032 data set contains 0 observations. You should see a message in the log window like the one shown above as well as see that no output for the subj310032 data set appears in the output window.

Example

If you use an assignment statement to create a new variable in a DATA step in the presence of OUTPUT statements, you have to make sure that you place the assignment statement before the OUTPUT statements. Otherwise, SAS will have already written the observation to the SAS data set, and the newly created variable will be set to missing. The following SAS program illustrates an example of how two variables, current and days_vis, get set to missing in the output data sets because their values get calculated after SAS has already written the observation to the SAS data set:

DATA subj210006 subj310032 subj410010;
    set phc6089.icdblog;
        if (subj = 210006) then output subj210006;
    else if (subj = 310032) then output subj310032;
    else if (subj = 410010) then output subj410010;
    current = today();
    days_vis = current - v_date;
    format current mmddyy8.;
RUN;
 
PROC PRINT data = subj310032 NOOBS;
    title 'The subj310032 data set';
RUN;

The subj310032 data set

SUBJ	V_TYPE	V_DATE	FORM	current	days_vis
310032	24	09/19/95	backf	.	.
310032	24	09/19/95	cmed	.	.
310032	24	09/19/95	diet	.	.
310032	24	09/19/95	med	.	.
310032	24	09/19/95	medhxf	.	.
310032	24	09/19/95	phs	.	.
310032	24	09/19/95	phytrt	.	.
310032	24	09/19/95	preg	.	.
310032	24	09/19/95	purg	.	.
310032	24	09/19/95	qul	.	.
310032	24	09/19/95	sympts	.	.
310032	24	09/19/95	urn	.	.
310032	24	09/19/95	void	.	.

The main thing to note in this program is that the current and days_vis assignment statements appear after the IF-THEN-ELSE and OUTPUT statements. That means that each observation will be written to one of the three output data sets before the current and days_vis values are even calculated. Because SAS sets variables created in the DATA step to missing at the beginning of each iteration of the DATA step, the values of current and days_vis will remain missing for each observation.

By the way, the today( ) function, which is assigned to the variable current, creates a date variable containing today's date. Therefore, the variable days_vis is meant to contain the number of days since the subject's recorded visit v_date. However, as described above, the values of current and days_vis get set to missing. Launch and run the SAS program to convince yourself that the current and days_vis variables in the subj310032 data set contain only missing values. If we were to print the subj210006 and subj410020 data sets, we would see the same thing.

The following SAS program illustrates the corrected code for the previous DATA step, that is, for creating new variables with assignment statements in the presence of OUTPUT statements:

DATA subj210006 subj310032 subj410010;
    set phc6089.icdblog;
    current = today();
    days_vis = current - v_date;
    format current mmddyy8.;
        if (subj = 210006) then output subj210006;
    else if (subj = 310032) then output subj310032;
    else if (subj = 410010) then output subj410010;
RUN;
 
PROC PRINT data = subj310032 NOOBS;
    title 'The subj310032 data set';
RUN;

The subj310032 data set

SUBJ	V_TYPE	V_DATE	FORM	current	days_vis
310032	24	09/19/95	backf	09/30/20	9143
310032	24	09/19/95	cmed	09/30/20	9143
310032	24	09/19/95	diet	09/30/20	9143
310032	24	09/19/95	med	09/30/20	9143
310032	24	09/19/95	medhxf	09/30/20	9143
310032	24	09/19/95	phs	09/30/20	9143
310032	24	09/19/95	phytrt	09/30/20	9143
310032	24	09/19/95	preg	09/30/20	9143
310032	24	09/19/95	purg	09/30/20	9143
310032	24	09/19/95	qul	09/30/20	9143
310032	24	09/19/95	sympts	09/30/20	9143
310032	24	09/19/95	urn	09/30/20	9143
310032	24	09/19/95	void	09/30/20	9143

Now, since the assignment statements precede the OUTPUT statements, the variables are correctly written to the output data sets. That is, now the variable current contains the date in which the program was run and the variable days_vis contains the number of days since that date and the date of the subject's visit. Launch and run the SAS program to convince yourself that the current and days_vis variables are properly written to the subj310032 data set. If we were to print the subj210006 and subj410020 data sets, we would see similar results.

Example

After SAS processes an OUTPUT statement within a DATA step, the observation remains in the program data vector and you can continue programming with it. You can even output the observation again to the same SAS data set or to a different one! The following SAS program illustrates how you can create different data sets with the some of the same observations. That is, the data sets created in your DATA statement do not have to be mutually exclusive:

DATA symptoms visitsix;
    set phc6089.icdblog;
    if form = 'sympts' then output symptoms;
    if v_type = 6 then output visitsix;
RUN;
 
PROC PRINT data = symptoms NOOBS;
    title 'The symptoms data set';
RUN;
 
PROC PRINT data = visitsix NOOBS;
    title 'The visitsix data set';
RUN;

The symptoms data set

SUBJ	V_TYPE	V_DATE	FORM
210006	12	05/06/94	sympts
310032	24	09/19/95	sympts
410010	6	05/12/94	sympts

---

The visitsix data set

SUBJ	V_TYPE	V_DATE	FORM
410010	6	05/12/94	cmed
410010	6	05/12/94	diet
410010	6	05/12/94	med
410010	6	05/12/94	phytrt
410010	6	05/12/94	purg
410010	6	05/12/94	qul
410010	6	05/12/94	sympts
410010	6	05/12/94	urn
410010	6	05/12/94	void

The DATA step creates two temporary data sets, symptoms and visitsix. The symptoms data set contains only those observations containing a form code of sympts. The visitsix data set, on the other hand, contains observations for which v_type equals 6. The observations in the two data sets are therefore not necessarily mutually exclusive. In fact, launch and run the SAS program and review the output from the PRINT procedures. Note that the observation for subject 410010 in which form = sympts is contained in both the symptoms and visitsix data sets.

11.1.2. The RETAIN Statement

When SAS reads the DATA statement at the beginning of each iteration of the DATA step, SAS places missing values in the program data vector for variables that were assigned by either an INPUT statement or an assignment statement within the DATA step. A RETAIN statement effectively overrides this default. That is, a RETAIN statement tells SAS not to set variables whose values are assigned by an INPUT or assignment statement to missing when going from the current iteration of the DATA step to the next. Instead, SAS retains the values. The RETAIN statement takes the generic form:

RETAIN variable1 variable2 ... variablen;

You can specify as few or as many variables as you want. If you specify no variable names, then SAS retains the values of all of the variables created in an INPUT or assignment statement. You may initialize the values of variables within a RETAIN statement. For example, in the statement:

RETAIN var1 0 var2 3 a b c 'XYZ'

the variable var1 is assigned the value 0; the variable var2 is assigned the value 3, and the variables a, b, and c are all assigned the character value ‘XYZ’. If you do not specify an initial value, SAS sets the initial value of a variable to be retained to missing.

Finally, since the RETAIN statement is not an executable statement, it can appear anywhere in the DATA step.

Throughout the remainder of the lesson, we will work with the grades data set that is created in the following DATA step:

DATA grades;
    input idno 1-2 l_name $ 5-9 gtype $ 12-13 grade 15-17;
    cards;
10  Smith  E1  78
10  Smith  E2  82
10  Smith  E3  86
10  Smith  E4  69
10  Smith  P1  97
10  Smith  F1 160
11  Simon  E1  88
11  Simon  E2  72
11  Simon  E3  86
11  Simon  E4  99
11  Simon  P1 100
11  Simon  F1 170
12  Jones  E1  98
12  Jones  E2  92
12  Jones  E3  92
12  Jones  E4  99
12  Jones  P1  99
12  Jones  F1 185
;
RUN;
 
PROC PRINT data = grades (obs=5) NOOBS;
    title 'The grades data set';
RUN;

The grades data set

idno	l_name	gtype	grade
10	Smith	E1	78
10	Smith	E2	82
10	Smith	E3	86
10	Smith	E4	69
10	Smith	P1	97

The grades data set is what we call a “subject- and grade-specific” data set. That is, there is one observation for each grade for each student. Students are identified by their id number (idno) and last name (l_name). The data set contains six different types of grades: exam 1 (E1), exam 2 (E2), exam 3 (E3), exam 4 (E4), each worth 100 points; one project (P1) worth 100 points; and a final exam (F1) worth 200 points. We’ll suppose that the instructor agreed to drop the students’ lowest exam grades (E1, E2, E3, E4) not including the final exam. Launch and run the SAS program so that we can work with the grades data set in the following examples. Review the output from the PRINT procedure to convince yourself that the data were properly read into the grades data set.

Before we look at an example using the RETAIN statement, let’s look at the SAS variables FIRST. and LAST.

Example

The following SAS program illustrates the SAS variables FIRST. and LAST. that can be obtained when using the BY statement on a sorted dataset in a DATA step to identify the first and last grade record for each student in the dataset.

PROC SORT data = grades out = srt_grades;
   BY idno;
RUN;

DATA grades_first_last;
   SET srt_grades;
   BY idno;
   firstGrade = FIRST.idno;
   lastGrade = LAST.idno;
RUN;

PROC PRINT data = grades_first_last;
RUN;

The grades data set

Obs	idno	l_name	gtype	grade	firstGrade	lastGrade
1	10	Smith	E1	78	1	0
2	10	Smith	E2	82	0	0
3	10	Smith	E3	86	0	0
4	10	Smith	E4	69	0	0
5	10	Smith	P1	97	0	0
6	10	Smith	F1	160	0	1
7	11	Simon	E1	88	1	0
8	11	Simon	E2	72	0	0
9	11	Simon	E3	86	0	0
10	11	Simon	E4	99	0	0
11	11	Simon	P1	100	0	0
12	11	Simon	F1	170	0	1
13	12	Jones	E1	98	1	0
14	12	Jones	E2	92	0	0
15	12	Jones	E3	92	0	0
16	12	Jones	E4	99	0	0
17	12	Jones	P1	99	0	0
18	12	Jones	F1	185	0	1

Because we are doing BY group processing on the variable idno, we must have the dataset sorted by idno. In this case the dataset was actually already sorted by idno, but I added the PROC SORT anyway to emphasize that the dataset must be sorted first.

The SET and BY statement tell SAS to process the data by grouping observations with the same idno together. To do this, SAS automatically creats two temporary variables for each variable name in the BY statement. One of the temporary variables is called FIRST.variable, where variable is the variable name appearing the BY statement. The other temporary variable is called LAST.variable. Both take the values 0 or 1:

• FIRST.variable = 1 when an observation is the first observation in a BY group
• FIRST.variable = 0 when an observation is not the first observation in a BY group
• LAST.variable = 1 when an observation is the last observation in a BY group
• LAST.variable = 0 when an observation is not the last observation in a BY group

SAS uses the values of the FIRST.variable and LAST.variable temporary variables to identify the first and last observations in a group, and therefore the group itself. Oh, a comment about that adjective temporary ... SAS places FIRST.variable and LAST.variable in the program data vector and they are therefore available for DATA step programming, but SAS does not add them to the SAS data set being created. It is in that sense that they are temporary.

Because SAS does not write FIRST.variables and LAST.variables to output data sets, we have to do some finagling to see their contents. The two assignment statements:

    firstGrade = FIRST.idno;
    lastGrade = LAST.idno;
    

simply tell SAS to assign the values of the temporary variables, FIRST.idno and LAST.idno, to permanent variables, firstGrade and lastGrade, respectively. The PRINT procedure tells SAS to print the resulting data set so that we can take an inside peek at the values of the FIRST.variables and LAST.variables.

Example

One of the most powerful uses of a RETAIN statement is to compare values across observations. The following program uses the RETAIN statement to compare values across observations, and in doing so determines each student's lowest grade of the four semester exams:

DATA exams;
    set grades (where = (gtype in ('E1', 'E2', 'E3', 'E4')));
RUN;
 
DATA lowest (rename = (lowtype = gtype));
    set exams;
    by idno;
    retain lowgrade lowtype;
    if first.idno then lowgrade = grade;
    lowgrade = min(lowgrade, grade);
    if grade = lowgrade then lowtype = gtype;
    if last.idno then output;
    drop gtype;
RUN;
 
PROC PRINT data=lowest;
    title 'Output Dataset: LOWEST';
RUN;

Output Dataset: LOWEST

Obs	idno	l_name	grade	lowgrade	gtype
1	10	Smith	69	69	E4
2	11	Simon	99	72	E2
3	12	Jones	99	92	E3

Because the instructor only wants to drop the lowest exam grade, the first DATA step tells SAS to create a data set called exams by selecting only the exam grades (E1, E2, E3, and E4) from the data set grades.

It's the second DATA step that is the meat of the program and the challenging one to understand. The DATA step searches through the exams data set for each subject ("by idno") and looks for the lowest grade ("min(lowgrade, grade)"). Because SAS would otherwise set the variables lowgrade and lowtype to missing for each new iteration, the RETAIN statement is used to keep track of the observation that contains the lowest grade. When SAS reads the last observation of the student ("last.idno") it outputs the data corresponding to the lowest exam type (lowtype) and grade (lowgrade) to the lowest data set. (Note that the statement "if last.idno then output;" effectively collapses multiple observations per student into one observation per student.) So that we can merge the lowest data set back into the grades data set, by idno and gtype, the variable lowtype is renamed back to gtype.

11.2. DO Loops

When programming, you can find yourself needing to tell SAS to execute the same statements over and over again. That’s when a DO loop can come in and save your day. The actions of some DO loops are unconditional in that if you tell SAS to do something 20 times, SAS will do it 20 times regardless. We call those kinds of loops iterative DO loops. On the other hand, actions of some DO loops are conditional in that you tell SAS to do something until a particular condition is met or to do something while a particular condition is met. We call the former a DO UNTIL loop and the latter a DO WHILE loop. In this lesson, we’ll explore the ins and outs of these three different kinds of loops, as well as take a look at lots of examples in which they are used. Then, in the next section, we’ll use DO loops to help us process arrays.

11.2.1. Iterative DO Loops

In this section, we’ll explore the use of iterative DO loops, in which you tell SAS to execute a statement or a group of statements a certain number of times. Let’s take a look at some examples.

Example

The following program uses a DO loop to tell SAS to determine what four times three (4 × 3) equals:

DATA multiply;
    answer = 0;
    do i = 1 to 4;
        answer + 3;
    end;
RUN;
 
PROC PRINT NOOBS;
    title 'Four Times Three Equals...';
RUN;

Four Times Three Equals...

answer	i
12	5

Okay... admittedly, we could accomplish our goal of determining four times three in a much simpler way, but then we wouldn't have the pleasure of seeing how we can accomplish it using an iterative DO loop! The key to understanding the DATA step here is to recall that multiplication is just repeated addition. That is, four times three (4 × 3) is the same as adding three together four times, that is, 3 + 3 + 3 + 3. That's all that the iterative DO loop in the DATA step is telling SAS to do. After having initialized answer to 0, add 3 to answer, then add 3 to answer again, and add 3 to answer again, and add 3 to answer again. After SAS has added 3 to the answer variable four times, SAS exits the DO loop, and since that's the end of the DATA step, SAS moves onto the next procedure and prints the result.

The other thing you might want to notice about the DATA step is that there is no input data set or input data file. We are generating data from scratch here, rather than from some input source. Now, launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that our code properly calculates four times three.

Ahhh, what about that i variable that shows up in our multiply data set? If you look at our DATA step again, you can see that it comes from the DO loop. It is what is called the index variable (or counter variable). Most often, you'll want to drop it from your output data set, but its presence here is educational. As you can see, its current value is 5. That's what allows SAS to exit the DO loop... we tell SAS only to take the actions inside the loop until i equals 4. Once i becomes greater than 4, SAS jumps out of the loop, and moves on to the next statements in the DATA step. Let's take a look at the general form of iterative DO loops.

To construct an iterative DO loop, you need to start with a DO statement, then include some action statements, and then end with an END statement. Here’s what a simple iterative DO loop should look like:

DO index-variable = start TO stop BY increment;
    action statements;
END;

where

• DO, index-variable, start, TO, stop, and END are required in every iterative DO loop

• index-variable, which stores the value of the current iteration of the DO loop, can be any valid SAS variable name. It is common, however, to use a single letter, with i and j being the most used.

• start is the value of the index variable at which you want SAS to start the loop

• stop is the value of the index variable at which you want SAS to stop the loop

• increment is by how much you want SAS to change the index variable after each iteration. The most commonly used increment is 1. In fact, if you don’t specify a BY clause, SAS uses the default increment of 1.

For example,

do jack = 1 to 5;

tells SAS to create an index variable called jack, start at 1, increment by 1, and end at 5, so that the values of jack from iteration to iteration are 1, 2, 3, 4, and 5. And, this DO statement:

do jill = 2 to 12 by 2;

tells SAS to create an index variable called jill, start at 2, increment by 2, and end at 12, so that the values of jill from iteration to iteration are 2, 4, 6, 8, 10, and 12.

Example

The following SAS program uses an iterative DO loop to count backwards by 1:

DATA backwardsbyone;
    do i = 20 to 1 by -1;
        output;
    end;
RUN;
 
PROC PRINT data = backwardsbyone NOOBS;
    title 'Counting Backwards by 1';
RUN;

Counting Backwards by 1

i
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1

As you can see in this DO statement, you can decrement a DO loop's index variable by specifying a negative value for the BY clause. Here, we tell SAS to start at 20, and decrease the index variable by 1, until it reaches 1. The OUTPUT statement tells SAS to output the value of the index variable i for each iteration of the DO loop. Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that our code properly counts backwards from 20 to 1.

Rather than specifying start, stop and increment values in a DO statement, you can tell SAS how many times to execute a DO loop by listing items in a series. In this case, the general form of the iterative DO loop looks like this:

DO index-variable = value1, value2, value3, ...;
    action statements;
END;

where the values can be character or numeric. When the DO loop executes, it executes once for each item in the series. The index variable equals the value of the current item. You must use commas to separate items in a series. To list items in a series, you must specify

either all numeric values:

DO i = 1, 2, 3, 4, 5;

all character values, with each value enclosed in quotation marks

DO j = 'winter', 'spring', 'summer', 'fall';

or all variable names:

DO k = first, second, third;

In this case, the index variable takes on the values of the specified variables. Note that the variable names are not enclosed in quotation marks, while quotation marks are required for character values.

11.2.2. Nested DO Loops

Just like in other programming languages. We can nest loops within each other.

Example

Suppose you are interested in conducting an experiment with two factors A and B. Suppose factor A is, say, the amount of water with levels 1, 2, 3, and 4; and factor B is, say, the amount of sunlight, say with levels 1, 2, 3, 4, and 5. Then, the following SAS code uses nested iterative DO loops to generate the 4 by 5 factorial design:

DATA design;
DO i = 1 to 4;
    DO j = 1 to 5;
        output;
            END;
    END;
RUN;
 
PROC PRINT data = design;
    TITLE '4 by 5 Factorial Design';
RUN;

4 by 5 Factorial Design

Obs	i	j
1	1	1
2	1	2
3	1	3
4	1	4
5	1	5
6	2	1
7	2	2
8	2	3
9	2	4
10	2	5
11	3	1
12	3	2
13	3	3
14	3	4
15	3	5
16	4	1
17	4	2
18	4	3
19	4	4
20	4	5

First, launch and run the SAS program. Then, review the output from the PRINT procedure to see the contents of the design data set. By doing so, you can get a good feel for how the nested DO loops work. First, SAS sets the value of the index variable i to 1, then proceeds to the next step which happens to be another iterative DO loop. While i is 1:

• SAS sets the value of j to 1, and outputs the observation in which i = 1 and j = 1.
• Then, SAS sets the value j to 2, and outputs the observation in which i = 1 and j = 2.
• Then, SAS sets the value j to 3, and outputs the observation in which i = 1 and j = 3.
• Then, SAS sets the value j to 4, and outputs the observation in which i = 1 and j = 4.
• Then, SAS sets the value j to 5, and outputs the observation in which i = 1 and j = 5.
• Then, SAS sets the value j to 6, and jumps out of the inside DO loop and proceeds to the next statement, which happens to be the end of the outside DO loop.

SAS then sets the value of the index variable i to 2, then proceeds through the inside DO loop again just as described above. This process continues until SAS sets the value of index variable i to 5, jumps out of the outside DO loop, and ends the DATA step.

11.2.3. DO UNITL and DO WHILE Loops

As you now know, the iterative DO loop requires that you specify the number of iterations for the DO loop. However, there are times when you want to execute a DO loop until a condition is reached or while a condition exists, but you don’t know how many iterations are needed. That’s when the DO UNTIL loop and the DO WHILE loop can help save the day!

In this section, we’ll first learn about the DO UNTIL and DO WHILE loops. Then, we’ll look at another form of the iterative DO loop that combines features of both conditional and unconditional DO loops.

When you use a DO UNTIL loop, SAS executes the DO loop until the expression you’ve specified is true. Here’s the general form of a DO UNTIL loop:

DO UNTIL (expression);
    action statements;
END;

where expression is any valid SAS expression enclosed in parentheses. The key thing to remember is that the expression is not evaluated until the bottom of the loop. Therefore, a DO UNTIL loop always executes at least once. As soon as the expression is determined to be true, the DO loop does not execute again.

Example

Suppose you want to know how many years it would take to accumulate 50,000 if you deposit 1200 each year into an account that earns 5% interest. The following program uses a DO UNTIL loop to perform the calculation for us:

DATA investment;
    RETAIN value 0 year 0;
    DO UNTIL (value >= 50000);
        value = value + 1200;
        value = value + value * 0.05;
        year = year + 1;
        OUTPUT;
    END;
RUN;
 
PROC PRINT data = investment NOOBS;
    title 'Years until at least $50,000';
RUN;

Years until at least $50,000

value	year
1260.00	1
2583.00	2
3972.15	3
5430.76	4
6962.30	5
8570.41	6
10258.93	7
12031.88	8
13893.47	9
15848.14	10
17900.55	11
20055.58	12
22318.36	13
24694.28	14
27188.99	15
29808.44	16
32558.86	17
35446.80	18
38479.14	19
41663.10	20
45006.26	21
48516.57	22
52202.40	23

Recall that the expression in the DO UNTIL statement is not evaluated until the bottom of the loop. Therefore, the DO UNTIL loop executes at least once. On the first iteration, the value variable is increased by 1200, or in this case, set to 1200. Then, the value variable is updated by calculating 1200 + 1200*0.05 to get 1260. Then, the year variable is increased by 1, or in this case, set to 1. The first observation, for which year = 1 and value = 1260, is then written to the output data set called investment. Having reached the bottom of the DO UNTIL loop, the expression (value >= 50000) is evaluated to determine if it is true. Since value is just 1260, the expression is not true, and so the DO UNTIL loop is executed once again. The process continues as described until SAS determines that value is at least 50000 and therefore stops executing the DO UNTIL loop.

Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that it would take 23 years to accumulate at least $50,000.

When you use a DO WHILE loop, SAS executes the DO loop while the expression you’ve specified is true. Here’s the general form of a DO WHILE loop:

DO WHILE (expression);
      action statements;
END;

where expression is any valid SAS expression enclosed in parentheses. An important difference between the DO UNTIL and DO WHILE statements is that the DO WHILE expression is evaluated at the top of the DO loop. If the expression is false the first time it is evaluated, then the DO loop doesn’t even execute once.

Example

The following program attempts to use a DO WHILE loop to accomplish the same goal as the program above, namely to determine how many years it would take to accumulate \$50,000 if you deposit \$1200 each year into an account that earns 5% interest:

DATA investtwo;
    RETAIN value 0 year 0;
    DO WHILE (value < 50000);
        value = value + 1200;
        value = value + value * 0.05;
        year = year + 1;
        OUTPUT;
     END;
RUN;
 
PROC PRINT data = investtwo NOOBS;
   title 'Years until at least $50,000';
RUN;

Years until at least $50,000

value	year
1260.00	1
2583.00	2
3972.15	3
5430.76	4
6962.30	5
8570.41	6
10258.93	7
12031.88	8
13893.47	9
15848.14	10
17900.55	11
20055.58	12
22318.36	13
24694.28	14
27188.99	15
29808.44	16
32558.86	17
35446.80	18
38479.14	19
41663.10	20
45006.26	21
48516.57	22
52202.40	23

The calculations proceed as before. First, the value variable is updated to by calculating 0 + 1200, to get 1200. Then, the value variable is updated by calculating 1200 + 1200*0.05 to get 1260. Then, the year variable is increased by 1, or in this case, set to 1. The first observation, for which year = 1 and value = 1260, is then written to the output data set called investthree. SAS then returns to the top of the DO WHILE loop, to determine if the expression (value < 50000) is true. Since value is just 1260, the expression is true, and so the DO WHILE loop executes once again. The process continues as described until SAS determines that value is as least 50000 and therefore stops executing the DO WHILE loop.

Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that this program also determines that it would take 23 years to accumulate at least \$50,000.

You should also try changing the WHILE condition from value < 50000 to value ≥ 50000 to see what happens. (Hint: you will get no output. Why?)

You have now seen how the DO WHILE and DO UNTIL loops enable you to execute statements repeatedly, but conditionally so. You have also seen how the iterative DO loop enables you to execute statements a set number of times unconditionally. Now, we’ll put the two together to create a form of the iterative DO loop that executes DO loops conditionally as well as unconditionally.

Example

Suppose again that you want to know how many years it would take to accumulate 50,000 if you deposit 1200 each year into an account that earns 5% interest. But this time, suppose you also want to limit the number of years that you invest to 15 years. The following program uses a conditional iterative DO loop to accumulate our investment until we reach 15 years or until the value of our investment exceeds 50000, whichever comes first:

DATA investfour (drop = i);
     RETAIN value 0 year 0;
     DO i = 1 to 15 UNTIL (value >= 50000);
          value = value + 1200;
          value = value + value * 0.05;
          year = year + 1;
          OUTPUT;
     END;
RUN;
 
PROC PRINT data = investfour NOOBS;
   title 'Value of Investment';
RUN;

Value of Investment

value	year
1260.00	1
2583.00	2
3972.15	3
5430.76	4
6962.30	5
8570.41	6
10258.93	7
12031.88	8
13893.47	9
15848.14	10
17900.55	11
20055.58	12
22318.36	13
24694.28	14
27188.99	15

Note that there are just two differences between this program and that of the program in the previous example that uses the DO UNTIL loop: i) The iteration i = 1 to 15 has been inserted into the DO UNTIL statement; and ii) because the index variable i is created for the DO loop, it is dropped before writing the contents from the program data vector to the output data set investfour.

11.3. SAS Arrays

In this section, we’ll learn about basic array processing in SAS. In DATA step programming, you often need to perform the same action on more than one variable at a time. Although you can process the variables individually, it is typically easier to handle the variables as a group. Arrays offer you that option. For example, until now, if you wanted to take the square root of the 50 numeric variables in your SAS data set, you’d have to write 50 SAS assignment statements to accomplish the task. Instead, you can use an array to simplify your task.

Arrays can be used to simplify your code when you need to:

• perform repetitive calculations

• create many variables that have the same attributes

• read data

• transpose “fat” data sets to “tall” data sets, that is, change the variables in a data set to observations

• transpose “tall” data sets to “fat” data sets, that is, change the observations in a data set to variables

• compare variables

In this lesson, we’ll learn how to accomplish such tasks using arrays. Using arrays in appropriate situations can seriously simplify and shorten your SAS programs!

11.3.1. One-Dimensional Arrays

A SAS array is a temporary grouping of SAS variables under a single name. For example, suppose you have four variables named winter, spring, summer, and, fall. Rather than referring to the variables by their four different names, you could associate the variables with an array name, say seasons, and refer to the variables as seasons(1), seasons(2), seasons(3), and seasons(4). When you pair an array up with an iterative DO loop, you create a powerful and efficient way of writing your computer programs. Let’s take a look at an example!

Example

The following program simply reads in the average montly temperatures (in Celsius) for ten different cities in the United States into a temporary SAS data set called avgcelsius:

DATA avgcelsius;
    input City $ 1-18 jan feb mar apr may jun
                        jul aug sep oct nov dec;
    DATALINES;
State College, PA  -2 -2  2  8 14 19 21 20 16 10  4 -1
Miami, FL          20 20 22 23 26 27 28 28 27 26 23 20
St. Louis, MO      -1  1  6 13 18 23 26 25 21 15  7  1
New Orleans, LA    11 13 16 20 23 27 27 27 26 21 16 12
Madison, WI        -8 -5  0  7 14 19 22 20 16 10  2 -5
Houston, TX        10 12 16 20 23 27 28 28 26 21 16 12
Phoenix, AZ        12 14 16 21 26 31 33 32 30 23 16 12
Seattle, WA         5  6  7 10 13 16 18 18 16 12  8  6
San Francisco, CA  10 12 12 13 14 15 15 16 17 16 14 11
San Diego, CA      13 14 15 16 17 19 21 22 21 19 16 14
;
RUN;
 
PROC PRINT data = avgcelsius;
    title 'Average Monthly Temperatures in Celsius';
    id City;
    var jan feb mar apr may jun 
        jul aug sep oct nov dec;
RUN;

Average Monthly Temperatures in Celsius

City	jan	feb	mar	apr	may	jun	jul	aug	sep	oct	nov	dec
State College, PA	-2	-2	2	8	14	19	21	20	16	10	4	-1
Miami, FL	20	20	22	23	26	27	28	28	27	26	23	20
St. Louis, MO	-1	1	6	13	18	23	26	25	21	15	7	1
New Orleans, LA	11	13	16	20	23	27	27	27	26	21	16	12
Madison, WI	-8	-5	0	7	14	19	22	20	16	10	2	-5
Houston, TX	10	12	16	20	23	27	28	28	26	21	16	12
Phoenix, AZ	12	14	16	21	26	31	33	32	30	23	16	12
Seattle, WA	5	6	7	10	13	16	18	18	16	12	8	6
San Francisco, CA	10	12	12	13	14	15	15	16	17	16	14	11
San Diego, CA	13	14	15	16	17	19	21	22	21	19	16	14

Now, suppose that we don't feel particularly comfortable with understanding Celsius temperatures, and therefore, we want to convert the Celsius temperatures into Fahrenheit temperatures for which we have a better feel. The following SAS program uses the standard conversion formula:

Fahrenheit temperature = 1.8*Celsius temperature + 32

to convert the Celsius temperatures in the avgcelsius data set to Fahrenheit temperatures stored in a new data set called avgfahrenheit:

DATA avgfahrenheit;
    set avgcelsius;
    janf = 1.8*jan + 32;
    febf = 1.8*feb + 32;
    marf = 1.8*mar + 32;
    aprf = 1.8*apr + 32;
    mayf = 1.8*may + 32;
    junf = 1.8*jun + 32;
    julf = 1.8*jul + 32;
    augf = 1.8*aug + 32;
    sepf = 1.8*sep + 32;
    octf = 1.8*oct + 32;
    novf = 1.8*nov + 32;
    decf = 1.8*dec + 32;
    drop jan feb mar apr may jun
            jul aug sep oct nov dec;
RUN;
 
PROC PRINT data = avgfahrenheit;
    title 'Average Monthly Temperatures in Fahrenheit';
    id City;
    var janf febf marf aprf mayf junf 
        julf augf sepf octf novf decf;
RUN;

Average Monthly Temperatures in Fahrenheit

City	janf	febf	marf	aprf	mayf	junf	julf	augf	sepf	octf	novf	decf
State College, PA	28.4	28.4	35.6	46.4	57.2	66.2	69.8	68.0	60.8	50.0	39.2	30.2
Miami, FL	68.0	68.0	71.6	73.4	78.8	80.6	82.4	82.4	80.6	78.8	73.4	68.0
St. Louis, MO	30.2	33.8	42.8	55.4	64.4	73.4	78.8	77.0	69.8	59.0	44.6	33.8
New Orleans, LA	51.8	55.4	60.8	68.0	73.4	80.6	80.6	80.6	78.8	69.8	60.8	53.6
Madison, WI	17.6	23.0	32.0	44.6	57.2	66.2	71.6	68.0	60.8	50.0	35.6	23.0
Houston, TX	50.0	53.6	60.8	68.0	73.4	80.6	82.4	82.4	78.8	69.8	60.8	53.6
Phoenix, AZ	53.6	57.2	60.8	69.8	78.8	87.8	91.4	89.6	86.0	73.4	60.8	53.6
Seattle, WA	41.0	42.8	44.6	50.0	55.4	60.8	64.4	64.4	60.8	53.6	46.4	42.8
San Francisco, CA	50.0	53.6	53.6	55.4	57.2	59.0	59.0	60.8	62.6	60.8	57.2	51.8
San Diego, CA	55.4	57.2	59.0	60.8	62.6	66.2	69.8	71.6	69.8	66.2	60.8	57.2

As you can see by the number of assignment statements necessary to make the conversions, the exercise becomes one of patience. Because there are twelve average monthly temperatures, we must write twelve assignment statements. Each assignment statement performs the same calculation. Only the name of the variable changes in each statement. Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that the Celsius temperatures were properly converted to Fahrenheit temperatures.

The above program is crying out for the use of an array. One of the primary arguments for using an array is to reduce the number of statements that are required for processing variables. Let's take a look at an example.

The following program uses a one-dimensional array called fahr to convert the average Celsius temperatures in the avgcelsius data set to average Fahrenheit temperatures stored in a new data set called avgfahrenheit:

DATA avgfahrenheit;
    set avgcelsius;
    array fahr(12) jan feb mar apr may jun
                   jul aug sep oct nov dec;
    do i = 1 to 12;
        fahr(i) = 1.8*fahr(i) + 32;
    end;
RUN;
 
PROC PRINT data = avgfahrenheit;
    title 'Average Monthly Temperatures in Fahrenheit';
    id City;
    var jan feb mar apr may jun 
        jul aug sep oct nov dec;
RUN;

Average Monthly Temperatures in Fahrenheit

City	jan	feb	mar	apr	may	jun	jul	aug	sep	oct	nov	dec
State College, PA	28.4	28.4	35.6	46.4	57.2	66.2	69.8	68.0	60.8	50.0	39.2	30.2
Miami, FL	68.0	68.0	71.6	73.4	78.8	80.6	82.4	82.4	80.6	78.8	73.4	68.0
St. Louis, MO	30.2	33.8	42.8	55.4	64.4	73.4	78.8	77.0	69.8	59.0	44.6	33.8
New Orleans, LA	51.8	55.4	60.8	68.0	73.4	80.6	80.6	80.6	78.8	69.8	60.8	53.6
Madison, WI	17.6	23.0	32.0	44.6	57.2	66.2	71.6	68.0	60.8	50.0	35.6	23.0
Houston, TX	50.0	53.6	60.8	68.0	73.4	80.6	82.4	82.4	78.8	69.8	60.8	53.6
Phoenix, AZ	53.6	57.2	60.8	69.8	78.8	87.8	91.4	89.6	86.0	73.4	60.8	53.6
Seattle, WA	41.0	42.8	44.6	50.0	55.4	60.8	64.4	64.4	60.8	53.6	46.4	42.8
San Francisco, CA	50.0	53.6	53.6	55.4	57.2	59.0	59.0	60.8	62.6	60.8	57.2	51.8
San Diego, CA	55.4	57.2	59.0	60.8	62.6	66.2	69.8	71.6	69.8	66.2	60.8	57.2

If you compare this program with the previous program, you can see the statements that replaced the twelve assignment statements. The ARRAY statement defines an array called fahr. It tells SAS that you want to group the twelve month variables, jan , feb, ... dec, into an array called fahr. The (12) that appears in parentheses is a required part of the array declaration. Called the dimension of the array, it tells SAS how many elements, that is, variables, you want to group together. When specifying the variable names to be grouped in the array, we simply list the elements, separating each element with a space. As with all SAS statements, the ARRAY statement is closed with a semicolon (;).

Once we've defined the array fahr, we can use it in our code instead of the individual variable names. We refer to the individual elements of the array using its name and an index, such as, fahr(i). The order in which the variables appear in the ARRAY statement determines the variable's position in the array. For example, fahr(1) corresponds to the jan variable, fahr(2) corresponds to the feb variable, and fahr(12) corresponds to the dec variable. It's when you use an array like fahr, in conjunction with an iterative DO loop, that you can really simplify your code, as we did in this program.

The DO loop tells SAS to process through the elements of the fahr array, each time converting the Celsius temperature to a Fahrenheit temperature. For example, when the index variable i is 1, the assignment statement becomes:

fahr(1) = 1.8*fahr(1) + 32;

which you could think of as saying:

jan = 1.8*jan + 32;

The value of jan on the right side of the equal sign is the Celsius temperature. After the assignment statement is executed, the value of jan on the left side of the equal sign is updated to reflect the Fahrenheit temperature.

Now, launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that the Celsius temperatures were again properly converted to Fahrenheit temperatures. Oh, one more thing to point out! Note that the variables listed in the PRINT procedure's VAR statement are the original variable names jan, feb, ..., dec, not the variables as they were grouped into an array, fahr(1), fahr(2), ..., fahr(12). That's because an array exists only for the duration of the DATA step. If in the PRINT procedure, you instead tell SAS to print fahr(1), fahr(2), ... you'll see that SAS will hiccup. Let's summarize!

To define an array, you must use an ARRAY statement having the following general form in order to group previously defined data set variables into an array:

ARRAY array-name(dimension) <elements>;

where:

• array-name must be a valid SAS name that specifies the name of the array

• dimension describes the number and arrangement of array elements. The default dimension is one.

• elements list the variables to be grouped together to form the array. The array elements must be either all numeric or all character. Using standard SAS Help notation, the term elements appears in <> brackets to indicate that they are optional. That is, you do not have to specify elements in the ARRAY statement. If no elements are listed, new variables are created with default names.

A few more points must be made about the array-name. Unless you are interested in confusing SAS, you should not give an array the same name as a variable that appears in the same DATA step. You should also avoid giving an array the same name as a valid SAS function. SAS allows you to do so, but then you won’t be able to use the function in the same DATA step. For example, if you named an array mean in a DATA step, you would not be able to use the mean function in the DATA step. SAS will print a warning message in your log window to let you know such. Finally, array names cannot be used in LABEL, FORMAT, DROP, KEEP, or LENGTH statements.

Let’s look at another example to see a different way to define the array used to convert degrees Celsius to Farenheit.

Example

The following program is identical to the program in the previous example, except the 12 in the ARRAY statement has been changed to an asterisk (*) and we use a SAS list to grab the variables for the array:

DATA avgfahrenheittwo;
    set avgcelsius;
    array fahr(*) jan -- dec;
    do i = 1 to 12;
            fahr(i) = 1.8*fahr(i) + 32;
    end;
RUN;
 
PROC PRINT data = avgfahrenheittwo;
    title 'Average Monthly Temperatures in Fahrenheit';
    id City;
    var jan feb mar apr may jun 
        jul aug sep oct nov dec;
RUN;

Average Monthly Temperatures in Fahrenheit

City	jan	feb	mar	apr	may	jun	jul	aug	sep	oct	nov	dec
State College, PA	28.4	28.4	35.6	46.4	57.2	66.2	69.8	68.0	60.8	50.0	39.2	30.2
Miami, FL	68.0	68.0	71.6	73.4	78.8	80.6	82.4	82.4	80.6	78.8	73.4	68.0
St. Louis, MO	30.2	33.8	42.8	55.4	64.4	73.4	78.8	77.0	69.8	59.0	44.6	33.8
New Orleans, LA	51.8	55.4	60.8	68.0	73.4	80.6	80.6	80.6	78.8	69.8	60.8	53.6
Madison, WI	17.6	23.0	32.0	44.6	57.2	66.2	71.6	68.0	60.8	50.0	35.6	23.0
Houston, TX	50.0	53.6	60.8	68.0	73.4	80.6	82.4	82.4	78.8	69.8	60.8	53.6
Phoenix, AZ	53.6	57.2	60.8	69.8	78.8	87.8	91.4	89.6	86.0	73.4	60.8	53.6
Seattle, WA	41.0	42.8	44.6	50.0	55.4	60.8	64.4	64.4	60.8	53.6	46.4	42.8
San Francisco, CA	50.0	53.6	53.6	55.4	57.2	59.0	59.0	60.8	62.6	60.8	57.2	51.8
San Diego, CA	55.4	57.2	59.0	60.8	62.6	66.2	69.8	71.6	69.8	66.2	60.8	57.2

Simple enough! Rather than you having to tell SAS how many variables and listing out exactly which ones you are grouping in an array, you can let SAS to the dirty work of counting the number of elements and listing the ones you include in your variable list. To do so, you simply define the dimension using an asterisk (*) and use the SAS list shortcut. You might find this strategy particularly helpful if you are grouping so many variables together into an array that you don't want to spend the time counting and listing them individually. Incidentally, throughout this lesson, we enclose the array's dimension (or index variable) in parentheses ( ). We could alternatively use braces { } or brackets [ ].

The above program used a SAS list to shorten the list of variable names grouped into the fahr array. In some cases, you could also consider using the special name lists _ALL_, _CHARACTER_ and _NUMERIC_:

• Use _ALL_ when you want SAS to use all of the same type of variables (all numeric or all character) in your SAS data set.
• Use _CHARACTER_ when you want SAS to use all of the character variables in your data set.
• Use _NUMERIC_ when you want SAS to use all of the numeric variables in your data set.

In this case, we could have used the _NUMERIC_ keyword instead as shown in the following program.

DATA avgfahrenheitthree;
    set avgcelsius;
    array fahr(*) _NUMERIC_;
    do i = 1 to 12;
            fahr(i) = 1.8*fahr(i) + 32;
    end;
RUN;
 
PROC PRINT data = avgfahrenheitthree;
    title 'Average Monthly Temperatures in Fahrenheit';
    id City;
    var jan feb mar apr may jun 
        jul aug sep oct nov dec;
RUN;

Average Monthly Temperatures in Fahrenheit

City	jan	feb	mar	apr	may	jun	jul	aug	sep	oct	nov	dec
State College, PA	28.4	28.4	35.6	46.4	57.2	66.2	69.8	68.0	60.8	50.0	39.2	30.2
Miami, FL	68.0	68.0	71.6	73.4	78.8	80.6	82.4	82.4	80.6	78.8	73.4	68.0
St. Louis, MO	30.2	33.8	42.8	55.4	64.4	73.4	78.8	77.0	69.8	59.0	44.6	33.8
New Orleans, LA	51.8	55.4	60.8	68.0	73.4	80.6	80.6	80.6	78.8	69.8	60.8	53.6
Madison, WI	17.6	23.0	32.0	44.6	57.2	66.2	71.6	68.0	60.8	50.0	35.6	23.0
Houston, TX	50.0	53.6	60.8	68.0	73.4	80.6	82.4	82.4	78.8	69.8	60.8	53.6
Phoenix, AZ	53.6	57.2	60.8	69.8	78.8	87.8	91.4	89.6	86.0	73.4	60.8	53.6
Seattle, WA	41.0	42.8	44.6	50.0	55.4	60.8	64.4	64.4	60.8	53.6	46.4	42.8
San Francisco, CA	50.0	53.6	53.6	55.4	57.2	59.0	59.0	60.8	62.6	60.8	57.2	51.8
San Diego, CA	55.4	57.2	59.0	60.8	62.6	66.2	69.8	71.6	69.8	66.2	60.8	57.2

11.3.2. Creating New Variable in an Array Statement

So far, we have learned several ways to group existing variables into an array. We can also create new variables in an ARRAY statement by omitting the array elements from the statement. When our ARRAY statement fails to reference existing variables, SAS automatically creates new variables for us and assigns default names to them.

Example

The following program again converts the average monthly Celsius temperatures in ten cities to average montly Fahrenheit temperatures. To do so, the already existing Celsius temperatures, jan, feb, ..., and dec, are grouped into an array called celsius, and the resulting Fahrenheit temperatures are stored in new variables janf, febf, ..., decf, which are grouped into an array called fahr:

DATA avgtemps;
    set avgcelsius;
    array celsius(12) jan feb mar apr may jun 
                        jul aug sep oct nov dec;
    array fahr(12) janf febf marf aprf mayf junf
                    julf augf sepf octf novf decf;
    do i = 1 to 12;
            fahr(i) = 1.8*celsius(i) + 32;
    end;
RUN;
 
PROC PRINT data = avgtemps;
    title 'Average Monthly Temperatures';
    id City;
    var jan janf feb febf mar marf;
    var apr aprf may mayf jun junf;
    var jul julf aug augf sep sepf;
    var oct octf nov novf dec decf;
RUN;

Average Monthly Temperatures

City	jan	janf	feb	febf	mar	marf	apr	aprf	may	mayf	jun	junf	jul	julf	aug	augf	sep	sepf	oct	octf	nov	novf	dec	decf
State College, PA	-2	28.4	-2	28.4	2	35.6	8	46.4	14	57.2	19	66.2	21	69.8	20	68.0	16	60.8	10	50.0	4	39.2	-1	30.2
Miami, FL	20	68.0	20	68.0	22	71.6	23	73.4	26	78.8	27	80.6	28	82.4	28	82.4	27	80.6	26	78.8	23	73.4	20	68.0
St. Louis, MO	-1	30.2	1	33.8	6	42.8	13	55.4	18	64.4	23	73.4	26	78.8	25	77.0	21	69.8	15	59.0	7	44.6	1	33.8
New Orleans, LA	11	51.8	13	55.4	16	60.8	20	68.0	23	73.4	27	80.6	27	80.6	27	80.6	26	78.8	21	69.8	16	60.8	12	53.6
Madison, WI	-8	17.6	-5	23.0	0	32.0	7	44.6	14	57.2	19	66.2	22	71.6	20	68.0	16	60.8	10	50.0	2	35.6	-5	23.0
Houston, TX	10	50.0	12	53.6	16	60.8	20	68.0	23	73.4	27	80.6	28	82.4	28	82.4	26	78.8	21	69.8	16	60.8	12	53.6
Phoenix, AZ	12	53.6	14	57.2	16	60.8	21	69.8	26	78.8	31	87.8	33	91.4	32	89.6	30	86.0	23	73.4	16	60.8	12	53.6
Seattle, WA	5	41.0	6	42.8	7	44.6	10	50.0	13	55.4	16	60.8	18	64.4	18	64.4	16	60.8	12	53.6	8	46.4	6	42.8
San Francisco, CA	10	50.0	12	53.6	12	53.6	13	55.4	14	57.2	15	59.0	15	59.0	16	60.8	17	62.6	16	60.8	14	57.2	11	51.8
San Diego, CA	13	55.4	14	57.2	15	59.0	16	60.8	17	62.6	19	66.2	21	69.8	22	71.6	21	69.8	19	66.2	16	60.8	14	57.2

The DATA step should look eerily similar to that of Example 7.6. The only thing that differs here is rather than writing over the Celsius temperatures, they are preserved by storing the calculated Fahrenheit temperatures in new variables called janf, febf, ..., and decf. The first ARRAY statement tells SAS to group the jan, feb, ..., dec variables in the avgcelsius data set into a one-dimensional array called celsius. The second ARRAY statement tells SAS to create twelve new variables called janf, febf, ..., and decf and to group them into an array called fahr. The DO loop processes through the twelve elements of the celsius array, converts the Celsius temperatures to Fahrenheit temperatures, and stores the results in the fahr array. The PRINT procedure then tells SAS to print the contents of the twelve Celsius temperatures and twelve Fahrenheit temperatures side-by-side. Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that the Celsius temperatures were properly converted to Fahrenheit temperatures.

Alternatively, we could let SAS do the naming for us in the fahr array.

DATA avgtempsinF;
    set avgcelsius;
    array celsius(12) jan feb mar apr may jun 
                      jul aug sep oct nov dec;
    array fahr(12);
    do i = 1 to 12;
            fahr(i) = 1.8*celsius(i) + 32;
    end;
RUN;
 
PROC PRINT data = avgtempsinF;
    title 'Average Monthly Temperatures in Fahrenheit';
    id City;
    var fahr1-fahr12;
RUN;

Average Monthly Temperatures in Fahrenheit

City	fahr1	fahr2	fahr3	fahr4	fahr5	fahr6	fahr7	fahr8	fahr9	fahr10	fahr11	fahr12
State College, PA	28.4	28.4	35.6	46.4	57.2	66.2	69.8	68.0	60.8	50.0	39.2	30.2
Miami, FL	68.0	68.0	71.6	73.4	78.8	80.6	82.4	82.4	80.6	78.8	73.4	68.0
St. Louis, MO	30.2	33.8	42.8	55.4	64.4	73.4	78.8	77.0	69.8	59.0	44.6	33.8
New Orleans, LA	51.8	55.4	60.8	68.0	73.4	80.6	80.6	80.6	78.8	69.8	60.8	53.6
Madison, WI	17.6	23.0	32.0	44.6	57.2	66.2	71.6	68.0	60.8	50.0	35.6	23.0
Houston, TX	50.0	53.6	60.8	68.0	73.4	80.6	82.4	82.4	78.8	69.8	60.8	53.6
Phoenix, AZ	53.6	57.2	60.8	69.8	78.8	87.8	91.4	89.6	86.0	73.4	60.8	53.6
Seattle, WA	41.0	42.8	44.6	50.0	55.4	60.8	64.4	64.4	60.8	53.6	46.4	42.8
San Francisco, CA	50.0	53.6	53.6	55.4	57.2	59.0	59.0	60.8	62.6	60.8	57.2	51.8
San Diego, CA	55.4	57.2	59.0	60.8	62.6	66.2	69.8	71.6	69.8	66.2	60.8	57.2

Note that when we define the fahr array in the second ARRAY statement, we specify how many elements the fahr array should contain (12), but we do not specify any variables to group into the array. That tells SAS two things: i) we want to create twelve new variables, and ii) we want to leave the naming of the variables to SAS. In this situation, SAS creates default names by concatenating the array name and the numbers 1, 2, 3, and so on, up to the array dimension. Here, for example, SAS creates the names fahr1, fahr2, fahr3, ..., up to fahr12. That's why we refer to the Fahrenheit temperatures as fahr1 to fahr12 in the PRINT procedure's VAR statement. Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that the Celsius temperatures were again properly converted to Fahrenheit temperatures.

11.3.3. Temporary Array Elements

When elements of an array are constants needed only for the duration of the DATA step, you can omit the variables associated with an array group and instead use temporary array elements. Although they behave like variables, temporary array elements:

• do not appear in the resulting data set;

• do not have names and can be only referenced by their array names and dimensions; and

• are automatically retained, rather than being reset to missing at the beginning of the next iteration of the DATA step.

In this section, we’ll look at three examples that involve checking a subset of Quality of Life data for errors. In the following example, we’ll look to see if the data recorded in ten variables — qul3a, qul3b, …, and qul3j —are within an expected range without using an array. Then, we’ll look to see if the data recorded in the same ten variables are within an expected range using an array that corresponds to three new variables error1, error2, and error3. Finally, we’ll look to see if the data recorded in the same ten variables are within an expected range using an array containing only temporary elements.

Example

The following program first reads a subset of Quality of Life data (variables qul3a, qul3b, ..., and qul3j) into a SAS data set called qul. Then, the program checks to make sure that the values for each variable have been recorded as either a 1, 2, or 3 as would be expected from the data form. If a value for one of the variables does not equal 1, 2, or 3, then that observation is output to a data set called errors. Otherwise, the observation is output to the qul data set. Because the error checking takes places without using arrays, the program contains a series of ten if/then statements, corresponding to each of the ten concerned variables:

DATA qul errors;
    input subj qul3a qul3b qul3c qul3d qul3e 
               qul3f qul3g qul3h qul3i qul3j;
    flag = 0;
    if qul3a not in (1, 2, 3) then flag = 1;
    if qul3b not in (1, 2, 3) then flag = 1;
    if qul3c not in (1, 2, 3) then flag = 1;
    if qul3d not in (1, 2, 3) then flag = 1;
    if qul3e not in (1, 2, 3) then flag = 1;
    if qul3f not in (1, 2, 3) then flag = 1;
    if qul3g not in (1, 2, 3) then flag = 1;
    if qul3h not in (1, 2, 3) then flag = 1;
    if qul3i not in (1, 2, 3) then flag = 1;
    if qul3j not in (1, 2, 3) then flag = 1;
    if flag = 1 then output errors;
                else output qul;
    drop flag;
    DATALINES;
    110011 1 2 3 3 3 3 2 1 1 3
    210012 2 3 4 1 2 2 3 3 1 1
    211011 1 2 3 2 1 2 3 2 1 3
    310017 1 2 3 3 3 3 3 2 2 1
    411020 4 3 3 3 3 2 2 2 2 2
    510001 1 1 1 1 1 1 2 1 2 2
    ;
RUN;
PROC PRINT data = qul;
    TITLE 'Observations in Qul data set with no errors';
RUN;
PROC PRINT data = errors;
    TITLE 'Observations in Qul data set with errors';
RUN;

Observations in Qul data set with no errors

Obs	subj	qul3a	qul3b	qul3c	qul3d	qul3e	qul3f	qul3g	qul3h	qul3i	qul3j
1	110011	1	2	3	3	3	3	2	1	1	3
2	211011	1	2	3	2	1	2	3	2	1	3
3	310017	1	2	3	3	3	3	3	2	2	1
4	510001	1	1	1	1	1	1	2	1	2	2

---

Observations in Qul data set with errors

Obs	subj	qul3a	qul3b	qul3c	qul3d	qul3e	qul3f	qul3g	qul3h	qul3i	qul3j
1	210012	2	3	4	1	2	2	3	3	1	1
2	411020	4	3	3	3	3	2	2	2	2	2

The INPUT statement first reads an observation of data containing one subject's quality of life data. An observation is assumed to be error-free (flag is initially set to 0) until it is found to be in error (flag is set to 1 if any of the ten values are out of range). If an observation is deemed to contain an error (flag = 1) after looking at each of the ten values, it is output to the errors data set. Otherwise (flag = 0) , it is output to the qul data set.

First, note that two of the observations in the input data set contain data recording errors. The qul3c value for subject 210012 was recorded as 4, as was the qul3a value for subject 411020. Then, launch and run the SAS program. Review the output to convince yourself that qul contains the four observations with clean data, and errors contains the two observations with bad data.

You should also appreciate that this is a classic situation that cries out for using arrays. If you aren't yet convinced, imagine how long the above program would be if you had to write similar if/then statements to check for errors in, say, a hundred such variables.

The following program performs the same error checking as the previous program except here the error checking is accomplished using two arrays, bounds and quldata:

DATA qul errors;
    input subj qul3a qul3b qul3c qul3d qul3e 
            qul3f qul3g qul3h qul3i qul3j;
    array bounds (3) error1 - error3 (1 2 3);
    array quldata (10) qul3a -- qul3j;
    flag = 0;
    do i = 1 to 10;
        if quldata(i) ne bounds(1) and
            quldata(i) ne bounds(2) and
            quldata(i) ne bounds(3)
        then flag = 1;
    end;
    if flag = 1 then output errors;
                else output qul;
    drop i flag;
    DATALINES;
    110011 1 2 3 3 3 3 2 1 1 3
    210012 2 3 4 1 2 2 3 3 1 1
    211011 1 2 3 2 1 2 3 2 1 3
    310017 1 2 3 3 3 3 3 2 2 1
    411020 4 3 3 3 3 2 2 2 2 2
    510001 1 1 1 1 1 1 2 1 2 2
    ;
RUN;
 
PROC PRINT data = qul;
    TITLE 'Observations in Qul data set with no errors';
RUN;
 
PROC PRINT data = errors;
    TITLE '
Observations in Qul data set with errors';
RUN;

Observations in Qul data set with no errors

Obs	subj	qul3a	qul3b	qul3c	qul3d	qul3e	qul3f	qul3g	qul3h	qul3i	qul3j	error1	error2	error3
1	110011	1	2	3	3	3	3	2	1	1	3	1	2	3
2	211011	1	2	3	2	1	2	3	2	1	3	1	2	3
3	310017	1	2	3	3	3	3	3	2	2	1	1	2	3
4	510001	1	1	1	1	1	1	2	1	2	2	1	2	3

---

Observations in Qul data set with errors

Obs	subj	qul3a	qul3b	qul3c	qul3d	qul3e	qul3f	qul3g	qul3h	qul3i	qul3j	error1	error2	error3
1	210012	2	3	4	1	2	2	3	3	1	1	1	2	3
2	411020	4	3	3	3	3	2	2	2	2	2	1	2	3

If you compare this program to the previous program, you'll see that the only differences here are the presence of two ARRAY definition statements and the IF/THEN statement within the iterative DO loop that does the error checking.

The first ARRAY statement uses a numbered range list to define an array called bounds that contains three new variables — error1, error2, and error3. The "(1 2 3)" that appears after the variable list error1-error3 tells SAS to set, or initialize, the elements of the array to equal 1, 2, and 3. In general, you initialize an array in this manner, namely listing as many values as their are elements of the array and separating each pair of values with a space. If you intend for your array to contain character constants, you must put the values in single quotes. For example, the following ARRAY statement tells SAS to define a character array (hence the dollar sign \$) called weekdays:

ARRAY weekdays(5) $ ('M' 'T' 'W' 'R' 'F');

and to initialize the elements of the array as M, T, W, R, and F.

The second ARRAY statement uses a name range list to define an array called quldata that contains the ten quality of life variables. The IF/THEN statement uses slightly different logic than the previous program to tell SAS to compare the elements of the quldata array to the elements of the bounds array to determine whether any of the values are out of range.

Now, launch and run the SAS program. Review the output to convince yourself that just as before qul contains the four observations with clean data, and errors contains the two observations with bad data. Also, note that the three new error variables error1, error2, and error3 remain present in the data set.

The valid values 1, 2, and 3 are needed only temporarily in the previous program. Therefore, we alternatively could have used temporary array elements in defining the bounds array. The following program does just that. It is identical to the previous program except here the bounds array is defined using temporary array elements rather than using three new variables error1, error2, and error3:

DATA qul errors;
    input subj qul3a qul3b qul3c qul3d qul3e 
            qul3f qul3g qul3h qul3i qul3j;
    array bounds (3) _TEMPORARY_ (1 2 3);
    array quldata (10) qul3a -- qul3j;
    flag = 0;
    do i = 1 to 10;
        if quldata(i) ne bounds(1) and
            quldata(i) ne bounds(2) and
            quldata(i) ne bounds(3)
        then flag = 1;
    end;
    if flag = 1 then output errors;
                else output qul;
    drop i flag;
    DATALINES;
    110011 1 2 3 3 3 3 2 1 1 3
    210012 2 3 4 1 2 2 3 3 1 1
    211011 1 2 3 2 1 2 3 2 1 3
    310017 1 2 3 3 3 3 3 2 2 1
    411020 4 3 3 3 3 2 2 2 2 2
    510001 1 1 1 1 1 1 2 1 2 2
    ;
RUN;
 
PROC PRINT data = qul;
    TITLE 'Observations in Qul data set with no errors';
RUN;
 
PROC PRINT data = errors;
    TITLE '
Observations in Qul data set with errors';
RUN

Observations in Qul data set with no errors

Obs	subj	qul3a	qul3b	qul3c	qul3d	qul3e	qul3f	qul3g	qul3h	qul3i	qul3j
1	110011	1	2	3	3	3	3	2	1	1	3
2	211011	1	2	3	2	1	2	3	2	1	3
3	310017	1	2	3	3	3	3	3	2	2	1
4	510001	1	1	1	1	1	1	2	1	2	2

---

Observations in Qul data set with errors

Obs	subj	qul3a	qul3b	qul3c	qul3d	qul3e	qul3f	qul3g	qul3h	qul3i	qul3j
1	210012	2	3	4	1	2	2	3	3	1	1
2	411020	4	3	3	3	3	2	2	2	2	2

If you compare this program to the previous program, you'll see that the only difference here is the presence of the _TEMPORARY_ argument in the definition of the bounds array. The bounds array is again initialized to the three valid values "(1 2 3)".

Launch and run the SAS program. Review the output to convince yourself that just as before qul contains the four observations with clean data, and errors contains the two observations with bad data. Also, note that the temporary array elements do not appear in the data set.

11.3.4. Array Bounds

Each of the arrays we’ve considered thus far have been defined, by default, to have a lower bound of 1 and an upper bound which equals the number of elements in the array’s dimension. For example, the array my_array:

ARRAY my_array(4) el1 el2 el3 el4;

has a lower bound of 1 and an upper bound of 4. In this section, we’ll look at three examples that concern the bounds of an array. In the first example, we’ll use the DIM function to change the upper bound of a DO loop’s index variable dynamically (rather than stating it in advance). In the second example, we’ll define the lower and upper bounds of a one-dimensional array to create a bounded array. In the third example, we’ll use the LBOUND and HBOUND functions to change the lower and upper bounds of a DO loop’s index variable dynamically.

Example

The following program reads the yes/no responses of five subjects to six survey questions (q1, q2, ..., q6) into a temporary SAS data set called survey. A yes response is coded and entered as a 2, while a no response is coded and entered as a 1. Just four of the variables (q3, q4, q5, and q6) are stored in a one-dimensional array called qxs. Then, a DO LOOP, in conjunction with the DIM function, is used to recode the responses to the four variables so that a 2 is changed to a 1, and a 1 is changed to a 0:

DATA survey (DROP = i);
    INPUT subj q1 q2 q3 q4 q5 q6;
    ARRAY qxs(4) q3-q6;
    DO i = 1 to dim(qxs);
        qxs(i) = qxs(i) - 1;
    END;
    DATALINES;
1001 1 2 1 2 1 1
1002 2 1 2 2 2 1
1003 2 2 2 1 . 2
1004 1 . 1 1 1 2
1005 2 1 2 2 2 1
;
RUN;
 
PROC PRINT data = survey;
    TITLE 'The survey data using dim function';
RUN;

The survey data using dim function

Obs	subj	q1	q2	q3	q4	q5	q6
1	1001	1	2	0	1	0	0
2	1002	2	1	1	1	1	0
3	1003	2	2	1	0	.	1
4	1004	1	.	0	0	0	1
5	1005	2	1	1	1	1	0

First, note that although all of the survey variables (q1, ..., q6) are read into the survey data set, the ARRAY statement groups only 4 of the variables (q3, q4, q5, q6) into the one-dimensional array qxs. For example, qxs(1) corresponds to the q3 variable, qxs(2) corresponds to the q4 variable, and so on. Then, rather than telling SAS to process the array from element 1 to element 4, the DO loop tells SAS to process the array from element 1 to the more general DIM(qxs). In general, the DIM function returns the number of the elements in the array, which in this case is 4. The DO loop tells SAS to recode the values by simply subtracting 1 from each value. And, the index variable i is output to the survey data set by default and is therefore dropped.

Example

As previously discussed and illustrated, if you do not specifically tell SAS the lower bound of an array, SAS assumes that the lower bound is 1. For most arrays, 1 is a convenient lower bound and the number of elements is a convenient upper bound, so you usually don't need to specify both the lower and upper bounds. However, in cases where it is more convenient, you can modify both bounds for any array dimension.

In the previous example, perhaps you find it a little awkward that the array element qxs(1) corresponds to the q3 variable, the array element qxs(2) corresponds to the q4 variable, and so on. Perhaps you would find it more clear for the array element qxs(3) to correspond to the q3 variable, the array element qxs(4) to correspond to the q4 variable, ..., and the array element qxs(6) to correspond to the q6 variable. The following program is similar in function to the previous program, except here the task of recoding is accomplished by defining the lower bound of the qxs array to be 3 and the upper bound to be 6:

DATA survey2 (DROP = i);
    INPUT subj q1 q2 q3 q4 q5 q6;
    ARRAY qxs(3:6) q3-q6;
    DO i = 3 to 6;
        qxs(i) = qxs(i) - 1;
    END;
    DATALINES;
1001 1 2 1 2 1 1
1002 2 1 2 2 2 1
1003 2 2 2 1 . 2
1004 1 . 1 1 1 2
1005 2 1 2 2 2 1
;
RUN;
 
PROC PRINT data = survey2;
    TITLE 'The survey data using bounded arrays';
RUN;

The survey data using bounded arrays

Obs	subj	q1	q2	q3	q4	q5	q6
1	1001	1	2	0	1	0	0
2	1002	2	1	1	1	1	0
3	1003	2	2	1	0	.	1
4	1004	1	.	0	0	0	1
5	1005	2	1	1	1	1	0

If you compare this program with the previous program, you'll see that only two things differ. The first difference is that the ARRAY statement here defines the lower bound of the qxs array to be 3 and the upper bound to be 6. In general, you can always define the lower and upper bounds of any array dimension in this way, namely by specifying the lower bound, then a colon (:), and then the upper bound. The second difference is that, for the DO loop, the bounds on the index variable i are specifically defined here to be between 3 and 6 rather than 1 to DIM(qxs) (which in this case is 4).

Example

Now, there's still a little bit more that we can do to automate the handling of the bounds of an array dimension. The following program again uses a one-dimensional array qxs to recode four survey variables as did the previous two programs. Here, though, an asterisk (*) is used to tell SAS to determine the dimension of the qxs array, and the LBOUND and HBOUND functions are used to tell SAS to determine, respectively, the lower and upper bounds of the DO loop's index variable dynamically:

DATA survey3 (DROP = i);
    INPUT subj q1 q2 q3 q4 q5 q6;
    ARRAY qxs(*) q3-q6;
    DO i = lbound(qxs) to hbound(qxs);
        qxs(i) = qxs(i) - 1;
    END;
    DATALINES;
1001 1 2 1 2 1 1
1002 2 1 2 2 2 1
1003 2 2 2 1 . 2
1004 1 . 1 1 1 2
1005 2 1 2 2 2 1
;
RUN;
 
PROC PRINT data = survey3;
    TITLE 'The survey data by changing upper and lower bounds automatically';
RUN;

The survey data by changing upper and lower bounds automatically

Obs	subj	q1	q2	q3	q4	q5	q6
1	1001	1	2	0	1	0	0
2	1002	2	1	1	1	1	0
3	1003	2	2	1	0	.	1
4	1004	1	.	0	0	0	1
5	1005	2	1	1	1	1	0

If you compare this program with the previous program, you'll see that only two things differ. The first difference is that the asterisk (*) that appears in the the ARRAY statement tells SAS to determine the bounds on the dimensions of the array during the declaration of qxs. SAS counts the number of elements in the array and determines that the dimension of qxs is 4. The second difference is that, for the DO loop, the bounds on the index variable i are determined dynamically to be between LBOUND(qxs) and HBOUND(qxs).

11.3.5. Two-Dimensional Arrays

Two-dimensional arrays are straightforward extensions of one-dimensional arrays. You can think of one-dimensional arrays such as the array barkers:

ARRAY barkers(4) dog1-dog4;

as a single row of variables:

dog1 dog2 dog3 dog4

And two-dimensional arrays such as the array pets:

ARRAY pets(2,4) dog1-dog4 cat1-cat4;

as multiple rows of variables:

dog1  dog2  dog3  dog4
cat1  cat2  cat3  cat4

As the previous ARRAY statement suggests, to define a two-dimensional array, you specify the number of elements in each dimension, separated by a comma. In general, the first dimension number tells SAS how many rows your array needs, while the second dimension number tells SAS how many columns your array needs.

When you define a two-dimensional array, the array elements are grouped in the order in which they appear in the ARRAY statement. For example, SAS assigns the elements of the array horse:

ARRAY horse(3,5) x1-x15;

as follows:

x1  x2  x3  x4  x5
x6  x7  x8  x9  x10
x11 x12 x13 x14 x15

In this section, we’ll look at two examples that involve checking a subset of Family History data for missing values. We’ll use one two-dimensional array — the first dimension to store the actual data and the second dimension to store binary status variables that indicate whether a particular data value is missing or not.

Example

This program searches a subset of the family history data for missing values. Here, we use one two-dimensional array called edit. The first row contains the actual data and the second row contains a 0/1 indicator of missingness for the observed data in the corresponding column of the two-dimensional array.

DATA fhx;
    input subj v_date mmddyy8. fhx1-fhx14;
    array edit(2,14) fhx1-fhx14 stat1-stat14;
    do i = 1 to 14;
        edit(2,i) = 0;
        if edit(1,i) = . then edit(2,i) = 1;
    end;
    DATALINES;
220004  07/27/93  0  0  0  .  8  0  0  1  1  1  .  1  0  1
410020  11/11/93  0  0  0  .  0  0  0  0  0  0  .  0  0  0
520013  10/29/93  0  0  0  .  0  0  0  0  0  0  .  0  0  1
520068  08/10/95  0  0  0  0  0  1  1  0  0  1  1  0  1  0
520076  08/25/95  0  0  0  0  1  8  0  0  0  1  1  0  0  1
;
RUN;
 
PROC PRINT data = fhx;
    var fhx1-fhx14;
    TITLE 'The FHX data itself';
RUN;
 
PROC PRINT data = fhx;
    var stat1-stat14;
    TITLE 'The presence of missing values in FHX data';
RUN;

The FHX data itself

Obs	fhx1	fhx2	fhx3	fhx4	fhx5	fhx6	fhx7	fhx8	fhx9	fhx10	fhx11	fhx12	fhx13	fhx14
1	3	0	0	0	.	8	0	0	1	1	1	.	1	0
2	3	0	0	0	.	0	0	0	0	0	0	.	0	0
3	3	0	0	0	.	0	0	0	0	0	0	.	0	0
4	5	0	0	0	0	0	1	1	0	0	1	1	0	1
5	5	0	0	0	0	1	8	0	0	0	1	1	0	0

---

The presence of missing values in FHX data

Obs	stat1	stat2	stat3	stat4	stat5	stat6	stat7	stat8	stat9	stat10	stat11	stat12	stat13	stat14
1	0	0	0	0	1	0	0	0	0	0	0	1	0	0
2	0	0	0	0	1	0	0	0	0	0	0	1	0	0
3	0	0	0	0	1	0	0	0	0	0	0	1	0	0
4	0	0	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	0	0	0	0	0	0	0	0	0	0	0	0

We have just one ARRAY statement that defines the two-dimensional array edit containing 2 rows and 14 columns. The ARRAY statement tells SAS to group the family history variables (fhx1, ..., fhx14) into the first dimension and to group the status variables (stat1, ..., stat14) into the second dimension. Then, the DO loop tells SAS to review the contents of the 14 variables and to assign each element of the status dimension a value of 0 ("edit(2,i) = 0;"). If the element of the edit dimension is missing, however, then SAS is told to change the element of the status dimension from a 0 to a 1 ("if edit(1,i) = . then edit(2,i) = 1").

11.4. Reshaping Data

What is wide/long data?

Wide means that we have multiple columns per observations, e.g. visit1, visit2, visit3

DATA wide;
    INPUT id visit1 visit2 visit3;
    INFILE DATALINES;
    DATALINES;
1 10 4 3
2 5 6 .
;
RUN;

PROC PRINT data = wide;
   TITLE 'Wide Dataset';
RUN;

Wide Dataset

Obs	id	visit1	visit2	visit3
1	1	10	4	3
2	2	5	6	.

Long means that we have multiple rows per observation.

DATA long;
    INPUT id visit value;
    INFILE DATALINES;
    DATALINES;
1 1 10 
1 2 4 
1 3 3
2 1 5 
2 2 6 
2 3 .
;
RUN;

PROC PRINT data = long;
   TITLE 'Long Dataset';
RUN;

Long Dataset

Obs	id	visit	value
1	1	1	10
2	1	2	4
3	1	3	3
4	2	1	5
5	2	2	6
6	2	3	.

In SAS, there are two ways to reshape data between wide and long formats

• PROC TRANSPOSE

• DATA step

We will explore both ways with some examples.

11.4.1. Reshaping Data from Long (Tall) Wide (Fat)

Recall the tallgrades dataset from an earlier section.

DATA tallgrades;
    input idno 1-2 l_name $ 5-9 gtype $ 12-13 grade 15-17;
    cards;
10  Smith  E1  78
10  Smith  E2  82
10  Smith  E3  86
10  Smith  E4  69
10  Smith  P1  97
10  Smith  F1 160
11  Simon  E1  88
11  Simon  E2  72
11  Simon  E3  86
11  Simon  E4  99
11  Simon  P1 100
11  Simon  F1 170
12  Jones  E1  98
12  Jones  E2  92
12  Jones  E3  92
12  Jones  E4  99
12  Jones  P1  99
12  Jones  F1 185
;
RUN;
 
PROC PRINT data = tallgrades NOOBS;
   TITLE 'The tall grades data set';
RUN;

The tall grades data set

idno	l_name	gtype	grade
10	Smith	E1	78
10	Smith	E2	82
10	Smith	E3	86
10	Smith	E4	69
10	Smith	P1	97
10	Smith	F1	160
11	Simon	E1	88
11	Simon	E2	72
11	Simon	E3	86
11	Simon	E4	99
11	Simon	P1	100
11	Simon	F1	170
12	Jones	E1	98
12	Jones	E2	92
12	Jones	E3	92
12	Jones	E4	99
12	Jones	P1	99
12	Jones	F1	185

The tallgrades data set contains one observation for each grade for each student. Students are identified by their id number (idno) and last name (l_name). The data set contains six different types of grades: exam 1 (E1), exam 2 (E2), exam 3 (E3), exam 4 (E4), each worth 100 points; one project (P1) worth 100 points; and a final exam (F1) worth 200 points. Launch and run the SAS program so that we can work with the tallgrades data set in the next two examples.

Example

In this example, we will transpose the tallgrades dataset from long to wide format by using a DATA step. This will require the use of an array and both the RETAIN and OUTPUT statements, and the FIRST. and LAST. SAS variables.

DATA fatgrades;
   set tallgrades;
   by idno;
   retain E1-E4 P1 F1 i;
   array allgrades (6) E1-E4 P1 F1;
   if first.idno then i = 1;
   allgrades(i) = grade;
   if last.idno then output;
   i = i + 1;
   drop i gtype grade;
RUN;
 
PROC PRINT data=fatgrades;
  title 'The fat grades data set';
RUN;

The fat grades data set

Obs	idno	l_name	E1	E2	E3	E4	P1	F1
1	10	Smith	78	82	86	69	97	160
2	11	Simon	88	72	86	99	100	170
3	12	Jones	98	92	92	99	99	185

Yikes! This code looks scary! Let's dissect it a bit. First, the tallgrades data set is processed BY idno. Doing so, makes the first.idno and last.idno variables available for us to use. The ARRAY statement defines an array called allgrades and, using a numbered range list, associates the array with six (uninitialized) variables E1, E2, E2, E4, P1, and F1. The allgrades array is used to hold the six grades for each student before they are output in their transposed direction to the fatgrades data set. Because the elements of any array, and therefore allgrades, must be assigned using an index variable, this is how the transposition takes place:

• ("if first.idno then i = 1;") If the input observation contains a student idno that hasn't yet been encountered in the data set, then the index variable i is initialized to 1. If the input observation doesn't contain a new student idno, then do nothing other than advance to the next step.
• ("allgrades(i) = grade;") The grade from the current observation is assigned to the array allgrades. (For example, if the input observation contains Smith's first grade, then allgrades(1) is assigned the value 78. If the input observation contains Smith's second grade, then allgrades(2) is assigned the value 82. And so on.) Note that this assumes that the order of the grades is the same within each student.
• ("if last.idno then output;") If the input observation is the last observation in the data set that contains the student idno, then dump the program data vector (which contains allgrades) to the output data set. (For example, if the input observation is Smith's final exam grade, then output the now fat observation containing his six grades). If the input observation is not the last observation in the data set that contains the student idno, do nothing other than advance to the next step.
• ("i = i + 1;") Then, increase the index variable i by 1. (For example, if i is 1, change i to 2.)
• ("retain E1-E4 P1 F1 i;") Rather than setting E1, E2, E3, E4, P1, F1, and i to missing at the beginning of the next iteration of the data step, retain their current values. (So, for example, for Smith, allgrades(1) would retain its value of 78, allgrades (2) would retain its value of 82, and so on.) Similar for the index coutner i. We do not want to reset this variable until we get to a new student.

The program would keep cycling through the above five steps until it encountered the last observation in the data set. Then, the variables i, gtype, and grade would be dropped from the output fatgrades data set.

Example

SAS also has procedure called PROC TRANSPOSE that can be used to transpose datasets between wide and tall formats. Personally, I find this function somewhat unintuitive compared to the DATA step method (at least once you get used to using the DATA step), so I tend to always use the DATA step. However, in this next example we will show how to perform the same transposition using PROC TRANSPOSE and leave it to the reader to decide which method is preferred.

PROC TRANSPOSE data = tallgrades 
               out = fatgrades2 (drop = _NAME_) ;
    BY idno l_name;
    VAR grade;
    ID gtype;
RUN;
 
PROC PRINT data = fatgrades2;
    title 'The fat grades data set';
RUN;

The fat grades data set

Obs	idno	l_name	E1	E2	E3	E4	P1	F1
1	10	Smith	78	82	86	69	97	160
2	11	Simon	88	72	86	99	100	170
3	12	Jones	98	92	92	99	99	185

In PROC TRANSPOSE,

• The OUT statement, as with PROC SORT, specifies the name of the output dataset created by PROC TRANSPOSE.
• The BY clause specifies the variable(s) that are unique within the groups between transposed to a single row. In this case, a single observation corresponds to a given student. Although, idno is the main key, last name (l_name) should also be kept. Without adding it to the BY statement, l_name would be dropped from the transposed dataset.
• The VAR statement specifies the variable containing the value of the transposed variable. In this case, it is the actual grade value.
• The ID statement can be used to specify column names from an existing variable's values. In this case, we use the assessment name to identify the grade.

11.4.2. Reshaping Data from Wide (Fat) to Tall (Long)

In the next two examples, we will learn how to transform the newly created wide version of the grades dataset back to the tall dataset version.

Example

In this example, we will use a DATA step to transpose the grades dataset from wide back to tall format.

DATA tallgrades2;
  set fatgrades;
  array gtypes(6) $ _TEMPORARY_ ('E1' 'E2' 'E3' 'E4' 'P1' 'F1');
  array grades(*) E1 -- F1;
  DO i = 1 TO 6;
      gtype = gtypes(i);
      grade = grades(i);
      OUTPUT;
  END;
  DROP E1--F1 i ;
RUN;

PROC PRINT data = tallgrades2 NOOBS;
   TITLE 'Tallgrades2 Data';
RUN;

Tallgrades2 Data

idno	l_name	gtype	grade
10	Smith	E1	78
10	Smith	E2	82
10	Smith	E3	86
10	Smith	E4	69
10	Smith	P1	97
10	Smith	F1	160
11	Simon	E1	88
11	Simon	E2	72
11	Simon	E3	86
11	Simon	E4	99
11	Simon	P1	100
11	Simon	F1	170
12	Jones	E1	98
12	Jones	E2	92
12	Jones	E3	92
12	Jones	E4	99
12	Jones	P1	99
12	Jones	F1	185

We create two arrays: gtypes is a temporary character array to return the columns names (the assessment types) to the variable gtypes and grades to store the grades on the current row (i.e. current student) to be assigned to the grade variable. Each iteration of the DO loop has an OUPUT statement to put each grade in its own row. Note that the idno and l_name are carried over from row to row until we run out of grades to OUTPUT. Then we exit the DO loop and move on the next row (student). We drop the (wide) columns E1, E2, E3, E4, P1, F1, and the index i from the final dataset to obtain the original tall dataset.

An alternative way to get the column names is to use the vname function instead of manually listing out the names in an character array. The vname function when applied to a variable returns the variable name as a character value.

DATA tallgrades3;
  set fatgrades;
  array grades(*) E1 -- F1;
  DO i = 1 TO 6;
      gtype = vname(grades(i));
      grade = grades(i);
      OUTPUT;
  END;
  DROP E1--F1 i ;
RUN;

PROC PRINT data = tallgrades3 NOOBS;
   TITLE 'Tallgrades3 Data';
RUN;

Tallgrades3 Data

idno	l_name	gtype	grade
10	Smith	E1	78
10	Smith	E2	82
10	Smith	E3	86
10	Smith	E4	69
10	Smith	P1	97
10	Smith	F1	160
11	Simon	E1	88
11	Simon	E2	72
11	Simon	E3	86
11	Simon	E4	99
11	Simon	P1	100
11	Simon	F1	170
12	Jones	E1	98
12	Jones	E2	92
12	Jones	E3	92
12	Jones	E4	99
12	Jones	P1	99
12	Jones	F1	185

Example

Now we will do the same operation as the previous example but using PROC TRANSPOSE.

PROC TRANSPOSE data = fatgrades 
               out = tallgrades3 (RENAME = (COL1 = grade 
                                            _NAME_ = gtype));
   BY idno l_name;
   VAR E1--F1;
RUN;

PROC PRINT data = tallgrades3;
RUN;

Tallgrades2 Data

Obs	idno	l_name	gtype	grade
1	10	Smith	E1	78
2	10	Smith	E2	82
3	10	Smith	E3	86
4	10	Smith	E4	69
5	10	Smith	P1	97
6	10	Smith	F1	160
7	11	Simon	E1	88
8	11	Simon	E2	72
9	11	Simon	E3	86
10	11	Simon	E4	99
11	11	Simon	P1	100
12	11	Simon	F1	170
13	12	Jones	E1	98
14	12	Jones	E2	92
15	12	Jones	E3	92
16	12	Jones	E4	99
17	12	Jones	P1	99
18	12	Jones	F1	185

The BY statement defines the grouping variables that define a single observation and are copied to each new row when going from wide to long. The VAR statement defines all the columns that should be gatherd into a multiple rows by defining two new columns _NAME_ which holds the former column name and _COL1_ which holds the data value from that former column in the current row. Typically, we will want to change these default names by using the RENAME dataset option.

11.5. Merging Datasets

In this section, we will learn how to combine multiple SAS datasets into a single dataset by

• Concatenating two datatsets vertically with the SET statement

• Merging datasets with the MERGE statement to perform inner, outer, left and right joins.

11.5.1. Concatenating Two or More Datasets

To concatenate two or more SAS data sets means to stack one “on top” of the other into a single SAS data set. For example, suppose the data set store1 contains three variables, store (number), day (of the week), and sales (in dollars):

Store	Day	Sale
1	M	1200
1	T	1435
1	W	1712
1	R	1529
1	F	1920
1	S	2325

and the data set store2 contains the same three variables:

Store	Day	Sales
2	M	2215
2	T	2458
2	W	1789
2	R	1692
2	F	2105
2	S	2847

Then, when we concatenate the two data sets, we get what I like to call a “tall” data set:

Store	Day	Sales
1	M	1200
1	T	1435
1	W	1712
1	R	1529
1	F	1920
1	S	2325
2	M	2215
2	T	2458
2	W	1789
2	R	1692
2	F	2105
2	S	2847

in which the data sets are stacked on top of each other. Note that the number of observations in the new data set is the sum of the numbers of observations in the original data sets. To concatenate SAS data sets, you simplify specify a list of data set names in one SET statement.

As you know, variable attributes include the type of variable (character vs. numeric), the informat (how the variable is read in) and format (how its values are printed) of a variable, the length of the variable, and the label (how its variable name is printed) of a variable. Concatenating data sets when variable attributes differ across the input data sets may pose problems for SAS (and therefore you):

• If the data sets you name in the SET statement contain variables with the same names and types, you can concatenate the data sets without modification.

• If the variable types differ, you must modify one or more of the data sets before concatenating them. SAS will not concatenate the data sets until you do.

• If the lengths, formats, informats or labels differ, you may want to modify one or more of the data sets before concatenating them. SAS will concatenate the data sets; you may just not like the results. These attributes will be taken from the dataset that is read in first (i.e. appears first in the SET statement).

Example

The following program concatenates the store1 and store2 data sets to create a new "tall" data set called bothstores:

DATA store1;
    input Store Day $ Sales;
    DATALINES;
    1 M 1200
    1 T 1435
    1 W 1712
    1 R 1529
    1 F 1920
    1 S 2325
    ;
RUN;
 
DATA store2;
    input Store Day $ Sales;
    DATALINES;
    2 M 2215
    2 T 2458
    2 W 1798
    2 R 1692
    2 F 2105
    2 S 2847
    ;
RUN;
 
DATA bothstores;
    set store1 store2;
RUN;
 
PROC PRINT data = bothstores NOOBS;
    title 'The bothstores data set';
RUN;

The bothstores data set

Store	Day	Sales
1	M	1200
1	T	1435
1	W	1712
1	R	1529
1	F	1920
1	S	2325
2	M	2215
2	T	2458
2	W	1798
2	R	1692
2	F	2105
2	S	2847

Note that the input data sets — store1 and store2 — contain the same variables — Store, Day, and Sales — with identical attributes. In the third DATA step, the DATA statement tells SAS to create a new data set called bothstores, and the SET statement tells SAS that the data set should contain first the observations from store1 and then the observations from store2. Note that although we have specified only two input data sets here, the SET statement can contain any number of input data sets.

Launch and run the SAS program, and review the output from the PRINT procedure to convince yourself that SAS did indeed concatenate the store1 and store2 data sets to make one "tall" data set called bothstores. You might then want to edit the SET statement so that store1 follows store2, and re-run the SAS program to see that then the contents of store1 follow the contents of store2 in the bothstores data set.

In general, a data set that is created by concatenating data sets contains all of the variables and all of the observations from all of the input data sets. Therefore, the number of variables the new data set contains always equals the total number of unique variables among all of the input data sets. And, the number of observations in the new data set is the sum of the numbers of observations in the input data sets. Let's return to the contrived example we've used throughout this lesson.

Example

The following program concatenates the one and two data sets to create a new "tall" data set called onetopstwo:

DATA one;
    input ID VarA $ VarB $;
    DATALINES;
    10 A1 B1
    20 A2 B2
    30 A3 B3
    ;
RUN;
 
DATA two;
    input ID VarB $ VarC $;
    DATALINES;
    40 B4 C1
    50 B5 C2
    ;
RUN;
 
DATA onetopstwo;
    set one two;
RUN;
 
PROC PRINT data = onetopstwo NOOBS;
    title 'The onetopstwo data set';
RUN;

The onetopstwo data set

ID	VarA	VarB	VarC
10	A1	B1
20	A2	B2
30	A3	B3
40		B4	C1
50		B5	C2

As you review the first two DATA steps, in which SAS reads in the respective one and two data sets, note that the total number of unique variables is four — ID, VarA, VarB, and VarC. The total number of observations among the two input data sets is 3 + 2 = 5. Therefore, we can expect the concatenated data set onetopstwo to contain four variables and five observations. Launch and run the SAS program, and review the output to convince yourself that SAS did grab first all of the variables and all of the observations from the one data set and then all of the variables and all of the observations from the two data set. As you can see, to make it all work out okay, observations arising from the one data set have missing values for VarC, and observations from the two data set have missing values for VarA.

11.5.2. Match-Merging SAS Datasets

Match-merging is one of the most powerful methods of combining two or more SAS data sets. A match-merge combines observations across data sets based on the values of one or more common variables.

Consider a fictional dataset called base that has baseline data for patients with the ids 1 to 10 and their age, and visits dataset which contains data for patients with the ids 1 to 8 and 11, the visit number (all patients have 3 visits), and some quantitative outcome measurement.

To match-merge, you simply specify the data sets you would like to merge in a MERGE statement, and indicate the variables on which you would like to merge in a BY statement. One thing to keep in mind, though, is you can’t match-merge SAS data sets unless they are sorted by the variables appearing in the BY statement. The variables that you are merging on (i.e that appear in the BY statement) must have the same name in both datasets. If this is not the case, then use the rename option to change the variable name in one of the datasets to match the other before merging.

Example

In the following SAS program, we will perform an outer join of the base and visits dataset by merging based in the patient id variable.

DATA base;
   INPUT id age;
   DATALINES;
1 50
2 51
3 52
4 53
5 54
6 55
7 56
8 57
9 58
10 59
;
RUN;

DATA visits;
    DO id = 1 TO 8;
       DO visit = 1 TO 3;
           outcome = 10*id + visit;
           OUTPUT;
        END;
    END;
    id = 11;
    visit = 3;
    outcome = 50;
    OUTPUT;
RUN;

PROC PRINT data = base;
   TITLE "Baseline Dataset";
RUN;

PROC PRINT data = visits;
   TITLE "Visits Dataset";
RUN;

Baseline Dataset

Obs	id	age
1	1	50
2	2	51
3	3	52
4	4	53
5	5	54
6	6	55
7	7	56
8	8	57
9	9	58
10	10	59

---

Visits Dataset

Obs	id	visit	outcome
1	1	1	11
2	1	2	12
3	1	3	13
4	2	1	21
5	2	2	22
6	2	3	23
7	3	1	31
8	3	2	32
9	3	3	33
10	4	1	41
11	4	2	42
12	4	3	43
13	5	1	51
14	5	2	52
15	5	3	53
16	6	1	61
17	6	2	62
18	6	3	63
19	7	1	71
20	7	2	72
21	7	3	73
22	8	1	81
23	8	2	82
24	8	3	83
25	11	3	50

To peform an outer join between the base and visits dataset, we simply use the MERGE statemet with these two datasets and a BY statement with the common variable id. Note that these two datasets are already sorted by id. If they were not, we would also need to sort both datasets by id first.

DATA outer;
   MERGE base visits;
   BY id;
RUN;

PROC PRINT data = outer;
   TITLE "Outer Join";
RUN;

Outer Join

Obs	id	age	visit	outcome
1	1	50	1	11
2	1	50	2	12
3	1	50	3	13
4	2	51	1	21
5	2	51	2	22
6	2	51	3	23
7	3	52	1	31
8	3	52	2	32
9	3	52	3	33
10	4	53	1	41
11	4	53	2	42
12	4	53	3	43
13	5	54	1	51
14	5	54	2	52
15	5	54	3	53
16	6	55	1	61
17	6	55	2	62
18	6	55	3	63
19	7	56	1	71
20	7	56	2	72
21	7	56	3	73
22	8	57	1	81
23	8	57	2	82
24	8	57	3	83
25	9	58	.	.
26	10	59	.	.
27	11	.	3	50

In this merge, all variables and rows from both datasets are kept with the id columns from both datasets merged to a single column. Note that for id's that appeared in base and not in visits, the variables in visits, visit and outcome, that were not in base were set to missing (see id 9 and 10), and for ids in the visit dataset that were not in the base dataset, the variables that were in base but not in visit, age in this case, were set to missing (see id 11).

Before we learn how to do inner, left and right joins, we need to discuss the IN= SAS dataset option. The IN= option tells SAS to create an “indicator variable” that takes on either the value 0 or 1 depending on whether or not the current observation comes from the input data set. If the observation does not come from the input data set, then the indicator variable takes on the value 0. If the observation does come from the input data set, then the indicator takes on the value 1. The IN= option is especially useful when merging and concatenating data sets which we’ll study in the next two lessons. The basic format of the IN option is:

IN = varname

where varname is the name of a variable in the input data set. Let’s revisit the previous example where we keep track of the IN= variable values.

Example

Let's merge base and visit again, but this time create the IN= variables for each dataset and store their values in two permanent variables in_base and in_visit:

DATA outer2;
   MERGE base (IN = in1) 
         visits (IN = in2);
   BY id;
   in_base = in1;
   in_visit = in2;
RUN;

PROC PRINT data = outer2 (FIRSTOBS=22 OBS=27);
   TITLE "Outer Join with IN Variables";
RUN;

Outer Join with IN Variables

Obs	id	age	visit	outcome	in_base	in_visit
22	8	57	1	81	1	1
23	8	57	2	82	1	1
24	8	57	3	83	1	1
25	9	58	.	.	1	0
26	10	59	.	.	1	0
27	11	.	3	50	0	1

The ids for patients 1 through 8 appear in both dataset, so for all of the rows corresponding to these ids both in_base and in_visit have the value 1 since we combined data from both datasets to create these rows. But for ids 9 and 10, these only appeared in the base dataset so in_base is 1 and in_visit is 0, since there was no data from visit to use to make these rows. Similarly for id 11, the only data was contained in the visit dataset so in_visit is 1 and in_base is 0.

To perform an inner join, we only want to keep rows that have matching ids in both datasets. Using the IN= variables, we only want to keep rows in which both (or all if we have more than 2 datasets) are 1.

Example

The following SAS program performs an inner join between the base and visit dataset. This means that we will only keep rows in which the merging variable, id, appear in both datasets.

DATA inner;
   MERGE base (IN = in1) 
         visits (IN = in2);
   BY id;
   IF in1 = 1 AND in2 = 1; *subsetting IF. Only keep these rows;
RUN;

PROC PRINT data = inner;
   TITLE "Inner Join";
RUN;

Inner Join

Obs	id	age	visit	outcome
1	1	50	1	11
2	1	50	2	12
3	1	50	3	13
4	2	51	1	21
5	2	51	2	22
6	2	51	3	23
7	3	52	1	31
8	3	52	2	32
9	3	52	3	33
10	4	53	1	41
11	4	53	2	42
12	4	53	3	43
13	5	54	1	51
14	5	54	2	52
15	5	54	3	53
16	6	55	1	61
17	6	55	2	62
18	6	55	3	63
19	7	56	1	71
20	7	56	2	72
21	7	56	3	73
22	8	57	1	81
23	8	57	2	82
24	8	57	3	83

Now only the rows made from ids 1 to 8 are in the merged dataset because these were the only ids that occurred in both the base and visit datasets.

Example

In this example, we will perform left and right joins using the IN= variables. A left join will keep all records from the left (i.e. first dataset in the MERGE statement) and join matching records from the right dataset and dropping the rest. The reverse happesn for a right join.

DATA left;
   MERGE base (IN = in1) 
         visits (IN = in2);
   BY id;
   IF in1 = 1; *subsetting IF. Only keep these rows;
RUN;

PROC PRINT data = left;
   TITLE "Left Join";
RUN;

DATA right;
   MERGE base (IN = in1) 
         visits (IN = in2);
   BY id;
   IF in2 = 1; *subsetting IF. Only keep these rows;
RUN;

PROC PRINT data = right;
   TITLE "Right Join";
RUN;

Left Join

Obs	id	age	visit	outcome
1	1	50	1	11
2	1	50	2	12
3	1	50	3	13
4	2	51	1	21
5	2	51	2	22
6	2	51	3	23
7	3	52	1	31
8	3	52	2	32
9	3	52	3	33
10	4	53	1	41
11	4	53	2	42
12	4	53	3	43
13	5	54	1	51
14	5	54	2	52
15	5	54	3	53
16	6	55	1	61
17	6	55	2	62
18	6	55	3	63
19	7	56	1	71
20	7	56	2	72
21	7	56	3	73
22	8	57	1	81
23	8	57	2	82
24	8	57	3	83
25	9	58	.	.
26	10	59	.	.

---

Right Join

Obs	id	age	visit	outcome
1	1	50	1	11
2	1	50	2	12
3	1	50	3	13
4	2	51	1	21
5	2	51	2	22
6	2	51	3	23
7	3	52	1	31
8	3	52	2	32
9	3	52	3	33
10	4	53	1	41
11	4	53	2	42
12	4	53	3	43
13	5	54	1	51
14	5	54	2	52
15	5	54	3	53
16	6	55	1	61
17	6	55	2	62
18	6	55	3	63
19	7	56	1	71
20	7	56	2	72
21	7	56	3	73
22	8	57	1	81
23	8	57	2	82
24	8	57	3	83
25	11	.	3	50

11.6. Exercises

For these exercises, we will use the Bike_Lanes_Wide.csv, Bike_Lanes.csv, crashes.csv and roads.csv. Please be sure that you have these datasets downloaded to a convenient location on your computer. See the datasets folder provided on the course webpage.

1. Read in the Bike_Lanes_Wide.csv dataset and call is wide using PROC IMPORT. Print the first few rows of the dataset.

2. Reshape wide using either PROC TRANSPOSE or a DATA step. You will need to gather all columns except the name column. Transform into a long dataset with two new columns lanetype (the former column names) and the_length the data values. In the variable the_length, replace ‘NA’ values with . and convert it to a numeric column.

3. Read in the roads and crashes .csv files and call them road and crash.

4. Replace (using tranwrd) any hyphens (-) with a space in Road variable of crash. Call this data crash2. Table the Road variable with PROC FREQ.

5. How many observations are in each of the crash and road datasets?

6. Separate the Road column (using scan) into (type and number) in crash2. Reassign this to crash2. Table type from crash2 using PROC FREQ. Then create a new variable calling it road_hyphen using one of the concatenate functions (such as CAT). Unite the type and number columns using a hyphen (-) and then table road_hyphen using PROC FREQ.

7. Which and how many years were data collected in the crash dataset?

8. Read in the dataset Bike_Lanes.csv and call it bike.

9. Keep rows where the record is not missing type and not missing name and re-assign the output to bike.

10. Using PROC MEANS with a BY statement grouping name and type (i.e for each type within each name), find the sum of the length. Use an OUTPUT statement to get this summary dataset and only keep the name, type and sum of the length column (after renaming this column length). Call this data set sub.

11. Reshape sub from long to wide by taking the type to be the new columns and length to be the value in those columns. (NOTE: the names have spaces in them. Do we need to replace the spaces with a character before changing them to column names? The DATA step approach is more challenging here since not all streets have the same bike lane types.)

12. Join data in the crash and road datasets to retain only complete data, (using an inner join on road) Merge by the variable Road. Call the output merged. How many observations are there?

13. Join data using a full_join. Call the output full. How many observations are there?

14. Do a left join of the road and crash. ORDER matters here! How many observations are there?

15. Repeat above with a right_join with the same order of the arguments. How many observations are there?

10. Data Cleaning 12. The Output Delivery System and Graphics