Research using simulated data is often done to predict future events based on real-world data. Once accepted as a reliable method to contribute to decision making, there are several applications in which computer simulation could be used to provide plausible outcome scenarios prior to actually making a decision to advance in a specific direction.  For example, using computer simulation tools, administrators can create financial forecasting models based on selected expenditure statements and health sector administrative data to estimate future costs and establish budgetary guidelines that are within the appropriate tolerances for a given fiduciary system. Similarly, health researchers can use demographic information about a cohort within the population or about the health care workforce to predict how many new health care professionals we will need in the years to come. This information can then be used to make decisions about the number of students that universities and colleges should accept into their programs in order to meet the predicted needs.

Creating and using a simulated dataset is also an excellent way to practice the application of statistical methods without having to collect real-world data. That is, we can create a simulated dataset by first establishing the set of independent and dependent variables that are of interest to us in our research project, and then establish the range for each response within the variables of interest.

For example, if in our research study we were interested in measuring the effect of a drug versus placebo on reacton time, then our study could be as simple as having three variables: ID, DRUG, and REACTION_TIME. Given that the ID is simply a counter which SAS will assign as an observation number, we need not be concerned with the scoring of ID. LIkewise, given that DRUG can either be DRUG or PLACEBO, we know that this is what we refer to as either a grouping variable or in some fileds we may see this referred to as a DUMMY variable, and the range for this variable will be DRUG=1  and PLACEBO=2. Further, from the literature we understand that the reaction time will have an upper threshold value we use to establish the range of outcomes for our response in our computer simulation data set.

With all of this information known before we begin, we can use a random number generator with SAS to create a dataset that is estimated from the set of values we provide to the computer.

Here is our first example of creating random numbers with the SAS random number generator functions. In this first example, we are simply testing the code for the random number function. Here we used 3 lines of SAS code.

DATA SASRNG;
/* THE SEED FOR THE RANDOM NUMBER */
call streaminit(999);
/* CREATE THE VARIABLE GROUP */
group=RAND("normal")*1000000000000;
/* RUN THE RNG AND PRINT OUTPUT */
run;
proc print; var group;
run;


The result of this code is a random number but the number has no real meaning to us except that it shows us SAS generated a value for the variable GROUP.

Now we want to modify that output so that it has meaning. In the following SAS code we will first create the random number, establish the sign of the output to be positive by using the ABS absolute number function and then set the range of the output by using the MOD functions (MODULO MATH function ). In the application of modulo math here we are setting the lowest value to 1 and the ceiling value to 2.

Notice here that we are generating a set of 20 values, and just to be sure that we restrict the output to 1 and 2 we add the logic statement if group=3 then group=1;

The output from this SAS code is presented here:

This is an amazing learning opportunity as it enables you to create, albeit artificially, a complete dataset with the variables in which you are interested.  The experience is invaluable as it provides you with the opportunity to critically evaluate both the strategies for input as well as the interpretation for output. Although not required, working through a computer-simulated dataset during the development of your research proposal can help you develop your data analysis plan, and enable you to become familiar with the ranges and nuances of the important variables.

In the following program, we will generate a set of values based on the application of SAS random number generator funtions.
For the variables age, which is a discrete random variable, we will set a minimum age of 18 and a maximum age of 72, The data will be generated from the random normal distribution to produce a variable for group and and a variable for reaction time. Each of these variables represents a different type of important variable that you might encounter in your data.
For example, the variable age is discrete and can have a range from 1 to 120; sex will be alphanumeric and can be of four types (M, F, O, U) where O is other and U is undisclosed; the group will be limited to a binary output (1,2), and reaction time will represent a continuous random variable. Here we will control the function of the random number generator by controlling the parameters of the processor to ensure that our output falls within a specific range.

.. Chapter 42 RNG_PRG01

The program above produced the following output.

Consider for example that you are asked to assess the benefits of a 12-week pulmonary rehabilitation program, consisting of exercise and education, for a cohort of individuals with varying classifications of chronic obstructive pulmonary disease (COPD). The intake data include demographic variables such as the individual’s age, sex, height, and weight; and performance data such as the distance walked in 6 minutes, a physician based rating of COPD, the program participant’s self reported smoking status, years smoked; and physiological measures such as forced expiratory volume in 1 second, and resting heart rate.

In the following example we will generate data artificially using random number generators written with SAS code.  In this way we can produce a simulated dataset that we can then use to observe what might happen if we were to actually conduct a research study with the same parameters and considerations.

Using random number generators we create the data set to produce a set of values representing 20 individuals (a random selection of males and females). The variables used in the table along with the variable types and the possible minimum and maximum range for each variable are presented in Table 6.1 below.

Table 6.1 Variables Used To Produce A Sample Of Raw Data For The COPD Clinic

Here we will use SAS code to produce the table of random numbers for each of the variables listed above. Recent developments in high speed computing and the creation of the Mersenne-Twister Random Number Generator which is now used by SAS, have led to the creation of the RAND() function.  As stated in the SAS Knowledge Base (SAS(R) 9.3 Functions and CALL Routines), the RAND function can generate random numbers for a distribution specified by the user.

In the following example the random number generator was seeded with the statement:  call streaminit(n);

Here we specify that the data we generate will be drawn from the normal distribution.

SAS User Notes provide an explanation of the RAND() function as follows:

Once we have established the parameters for random number selection we begin writing the SAS program to create random number generators as we would for any SAS program.  Start by stating the options that you would like included in the output and then name the workspace using normal SAS code.

Our next statement is to create an array. An array is a set of variables that generally have some commonality and that you wish to process together. In our example, we will start by creating an array that we name  SCORES, and which has three elements or variables.

By naming the array, as we have here (SCORES) we can refer to the array SCORES later to reference the specific elements that are contained within. For example, since the array has three elements, then SCORES(1) refers to the first element—the participant’s SEX, while SCORES(2) refers to the second element—the SEVERITY of the COPD condition, and SCORES(3) refers to the third element—the patient’s SMOKING status.

Once we create the workspace in SAS, we next use the do-loop statements to generate a data set consisting of 20 cases. The first do-loop (DO K=1 TO 20) tells SAS to execute the statements within the loop 20 times.

The second do-loop (DO K=1 TO 3) is contained within the first loop and is designed to provide data specifically for the variables SEX, SEVERITY, and SMOKING

Figure 6.1 Functions of The Do-Loop To Generate Random Numbers For The Array SCORES

Finally, we end the do loops with the following statement sequence.

END;

OUTPUT;

END;

The first END; statement closes the inside loop that begins with DO I=1 TO 3; likewise, the  OUTPUT;  statement is needed to assign the RNG values to each variable for each participant, the outside loop (DO K=1 TO 20😉 is closed with the second  END; statement.

Figure 6.2  Closing the do-loops and producing output

The actual statement sequence to generate a random number for each of the variables in the array is shown here as a three step process beginning by seeding the Random Number Generator (RNG)    with CALL STREAMINIT(N); where the (N) can be any number you wish to use.  In this first example here we used the number 13 (only because 13 is MY lucky number!).

The call statement initiates or seeds the random number generator.

This sequence of statemente invokes the random number generator and places a value in each element of the array (i.e., the list of variables).

After generating the random numbers for each variable in the array  SCORE (SEX, SEVERITY, SMOKING) we then process the number with a logic filter so that it makes sense in relation to the range of scores that we would expect to see for each given variable.

For example, if the RNG produces a value of 75 for the variable sex, then what does that mean?

Well actually it is meaningless until you assign the meaning.

We assign meaning to the values within a variable using logic statements. For each of the elements (variables) within the array we process the RNG value with logic statements that will make the data relevant to our variables.

For example, the logic statements to convert the RNG values for sex are shown here. In this situation we convert the numeric variable for sex to a text variable that we call sex. Since we have text labels that extend beyond 8 characters we use the length statement with the $ to ensure that the full length of the text label is used.

In SAS, the logic statements use the if-then conventional approach. That is, for every IF statement we use a corresponding THEN statement. In this way we process the RNG values to be within the range of logical outcomes for the variable that we are creating.

Next we create RNGs for the remaining seven variables that we plan to include in the analysis. We do not need to include these in the array and can simply generate the values when SAS walks through the outer do loop. The independent execution of the rand(“normal”) function can run with a new seed and a new maximum score.  Notice that these follow the array processing statements.

The continuous discrete variables were age, years smoked, resting heart rate, weight, and distance walked in 6 minutes (measured in metres).

/* CONTINUOUS DISCRETE VARIABLE AGE */

CALL STREAMINIT(13); AGE=RAND(“NORMAL”)*1000000000000;

AGE=40+ABS((MOD(AGE,62))); AGE=ROUND(AGE);

IF AGE>72 THEN AGE=35+ABS((MOD(AGE,50)));

/* CONTINUOUS DISCRETE VARIABLE YRSMOKE */

CALL STREAMINIT(13); YRSMOKE=RAND(“NORMAL”)*1000000000000;

YRSMOKE=1+ABS((MOD(YRSMOKE,12))); YRSMOKE=ROUND(YRSMOKE);

/* CONTINUOUS DISCRETE VARIABLE RHR */

CALL STREAMINIT(69); RHR=RAND(“NORMAL”)*1000000000000;

RHR=54+ABS((MOD(RHR,80))); RHR=ROUND(RHR);

/* CONTINUOUS DISCRETE VARIABLE WT */

CALL STREAMINIT(45); WT=RAND(“NORMAL”)*1000000000000;

WT=45+ABS((MOD(WT,65)));WT=ROUND(WT,0.01);

IF WT>85 THEN WT=55+ABS((MOD(WT,12)));

/* CONTINUOUS DISCRETE VARIABLE WALKDIST */

CALL STREAMINIT(69);WALKDIST=RAND(“NORMAL”)*1000000000000;

WALKDIST=54+ABS((MOD(WALKDIST,80))); WALKDIST=ROUND(WALKDIST);

Next we created the continuous decimal variables. Again these statements are placed within the do loops to produce a full set of 20 outputs.

/* CONTINUOUS DECIMAL VARIABLE FEV1 */

CALL STREAMINIT(99); FEV1=RAND(“NORMAL”)*1000000000000;

FEV1=1+ABS((MOD(FEV1,3)));FEV1=ROUND(FEV1,0.01);

/* CONTINUOUS DECIMAL VARIABLE HT */

CALL STREAMINIT(21); HT=RAND(“NORMAL”)*1000000000000;

HT=1+ABS((MOD(HT,1.1)));HT=ROUND(HT,0.01);

IF HT<1.5 THEN HT=1.2+ABS((MOD(HT,1.1)));