SAS: The Power To Know

PROC SPELL: The Spell of SAS PART -2

2016-06-18T19:40:00.002+05:30

Continuing to PROC SPELL: The Spell of SAS PART -1, this is part 2 for making proc spell more comfortable.
Lets take some example to understand how proc spell works.

First create a misspelled file :

Industries understand special traininng needs
Industry understand special training needs
Industrys understund special traininng needs
industri understand spesial training needs
indastry usderstand special training needs
industre undarstund special trainng needs

You should not trast anyone blindly

Now import this SAS file in a SAS system:

%let location = M:\sasfolder\SAS files;
libname data "&location.";

filename sample "&location.\misspelled file.txt";

Now to create a catalogue of words in the file
Proc SPELL words = sample
Create dict = data.mycatgalog.Spell;

Run;

Now initiate a file for accommodating required output :

Proc Printto print = "&location.\output.txt" new;
Run;

/* Now with the help of Proc Spell, we try to identify the misspelled words and seek suggestion to correct those, and take output in the above initialized file */

Proc Spell in = sample
dictionary = data.mycatgalog.Spell
verify suggest;
run;

Proc Printto print = print; Run;

/* Open the output file to understand the output of Proc Spell, let's get the output back into SAS */

Data data.List_correction;
infile "&location.\output.txt" missover firstobs = 7 ;
input A & $1000. ;

Run;

/* Transform the output file into readily usable form */
Data data.List_correction;
set data.List_correction;
retain id 1;
if A = "" then id +1;
Run;
Proc transpose data = data.List_correction out = data.transposed;
by id;
var A;
where A ~="";

Run;

data data.transposed;
length suggested $1000.;
retain id original_word suggested;
set data.transposed (drop = _name_);
rename Col1 = original_word;
suggested = scan(Col2,2,":"); drop col2; run;

Data data.transposed;
retain id
original_word suggested;
set data.transposed;

run;

... and here we are with a list of incorrect words with suggested correction. For few words, we might not get any and for others, we might get more than one, Now to it is time to build the further algorithm to replace wrong word with the most appropriate corrected word. You can build a macro and use tranwrd function to replace the word.

This page has taken reference from the link: SAS Gems

PROC SPELL: The Spell of SAS PART -1

2016-06-18T19:26:00.003+05:30

Where spelt is a fileref for the file containing the text to be spell checked and words is a libref pointing to the SAS library where the spell checker list is located. The suggest option lists spelling suggestions from the dictionary.

Verify is the default and is assumed unless a custom catalog is being created or updated with Proc SPELL.

To be more useful, a custom dictionary of industry relevant words that are not in SAS' dictionary can be created. This dictionary is a SAS catalog entry and is created with the spell procedure. To create a dictionary:

Create a text file with the upper case words that you want to define.

Put each word on a separate line.

Point to the SAS file that holds the dictionary catalog (if updating) or create a new catalog.

Point to the location of the custom word list.

filename Spelt '<file-specification>';

PROC Spell in = Spelt

dictionary = Words.spell.mywords

verify

suggest;

run;

//***********************************************

filename textdata 'c:\text.txt';

PROC Spell in = textdata

verify;

run;

//***********************************************

The code below creates the custom word catalog. This newly created catalog includes those entries in the SAS catalog in addition to the added custom words. To add words to a custom catalog change create to update.

PROC Spell words = "e:sasfolder\condition.txt"

create

dict = work.mycatalog.spell;

run;

//*********************************************

/*** Using Proc Spell, find all combination***/

/*** of letters that compose a valid word composed ***/

/*** of 3 or 4 letters from a phone number. ***/

%let myphone = 8 6 0 6 7 3 9 2 7 8; /*** 10 digit phone number ***/
 /*** with spaces between each number as delimiters ***/

 Data A (Keep = L) ;
   Array C (0:9, 4) $1. _Temporary_
                        (' '  ' '  ' '  ' '
                         ' '  ' '  ' '  ' '
                         'A'  'B'  'C'  ' '
                         'D'  'E'  'F'  ' '
                         'G'  'H'  'I'  ' '
                         'J'  'K'  'L'  ' '
                         'M'  'N'  'O'  ' '
                         'P'  'Q'  'R'  'S'
                         'T'  'U'  'V'  ' '
                         'W'  'X'  'Y'  'Z');

  /***                       0 1 2 3 4 5 6 7 8 9 ***/
  Array T (0:9) _Temporary_ (1 1 3 3 3 3 3 4 3 4) ;
  /***                       my    phone number  ***/
  Array P (0:9)  P0 - P9    (&myphone);
  Length L  $12. ;

  Do X0=1 To T(P0) ;  SubStr(L, 1,1) = C(P0,X0) ;
  Do X1=1 To T(P1) ;  SubStr(L, 2,1) = C(P1,X1) ;
  Do X2=1 To T(P2) ;  SubStr(L, 3,1) = C(P2,X2) ;
/*** create a space for position 4 ***/
  Do X3=1 To T(P3) ;  SubStr(L, 5,1) = C(P3,X3) ;
  Do X4=1 To T(P4) ;  SubStr(L, 6,1) = C(P4,X4) ;
  Do X5=1 To T(P5) ;  SubStr(L, 7,1) = C(P5,X5) ;
/*** create a space for position 8 ***/
  Do X6=1 To T(P6) ;  SubStr(L, 9,1) = C(P6,X6) ;
  Do X7=1 To T(P7) ;  SubStr(L,10,1) = C(P7,X7) ;
  Do X8=1 To T(P8) ;  SubStr(L,11,1) = C(P8,X8) ;
  Do X9=1 To T(P9) ;  SubStr(L,12,1) = C(P9,X9) ;
     Output ;
  End; End; End; End; End; End; End; End; End; End;
Run ;

 /*** create an external bad word file for PROC SPELL ***/
 data _null_;
 file "testprocspell.txt";
 set a;
 put L;
 run;

 proc printto file="badwords.lis" new; run;
 proc spell wordlist="testprocspell.txt"; run;
 proc printto; run;

  /*** read bad words created by proc spell ***/
  data badwords;
   infile 'badwords.lis'      missover ;
   input @1 badwords $ 30. ;
   if badwords = ' ' then delete;
   badwords = left(badwords);
   if 0 ne index(badwords, 'File:') then delete;
   if 0 ne index(badwords, 'Unrecognized') then delete;
  run;

  proc sort data=badwords out=badwords nodupkey; by badwords; run;

  /*** now create a badword cleanup file ***/
  data clnbadwd (drop=badwords);
   length target $ 50 replace $ 50;
   set badwords;
   target = badwords; replace = ' ';
  run;

  /*** Using TIP 00128a (CLEANSEM.sas) ***/
  %include 'cleanse_my.sas'; /*** my temporary version ***/

  /*** need to check each schema for cyclical mappings  ***/
  /*** as well as create a global macro variable to get ***/
  /*** number of records for each schema used           ***/
  /*** CHECK OUTPUT for any cyclical mapping reports    ***/

  %chkschem( schema=clnbadwd);

 data clean;
  set a;
        %cleanse(schema=clnbadwd ,var=L       );
  if L ne ' '; /*** keep only non blank L ***/
 run;

 proc sort data=clean out=clean nodupkey; by L; run;

 /*** now create an output file of just valid words ***/
 data _null_;
  set work.clean;
  file "cleanwords.txt";
  put L;
 run;

/*** output from Clean Words Recognized by PROC SPELL 
     default Dictionary                                 ***/
ORE
ORE PART
ORE PAST
ORE WART
PART
PAST
TO
TO    PART
TO    PAST
TO    WART
TO  ORE
TO  ORE PART
TO  ORE PAST
TO  ORE WART
WART

/*** end of program ***/

Reference for PROC Spell: http://analytics.ncsu.edu/sesug/2007/SD06.pdf

For Practice part , next part to be continued in next blog-

BASE SAS : Interview Questions (Written Exams)

2016-06-05T19:01:00.002+05:30

QUESTION 1

The following SAS program is submitted:

data one;

addressl = ‘214 London Way’;

run;

data one;

set one;

address = tranwrd(address1, ‘Way’, ‘Drive’);

run;

What are the length and value of the variable ADDRESS?

Options:

A. Length is 14; value is ‘214 London Dri’.

B. Length is 14; value is ‘214 London Way’.

C. Length is 16; value is ‘214 London Drive’.

D. Length is 200; value is ‘214 London Drive’.

QUESTION 2

The following program is submitted.

data WORK.TEST;

input Name $ Age;

datalines;

John +35

;

run;

Which values are stored in the output data set?

Options:

A. Name Age

---------------------

John 35

B. Name Age

---------------------

John (missing value)

C. Name Age

---------------------

(missing value) (missing value)

The DATA step fails execution due to data errors.

QUESTION 3

Given the SAS data set WORK.ONE:

Id Char1

--- -----

182 M

190 N

250 O

720 P

and the SAS data set WORK.TWO:

Id Char2

--- -----

182 Q

623 R

720 S

The following program is submitted:

data WORK.BOTH;

merge WORK.ONE WORK.TWO;

by Id;

run;

What is the first observation in the SAS data set WORK.BOTH?

Options:

A. Id Char1 Char2

--- ----- -----

182 M

B. Id Char1 Char2

--- ----- -----

182 Q

C. Id Char1 Char2

--- ----- -----

182 M Q

D. Id Char1 Char2

--- ----- -----

720 P S

QUESTION 4

Which program displays a listing of all data sets in the SASUSER library?

Options:

A. proc contents lib = sasuser.all; run;

B. proc contents data = sasuser.all; run;

C. proc contents lib = sasuser._alI_; run;

D. proc contents data = sasuser._all_; run;

QUESTION 5

The following SAS program is submitted:

proc format;

value score 1 - 50 = 'Fail'

51 - 100 = 'Pass';

run;

Which one of the following PRINT procedure steps correctly applies the format?

Options:

A. proc print data = SASUSER.CLASS;

var test;

format test score;

run;

B. proc print data = SASUSER.CLASS;

var test;

format test score.;

run;

C. proc print data = SASUSER.CLASS format = score;

var test;

run;

D. proc print data = SASUSER.CLASS format = score.;

var test;

run;

QUESTION 6

Given the text file COLORS.TXT:

----+----1----+----2----+----

RED ORANGE YELLOW GREEN

BLUE INDIGO PURPLE VIOLET

CYAN WHITE FUCSIA BLACK

GRAY BROWN PINK MAGENTA

The following SAS program is submitted:

data WORK.COLORS;

infile 'COLORS.TXT';

input @1 Var1 $ @8 Var2 $ @;

input @1 Var3 $ @8 Var4 $ @;

run;

What will the data set WORK.COLORS contain?

Options:

A. Var1 Var2 Var3 Var4

------ ------ ------ ------

RED ORANGE RED ORANGE

BLUE INDIGO BLUE INDIGO

CYAN WHITE CYAN WHITE

GRAY BROWN GRAY BROWN

B. Var1 Var2 Var3 Var4

------ ------ ------ ------

RED ORANGE BLUE INDIGO

CYAN WHITE GRAY BROWN

C. Var1 Var2 Var3 Var4

------ ------ ------ ------

RED ORANGE YELLOW GREEN

BLUE INDIGO PURPLE VIOLET

D. Var1 Var2 Var3 Var4

------ ------ ------ ------

RED ORANGE YELLOW GREEN

BLUE INDIGO PURPLE VIOLET

CYAN WHITE FUCSIA BLACK

GRAY BROWN PINK MAGENTA

QUESTION 7

The following SAS program is submitted:

data work.accounting;

set work.dept1 work.dept2;

jobcode = ‘FA1’;

length jobcode $ 8;

run;

A character variable named JOBCODE is contained in both the WORK.DEPT1 and WORK.DEPT2 SAS data sets. The variable JOBCODE has a length of 5 in the WORK.DEPT1 data set and a length of 7 in the WORK.DEPT2 data set. What is the length of the variable JOBCODE in the output data set?

Options:

A. 3

B. 5

C. 7

D. 8

QUESTION 8

Given the SAS data set WORK.INPUT:

Var1 Var2

------ -------

A one

A two

B three

C four

A five

The following SAS program is submitted:

data WORK.ONE WORK.TWO;

set WORK.INPUT;

if Var1='A' then output WORK.ONE;

output;

run;

How many observations will be in data set WORK.ONE?

Options:

A. 8

B. 7

C. 9

D. 5

QUESTION 9

Given the following SAS error log

data WORK.OUTPUT;

set SASHELP.CLASS;

BMI=(Weight*703)/Height**2;

where bmi ge 20;

ERROR: Variable bmi is not on file SASHELP.CLASS.

run;

What change to the program will correct the error?

Options:

A. Replace the WHERE statement with an IF statement
B. Change the ** in the BMI formula to a single *
C. Change bmi to BMI in the WHERE statement
D. Add a (Keep=BMI) option to the SET statement

QUESTION 10

The following SAS program is submitted:

footnote1 ‘Sales Report for Last Month’;

footnote2 ‘Selected Products Only’;

footnote3 ‘All Regions’;

footnote4 ‘All Figures in Thousands of Dollars’;

proc print data = sasuser.shoes;

footnote2 ‘All Products’;

run;

Which footnote(s) is/are displayed in the report?

Options:

A. All Products

B. Sales Report for Last Month All Products

C. All Products All Regions All Figures in Thousands of Dollars

D. Sales Report for Last Month All Products All Regions All Figures in Thousands of Dollars

QUESTION 11

The following SAS program is submitted:

data WORK.LOOP;

X = 0;

do Index = 1 to 5 by 2;

X = Index;

end;

run;

Upon completion of execution, what are the values of the variables X and Index in the SAS data set named WORK.LOOP?

Options:

A. X = 3, Index = 5
B. X = 5, Index = 5
C. X = 5, Index = 6
D. X = 5, Index = 7

QUESTION 12

This item will ask you to provide a line of missing code;
The SAS data set WORK.INPUT contains 10 observations, and includes the numeric variable Cost.

The following SAS program is submitted to accumulate the total value of Cost for the 10 observations:

data WORK.TOTAL;

set WORK.INPUT;

Total=Total+Cost;

run;

Which statement correctly completes the program?

Options:

A. keep Total;
B. retain Total 0;
C. Total = 0;
D. If _N_= 1 then Total = 0;

QUESTION 13

Given the raw data record DEPT:

----|----10---|----20---|----30

Printing 750

The following SAS program is submitted:

data bonus;

infile ‘dept’;

input dept$ 1-11 number 13- 15;

run;

Which SAS statement completes the program and results in a value of ‘Printing750’ for the DEPARTMENT variable?

Options:

A. department = dept || number;

B. department = left(dept) || number;

C. department = trim(dept) number;

D. department=trim(dept)||put(number,3.);

QUESTION 14

This question will ask you to provide a line of missing code.

Given the following data set WORK.SALES:

SalesID SalesJan FebSales MarchAmt

------- -------- -------- --------

W6790 50 400 350

W7693 25 100 125

W1387 . 300 250

The following SAS program is submitted:

data WORK.QTR1;

set WORK.SALES;

array month{3} SalesJan FebSales MarchAmt;

run;

Which statement should be inserted to produce the following output?

SalesID SalesJan FebSales MarchAmt Qtr1

------- -------- -------- -------- ----

W6790 50 400 350 800

W7693 25 100 125 250

W1387 . 300 250 550

Options:

A. Qtr1 = sum(of month{_ALL_});

B. Qtr1 = month{1} + month{2} + month{3};

C. Qtr1 = sum(of month{*});

D. Qtr1 = sum(of month{3});

QUESTION 15

The SAS data set SASUSER.HOUSES contains a variable PRICE which has been assigned a permanent label of “Asking Price”. Which SAS program temporarily replaces the label “Asking Price” with the label “Sale Price” in the output?

Options:

A. proc print data = sasuser.houses; label price = “Sale Price”; run;

B. proc print data = sasuser.houses label; label price “Sale Price”; run;

C. proc print data = sasuser.houses label; label price = “Sale Price”; run;

D. proc print data = sasuser.houses; price = “Sale Price”; run;

QUESTION 16

The following SAS program is submitted:

data WORK.TEMP;

Char1='0123456789';

Char2=substr(Char1,3,4);

run;

What is the value of Char2?

Options:

A. 23

B. 34

C. 345

D. 2345

QUESTION 17

The SAS data sets WORK.EMPLOYEE and WORK.SALARY are shown below:

WORK.EMPLOYEE WORK.SALARY

fname age name salary

Bruce 30 Bruce 25000

Dan 40 Bruce 35000

Dan 25000

The following SAS program is submitted:

data work.empdata;

by fname;

totsal + salary;

run;

Which one of the following statements completes the merge of the two data sets by the FNAME variable?

Options:

A. merge work.employee

work.salary (fname = name);

B. merge work.employee

work.salary (name = fname);

C. merge work.employee

work.salary (rename = (fname = name));

D. merge work.employee

work.salary (rename = (name = fname));

QUESTION 18

The following SAS program is submitted:

data work.sets;

do until (prod gt 6);

prod + 1;

end;

run;

What is the value of the variable PROD in the output data set?

Options:

A. 6

B. 7

C. 8

D. (missing numeric)

How can I put a value from a data file to a Macro Variable?

2014-07-19T09:57:00.005+05:30

We can use the SYMPUT function to get information from a data file to a SAS Macro variable. Consider the example below. We have a data file test and we have used proc means to save the mean of x to xbar in a new data file named testmean.

data test;
  input x ;
cards;
100
200
300
;
run;

proc means data=test;
  var x;
  output out=testmean mean=xbar;
run;

We would like to get the value of xbar into a macro variable to be used elsewhere. Below, we use the symput command to put the value of xbar into a macro variable called xbarmac. At the end of the data step we use %put to display this value (to check that it worked) and then in test2 we can use this macro variable to create a mean-centered variable.

data _null_;
  set testmean;
  call symput("xbarmac",xbar);
run;

%put mean of x is &xbarmac;

data test2;
  set test;
  xcent = x - &xbarmac;
run;

proc print data=test2;
run;

Below is the part of the log that shows the value of the macro variable.

%put mean of X is &xbarmac;

mean of X is          200

And below we see the output of proc print, and indeed xcent contains x minus the mean of x.

Obs     x     xcent
1     100     -100
2     200       0

3          300           100

 

General Date and Time Functions On SAS

2013-12-30T20:42:00.003+05:30

datepart – Extract date from date time value
dateonly = datepart(fulldate);
day,month year – Extract part of a date value
day = day(date);
dhms – Construct value from date, hour, minute and second
dtval = dhms(date,9,15,0);
mdy – Construct date from month, day and year
date = mdy(mon,day,1996);
time – Returns the current time of day
now = time();
today – Returns the current date
datenow = today();
intck – Returns the number of intervals between two values
days = intck(’day’,then,today());
intnx – Increments a value by a number of intervals
tomrw = intnx(’day’,today(),1);

Difference In Excel, Access & SAS

2013-12-18T14:06:00.000+05:30

	Description	Advantages	Disadvantages
Excel	§Data manipulation and analysis program for which the user provides cell-based data and instructions to produce numerical and graphical output	§Cell-based model creation §Ability to model "what-if" scenarios §Comprehensive graphing and print formatting functions	§Basic functionality for novice users (extended greatly if you know macros)
Access	§Data storage and retrieval program for which the user provides record and table-based data and instructions to produce numerical, textual (typically tabular) and graphical output	§ Ability to: –Structure complex and interrelated data –Run complex queries on data –Develop customer applications	§Substantial setup time for structuring data and creating tables §Can't easily manipulate data in individual cells
SAS	§High-power record and table-based data analysis tool for managing queries and statistical analysis	§More powerful analytic functions	§Limited applicability and access to program

SAS Question- Replace ' Mr ' with 'Dr' in a dataset.

2013-12-17T17:19:00.000+05:30

Example 1.

Data a;
input name $ 1-15;
new_name=prxchange('s/\Mr /Dr /i',-1,name);
cards;
Mr Mridul
Mr Mrinda
;run;

Example 2.

data test;
length have want1 want2 $20;
have=' Mr Mridul';
want1=tranwrd(have,'Mr ','Dr ');
want2=prxchange('s/^ *Mr\b/Dr/oi',1,have);
run;

Example 3.

DATA a;
INPUT name $ 1-15;
DATALINES;
Mr Mridul
Mr Mrinda
;;
RUN;

Example 4.

DATA a;
SET a;
name = TRANWRD(SCAN(name, 1, ' '), 'Mr', 'Dr ') || SCAN(name, 2, ' ');
RUN;

SAS Code for Question When a blue moon Occure?

2013-12-17T17:04:00.001+05:30

When there are two full moons in a single month, the second is
known as a blue moon. Given that July 9, 1998 is a full moon, and
there are 29 days between full moons, in what months will the next
few blue moons occur?

Solution--

data fullmoon;
date = ’09jul98’d;
do i=1 to 500;
month = month(date);
year = year(date);
output;
date = intnx(’day’,date,29);
end;
run;

Now we can use the put function to create a variable with the full month name and the year.

data bluemoon;
set fullmoon;
by year month;
if last.month and not first.month then do;
when = put(date,monname.) || ", " || put(date,year.);
output;
end;
run;
proc print data=bluemoon noobs;
var when;
run;

Base SAS Certification Question Papers With Answers

2013-12-12T08:57:00.002+05:30

Click here to download Base SAS question paper 1.
Click here to download Base SAS question paper 2.

To download Advance SAS question paper 1 Click here
To download Advance SAS question paper 2 Click here

Review: An Introduction to the SAS System Part-3

2013-11-22T00:36:00.002+05:30

Multiple Data Sets: Overview
One of SAS’s greatest strengths is its ability to combine and
process more than one data set at a time. The main tools used to
do this are the set, merge and update statements, along with the
by statement and first. and last. variables.
We’ll look at the following situations:
• Concatenating datasets by observation
• Interleaving several datasets based on a single variable value
• One-to-one matching
• Simple Merge Matching, including table lookup
• More complex Merge Matching

Concatenating Data Sets by Observation
The simplest operation concerning multiple data sets is to
concatenate data sets by rows to form one large data set from
several other data sets. To do this, list the sets to be concatenated
on a set statement; each data set will be processed in turn,
creating an output data set in the usual way.
For example, suppose we wish to create a data set called last by
concatenating the data sets first, second, and third.
data last;
set first second third;
If there are variables in some of the data sets which are not in the
others, those variables will be set to missing (. or ’ ’) in
observations derived from the data sets which lacked the variable in
question.

Concatenating Data Sets (cont’d)
Consider two data sets clerk and manager:
Name Store Position Rank Name Store Position Staff
Joe Central Sales 5 Fred Central Manager 10
Harry Central Sales 5 John Mall Manager 12
Sam Mall Stock 3
The SAS statements to concatenate the data sets are:
data both;
set clerk manager;
run;
resulting in the following data set:
Name Store Position Rank Staff
Joe Central Sales 5 .
Harry Central Sales 5 .
Sam Mall Stock 3 .
Fred Central Manager . 10
John Mall Manager . 12
Note that the variable staff is missing for all observations from set
clerk, and rank is missing for all observations from manager. The
observations are in the same order as the input data sets.

Concatenating Data Sets with proc append
If the two data sets you wish to concatenate contain exactly the
same variables, you can save resources by using proc append
instead of the set statement, since the set statement must process
each observation in the data sets, even though they will not be
changed. Specify the “main” data set using the base= argument
and the data set to be appended using the new= argument. For
example, suppose we wish to append the observations in a data set
called new to a data set called master.enroll. Assuming that
both data sets contained the same variables, you could use proc
append as follows:
proc append base=master.enroll new=new;
run;
The SAS System will print an error message if the variables in the
two data sets are not the same.

Interleaving Datasets based on a Single Variable
If you want to combine several datasets so that observations
sharing a common value are all adjacent to each other, you can list
the datasets on a set statement, and specify the variable to be
used on a by statement. Each of the datasets must be sorted by the
variable on the by statement.
For example, suppose we had three data sets A, B, and C, and each
contained information about employees at different locations:
Set A Set B Set C
Loc Name Salary Loc Name Salary Loc Name Salary
NY Harry 25000 LA John 18000 NY Sue 19000
NY Fred 20000 NY Joe 25000 NY Jane 22000
NY Jill 28000 SF Bill 19000 SF Sam 23000
SF Bob 19000 SF Amy 29000 SF Lyle 22000
Notice that there are not equal numbers of observations from the
different locations in each data set.

Interleaving Datasets (cont’d)
To combine the three data sets, we would use a set statement
combined with a by statement.
data all;
set a b c;
by loc;
run;
which would result in the following data set:
Loc Name Salary Loc Name Salary
LA John 18000 NY Jane 22000
NY Harry 25000 SF Bob 19000
NY Fred 20000 SF Bill 19000
NY Jill 28000 SF Amy 29000
NY Joe 25000 SF Sam 23000
NY Sue 19000 SF Lyle 22000
Similar results could be obtained through a proc sort on the
concatenated data set, but this technique is more efficient and
allows for further processing by including programming statements
before the run;.

One-to-one matching
To combine variables from several data sets where there is a
one-to-one correspondence between the observations in each of the
data sets, list the data sets to be joined on a merge statement. The
output data set created will have as many observations as the
largest data set on the merge statement. If more than one data set
has variables with the same name, the value from the rightmost
data set on the merge statement will be used.
You can use as many data sets as you want on the merge
statement, but remember that they will be combined in the order
in which the observations occur in the data set.

Example: one-to-one matching
For example, consider the data sets personal and business:
Personal Business
Name Age Eyes Name Job Salary
Joe 23 Blue Joe Clerk 20000
Fred 30 Green Fred Manager 30000
Sue 24 Brown Sue Cook 24000
To merge the variables in business with those in personal, use
data both;
merge personal business;
to result in data set both
Name Age Eyes Job Salary
Joe 23 Blue Clerk 20000
Fred 30 Green Manager 30000
Sue 24 Brown Cook 24000
Note that the observations are combined in the exact order in
which they were found in the input data sets.

Simple Match Merging
When there is not an exact one-to-one correspondence between
data sets to be merged, the variables to use to identify matching
observations can be specified on a by statement. The data sets
being merged must be sorted by the variables specified on the by
statement.
Notice that when there is exactly one observation with each by
variable value in each data set, this is the same as the one-to-one
merge described above. Match merging is especially useful if you’re
not sure exactly which observations are in which data sets.
By using the IN= data set option, explained later, you can
determine which from data set(s) a merged observation is derived.

Simple Match Merging (cont’d)
Suppose we have data for student’s grades on two tests, stored in
two separate files
ID Score1 Score2 ID Score3 Score4
7 20 18 7 19 12
9 15 19 10 12 20
12 9 15 12 10 19
Clearly a one-to-one merge would not be appropriate.
Pay particular attention to ID 9, which appears only in the first
data set, and ID 10 which appears only in the second set.
To merge the observations, combining those with common values of
ID we could use the following SAS statements:
data both;
merge scores1 scores2;
by id;
run;

Simple Match Merging (cont’d)
Here’s the result of the merge:
ID Score1 Score2 Score3 Score4
7 20 18 19 12
9 15 19 . .
10 . . 12 20
12 9 15 10 19
Notes
1. All datasets must be sorted by the variables on the by
statement.
2. If an observation was missing from one or more data sets, the
values of the variables which were found only in the missing
data set(s) are set to missing.
3. If there are multiple occurences of a common variable in the
merged data sets, the value from the rightmost data set is used.

Table Lookup
Consider a dataset containing a patient name and a room number,
and a second data set with doctors names corresponding to each of
the room numbers. There are many observations with the same
room number in the first data set, but exactly one observation for
each room number in the second data set. Such a situation is called
table lookup, and is easily handled with a merge statement
combined with a by statement.
Patients Doctors
Patient Room Doctor Room
Smith 215 Reed 215
Jones 215 Ellsworth 217
Williams 215 . . .
Johnson 217
Brown 217
. . .

Table Lookup (cont’d)
The following statements combine the two data sets.
data both;
merge patients doctors;
by room;
run;
resulting in data set both
Patient Room Doctor
Smith 215 Reed
Jones 215 Reed
Williams 215 Reed
Johnson 217 Ellsworth
Brown 217 Ellsworth
Notes: . . .
• As always, both data sets must be sorted by the variables on
the by list.
• The data set with one observation per by variable must be the
second dataset on the merge statement.

Updating Data Sets
When you’re combining exactly two data sets with the goal of
updating some or all of the first data set’s values with values from
the second data set, you can use the update statement.
An update statement accepts exactly two data sets, and must be
followed by a by statement. An update statement is similar to a
merge statement except that
• the update statement will not overwrite non-missing values in
data set one with missing values from data set two, and
• the update statement doesn’t create any observations until all
the observations for a by group are processed. Thus, the first
data set should contain exactly one observation for each by
group, while the second data set can contain multiple
observations, with later observations supplementing or
overriding earlier ones.

Example: update statement
Set orig Set upd
ID Account Balance ID Account Balance
1 2443 274.40 1 . 699.00
2 4432 79.95 2 2232 .
3 5002 615.00 2 . 189.95
3 6100 200.00
Data set orig can be updated with the values in upd using the
following statements:
data orig;
update orig upd;
by id;
resulting in the updated data set:
ID Account Balance
1 2443 699.00
2 2232 189.95
3 6100 200.00

More Complex Merging
Keep the following in mind when performing more complex merges:
• If the merged data sets have variables in common (in addition
to the variables on the by statement), and the values differ, the
values from the rightmost data set in the merge statement are
used.
• If there are multiple occurences of observations with the same
value for the by variable(s) in the data sets being merged, they
are combined one-to-one. If there are unequal numbers of these
observations in any of the data sets being merged, the last
value from the data set with fewer observations is reused for all
the other observations with matching values.
• Various problems arise if variables in data sets being merged
have different attributes. Try to resolve these issues before
merging the data.

More Complex Merging (cont’d)
The following example, although artificial, illustrates some of the
points about complex merging:
one two three
a b c a b d a b c d
1 3 20 1 3 17 1 3 20 17
1 3 19 1 5 12 1 5 19 12
1 7 22 2 9 21 =) 1 7 22 12
2 9 18 2 3 15 2 9 18 21
2 3 22 2 6 31 2 3 22 15
2 6 22 31
The data sets were merged with the following statements:
data three;
merge one two;
by a;

in= data set option
When creating observations from multiple data sets, it is often
helpful to know which data set an observation should come from. It
should be clear that when merging large data sets, additional tools
will be necessary to determine exactly how observations are created.
The in= data set option is one such tool. The option is associated
with one or more of the data sets on a merge statement, and
specifies the name of a temporary variable which will have a value
of 1 if that data set contributed to the current observation and a 0
otherwise.
Two common uses of the in= variable are to make sure that only
complete records are output, and to create a data set of problem
observations which were missing from one of the merged data sets.
The next slide provides an example of these ideas, using the test
scores data from a previous example.

Example of in= data set option
data both problem;
merge scores1(in=one) scores2(in=two);
by id;
if one and two then output both;
else output problem;
run;
The resulting data sets are shown below; note that the in=
variables are not output to the data sets which are created.
Data set both
Obs Id Score1 Score2 Score3 Score4
1 7 20 18 19 12
2 12 9 15 10 19
Data set problem
Obs Id Score1 Score2 Score3 Score4
1 9 15 19 . .
2 10 . . 12 20

Programming with by statements
The power of the by statement coupled with the merge and set
statements is enough to solve most problems, but occasionally more
control is needed.
Internally, SAS creates two temporary variables for each variable
on the by statement of a data step. first.variable is equal to 1
if the current observation is the first occurence of this value of
variable and 0 otherwise. Similarly, last.variable is equal to 1
if the current observation is the last occurence of the value of
variable and 0 otherwise.
When there are several by variables, remember that a new
by-group begins when the value of the rightmost variable on the by
statement changes.

Application: Finding Duplicate Observations I
Many data sets are arranged so that there should be exactly one
observation for each unique combination of variable values. In the
simplest case, there may be an identifier like a social security or
student identification number, and we want to check to make sure
there are not multiple observations with the same value for that
variable.
If the data set is sorted by the identifier variable (say, ID), code like
the following will identify the duplicates:
data check;
set old;
by id;
if first.id and ^last.id;
run;
The duplicates can now be found in data set check

Example of first. and last. variables
Suppose we have a data set called grp with several observations for
each value of a variable called group. We wish to output one
observation for each group containing the three highest values of
the variable x encountered for that group.
data max;
set grp;
by group;
retain x1-x3; * preserve values btwn obs;
if first.group then do; * initialize
x1 = .; x2 = .; x3 = .;
end;
if x >= x1 then do;
x3 = x2; x2 = x1; x1 = x; end;
else if x >= x2 then do;
x3 = x2; x2 = x; end;
else if x >= x3 then x3 = x;
if last.group then output; * output one obs per group;
keep group x1-x3;
run;

Example of first. and last. variables (cont’d)
Here are the results of a simple example of the previous program:
Set grp
Group X
1 16
1 12
1 19 Set max
1 15 Group X1 X2 X3
1 18 1 19 18 17
1 17 =) 2 30 20 14
2 10 3 59 45 18
2 20
2 8
2 14
2 30
3 59
3 45
3 2
3 18

Sorting datasets
For procedures or data steps which need a data set to be sorted by
one or more variables, there are three options available:
1. You can use proc sort; to sort your data. Note that SAS
stores information about the sort in the dataset header, so that
it will not resort already sorted data.
2. You can enter your data in sorted order. If you choose this
option, make sure that you use the correct sorting order.* To
prevent proc sort from resorting your data, use the
sortedby= data set option when you create the data set.
3. You can create an index for one or more combinations of
variables which will stored along with the data set.
* EBCDIC Sorting Sequence (IBM mainframes):
blank .<(+|\&!$*);^-/,%_>?‘:#@’="abcdefghijklmnopqr~stuvwxyz{ABCDEFGHI}JKLMNOOPQR\STUVWXYZ0123456789
ASCII Sorting Sequence (most other computers):
blank !"#$%&’()* +,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_‘abcdefghijklmnopqrstuvwxyz{|}~

Indexed Data Sets
If you will be processing a data set using by statements, or
subsetting your data based on the value(s) of one or more variables,
you may want to store an index based on those variables to speed
future processing.
proc datasets is used to create an index for a SAS data set.
Suppose we have a data set called company.employ, with variables
for branch and empno. To store a simple index (based on a single
variable), statements like the following are used:
proc datasets library=company;
modify employ;
index create branch;
run;
More than one index for a data set can be specified by including
multiple index statements. The index will be used whenever a by
statement with the indexed variable is encountered.

Indexed Data Sets (cont’d)
To create a composite index (based on more than one variable),
you need to provide a label for the index. (This label need not be
specified when you access the data set.) You can have multiple
composite indices within the same data set:
proc datasets library=company;
modify employ;
index create brnum = (branch idnum);
run;
In the previous example, the composite index would mean the data
set is also indexed for branch, but not for idnum.
Note: If you are moving or copying an indexed data set, be sure to
use a SAS procedure like proc copy, datasets, or cport rather
than system utilities, to insure that the index gets correctly copied.

Formats and Informats
Formats control the appearance of variable values in both
procedures and with the put statement of the data step. Most
procedures also use formats to group values using by statements.
Informats are used in conjunction with the input statement to
specify the way that variables are to be read if they are not in the
usual numeric or character format.
SAS provides a large number of predefined formats, as well as the
ability to write your own formats, for input as well as output.
If you include a format or attribute statement in the data step
when the data set is created, the formats will always be associated
with the data. Alternatively, you can use a format statement
within a procedure.
The system option nofmterr will eliminate errors produced by
missing formats.

Basic Formats
Numeric formats are of the form w. or w.d, representing a field
width of w, and containing d decimal places.
put x 6.; *write x with field width of 6;
format price 8.2; *use field width of 8 and 2 d.p. for price;
The bestw. format can be used if you’re not sure about the
number of decimals. (For example, best6. or best8..)
Simple character formats are of the form $w., where w is the
desired field width. (Don’t forget the period.)
put name $20.; * write name with field width of 20;
format city $50.; * use field width of 50 for city;
You can also use formats with the put function to create character
variables formatted to your specifications:
x = 8;
charx = put(x,8.4);
creates a character variable called charx equal to 8.0000

Informats
The basic informats are the same as the basic formats, namely w.d
for numeric values, and $w. for character variables.
By default, leading blanks are stripped from character values. To
retain them, use the $charw. format.
When you specify a character informat wider than the default of 8
columns, SAS automatically will make sure the variable is big
enough to hold your input values.
Some Other SAS Informats
Name Description Name Description
hexw. numeric hexadecimal $hexw. character hexadecimal
octalw. numeric octal $octalw. character octal
bzw.d treat blanks as zeroes ew.d scientific notation
rbw.d floating point binary ibw.d integer binary
pdw.d packed decimal $ebcdicw. EBCDIC to ASCII

Writing User-defined formats using proc format
• You can specify several different value statements within a
single invocation of proc format.
• Each value must be given a name (which does not end in a
number), followed by a set of range/value pairs.
• The keywords low, high, and other can be used to construct
ranges.
• If you wish a range of values to be formatted using some other
format, enclose its name (including the period) in square
brackets ([ ]) as the value for that range.
• Character values should be enclosed in quotes; the name of a
character format must begin with a dollar sign ($).
• If a variable falls outside of the specified ranges, it is formatted
using the usual defaults
102
User-defined Format: Examples
For a variable with values from 1 to 5, the format qval. displays 1
and 2 as low, 3 as medium and 4 and 5 as high.
The format mf. displays values of 1 as male, 2 as female and all
other values as invalid.
The format tt. display values below .001 as undetected, and all
other values in the usual way.
proc format;
value qval 1-2=’low’ 3=’medium’ 4-5=’high’;
value mf 1=’male’ 2=’female’ other=’invalid’;
value tt low-.001=’undetected’;
run;

Recoding Values using Formats
Since many SAS procedures use formatted values to produce
groups, you can often recode variables by simply changing their
formats. This is more efficient than processing an entire data set,
and leaves the original variable unchanged for future use.
Suppose we have a survey which asks people how long they’ve been
using computers (measured in years), and how happy they are with
the computer they are using (measured on a scale of 1 to 5). We
wish to produce a cross tabulation of these results, that is a table
where rows represent levels of one variable, columns represent the
level of another variable, and the entries represent the number of
observations which fall into the row/column categories. Often the
unformatted table will have many empty cells - it is common
practice to group categories or values to create more meaningful
tables.

Recoding Values using Formats (cont’d)
If the two variables in our survey are called years and happy, the
following program would produce a cross tabulation:
proc freq;tables years*happy/nocol norow nocum nopct;
TABLE OF YEARS BY HAPPY
YEARS HAPPY
Frequency| 1| 2| 3| 4| 5| Total
---------+--------+--------+--------+--------+--------+
0.5 | 1 | 2 | 1 | 2 | 0 | 6
---------+--------+--------+--------+--------+--------+
1 | 0 | 0 | 2 | 2 | 0 | 4
---------+--------+--------+--------+--------+--------+
1.5 | 0 | 0 | 0 | 1 | 0 | 1
---------+--------+--------+--------+--------+--------+
2 | 0 | 0 | 2 | 2 | 3 | 7
---------+--------+--------+--------+--------+--------+
3 | 1 | 1 | 0 | 1 | 1 | 4
---------+--------+--------+--------+--------+--------+
8 | 0 | 0 | 0 | 0 | 1 | 1
---------+--------+--------+--------+--------+--------+
10 | 0 | 1 | 0 | 0 | 0 | 1
---------+--------+--------+--------+--------+--------+
12 | 0 | 0 | 0 | 1 | 0 | 1
---------+--------+--------+--------+--------+--------+
Total 2 4 5 9 5 25

Recoding Values using Formats (cont’d)
To make the table more useful, we define the following formats:
proc format;
value yy 0-1=’<=1yr’ 1.5-3=’1-3yr’ 3.5-high=’>3yr’;
value hh 1-2=’Low’ 3=’Medium’ 4-5=’High’;
run;
proc freq;
tables years*happy/nocol norow nocum nopct;
format years yy. happy hh.;
run;
TABLE OF YEARS BY HAPPY
YEARS HAPPY
Frequency|Low |Medium |High | Total
---------+--------+--------+--------+
<=1yr | 3 | 3 | 4 | 10
---------+--------+--------+--------+
1-3yr | 2 | 2 | 8 | 12
---------+--------+--------+--------+
>3yr | 1 | 0 | 2 | 3
---------+--------+--------+--------+
Total 6 5 14 25

SAS Date and Time Values
There are three types of date and time values which SAS can
handle, shown with their internal representation in parentheses:
• Time values (number of seconds since midnight)
• Date values (number of days since January 1, 1970)
• Datetime values (number of seconds since January 1, 1970)
You can specify a date and/or time as a constant in a SAS program
by surrounding the value in quotes, and following it with a t, a d or
a dt. The following examples show the correct format to use:
3PM ) ’3:00p’t or ’15:00’t or ’15:00:00’t
January 4, 1937 ) ’4jan37’d
9:15AM November 3, 1995 )
’3nov95:9:15’dt or ’3nov95:9:15:00’dt

Date and Time Informats and Formats
SAS provides three basic informats for reading dates which are
recorded as all numbers, with or without separators:
• ddmmyyw. - day, month, year (021102, 6-3-2002, 4/7/2000)
• mmddyyw. - month, day, year (110202, 3-6-2002, 7/4/2000)
• yymmddw. - year, month, day (021102, 2002-3-6, 2000/7/4)
These informats will correctly recognize any of the following
separators: blank : - . /, as well as no separator.
For output, the ddmmyyXw., mmddyyXw. and yymmddXw. formats are
available, where “X” specifies the separator as follows:
B - blank C - colon(:) D - dash(-)
N - no separator P - period(.) S - slash(/)

Other Date and Time Informats and Formats
Name Width(default) Examples
datew. 5-9 (7) 26jun96
datetimew. 7-40 (16) 4JUL96:01:30p
julianw. 5-7 (5) 96200 1995001
monyyw. 5-7 (5) jan95 mar1996
timew. 2-20 (8) 6:00:00 3:15:00p
The above formats are valid for input and output. In addition, the
yymmnw. format reads values with only a year and month. The
nldatew. format/informat provides natural language support for
written dates (like July 4, 1996), based on the value of the
locale option. The monnamew. and yearw. formats display parts
of dates.

SAS and Y2K
Since SAS stores its date/time values as the number of seconds or
days from a fixed starting point, there is no special significance of
the year 2000 to SAS. But when dates are input to SAS with only
two digits, there is no way to tell whether they should be
interpreted as years beginning with 19 or 20. The yearcutoff
option controls this decision.
Set the value of this option to the first year of a hundred year span
to be used to resolve two digit dates. For example, if you use the
statement
options yearcutoff=1950;
then two digit dates will be resolved as being in the range of 1950
to 2050; i.e. years greater than 50 will be interpreted as beginning
with 19, and dates less than 50 will be interpreted as beginning
with 20

Date and Time Functions
datepart – Extract date from datetime value
dateonly = datepart(fulldate);
day,month year – Extract part of a date value
day = day(date);
dhms – Construct value from date, hour, minute and second
dtval = dhms(date,9,15,0);
mdy – Construct date from month, day and year
date = mdy(mon,day,1996);
time – Returns the current time of day
now = time();
today – Returns the current date
datenow = today();
intck – Returns the number of intervals between two values
days = intck(’day’,then,today());
intnx – Increments a value by a number of intervals
tomrw = intnx(’day’,today(),1);

Application: Blue Moons
When there are two full moons in a single month, the second is
known as a blue moon. Given that July 9, 1998 is a full moon, and
there are 29 days between full moons, in what months will the next
few blue moons occur?
First, we create a data set which has the dates of all the full moons,
by starting with July 9, 1998, and incrementing the date by 29
days.
data fullmoon;
date = ’09jul98’d;
do i=1 to 500;
month = month(date);
year = year(date);
output;
date = intnx(’day’,date,29);
end;
run;

Application: Blue Moons (cont’d)
Now we can use the put function to create a variable with the full
month name and the year.
data bluemoon;
set fullmoon;
by year month;
if last.month and not first.month then do;
when = put(date,monname.) || ", " || put(date,year.);
output;
end;
run;
proc print data=bluemoon noobs;
var when;
run;
The results look like this:
December, 1998
August, 2000
May, 2002
. . .

Customized Output: put statement
The put statement is the reverse of the input statement, but in
addition to variable names, formats and pointer control, you can
also print text. Most of the features of the input statement work
in a similar fashion in the put statement. For example, to print a
message containing the value of of a variable called x, you could use
a put statement like:
put ’the value of x is ’ x;
To print the values of the variables x and y on one line and name
and address on a second line, you could use:
put x 8.5 y best10. / name $20 @30 address ;
Note the use of (optional) formats and pointer control.
By default, the put statement writes to the SAS log; you can
override this by specifying a filename or fileref on a file statement.

Additional Features of the put statement
By default, the put statement puts a newline after the last item
processed. To prevent this (for example to build a single line with
multiple put statements, use a trailing @ at the end of the put
statement.
The n* operator repeats a string n times. Thus
put 80*"-";
prints a line full of dashes.
Following a variable name with an equal sign causes the put
statement to include the variable’s name in the output. For
example, the statements
x = 8;
put x=;
results in X=8 being printed to the current output file. The keyword
all on the put statement prints out the values of all the variables
in the data set in this named format.

Headers with put statements
You can print headings at the top of each page by specifying a
header= specification on the file statement with the label of a set
of statements to be executed. For example, to print a table
containing names and addresses, with column headings at the top
of each page, you could use statements like the following:
options ps=50;
data _null_;
set address;
file "output" header = top print;
put @1 name $20. @25 address $30.;
return;
top:
put @1 ’Name’ @25 ’Address’ / @1 20*’-’ @25 30*’-’;
return;
run;
Note the use of the two return statements. The print option is
required when using the header= option on the file statement.

Output Delivery System (ODS)
To provide more flexibility in producing output from SAS data
steps and procedures, SAS introduced the ODS. Using ODS, output
can be produced in any of the following formats (the parenthesized
keyword is used to activate a particular ODS stream):
• SAS data set (OUTPUT)
• Normal listing (LISTING) - monospaced font
• Postscript output (PRINTER) - proportional font
• PDF output (PDF) - Portable Document Format
• HTML output (HTML) - for web pages
• RTF output (RTF) - for inclusion in word processors
Many procedures produce ODS objects, which can then be output
in any of these formats. In addition, the ods option of the file
statement, and the ods option of the put statement allow you to
customize ODS output.

ODS Destinations
You can open an ODS output stream with the ODS command and a
destination keyword. For example, to produce HTML formatted
output from the print procedure:
ods html file="output.html";
proc print data=mydata;
run;
ods html close;
Using the print and ods options of the file statement, you can
customize ODS output:
ods printer;
data _null_;
file print ods;
... various put statements ...
run;
ods printer close;

SAS System Options
SAS provides a large number of options for fine tuning the way the
program behaves. Many of these are system dependent, and are
documented online and/or in the appropriate SAS Companion.
You can specify options in three ways:
1. On the command line when invoking SAS, for example
sas -nocenter -nodms -pagesize 20
2. In the system wide config.sas file, or in a local config.sas
file (see the SAS Companion for details).
3. Using the options statement:
options nocenter pagesize=20;
Note that you can precede the name of options which do not take
arguments with no to shut off the option. You can display the
value of all the current options by running proc options.

Review: An Introduction to the SAS System Part-2

2013-11-22T00:35:00.003+05:30

Some Common Options
Option Argument Description
Options which are useful when invoking SAS
dms - Use display manager windows
stdio - Obey UNIX standard input and output
config filename Use filename as configuration file
Options which control output appearance
center - Center output on the page
date - Include today’s date on each page
number - Include page numbers on output
linesize number Print in a width of number columns
pagesize number Go to a new page after number lines
ovp - Show emphasis by overprinting
Options which control data set processing
obs number Process a maximum of number obs.
firstobs number Skip first number observations
replace - Replace permanent data sets?

Application: Rescanning Input
Suppose we have an input file which has a county name on one line
followed by one or more lines containing x and y coordinates of the
boundaries of the county. We wish to create a separate observation,
including the county name, for each set of coordinates.
A segment of the file might look like this:
alameda
-121.55 37.82 -121.55 37.78 -121.55 37.54 -121.50 37.53
-121.49 37.51 -121.48 37.48
amador
-121.55 37.82 -121.59 37.81 -121.98 37.71 -121.99 37.76
-122.05 37.79 -122.12 37.79 -122.13 37.82 -122.18 37.82
-122.20 37.87 -122.25 37.89 -122.27 37.90
calaveras
-121.95 37.48 -121.95 37.48 -121.95 37.49 -122.00 37.51
-122.05 37.53 -122.07 37.55 -122.09 37.59 -122.11 37.65
-122.14 37.70 -122.19 37.74 -122.24 37.76 -122.27 37.79
-122.27 37.83 -122.27 37.85 -122.27 37.87 -122.27 37.90
. . .

Application: Rescanning Input (cont’d)
Note that we don’t know how many observations (or data lines)
belong to each county.
data counties;
length county $ 12 name $ 12;
infile "counties.dat";
retain county;
input name $ @; * hold current line for rescanning;
if indexc(name,’0123456789’) = 0 then do;
county = name;
delete; * save county name, but don’t output;
end;
else do;
x = input(name,12.) * do numeric conversion;
input y @@; * hold the line to read more x/y pairs;
end;
drop name;
run;

Application: Reshaping a Data Set I
Since SAS procedures are fairly rigid about the organization of
their input, it is often necessary to use the data step to change the
shape of a data set. For example, repeated measurements on a
single subject may be on several observations, and we may want
them all on the same observation. In essence, we want to perform
the following transformation:
Subj Time X
1 1 10
1 2 12
· · · Subj X1 X2 · · · Xn
1 n 8 =) 1 10 12 · · · 8
2 1 19 2 19 7 · · · 21
2 2 7
· · ·
2 n 21

Application: Reshaping a Data Set I(cont’d)
Since we will be processing multiple input observations to produce
a single output observation, a retain statement must be used to
remember the values from previous inputs. The combination of a
by statement and first. and last. variables allows us to create
the output observations at the appropriate time, even if there are
incomplete records.
data two;
set one;
by subj;
array xx x1-xn;
retain x1-xn;
if first.subj then do i=1 to dim(xx); xx{i} = .;end;
xx{time} = x;
if last.subj then output;
drop time x;
run;

Application: Reshaping a Data Set II
A similar problem to the last is the case where the data for several
observations is contained on a single line, and it is necessary to
convert each of the lines of input into several observations. Suppose
we have test scores for three different tests, for each of several
subjects; we wish to create three separate observations from each of
these sets of test scores:
data scores;
* assume set three contains id, group and score1-score3;
set three;
array sss score1-score3;
do time = 1 to dim(sss);
score = sss{time};
output;
end;
drop score1-score3;
run;

Output Data Sets
Many SAS procedures produce output data sets containing data
summaries (means, summary, univariate), information about
statistical analyses (reg, glm, nlin, tree) or transformed variables
(standard, score, cancorr, rank); some procedures can produce
multiple output data sets. These data sets can be manipulated just
like any other SAS data sets.
Recall that the statistical functions like mean() and std() can
calculate statistical summaries for variables within an observation;
output data sets are used to calculate summaries of variables over
the whole data set.
When you find that you are looping through an entire data set to
calculate a single quantity which you then pass on to another data
step, consider using an output data set instead.

Using ODS to create data sets
Many procedures use the output delivery system to provide
additional control over the output data sets that they produce. To
find out if ODS tables are available for a particular procedure, use
the following statement before the procedure of interest:
ods trace on;
Each table will produce output similar to the following on the log:
Output Added:
-------------
Name: ExtremeObs
Label: Extreme Observations
Template: base.univariate.ExtObs
Path: Univariate.x.ExtremeObs
-------------
Once the path of a table of interest is located, you can produce a
data set with the ods output statement, specifying the path with
an equal sign followed by the output data set name.

ODS Output Data Set: Example
The univariate procedure provides printed information about
extreme observations, but this information is not available through
the out= data set. To put this information in a data set, first find
the appropriate path by using the ods trace statement, and then
use an ODS statement like the following:
ods output Univariate.x.ExtremeObs=extreme;
proc univariate data=mydata;
var x;
run;
ods output close;
The data set extreme will now contain information about the
extreme values.

Output Data Sets: Example I
It is often useful to have summary information about a data set
available when the data set is being processed. Suppose we have a
data set called new, with a variable x, and we wish to calculate a
variable px equal to x divided by the maximum value of x.
proc summary data=new;
var x;
output out=sumnew max=maxx;
run;
data final;
if _n_ = 1 then set sumnew(keep=maxx);
set new;
px = x / maxx;
run;
The automatic variable n will be 1 for the first observation only;
the single observation in sumnew gets read at this time. The set
new; statement then reads in the original data.

Output Data Sets: Example II
Now suppose we have two classification variables called group and
trtmnt, and we wish to use the maximum value for each
group/trtmnt combination in the transformation. If the data set
had already been sorted, the following statements could be used:
proc summary nway data=new;
class group trtmnt;
var x;
output out=sumnew max=maxx;
run;
data final;
merge new sumnew(keep=maxx);
by group trtmnt;
px = x / maxx;
run;
The nway option limits the output data set to contain observations
for each unique combination of the variables given in the class
statement.

Output Data Sets: Example III
Suppose we have a data set called hdata, consisting of three
variables: hospital, time and score, representing the score of
some medical exam taken at three different times at three different
hospitals, and we’d like to produce a plot with three lines: one for
the means of each of the three hospitals over time. The following
statements could be used:
proc means noprint nway data=hdata;
class hospital time;
var score;
output out=hmeans mean=mscore;
run;
The noprint option suppresses the usual printing which is the
default for proc means. You could acheive similar results using a
by statement instead of a class statement, but the data set would
need to be sorted.

Output Data Sets: Example III(cont’d)
The transformation which the previous program produced can be
thought of as the following:
hospital time score
mercy 1 132
mercy 2 125
. . . hospital time _type_ _freq_ mscore
mercy 1 144 city 1 3 2 146.500
mercy 2 224 city 2 3 2 120.000
county 1 119 city 3 3 2 128.000
county 2 125 =) county 1 3 2 125.500
. . . county 2 3 2 127.000
county 2 129 county 3 3 2 117.000
county 3 113 mercy 1 3 3 131.667
city 1 144 mercy 2 3 2 174.500
city 2 121 mercy 3 3 1 121.000
. . .
city 1 149
city 3 122
The type variable indicates the observations are for a unique
combination of levels of two class variables, while the freq
variable is the number of observations which were used for the
computation of that statistic.

Plotting the Means
The following program produces the graph shown on the right:
symbol1 interpol=join
value=plus;
symbol2 interpol=join
value=square;
symbol3 interpol=join
value=star;
title "Means versus Time";
proc gplot data=hmeans;
plot mscore*time=hospital;
run;

Application: Finding Duplicate Observations II
In a previous example, duplicates were found by using by
processing and first. and last. variables. If the data set were
very large, or not already sorted by id, that program would not be
very efficient. In this case, an output data set from proc freq
might be more useful. Once again, assume the identifier variable is
called id. The following statements will produce a data set with
the id values of the duplicate observations.
proc freq data=old noprint;
tables id/ out=counts(rename = (count = n) keep=id count);
run;
data check;
set counts;
if n > 1;
run;
Note that, even though count is renamed to n, the original variable
name (count) is used on the keep statement.

SAS Macro Language: Overview
At it’s simplest level, the SAS Macro language allows you to assign
a string value to a variable and to use the variable anywhere in a
SAS program:
%let header = "Here is my title";
. . .
proc print ;
var x y z;
title &header;
run;
This would produce exactly the same result as if you typed the
string "Here is my title" in place of &header in the program.
Notice that the substitution is very simple - the text of the macro
variable is substituted for the macro symbol in the program.

SAS Macro Language: Overview (cont’d)
The macro facility can be used to replace pieces of actual programs
by creating named macros:
%macro readsome;
data one;
infile "myfile";
input x y z;
if
%mend;
%readsome x > 1; run;
The final statement is equivalent to typing
data one;
infile "myfile";
input x y z;
if x > 1; run;
Once again, all that is performed is simple text replacement.

SAS Macro Language: Overview (cont’d)
A large part of the macro facility’s utility comes from the macro
programming statements which are all preceded by a percent sign
(%). For example, suppose we need to create 5 data sets, named
sales1, sales2, etc., each reading from a corresponding data file
insales1, insales2, etc.
%macro dosales;
%do i=1 %to 5;
data sales&i;
infile "insales&i";
input dept $ sales;
run;
%end;
%mend dosales;
%dosales;
Note that, until the last line is entered, no actual SAS statements
are carried out; the macro is only compiled.

Defining and Accessing Macro Variables in the Data Step
You can set a macro variable to a value in the data step using the
call symput function. The format is
call symput(name,value);
where name is a string or character variable containing the name of
the macro variable to be created, and value is the value the macro
variable will have.
To access a macro variable in a data step, you can use the symget
function.
value = symget(name);
name is a string or character variable containing the name of the
macro variable to be accessed.

call symput: Example
Suppose we want to put the maximum value of a variable in a title.
The following program shows how.
data new;
retain max -1e20;
set salary end = last;
if salary > max then max = salary;
if last then call symput("maxsal",max);
drop max;
run;
title "Salaries of employees (Maximum = &maxsal)";
proc print data=salary;
run;
Note that no ampersand is used in call symput, but you must use
an ampersand to reference the macro variable later in your
program.

An Alternative to the macro facility
As an alternative to the previous example, we can use the put
statement to write a SAS program, and then use the %include
statement to execute the program. Using this technique, the
following statements recreate the previous example:
proc means data=salary noprint;
var salary;
output out=next max=maxsal;
data _null_;
set next;
file "tmpprog.sas";
put ’title "Salaries of employees (Maximum =’ maxsal ’)";’;
put ’proc print data=salary;’;
put ’run;’;
run;
%include "tmpprog.sas";
Pay special attention to quotes and semicolons in the generated
program.

Another Alternative to the Macro Facility
In addition to writing SAS statements to a file, SAS provides the
call execute function. This function takes a quoted string, a
character variable, or a SAS expression which resolves to a
character variable and then executes its input when the current
data step is completed.
For example, suppose we have a data set called new which contains
a variable called maxsal. We could generate a title statement
containing this value with statements like the following.
data _null_;
set new;
call execute(’title
"Salaries of employees (Maximum = ’|| put(maxsal,6.) || ’)";’);
run;

call execute Example
As a larger example of the use of the call execute function,
consider the problem of reading a list of filenames from a SAS data
set and constructing the corresponding data steps to read the files.
The following program performs the same function as the earlier
macro example.
data _null_;
set files;
call execute(’data ’ || name || ’;’);
call execute(’infile "’|| trim(name) || ’";’);
call execute(’input x y;’);
call execute(’run;’);
run;
Be careful with single and double quotes, and make sure the
generated statements follow the rules of SAS syntax.

Application: Reading a Series of Files
Suppose we have a data set containing the names of files to be read,
and we wish to create data sets of the same name from the data in
those files. First, we use the call symput function in the data step
to create a series of macro variables containing the file names
data _null_;
set files end=last;
n + 1;
call symput("file"||left(n),trim(name));
if last then call symput("num",n);
run;
Since macros work by simple text substitution, it is important that
there are no blanks in either the macro name or value, thus the use
of left and trim

Application: Reading a Series of Files (cont’d)
Now we can write a macro to loop over the previously defined file
names and create the data sets.
%macro readem;
%do i=1 %to &num;
data &&file&i;
infile "&&file&i";
input x y;
run;
%end;
%mend;
%readem;
Notice that the macro variable is refered to as &&file&i, to force
the macro substitution to be scanned twice. If we used just a single
ampersand, SAS would look for a macro variable called &file.

Macros with Arguments
Consider the following program to print duplicate cases with
common values of the variables a and b in data set one:
data one;
input a b y @@;
datalines;
1 1 12 1 1 14 1 2 15 1 2 19 1 3 15 2 1 19 2 4 16 2 4 12 2 8 18 3 1 19
proc summary data=one nway ;
class a b;
output out=next(keep = a b _freq_ rename=(_freq_ = count));
data dups;
merge one next;
by a b;
if count > 1;
proc print data=dups;
run;
If we had simple way of changing the input data set name and the
list of variables on the by statement, we could write a general
macro for printing duplicates in a data set.

Macros with Arguments (cont’d)
To add arguments to a macro, simply replace the parts of the
program in question with macro variables (beginning with &), and
list the variables in the argument list (without the &).
%macro prntdups(data,by);
proc summary data=&data nway ;
class &by;
output out=next(keep = &by _freq_ rename=(_freq_ = count));
run;
data dups;
merge &data next;
by &by;
if count > 1;
run;
proc print data=dups;
run;
%mend prntdups;
Then the program on the previous slide would be replaced by:
%prntdups(one,a b);

Accessing Operating System Commands
If you need to run an operating system command from inside a
SAS program, you can use the x command. Enclose the command
in quotes after the x, and end the statement with a semicolon. The
command will be executed as soon as it is encountered.
For example, in an earlier program, a file called tmpprog.sas was
created to hold program statements which were later executed. To
remove the file after the statements were executed (on a UNIX
system) you could use the SAS statement:
x ’rm tmpprog.sas’;
Other interfaces to the operating system may be available. For
example, on UNIX systems the pipe keyword can be used on a
filename statement to have SAS read from or write to a process
instead of a file. See the SAS Companion for your operating system
for more details.

Transporting Data Sets
It is sometimes necessary to move a SAS data set from one
computer to another. The internal format of SAS data sets is not
the same on all computers, so to make it possible to transfer data
sets from one computer to another, SAS provides what is known as
a transport format. Whenever you move a SAS data set from one
computer to another, you must first convert it into transport
format.
Keep in mind that SAS data sets are in general readable only by
SAS. Thus, an alternative (or perhaps a backup) method for
transporting data sets is to write them in a human-readable way,
using, for example, put statements. Human-readable files can be
processed by SAS (or some other program), and are generally easier
to move around than SAS transport data sets.

SAS/CONNECT
SAS also provides a product called SAS/CONNECT which lets you
initiate a SAS job on a remote computer from a local SAS display
manager session. It also provides two procedures, proc upload and
proc download to simplify transporting data sets. If
SAS/CONNECT is available on the machines between which the
data set needs to be moved, it may be the easiest way to move the
data set.
SAS/CONNECT must be run from the display manager. When
you connect with the other system, you will be prompted for a
login name and a password (if appropriate). Once you’re
connected, the rsubmit display manager command will submit jobs
to the remote host, even though the log and output will be
managed by the local host.

Creating a Dataset in transport format
proc copy can be used to create a transport format file, but the
critical step is to use the xport keyword in the libname statement.
The specified libname is then the name of the transport format file
which SAS will create, not a directory as is usually the case.
Suppose we wanted to create a SAS transport data file named
move.survey from a SAS data set named save.results.
libname save "/my/sas/dir";
libname move xport "move.survey";
proc copy in=save out=move;
select results;
run;
If you transfer the transport data set using a program like ftp,
make sure that you use binary (image) mode to transfer
the file.

proc transpose
Occasionally it is useful to switch the roles of variables and
observations in a data set. The proc transpose program takes
care of this task.
To understand the workings of proc transpose, consider a data
set with four observations and three variables (x, y and z). Here’s
the transformation proc transpose performs:
Original data Transposed data
X Y Z _NAME_ COL1 COL2 COL3 COL4
12 19 14 X 12 21 33 14
21 15 19 =) Y 19 15 27 32
33 27 82 Z 14 19 82 99
14 32 99
The real power of proc transpose becomes apparent when it’s
used with a by statement.

proc transpose with a by statement
When a by statement is used with proc transpose, a variety of
manipulations which normally require programming can be
acheived automatically.
For example, consider a data set with several observations for each
subject, similar to a previous example:
subj time x
1 1 12
1 2 15
1 3 19
2 1 17
2 3 14
3 1 21
3 2 15
3 3 18
Notice that there is no observation for subject 2 at time 2.

proc transpose with a by statement (cont’d)
To make sure proc transpose understands the structure that we
want in the output data set, an id statement is used to specify
time as the variable which defines the new variables being created.
The prefix= option controls the name of the new variables:
proc transpose data=one out=two prefix=value;
by subj;
id time;
The results are shown below:
subj _NAME_ value1 value2 value3
1 x 12 15 19
2 x 17 . 14
3 x 21 15 18
Notice that the missing value for subject 2, time 2 was handled
correctly.

proc contents
Since SAS data sets cannot be read like normal files, it is important
to have tools which provide information about data sets. proc
print can show what’s in a data set, but it not always be
appropriate. The var and libname windows of the display manager
are other useful tools, but to get printed information or to
manipulate that information, you should use proc contents.
Among other information, proc contents provides the name,
type, length, format, informat and label for each variable in the
data set, as well as the creation date and time and the number of
observations. To use proc contents, specify the data set name as
the data= argument of the proc contents statement; to see the
contents of all the data sets in a directory, define an appropriate
libname for the directory, and provide a data set name of the form
libname. all .

Options for proc contents
The short option limits the output to just a list of variable names.
The position option orders the variables by their position in the
data set, instead of the default alphabetical order. This can be
useful when working with double dashed lists.
The directory option provides a list of all the data sets in the
library that the specified data set comes from, along with the usual
output for the specified data set.
The nods option, when used in conjunction with a data set of the
form libname. all , limits the output to a list of the data sets in
the specified libname, with no output for the individual data sets.
The out= option specifies the name of an output data set to
contain the information about the variables in the specified data
set(s). The program on the next slide uses this data set to write a
human readable version of a SAS data set.

Using the output data set from proc contents
%macro putdat(indata,outfile);
proc contents noprint data=&indata out=fcon; run;
data _null_;
file "tmpprog.sas";
set fcon end=last;
length form $ 8;
if _n_ = 1 then do;
put "data _null_;"/"set &indata;";
put ’file "&outfile";’ / "put " @;
end;
put name @;
if type = 2 then
form = "$"||trim(left(put(length,3.)))||".";
else form = "best12.";
put form @;
if ^last then put "+1 " @;
else put ";" / "run;" ;
run;
%include "tmpprog.sas";
x ’rm tmpprog.sas’;
%mend putdat;

The Display Manager
When SAS is invoked, it displays three windows to help you
interact with your programs and output:
• Program Window - for editing and submitting SAS statements
• Log Window - for viewing and saving log output
• Output Window - for viewing and saving output
Some commands which open other useful windows include:
• assist - menu driven version of SAS
• dir - shows data sets in a library
• var - shows variables in a data set
• notepad - simple text window
• options - view and change system options
• filename - view current filename assignments
• help - interactive help system
• libname - view current libname assignments

Appearance of Display Manager
OUTPUT----------------------------------------------------------------------------------+
|Command ===> |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
LOG-------------------------------------------------------------------------------------+
|File Edit View Locals Globals Help |
| |
| |
|This is version 6.11 of the SAS System. |
| |
| |
|NOTE: AUTOEXEC processing beginning; file is /app/sas611/autoexec.sas. |
| |
|NOTE: SAS initialization used: |
| real time 0.567 seconds |
| cpu time 0.421 seconds |
| |
PROGRAM EDITOR--------------------------------------------------------------------------+
|Command ===> |
| |
|00001 |
|00002 |
|00003 |
|00004 |
|00005 |
|00006 |
|00007 |
|00008 |
|00009 |
|00010 |
+---------------------------------------------------------------------------------------+

Entering Display Manager Commands
You can type display manager commands on the command line of
any display manager window. (To switch from menu bar to
command line select Globals -> Options -> Command line; to
switch back to menu bar, enter the command command.)
You can also enter display manager commands from the program
editor by surrounding them in quotes, and preceding them by dm,
provided that the display manager is active.
Some useful display manager commands which work in any window
include:
• clear - clear the contents of the window
• end - close the window
• endsas - end the sas session
• file "filename" - save contents of the window to filename
• prevcmd - recall previous display manager command

The Program Editor
There are a number of special display manager commands available
in the program editor.
• submit - submit all the lines in the editor to SAS
• subtop - submit the first line in the editor to SAS
• recall - place submitted statements back in the editor
• include "file" - place the contents of file in the editor
• hostedit - on UNIX systems, invoke the editor described in
the editcmd system option
Typing control-x when the cursor is in the program editor toggles
between insert and overwrite mode.
You can close the program window with the display manager
command program off.

Using the Program Editor
There are two types of commands which can be used with the
program editor
• Command line commands are entered in the Command ===>
prompt, or are typed into a window when menus are in effect.
• Line commands are entered by typing over the numbered lines
on the left hand side of the editor window. Many of the line
commands allow you to operate on multiple selected lines of
text.
In addition, any of the editor or other display manager commands
can be assigned to a function or control key, as will be explained
later.
Note: The undo command can be used to reverse the effect of
editing commands issued in the display manager.

Editor Line Commands
Commands followed by <n> optionally accept a number to act on
multiple lines.
Inserting Lines Deleting Lines
i<n> insert after current line d<n> delete lines
ib<n> insert before current line dd block delete
Moving Lines Copying Lines
m<n> move lines c<n> copy lines
mm block move cc block copy
Other Commands
>><n> indent lines <<<n> remove indentation
tc connect text ts split text
Type block commands on the starting and ending lines of the block
and use a b or a command to specify the a line before which or
after which the block should be placed.

Defining Function and Control Keys
You can define function keys, control keys, and possibly other keys
depending on your operating system, through the keys window of
the display manager.
To define a function key to execute a display manager command,
enter the name of the command in the right hand field next to the
key you wish to define.
To define a function key to execute an editor line command, enter
the letter(s) corresponding to the command preceded by a colon (:)
in the right hand field.
To define a function key to insert text into the editor, precede the
text to be inserted with a tilda (~) in the right hand field.
Some display manager commands only make sense when defined
through keys. For example the command home puts the cursor on
the command line of a display manager window.

More on Function Keys
You can define a function key to perform several commands by
separating the commands with a semicolon (;).
Function keys defining display manager commands are executed
before any text which is on the command line. Thus, you can enter
arguments to display manager commands before hitting the
appropriate function key.
To set function keys without using the keys window, use the
display manager keydef command, for example:
keydef f2 rfind
Keys set in this way will only be in effect for the current session.

Cutting and Pasting
If block moves and/or copies do not satisfy your editing needs, you
can cut and paste non-rectangular blocks of text. Using these
commands generally requires that keys have been defined for the
display manager commands mark, cut, and paste, or home.
To define a range of text, issue the mark command at the beginning
and end of the text you want cut or pasted. Then issue the cut
(destructive) or store (non-destructive) command. Finally, place
the cursor at the point to which you want the text moved, and
issue the paste command.
When using cut or store, you can optionally use the append
option, which allows you to build up the contents of the paste
buffer with several distinct cuts or copies, or the buffer=name
option, to create or use a named buffer.

Searching and Changing Text
The display manager provides the following commands for
searching and, in the program editor or notepad, changing text.
These commands include:
• find string - search forward for string
• bfind string - search backward for string
• rfind - repeat previous find command
• change old new - change old to new
• rchange - repeat previous change command
Each of these commands takes a variety of options:
Scope of Search: next, first, last, prev, all
Component of Search: word, prefix, suffix
Case Independence: icase
If there are blanks or special symbols in any of the strings,
surround the entire string in single or double quotes.

Using the Find and Change Commands
• To change every occurence of the string “sam” to “fred”,
ignoring the case of the first string, enter
change sam fred all icase
• To selectively change the word cat to dog, use
change cat dog word
followed by repeated use of rfind, to find the next occurence
of the word, and rchange if a change is desired.
• To count the number of occurences of the word fish, use
find fish all
and the count will be displayed under the command line.
If an area of text is marked (using the display manager mark
command), then search and/or find commands apply only to the
marked region.

Customizing the Display Manager
Key definitions entered through the keys window are automatically
stored from session to session.
The color display manager command allows you to customize the
colors of various components of SAS windows. The sascolor
window allows you to change colors through a window.
To save the geometry and location of display manager windows,
issue the display manager command wsave from within a given
window, or wsave all to save for all windows.

Review: An Introduction to the SAS System Part-1

2013-11-22T00:33:00.003+05:30

What is SAS?
• Developed in the early 1970s at North Carolina State
University
• Originally intended for management and analysis of
agricultural field experiments
• Now the most widely used statistical software
• Used to stand for “Statistical Analysis System”, now it is not
an acronym for anything
• Pronounced “sass”, not spelled out as three letters.

Overview of SAS Products
• Base SAS - data management and basic procedures
• SAS/STAT - statistical analysis
• SAS/GRAPH - presentation quality graphics
• SAS/OR - Operations research
• SAS/ETS - Econometrics and Time Series Analysis
• SAS/IML - interactive matrix language
• SAS/AF - applications facility (menus and interfaces)
• SAS/QC - quality control
There are other specialized products for spreadsheets, access to
databases, connectivity between different machines running SAS,
etc.

Resources: Introductory Books
Mastering the SAS System, 2nd Edition, by Jay A. Jaffe,
Van Nostrand Reinhold
Quick Start to Data Analysis with SAS, by Frank C. DiIorio and
Kenneth A. Hardy, Duxbury Press.
How SAS works: a comprehensive introduction to the SAS System, by
P.A. Herzberg, Springer-Verlag
Applied statistics and the SAS programming language, by R.P. Cody,
North-Holland, New York
The bulk of SAS documentation is available online, at
http://support.sas.com/documentation/onlinedoc/index.html. A
catalog of printed documentation available from SAS can be found at
http://support.sas.com/publishing/index.html.

Online Resources
Online help: Type help in the SAS display manager input window.
Sample Programs, distributed with SAS on all platforms.
SAS Institute Home Page: http://www.sas.com
SAS Institute Technical Support:
http://support.sas.com/resources/
Searchable index to SAS-L, the SAS mailing list:
http://www.listserv.uga.edu/archives/sas-l.html
Usenet Newsgroup (equivalent to SAS-L):
comp.soft-sys.sas
Michael Friendly’s Guide to SAS Resources on the Internet:
http://www.math.yorku.ca/SCS/StatResource.html#SAS
Brian Yandell’s Introduction to SAS:
http://www.stat.wisc.edu/~yandell/software/sas/intro.html

Basic Structure of SAS
There are two main components to most SAS programs - the data
step(s) and the procedure step(s).
The data step reads data from external sources, manipulates and
combines it with other data set and prints reports. The data step is
used to prepare your data for use by one of the procedures (often
called “procs”).
SAS is very lenient about the format of its input - statements can
be broken up across lines, multiple statements can appear on a
single line, and blank spaces and lines can be added to make the
program more readable.
The procedure steps perform analysis on the data, and produce
(often huge amounts of) output.
The most effective strategy for learning SAS is to concentrate on
the details of the data step, and learn the details of each procedure
as you have a need for them.

Accessing SAS
There are four ways to access SAS on a UNIX system:
1. Type sas . This opens the SAS “display manager”, which
consists of three windows (program, log, and output). Some
procedures must be run from the display manager.
2. Type sas -nodms . You will be prompted for each SAS
statement, and output will scroll by on the screen.
3. Type sas -stdio . SAS will act like a standard UNIX
program, expecting input from standard input, sending the log
to standard error, and the output to standard output;
4. Type sas filename.sas . This is the batch mode of SAS -
your program is read from filename.sas, the log goes to
filename.log and the output goes to filename.lst.

Some Preliminary Concepts and Rules
• SAS variable names must be 32 characters or less, constructed
of letters, digits and the underscore character. (Before version
7, the limit was 8.)
• It’s a good idea not to start variable names with an underscore,
because special system variables are named that way.
• Data set names follow similar rules as variables, but they have
a different name space.
• There are virtually no reserved keywords in SAS; it’s very good
at figuring things out by context.
• SAS is not case sensitive, except inside of quoted strings.
Starting in Version 7, SAS will remember the case of variable
names when it displays them.
• Missing values are handled consistently in SAS, and are
represented by a period (.).
• Each statement in SAS must end in a semicolon (;).

Structure of SAS programs
• Lines beginning with an asterisk (*) are treated as comments.
Alternatively you can enclose comments between /* and */.
• You can combine as many data and proc steps in whatever
order you want.
• Data steps begin with the word data and procedure steps
begin with the word proc.
• The run; command signals to SAS that the previous
commands can be executed.
• Terminate an interactive SAS job with the endsas; statement.
• There are global options (like linesize and pagesize) as well as
options specific to datasets and procedures.
• Informative messages are written to the SAS log - make sure
you read it!

The Data Step
The data step provides a wide range of capabilities, among them
reading data from external sources, reshaping and manipulating
data, transforming data and producing printed reports.
The data step is actually an implied do loop whose statements will
be executed for each observation either read from an external
source, or accessed from a previously processed data set.
For each iteration, the data step starts with a vector of missing
values for all the variables to be placed in the new observation. It
then overwrites the missing value for any variables either input or
defined by the data step statements. Finally, it outputs the
observation to the newly created data set.
The true power of the data step is illustrated by the fact that all of
these defaults may be overridden if necessary.

Data Step: Basics
Each data step begins with the word data and optionally one or
more data set names (and associated options) followed by a
semicolon. The name(s) given on the data step are the names of
data sets which will be created within the data step.
If you don’t include any names on the data step, SAS will create
default data set names of the form datan, where n is an integer
which starts at 1 and is incremented so that each data set created
has a unique name within the current session. Since it becomes
difficult to keep track of the default names, it is recommended that
you always explicitly specify a data set name on the data
statement.
When you are running a data step to simply generate a report, and
don’t need to create a data set, you can use the special data set
name _null_ to eliminate the output of observations.

Data Step: Inputting Data
The input statement of SAS is used to read data from an external
source, or from lines contained in your SAS program.
The infile statement names an external file or fileref from which
to read the data; otherwise the cards; or datalines; statement is
used to precede the data.
data one;
infile "input.data";
input a b c;
run;
Reading data from an external file
data one;
input a b c;
datalines;
. . .
;
Reading from inline data
By default, each invocation of the input statement reads another
record. This example uses free-form input, with at least one space
between values.
A fileref is a SAS name, created by the filename statement, which refers to
an external file or other device

Data Step: input Statement
There are three basic forms of the input statement:
1. List input (free form) - data fields must be separated by at
least one blank. List the names of the variables, follow the
name with a dollar sign ($) for character data.
2. Column input - follow the variable name (and $ for character)
with startingcolumn – endingcolumn.
3. Formatted input - Optionally precede the variable name with
@startingcolumn; follow the variable name with a SAS format
designation. (Examples of formats: $10. (10 column
character), 6. (6 column numeric))
When mixing different input styles, note that for column and
formatted input, the next input directive reads from the column
immediately after the previous value, while for list input, the next
directive reads from the second column after the previous value.

Modifiers for List Input
The colon (:) modifier for list input tells SAS to use a format for
input, but to stop when the next whitespace is found. Data like:
17,244 2,500,300 600 12,003
14,120 2,300 4,232 25
could be read using an input statement like
input x1 : comma. x2 : comma. x3 : comma. x4 : comma. ;
The ampersand (&) modifier tells SAS to use two whitespace
characters to signal the end of a character variable, allowing
embedded blanks to be read using list input. Thus, the statements:
length name $ 25;
input name & $ year;
could be used to read data such as
George Washington 1789
John Adams 1797
Thomas Jefferson 1801

Other Modifiers for the Input Statement
+number advance number columns.
#number advance to line number.
/ advance to next line.
trailing @ hold the line to allow further input statements in this
iteration of the data step on the same data.
trailing @@ hold the line to allow continued reading from the line
on subsequent iterations of the data step.
Note: If SAS needs to read an additional line to input all the
variables referenced in the input statement it prints the following
message on the log:
NOTE: SAS went to a new line when INPUT statement reached past
the end of a line.
If you see this note, make sure you understand why it was printed!!

The input Statement
Variable lists can be used on the input statement. For example, the
list var1 - var4 expands to var1 var2 var3 var4.
You can repeat formats for variable lists by including the names
and formats in parentheses: (var1 - var4) (5.) reads four
numeric variables from 20 consecutive columns (5 columns for each
variable).
You can also repeat formats using the notation num*format. The
previous example could be replaced with (4 * 5.).
A null input statement (no variables) can be used to free holding
caused by trailing @-signs.
The @, + and # specifications can all be followed by a variable name
instead of a number.
If you want to make sure your input data is really arranged the way
you think it is, the list; command will display your input data
with a “ruler” showing column numbers.

FTP Access
SAS provides the ability to read data directly from an FTP server,
without the need to create a local copy of the file, through the ftp
keyword of the filename statement.
Suppose there is a data file called user.dat in the directory
public on an ftp server named ftp.myserver.com. If your user
name is joe and your password is secret, the following statement
will establish a fileref for reading the data:
filename myftp ftp ’user.dat’ cd=’/public’ user=’joe’
pass=’secret’ host=’ftp.myserver.com’;
The fileref can now be used in the infile statement in the usual
way.
You can read files from http (web) servers in a similar fashion,
using the url keyword.

Options for the infile statement
For inline data, use the infile name cards or datalines.
missover Sets values to missing if an input statement would
read more than one line.
stopover Like missover, but declares an error and stops
lrecl=num Treats the input as having a length of num characters.
Required if input records are longer than 256 characters.
dlm=’chars’ Uses the characters in chars instead of blanks
and tabs as separators in list (free-form) input.
dsd Read comma-separated data
expandtabs expand tabs to spaces before inputting data.
end=varname creates a SAS variable whose value is 1 when SAS
processes the last line in the file.
obs=n Limits processing of infile to n records
pad Adds blanks to lines that are shorter than the input
statement specifies.

Variable Length Records
Consider the following file, containing the year and name of the
first three American presidents:
1789 George Washington
1797 John Adams
1801 Thomas Jefferson
If we were to use an input statement like
input year 4. @6 name $17.;
SAS would try to read past the end of the second line, since the
name only has 10 characters. The solution is the pad option of the
infile statement. Suppose the data is in a file called p.txt. The
following program correctly reads the data:
data pres;
infile ’p.txt’ pad;
input year 4. @6 name $17.;
run;

Reading SAS programs from external files
The infile statement can be used to read data which is stored in
a file separate from your SAS program. When you want SAS to
read your program from an external file you can use the %include
statement, followed by a filename or fileref. After SAS processes a
%include statement, it continues to read data from its original
source (input file, keyboard or display manager.)
For example, suppose the SAS program statements to read a file
and create a data set are in the system file readit.sas. To process
those statements, and then print the data set, the following
commands can be used:
%include "readit.sas";
proc print;
run;

proc import
For certain simple data files, SAS can create a SAS data set directly
using proc import. The dbms= option informs SAS of the type of
file to be read, and choices include xls (Excel spreadsheets), csv
(Comma-separated values), dbf (Dbase files), dta (Stata files), sav
(SPSS files), and tab (Tab-separated files). For example,to read an
Excel spreadsheet called data.xls into a SAS data set named
xlsdata, the following statements can be used:
proc import dbms=xls datafile=’data.xls’ out=xlsdata;
run;
proc import provides no options for formatting, and may not be
successful with all types of data files

Repetitive Processing of Variables
The array statement can be used to perform the same task on a
group of variables.
array arrayname variable list <$> <(startingvalues)>;
array arrayname{n} variable list <$> <(startingvalues)>;
You can then use the array name with curly braces ({}) and a
subscript, or in a do over loop:
array x x1-x9;
do i = 1 to dim(x);
if x{i} = 9 then x{i} = .;
end;
array x x1-x9;
do over x;
if x = 9 then x = .;
end;
Notes: 1. All the variables in an array must be of the same type.
2. An array can not have the same name as a variable.
3. You can use the keyword _temporary_ instead of a variable list.
4. The statement array x{3}; generates variables x1, x2, and x3.
5. The function dim returns the number of elements in an array.

Titles and Footnotes
SAS allows up to ten lines of text at the top (titles) and bottom
(footnotes) of each page of output, specified with title and
footnote statements. The form of these statements is
title<n> text; or footnote<n> text;
where n, if specified, can range from 1 to 10, and text must be
surrounded by double or single quotes. If text is omitted, the title
or footnote is deleted; otherwise it remains in effect until it is
redefined. Thus, to have no titles, use:
title;
By default SAS includes the date and page number on the top of
each piece of output. These can be suppressed with the nodate and
nonumber system options.

Missing Values
SAS handles missing values consistently throughout various
procedures, generally by deleting observations which contain
missing values. It is therefore very important to inspect the log and
listing output, as well as paying attention to the numbers of
observations used, when your data contains missing values.
For character variables, a missing value is represented by a blank
(" " ; not a null string)
For numeric variables, a missing value is represented by a period
(with no quotes). Unlike many languages, you can test for equality
to missing in the usually fasion:
if string = " " then delete; * character variable;
if num = . then delete; * numeric variable;
if x > 10 then x = .; * set a variable to missing;

Special Missing Values
In addition to the regular missing value (.), you can specify one or
more single alphabetic characters which will be treated as missing
values when encountered in your input.
Most procedures will simply treat these special missing values in
the usual way, but others (such as freq and summary) have options
to tabulate each type of missing value separately. For example,
data one;
missing x;
input vv @@;
datalines;
12 4 5 6 x 9 . 12
;
The 5th and 7th observations will
both be missing, but internally they
are stored in different ways.
Note: When you use a special missing value, it will not be detected
by a statement like if vv = .; in the example above, you would
need to use if vv = .x to detect the special missing value, or to
use the missing function of the data step.

Variable Lists
SAS provides several different types of variable lists, which can be
used in all procedures, and in some data step statements.
• Numbered List - When a set of variables have the same prefix,
and the rest of the name is a consecutive set of numbers, you
can use a single dash (-) to refer to an entire range:
x1 - x3 ) x1, x2, x3; x01 - x03 ) x01, x02, x03
• Colon list - When a set of variables all begin with the same
sequence of characters you can place a colon after the sequence
to include them all. If variables a, b, xheight, and xwidth
have been defined, then x:)xwidth, xheight.
• Special Lists - Three keywords refer to a list with the obvious
meaning: numeric character all
In a data step, special lists will only refer to variables which
were already defined when the list is encountered.

Variable Lists (cont’d)
• Name range list - When you refer to a list of variables in the
order in which they were defined in the SAS data set, you can
use a double dash (--) to refer to the range:
If the input statement
input id name $ x y z state $ salary
was used to create a data set, then
x -- salary ) x, y, z, state, salary
If you only want character or numeric variables in the name
range, insert the appropriate keyword between the dashes:
id -numeric- z ) id, x, y, z
In general, variables are defined in the order they appear in the
data step. If you’re not sure about the order, you can check
using proc contents.

The set statement
When you wish to process an already created SAS data set instead
of raw data, the set statement is used in place of the input and
infile or lines statements.
Each time it encounters a set statement, SAS inputs an
observation from an existing data set, containing all the variables
in the original data set along with any newly created variables.
This example creates a data set called trans with all the variables
in the data set orig plus a new variable called logx:
data trans;
set orig;
logx = log(x);
run;
You can specify the path to a SAS data set in quotes instead of a
data set name. If you use a set statement without specifying a
data set name, SAS will use the most recently created data set.

drop= and keep= data set options
Sometimes you don’t need to use all of the variables in a data set
for further processing. To restrict the variables in an input data
set, the data set option keep= can be used with a list of variable
names. For example, to process the data set big, but only using
variables x, y, and z, the following statements could be used:
data new;
set big(keep = x y z);
. . .
Using a data set option in this way is very efficient, because it
prevents all the variables from being read for each observation. If
you only wanted to remove a few variables from the data set, you
could use the drop= option to specify the variables in a similar
fashion.

drop and keep statements
To control the variables which will be output to a data set, drop or
keep statements can be used. (It is an error to specify both drop
and keep in the same data step). Suppose we have a data set with
variables representing savings and income. We wish to output
only those observations for which the ratio of savings to income is
greater than 0.05, but we don’t need this ratio output to our final
result.
data savers;
set all;
test = savings / income;
if test > .05 then output;
drop test;
run;
As an alternative to drop, the statement
keep income savings;
could have been used instead.

retain statement
SAS’ default behavior is to set all variables to missing each time a
new observation is read. Sometimes it is necessary to “remember”
the value of a variable from the previous observation. The retain
statement specifies variables which will retain their values from
previous observations instead of being set to missing. You can
specify an initial value for retained variables by putting that value
after the variable name on the retain statement.
Note: Make sure you understand the difference between retain
and keep.
For example, suppose we have a data set which we assume is sorted
by a variable called x. To print a message when an out-of-order
observation is encountered, we could use the following code:
retain lastx .; * retain lastx and initialize to missing;
if x < lastx then put ’Observation out of order, x=’ x;
else lastx = x;

sum Statement
Many times the sum of a variable needs to be accumulated between
observations in a data set. While a retain statement could be used,
SAS provides a special way to accumulate values known as the sum
statement. The format is
variable + expression;
where variable is the variable which will hold the accumulated
value, and expression is a SAS expression which evaluates to a
numeric value. The value of variable is automatically initialized
to zero. The sum statement is equivalent to the following:
retain variable 0;
variable = variable + expression;
with one important difference. If the value of expression is
missing, the sum statement treats it as a zero, whereas the normal
computation will propogate the missing value.

Default Data Sets
In most situations, if you don’t specify a data set name, SAS will
use a default dataset, using the following rules:
• When creating data sets, SAS uses the names data1, data2,
etc, if no data set name is specified. This can happen because
of a data step, or if a procedure automatically outputs a data
set which you have not named.
• When processing data sets, SAS uses the most recently created
data set, which has the special name last . This can happen
when you use a set statement with no dataset name, or invoke
a procedure without a data= argument. To override this, you
can set the value of last to a data set of your choice with the
options statement:
options _last_ = mydata;

Temporary Data Sets
By default, the data sets you create with SAS are deleted at the
end of your SAS session. During your session, they are stored in a
directory with a name like SAS workaXXXX, where the Xs are used
to create a unique name. By default, this directory is created
within the system /tmp directory.
You can have the temporary data sets stored in some other
directory using the -work option when you invoke sas, for example:
sas -work .
to use the current directory or, for example,
sas -work /some/other/directory
to specify some other directory.
Note: If SAS terminates unexpectedly, it may leave behind a work
directory which may be very large. If so, it will need to be removed
using operating system commands.

Permanent Data Sets
You can save your SAS data sets permanently by first specifying a
directory to use with the libname statement, and then using a two
level data set name in the data step.
libname project "/some/directory";
data project.one;
Data sets created this way will have filenames of the form
datasetname.sas7bdat.
In a later session, you could refer to the data set directly, without
having to create it in a data step.
libname project "/some/directory";
proc reg data=project.one;
To search more than one directory, include the directory names in
parentheses.
libname both ("/some/directory" "/some/other/directory");

Operators in SAS
Arithmetic operators:
* multiplication + addition / division
- subtraction ** exponentiation
Comparison Operators:
= or eq equal to ^= or ne not equal to
> or gt greater than >= or ge greater than or equal to
< or lt less than <= or le less than or equal to
Boolean Operators:
& or and and | or or or ^ or not negation
Other Operators:
>< minimum <> maximum || char. concatenation
The in operator lets you test for equality to any of several constant
values. x in (1,2,3) is the same as x=1 | x=2 | x=3.

Comparison Operators
Use caution when testing two floating point numbers for equality,
due to the limitations of precision of their internal representations.
The round function can be used to alleviate this problem.
Two SAS comparison operators can be combined in a single
statement to test if a variable is within a given range, without
having to use any boolean operators. For example, to see if the
variable x is in the range of 1 to 5, you can use if 1 < x < 5 ....
SAS treats a numeric missing value as being less than any valid
number. Comparisons involving missing values do not return
missing values.
When comparing characters, if a colon is used after the comparison
operator, the longer argument will be truncated for the purpose of
the comparison. Thus, the expression name =: "R" will be true
for any value of name which begins with R.

Logical Variables
When you write expressions using comparison operators, they are
processed by SAS and evaluated to 1 if the comparison is true, and
0 if the comparison is false. This allows them to be used in logical
statements like an if statement as well as directly in numerical
calculations.
For example, suppose we want to count the number of observations
in a data set where the variable age is less than 25. Using an if
statement, we could write:
if age < 25 then count + 1;
(Note the use of the sum statement.)
With logical expressions, the same effect can be acheived as follows:
count + (age < 25);

Logical Variables (cont’d)
As a more complex example, suppose we want to create a
categorical variable called agegrp from the continuous variable age
where agegrp is 1 if age is less than 20, 2 if age is from 21 to 30, 3
if age is from 31 to 40, and 4 if age is greater than 40. To perform
this transformation with if statements, we could use statements
like the following:
agegrp = 1;
if 20 < age <= 30 then agegrp = 2;
if 30 < age <= 40 then agegrp = 3;
if age > 40 then agegrp = 4;
Using logical variables provides the following shortcut:
agegrp = 1 + (age > 20) + (age > 30) + (age > 40);

Variable Attributes
There are four attributes common to SAS variables.
• length - the number of bytes used to store the variable in a
SAS data set
• informat - the format used to read the variable from raw data
• format - the format used to print the values of the variable
• label - a descriptive character label of up to 40 characters
You can set any one of these attributes by using the statement of
the appropriate name, or you can set all four of them using the
attrib statement.
Since named variable lists depend on the order in which variables
are encountered in the data step, a common trick is to use a
length or attribute statement, listing variables in the order you
want them stored, as the first statement of your data step.

Variable Lengths: Character Values
• For character variables, SAS defaults to a length of 8
characters. If your character variables are longer than that,
you’ll need to use a length statement, an informat statement or
supply a format on the input statement.
• When specifying a length or format for a character variable,
make sure to precede the value with a dollar sign ($):
attrib string length = $ 12 format = $char12.;
• The maximum length of a SAS character variable is 32767.
• By default SAS removes leading blanks in character values. To
retain them use the $charw. informat.
• By default SAS pads character values with blanks at the end.
To remove them, use the trim function.

Variable Lengths: Numeric Values
• For numeric variables, SAS defaults to a length of 8 bytes
(double precision.) For non-integers, you should probably not
change from the default.
• For integers, the following chart shows the maximum value
which can be stored in the available lengths:
length Max. value length Max. value
3 8,192 6 137,438,953,472
4 2,097,152 7 35,184,372,088,832
5 536,870,912 8 9,007,199,254,740,992
• You can use the default= option of the length statement to set
a default for all numeric variables produced:
length default = 4;
• Even if a numeric variable is stored in a length less than 8, it
will be promoted to double precision for all calculations.

Initialization and Termination
Although the default behavior of the data step is to automatically
process each observation in an input file or existing SAS data set, it
is often useful to perform specific tasks at the very beginning or
end of a data step. The automatic SAS variable _n_ counts the
number of iterations of the data set. It is always available within
the data step, but never output to a data set. This variable will be
equal to 1 only on the first iteration of the data step, so it can be
used to signal the need for initializations.
To tell when the last observation is being processed in a data step,
the end= variable of either the infile or set statement can be
used. This variable is not output to a data set, but will be equal to
1 only when the last observation of the input file or data set is
being processed, and will equal 0 otherwise; thus any actions to be
done at the very end of processing can be performed when this
variable is equal to 1.

Flow Control: if-then-else
The if-then statement (with optional else) is used to
conditionally execute SAS statements:
if x < 5 then group = "A";
t may be followed by a (separate) else statement:
if x < 5 then group = "A";
else group = "B";
To execute more than one statement (for either the then or the
else), use a do-end block:
if x < 5 then do;
group = "A";
use = 0;
end;

Flow Control: Subsetting if
Using an if statement without a corresponding then serves as a
filter; observations which do not meet the condition will not be
processed any further.
For example, the statement
if age < 60;
is equivalent to the statement
if age >= 60 then delete;
and will prevent observations where age is not less than 60 from
being output to the data set. This type of if statement is therefore
known as a subsetting if.
Note: You can not use an else statement with a subsetting if.

ifc and ifn functions
If your goal is to set a variable to a value based on some logical
expression, the ifc or ifn function may be more convenient than
using an if/else statement. For example, to set a tax rate based
on whether or not a state name is equal to california, the following
could be used:
rate = ifn(state = ’california’,7.25,5.25);
ifn returns numeric values, while ifc returns character values.
result = ifc(score > 80,’pass’,’fail’)
An optional fourth argument can be used to handle the case where
the first argument is missing.

Flow Control: goto statement
You can use the goto statement to have SAS process statements in
some other part of your program, by providing a label followed by a
colon before the statements you wish to jump to. Label names
follow the same rules as variable names, but have a different name
space. When a labeled statement is encountered in normal
processing, it is ignored.
Use goto statements with caution, since they can make program
logic difficult to follow.
data two;
set one;
if x ^= . then goto out;
x = (y + z) / 2;
out: if x > 20 then output;
run;

Flow Control: stop, abort, return
Although rarely necessary, it is sometimes useful to override SAS’
default behavior of processing an entire set of data statements for
each observation. Control within the current execution of the data
step can be acheived with the goto statement; these statements
provide more general control.
stop immediately discontinue entire execution of the data step
abort like stop, but set error to 1
error like abort, but prints a message to the SAS log
return begin execution of next iteration of data step
For example, the following statement would stop processing the
current data step and print an error message to the log:
if age > 99 then error "Age is too large for subject number " subjno ;

Do-loops
Do-loops are one of the main tools of SAS programming. They
exist in several forms, always terminated by an end; statement
• do; - groups blocks of statements together
• do over arrayname; - process array elements
• do var=start to end <by inc>; - range of numeric values
• do var=list-of-values;
• do while(expression); (expression evaluated before loop)
• do until(expression); (expression evaluated after loop)
The do until loop is guaranteed to be executed at least once.
Some of these forms can be combined, for example
do i= 1 to end while (sum < 100);

Iterative Do-loops: Example 1
Do-loops can be nested. The following example calculates how long
it would take for an investment with interest compounded monthly
to double:
data interest;
do rate = 4,4.5,5,7,9,20;
mrate = rate / 1200; * convert from percentage;
months = 0;
start = 1;
do while (start < 2);
start = start * (1 + mrate);
months + 1;
end;
years = months / 12;
output;
end;
keep rate years;
run;

Iterative Do-loops: Example 2
Suppose we have a record of the number of classes students take in
each year of college, stored in variables class1-class5. We want
to find out how long it takes students to take 10 classes:
data ten;
set classes;
array class class1-class5;
total = 0;
do i = 1 to dim(class) until(total >= 10);
total = total + class{i};
end;
year = i;
if total lt 10 then year = .;
drop i total;
run;

Getting out of Do-loops
There are two options for escaping a do-loop before its normal
termination:
You can use a goto statement to jump outside the loop:
count = 0;
do i=1 to 10;
if x{i} = . then count = count + 1;
if count > 5 then goto done:
end;
done: if count < 5 then output;
. . .
You can also force termination of a do-loop by modifying the value
of the index variable. Use with caution since it can create an
infinite loop.
do i=1 to 10;
if x{i} = . then count = count + 1;
if count > 5 then i=10;
end;

SAS Functions: Mathematical
Each function takes a single argument, and may return a missing
value (.) if the function is not defined for that argument.
Name Function Name Function
abs absolute value arcos arccosine
digamma digamma function arsin arcsin
erf error function atan arctangent
exp power of e (2.71828 · · ·) cos cosine
gamma gamma function cosh hyperbolic cosine
lgamma log of gamma sin sine
log log (base e) sinh hyperbolic sine
log2 log (base 2) tan tangent
log10 log (base 10) tanh hyperbolic tangent
sign returns sign or zero
sqrt square root

SAS Functions: Statistical Summaries
The statistical summary functions accept unlimited numbers of
arguments, and ignore missing values.
Name Function Name Function
css corrected range maximium − minimum
sum of squares skewness skewness
cv coefficient std standard deviation
of variation stderr standard error
kurtosis kurtosis of the mean
max maximum sum sum
mean mean uss uncorrected
median median sum of squares
min minimun var variance
pctl percentiles
In addition, the function ordinal(n,...) gives the nth ordered
value from its list of arguments.

Using Statistical Summary Functions
You can use variable lists in all the statistical summary functions
by preceding the list with the word “of”; for example:
xm = mean(of x1-x10);
vmean = mean(of thisvar -- thatvar);
Without the of, the single dash is interpreted in its usual way, that
is as a minus sign or the unary minus operator; thus
xm = mean(of x1-x10);
is the same as
xm = mean(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10);
but
xm1 = mean(x1-x10);
calculates the mean of x1 minus x10, and
xm2 = mean(x1--x10);
calculates the mean of x1 plus x10.

Concatenating Character Strings
SAS provides the following functions for joining together character
strings:
cat - preserve all spaces
cats - remove trailing blanks
catt - remove all blanks
catx - join with separator (first argument)
Each function accepts an unlimited number of arguments. To join
together all the elements in a variable list, use the of keyword:
x1 = ’one’;
x2 = ’two’;
x3 = ’three’;
all = catx(’ ’,of x1-x3); * or catx(’ ’,x1,x2,x3);
The variable all will have the value ’one two three’

SAS Functions: Character Manipulation
compress(target,<chars-to-remove>)
expr = "one, two: three:";
new = compress(expr,",:"); *new => "one two three"
With no second argument compress removes blanks.
count(string,substring) - counts how many times substring
appears in string
index(source,string) - finds position of string in source
where = "university of california";
i = index(where,"cal"); * i => 15
indexc(source,string) - finds position of any character in
string in source
where = "berkeley, ca";
i = indexc(where,"abc"); * i=1 (b is in position 1);
index and indexc return 0 if there is no match

SAS Functions: Character Manipulation (cont’d)
left(string) - returns a left-justified character variable
length(string) - returns number of characters in a string
length returns 1 if string is missing, 12 if string is uninitialized
repeat(string,n) - repeats a character value n times
reverse(string) - reverses the characters in a character variable
right(string) - returns a right-justified character variable
scan(string,n,<delims>) - returns the nth “word” in string
field = "smith, joe";
first = scan(field,2," ,"); * first will be ’joe’;
negative numbers count from right to left.
substr(string,position,<n>) - returns pieces of a variable
field = "smith, joe";
last = substr(field,1,index(field,",") - 1);
results in last equal to "smith".

SAS Functions: Character Manipulation (cont’d)
translate(string,to,from) - changes from chars to to chars
word = "eXceLLent";
new = translate(word,"xl","XL"); *new => "excellent";
transwrd(string,old,new) - changes old to new in string
trim(string) - returns string with leading blanks removed
upcase(string) - converts lowercase to uppercase
verify(source,string) - return position of first char. in source
which is not in string
check = verify(val,"0123456789.");
results in check equal to 0 if val is a character string containing
only numbers and periods.

Regular Expressions in SAS
The prxmatch and prxchange functions allow the use of
Perl-compliant regular expressions in SAS programs. For example,
to find the location of the first digit followed by a blank in a
character string, the following code could be used:
str = ’275 Main Street’;
wh = prxmatch(’/\d /’,str); * wh will be equal to 3;
To reverse the order of two names separated by commas, the
following could be used:
str = ’Smith, John’;
newstr = prxchange(’s/(\w+?), (\w+?)/$2 $1/’,-1,str);
The second argument is the number of changes to make; −1 means
to change all occurences.
For more efficiency, regular expresssions can be precompiled using
the prxparse function.

SAS Functions for Random Number Generation
Each of the random number generators accepts a seed as its first
argument. If this value is greater than 0, the generator produces a
reproducible sequence of values; otherwise, it takes a seed from the
system clock and produces a sequence which can not be reproduced.
The two most common random number functions are
ranuni(seed) - uniform variates in the range (0, 1), and
rannor(seed) - normal variates with mean 0 and variance 1.
Other distributions include binomial (ranbin), Cauchy (rancau),
exponential (ranexp), gamma (rangam), Poisson (ranpoi), and
tabled probability functions (rantbl).
For more control over the output of these generators, see the
documention for the corresponding call routines, for example call
ranuni.

Generating Random Numbers
The following example, which uses no input data, creates a data set
containing simulated data. Note the use of ranuni and the int
function to produce a categorical variable (group) with
approximately equal numbers of observations in each category.
data sim;
do i=1 to 100;
group = int(5 * ranuni(12345)) + 1;
y = rannor(12345);
output;
end;
keep group y;
run;

Creating Multiple Data Sets
To create more than one data set in a single data step, list the
names of all the data sets you wish to create on the data statement.
When you have multiple data set names on the data statement
observations will be automatically output to all the data sets unless
you explicitly state the name of the data set in an output
statement.
data young old;
set all;
if age < 25 then output young;
else output old;
run;
Note: If your goal is to perform identical analyses on subgroups of
the data, it is usually more efficient to use a by statement or a
where statement.

Subsetting Observations
Although the subsetting if is the simplest way to subset
observations you can actively remove observations using a delete
statement, or include observations using a output statement.
• delete statement
if reason = 99 then delete;
if age > 60 and sex = "F" then delete;
No further processing is performed on the current observation
when a delete statement is encountered.
• output statement
if reason ^= 99 and age < 60 then output;
if x > y then output;
Subsequent statements are carried out (but not reflected in the
current observation). When a data step contains one or more
output statements, SAS’ usual automatic outputting at the end
of each data step iteration is disabled — only observations
which are explicitly output are included in the data set.

Random Access of Observations
In the usual case, SAS automatically processes each observation in
sequential order. If you know the position(s) of the observation(s)
you want in the data set, you can use the point= option of the set
statement to process only those observations.
The point= option of the set statement specifies the name of a
temporary variable whose value will determine which observation
will be read. When you use the point= option, SAS’ default
behavior of automatically looping through the data set is disabled,
and you must explicitly loop through the desired observations
yourself, and use the stop statement to terminate the data step.
The following example also makes use of the nobs= option of the
set statement, which creates a temporary variable containing the
number of observations contained in the data set.

Random Access of Observations: Example
The following program reads every third observation from the data
set big:
data sample;
do obsnum = 1 to total by 3;
set big point=obsnum nobs=total;
if _error_ then abort;
output;
end;
stop;
run;
Note that the set statement is inside the do-loop. If an attempt is
made to read an invalid observation, SAS will set the automatic
variable error to 1. The stop statement insures that SAS does
not go into an infinite loop;

Application: Random Sampling I
Sometimes it is desirable to use just a subsample of your data in an
analysis, and it is desired to extract a random sample, i.e. one in
which each observation is just as likely to be included as each other
observation. If you want a random sample where you don’t control
the exact number of observations in your sample, you can use the
ranuni function in a very simple fashion. Suppose we want a
random sample consisting of roughly 10% of the observations in a
data set. The following program will randomly extract the sample:
data sample;
set giant;
if ranuni(12345) < .1;
run;

Application: Random Sampling II
Now suppose we wish to randomly extract exactly n observations
from a data set. To insure randomness, we must adjust the fraction
of observations chosen depending on how many observations we
have already chosen. This can be done using the nobs= option of
the set statement. For example, to choose exactly 15 observations
from a data set all, the following code could be used:
data some;
retain k 15 n ;
drop k n;
set all nobs=nn;
if _n_ = 1 then n = nn;
if ranuni(0) < k / n then do;
output;
k = k - 1;
end;
if k = 0 then stop;
n = n - 1;
run;

Application: Random Sampling III
The point= option of the set statement can often be used to create
many random samples efficiently. The following program creates
1000 samples of size 10 from the data set big , using the variable
sample to identify the different samples in the output data set:
data samples;
do sample=1 to 1000;
do j=1 to 10;
r = round(ranuni(1) * nn);
set big point=r nobs=nn;
output;
end;
end;
stop;
drop j;
run;

By Processing in Procedures
In procedures, the by statement of SAS allows you to perform
identical analyses for different groups in your data. Before using a
by statement, you must make sure that the data is sorted (or at
least grouped) by the variables in the by statement.
The form of the by statement is
by <descending> variable-1 · · · <<descending> variable-n <notsorted>>;
By default, SAS expects the by variables to be sorted in ascending
order; the optional keyword descending specifies that they are in
descending order.
The optional keyword notsorted at the end of the by statement
informs SAS that the observations are grouped by the by variables,
but that they are not presented in a sorted order. Any time any of
the by variables change, SAS interprets it as a new by group.

Selective Processing in Procedures: where statement
When you wish to use only some subset of a data set in a
procedure, the where statement can be used to select only those
observations which meet some condition. There are several ways to
use the where statement.
As a procedure statement: As a data set option:
proc reg data=old; proc reg data=old(where = (sex eq ’M’));
where sex eq ’M’; model y = x;
model y=x; run;
run;
In the data step:
data survey;
input id q1-q10;
where q2 is not missing and q1 < 4;
data new;
set old(where = (group = ’control’));

where statement: Operators
Along with all the usual SAS operators, the following are available
in the where statement:
between/and - specify a range of observations
where salary between 20000 and 50000;
contains - select based on strings contained in character variables
where city contains ’bay’;
is missing - select based on regular or special missing value
where x is missing and y is not missing;
like - select based on patterns in character variables
(Use % for any number of characters, _ for exactly one)
where name like ’S%’;
sounds like (=*) - select based on soundex algorithm
where name =* ’smith’;
You can use the word not with all of these operators to reverse the
sense of the comparison.

SAS programming in Mainframe

2013-09-18T13:58:00.000+05:30

Abstract
Versions 8 and 9 of the SAS System have included many enhancements that are typically enjoyed by users of the PC platform. While working on a major overhaul of one of our reporting systems, we discovered many features of SAS that worked very well on the Mainframe, but were not widely known. This paper illustrates a few ‘modern’ tools that SAS Programmers can use in the Mainframe environment to move their systems forward into 21st Century techniques and applications. We will take a quick look at generating PDF files, using the SAS FTP access method, and generating e.mails, all from the z/OS (Mainframe) environment.

OUTPUT DELIVERY SYSTEM
One of the most significant developments in Version 7 of SAS was the inclusion of the Output Delivery System, or
ODS. Greatly enhanced in Versions 8 and 9, ODS allows users to create customized versions of output in a variety
of destinations (including HTML, RTF, XML, and PDF) instead of being limited to traditional line-listing printouts. For
flexibility and convenience, we have converted many of our reports to PDF format.
Generating default (unenhanced) PDF files is fairly simple with ODS, but there can be a lot of extra work involved in
making minor changes to the default PDF generator. SAS includes a number of ‘styles’ for generating ODS output.
Styles are collections of parameters that tell SAS how to format output by specifying fonts, colors, margins, and many
other attributes. You can also modify existing styles to suit your needs, but that is beyond the scope of this paper. A
copy of one of our customized styles is included as an appendix.
Simple ODS output can be accomplished by ‘wrapping’ your existing SAS program with a few lines of code. Before
your procedures, you will need to code at least 3 statements:
1 FILENAME, which creates a file reference name (fileref) and allocates space for your PDF file on the
Mainframe.
2 ODS LISTING CLOSE, which closes the default LISTING destination. It is recommended to keep open only
the specific destinations you are sending output to.
3 ODS PDF, which opens the PDF destination, and provides SAS with additional details about the file that you
are generating.
There are other ODS statements and SAS options that you may find useful to include in this initialization section.
Here is a sample of some code used to initiate a PDF job:
1 FILENAME OUTPDF "KJK4.FDWCTNAT" DISP=NEW UNIT=TEMP RECFM=VB LRECL=259;
2 ODS LISTING CLOSE;
3 OPTIONS ORIENTATION=LANDSCAPE;
4 ODS NOPTITLE;
5 ODS PATH SASHELP.TMPLMST (READ) NEWTEMP.TEMPLAT (READ);
6 ODS ESCAPECHAR='^';
7 ODS PDF FILE=OUTPDF STYLE=STYLES.TEST1 NOTOC;
Code Explanation:
Line 1 These are the recommended Data Control Block (DCB) parameters from SAS when defining a PDF file
on the Mainframe. On this particular system, UNIT=TEMP will automatically delete the file after 3 to 8
days, depending on the file size.
Line 2 Before generating output with ODS, you should close the default LISTING destination.
Line 3 ODS output uses portrait layout unless otherwise specified.
SUGI 30 Coders' Corner2
Line 4 This optional statement suppresses the printing of the default procedure name in your output.
Line 5 This statement is only necessary if you have defined your own ODS Style templates, and refers to your
own Template store; if you are using one of the built-in styles, you can omit it.
Line 6 This optional statement defines a special character not present in your dataset that can allow you to add
very specific in-line formatting inside of some of your procedure code.
Line 7 This is the primary statement that initiates the generation of your PDF file, and refers to the FILENAME
statement (Line 1) specified earlier. The STYLE parameter refers to the desired ODS style you want
used for your output. This example refers to a user-defined ODS template called TEST1. The NOTOC
option suppresses the automatic generation of the PDF Table of Contents.
Remember that only statements 1, 2, and 7 are required to generate your ODS code.
Following these statements, any output generated from SAS Procedures will be directed to the ODS destination.
After your last output procedure, you can then close your ODS destination with just two lines of code:
8 ODS PDF CLOSE;
9 ODS LISTING;
Line 8 This statement is issued after the final data step boundary (make sure to include a RUN statement after
your final procedure, before this statement) to end the generation of your PDF file.
Line 9 This statement re-opens the default destination, and is good practice to include after closing another
ODS destination.
The capability to generate PDF files was put into production for the Mainframe in Version 8.1, although the files
generated were quite large. Improved compression for PDF files was introduced in Version 9.0, which was used for

the code in this paper.

SAS FTP ACCESS METHOD
Once you have created your ODS output on the Mainframe, you have a number of options to move that file
somewhere where it can be easily accessed by you and your users.
Within your mainframe terminal emulation software, there may be an option to directly transfer files, or you may have
a standalone software package (such as WS_FTP) that can be used. If you have worked with UNIX System Services
on the Mainframe, and have access to a web-served directory on the system, you can actually create PDF files on
the Mainframe that can be directly browsed by Internet Explorer, without having to transfer the files.
We opted to use the SAS built-in method of transferring files via FTP. The process is fairly simple, and is
accomplished through the FILENAME statement. To use this method, you will need access to an active FTP server.
Here is a sample FILENAME statement:
FILENAME OUTFTP FTP
"TESTFILE.TXT"
CD="/home/kjk4/public_html"
HOST=”111.111.111.111”
USER="kjk4"
PASS=”password”
RECFM=S
DEBUG;
While the syntax for the FTP Filename statement is quite different from typical FILENAME statements on the
Mainframe, the parameters that are coded are fairly standard.
After the FILENAME statement, code a fileref that you will refer to later. In this example, OUTFTP is the fileref. FTP
is then coded to indicate to SAS that you will be using File Transfer Protocol with this file. Next, list the name of the
file that you will be creating on the remote host. The naming conventions of the destination should be used when
specifying the filename.
In this example, we are transferring data to a Linux server, so the options that are shown here may or may not apply
to other destinations you may use. The SAS Language Reference documentation for “FILENAME, FTP Access
Method” explains all of the different options available for this statement. Since the Linux operating system is case-sensitive, we had to issue a “CAPS OFF” mainframe command in our ISPF
edit session, and make sure that we were not using the CAPS option anywhere in our program. This preserves
lower-case letters in the SAS programs. Depending on your remote destination, this may be necessary to do in your
programs as well.
We use the CD command to change the directory of the destination to point to the remote location where we want to
store our file. HOST is the network name of the destination server. It can be specified using an IP address or the
actual host name.
USER and PASS specify the UserID and associated Password for access to the remote FTP server. RECFM=S sets
the record format type, creating a binary data transfer. The DEBUG option prints log messages from the actual FTP
login on the remote server to your SAS Mainframe log.
Notice that even though we are in the Mainframe environment, we did not have to specify any of the typical keywords
associated with a fileref on the Mainframe, such as LRECL, DISP, or SPACE. The SAS internal FTP client transfers
the file to the remote destination, and no permanent file is written to the Mainframe.
Once you have coded your FILENAME statement, you can use that fileref just as you would in any statement that
generates an output file:
DATA _NULL_;
SET ONE;
FILE OUTFTP;
PUT …
Or, you could combine it with ODS code presented earlier, and have the Mainframe generate the PDF file and
automatically transfer it to your remote system. Since the file is never actually stored on the mainframe, it is not
necessary to code any DCB parameters in this FILENAME statement.
FILENAME OUTPDF FTP "TESTFILE.PDF"
CD="/home/kjk4/public_html"
HOST=”111.111.111.111”
USER="kjk4"
PASS=”password”
RECFM=S
DEBUG;
ODS PDF FILE=OUTFTP STYLE=STYLES.TEST1 NOTOC;

MAINFRAME-GENERATED E.MAIL

Our Mainframe offers the capability to generate automated e.mail messages from within SAS programs, and can also
include attachments and links to files. We began by trying to send files as attachments, but because of size
limitations, we abandoned this method for our project, and instead use e.mail to notify users that files have been
created and stored on local servers. These automated e.mails contain hyperlinks to the files, and allows users to
quickly access reports in an electronic format. This feature is experimental in Version 8, and production in Version 9,
where it is documented.
First, we show code on how to send an e.mail from the Mainframe, and then explain how to send different
attachments.
E.mails are also generated on the Mainframe through use of the FILENAME statement. Here is some sample code
for generating a plain text message:
FILENAME OUTBOX EMAIL
TO=(’KJK4@XYZ.GOV’ ‘ZQQ8@XYZ.GOV’)
REPLYTO='TBE2@XYZ.GOV'
TYPE='TEXT/PLAIN'
SUBJECT="Your file is ready";
SUGI 30 Coders' Corner4
In this example, OUTBOX is our fileref for the e.mail that we are going to generate, and EMAIL is the keyword to tell
SAS that this file is an e.mail to be sent via SMTP. The TO parameter denotes the e.mail address(es) of the
recipients for the e.mail. If you have a single recipient, you may omit the parentheses. You can also code CC= in the
same manner if you want to send copies of the message to other users.
By default, the FROM address on messages generated by the Mainframe will not look like a standard e.mail address.
In addition, there’s probably not a mailbox on that end that you can access. It is good practice to use the REPLYTO
parameter with an address you can access so that if there are problems, users can easily contact you. Note that if
delivery of a message fails, you may or may not get any type of error in your log, depending on other JCL settings in
your job. While we have had very good success with our system, we frequently include developers’ e.mail addresses
in the list of recipients to monitor performance of the system and make certain that there are no problems.
We code TYPE to make sure that SAS will send the file as plain text. The SUBJECT keyword is optional, but
recommended, and values inside quotation marks will have their case preserved.
Once you have issued your FILENAME command, you can then generate an e.mail using PUT statements inside a
DATA _NULL_ step, like this:
OPTIONS NOCAPS;
DATA _NULL_;
FILE OUTBOX;
PUT "The report listed above is now available via the following";
PUT "link for 21 days:";
PUT / "http://111.111.111.111/~kjk4/testfile.pdf";
PUT // "Thanks,";
PUT "KJK4";
RUN;
The NOCAPS option makes sure to preserve the lower case letters in the body of the message. This is necessary
when including hyperlinks that point to a file stored on a case-sensitive system. The FILE statement tells SAS to
refer to the OUTBOX fileref, which alerts the system that this is an e.mail. Then, PUT statements are used to specify
the text. Our e.mail system, Outlook, automatically recognizes the third line of this e.mail as a hyperlink, and allows
the recipient to click on it to access the file specified.
Attachments can also be sent by e.mail, although the maximum attachment size allowed by our Mainframe is 500KB.
This maximum is set by an IBM SMTP Configuration File, and is independent of SAS. Text, PDF, HTML, and other
types of files can be sent via e.mail.
To send an attachment, you will need to have already created a file on the Mainframe, using a standard fileref earlier
in your program. Then, you simply add one additional option to your FILENAME EMAIL statement that denotes the
attachment:
ATTACH=("KJK4.T1030.TXT” NAME=”KJK4”);
This statement attaches a text file that is named KJK4.T1030.TXT on the Mainframe. Since PC users may be
confused by a 3-level file name, I can use the NAME= option to specify a new name for the file, to which SAS
automatically adds the correct file type extension. So, the above statement sends the file KJK4.T1030.TXT as an
attachment, but in the e.mail, it appears as a file named KJK4.TXT.
This statement attaches a PDF file directly to the e.mail message:
ATTACH=("KJK4.T1030” CT='APPLICATION/PDF' EXT='PDF');
Since we have coded the EXT keyword, the Mainframe attaches the file denoted by the filename in quotes, and adds
the extension, which becomes KJK4.T1030.PDF in this case. The CT parameter specifies to the receiver’s e.mail
system what to do when the attachment is opened. With the value of ‘APPLICATION/PDF’, the recipient’s e.mail
program should automatically open the attachment in Adobe Acrobat when clicked.
The syntax for sending attachments is not always obvious, but there are a number of examples located on the SAS

website, and in SUGI papers. The documentation for Version 9 also gives additional examples.

Lesson 7: Data Set Options, Set and Merge Statements

2012-09-02T11:42:00.003+05:30

Data Set Options
"Options" are used in SAS in various places, and with various different kinds of syntax. For this reason, the concept of options can be a bit confusing. An earlier lesson introduced the idea of a global system options statement, where we can set things like linesize, page numbering, and so forth.  Data set options are something different. They are commands added to a basic data step statement to refine or modify the work of the data step, or they can be used to modify how a data set is used in a proc step. (The term, "options," is also used for any optional command in any SAS statement. This is why we have to distinguish between system options, data set options, and other options.)
We begin with the drop and keep options. The examples below show how these two options can be used to accomplish the same thing. The choice between them is purely a matter of convenience. The drop option lists the variables to be omitted from the data set, while the keep option lists those which are to remain in the data set. There could be many reasons why you might not want all of the original variables in your data set. In the next example, we use the original variables for calculations, but do not include them in the data set. In other cases, we may create variables that are only used in the program and do not need to be saved.

Take note of the syntax used here, as it is unique for data set options. All the options to be applied to a particular data set are enclosed in parentheses, following the name of the data set to which they apply. An equal sign after each option is followed by the list of items involved. Here they are part of the data step, but they are NOT called DATA STEP options, but rather DATA SET options, and they can be used any time a data set is referenced, such as in this proc print statement:

(A var statement under proc print would be more appropriate, but this works. Var statements are covered later.)
The Set Statement
The set statement is used to create a new data set from an existing one. In the simplest example, it merely copies a data set. The following program will create a new data set called two that is an exact copy of one, providing one exists.

Now suppose that a data set called one has been created, as shown in the data step below, and that you later wanted to create a new data set called two, with some new variables, but leaving the old oneunchanged. The set statement can be used to copy the original data set and add new variables.

SAS will now go through all the observations in one, and place in the new data set two the original variables together with the new ones that are defined.
There are two data sets now. Suppose we want to print both of them.  Most procs, including proc print, will use the most recently created data set by default. Thus the second statement below would print only two.  To specify another data set, use the syntax shown in the first statement below.  Each “proc print” statement prints one data set.

Using Data Set Options with Set Statements
Next we show how data set options can be applied to either input or output data sets when using the set statement to read another data set. In the example below, data set one is first created to serve as the input data set. The data sets two and three will be exactly the same, but the processes by which they are produced differ. When two is created, all four variables from one are read into memory, then when the data are written to two the variables x and y are eliminated. When three is created, only sumxy and prodxy are read into memory from one, and subsequently saved to three. If there are many variables and observations involved, the second method is preferred because it is more efficient (saves system resources). However, you cannot drop variables from an input data set if you intend to use them in calculations!

The firstobs and obs options specify the starting and stopping observation number to read. They do not apply to output data sets, but are used with set statements and in procs where data sets are referenced. In the first example, a second data set is created using these options to make a subset of the original data. Note the observation numbers in the output.

In the next example, the option is given in the proc print statement. Compare the observation numbers. In both cases, the observation numbers correspond to the observations actually stored in the data. They are not renumbered by proc print.

Finally, we discuss the rename option. At times it will be necessary to change the names of variables. As with the other options, this can be done when reading or writing the data. When used with an output data set, it renames the variables when the data set is saved, and does not affect the names used within the data step, as shown below. Also, the rename option requires another set of parentheses for the list of variables to be renamed. The name change is specified as "old name=new name."

When the rename statement is used with an input data set, the new names are in effect during the data step, as in this example:

Using Firstobs and Obs in the Infile Statement
Firstobs and obs can also be used in the infile statement when reading from an external file or cards. Here, the syntax is different, since they are not connected with a data set, and the options are simply typed on the line following the filename or cards keyword. There is one other difference--in this case, the numbers refer to the starting and ending line in the data, which is not always the same as the observation (e.g., observations might take up two lines each).

Concatenating Data Sets Using the Set Statement
The set statement can also be used to combine data sets in various ways. The first way is called concatenation, and is simply combining them in order, one after the other. The example below uses two data sets, but there can be more. When using concatenation, all of the observations of all of the listed data sets are included in the result. All variables from all the sets are included, with missing values assigned in cases where a variable does not occur in the original.

Suppose the data sets have different variable names.

You could use data set options to re-align the variables in a case like this.

Combining Observations with the Set Statement
The second method of combining data sets is called "one-to-one reading" and may be thought of as a side-by-side version of concatenation. The programming difference is that while in concatenation the source data sets are listed in one set statement, in one-to-one reading each source data set is given in a separate set statement. If the same variable names occur in more than one source data set, the values of the later sets overwrite the earlier ones. If the data sets do not have the same number of observations, the result is cut off at the length of the shortest set. The example below shows two data sets of different lengths and the same variables. The x variable is changed using a rename option during input. Thus the source variable is overwritten with the second data set values, but because of the name change, we now have x and y coming from the original x variables.

Interleaving Data with the Set Statement
The third method is called interleaving. This is like concatenation, except that the observations are combined so that they are sorted, instead of having one data set placed after the other. The variable(s) on which the sort is done are called by variables, and the interleave is done by adding a by statement to the concatenation program. The by variables must be sorted before the interleave is done, so if they are not in order to begin with, we use proc sort to do the job. Proc sort will also have a by statement, listing the by variable(s), just like the data step that does the interleave.

Merging Data Sets
Now, if you're thinking ahead, you must realize that we should be able to take this to another level--how about putting the data side-by-side while matching up variables? That's called a merge. And that's where we're going next. But before getting to the programming, there are some things that need to be explained. We need to be very careful about how things match up. For convenience, we'll visualize the data sets laid out side by side, so that we have a right and a left data set. The simplest case occurs when there is exactly one item on the left to match exactly one item on the right. This is called a one-to-one merge. If there is exactly one on the left to match more than one on the right, we call it a one-to-many merge, and if the roles are reversed, a many-to-one merge. Finally, if there are multiple instances of variable values on both sides, it is called a many-to-many merge. The latter should usually be avoided, but an example will be provided to show what happens.
Our first example will be one-to-one reading again, but this time using a merge statement. The difference is that the data set continues building until the end of the longest data set is reached. (In the following examples the variables have been given unique names to avoid needing rename options.)

Next, we do a one-to-one merge. The data sets will be matched by the name variable, therefore this variable may be called the match key. The match key is identified using a by statement, and it must be the same in both source data sets. Just as in interleaving, the data sets must be sorted. To simplify the example, the data are entered in sorted order. Note that if something doesn't have a match, it is included, with missing values where the matching data should be. Also, this is a good time to mention that SAS character variables are case sensitive, so that "john" and "John" are two different values. If your data might have mixed case, the upcase function can be used to convert everything to upper case to ensure it matches.

Now consider a one-to-many merge. We will have one instance of each name on the left, and multiple instances of some names on the right. There is no change to the program (only the data). The result is that one observation is produced for each observation on the "many" side, but if there is no match, again the relevant observations on either side are included with missing values.

Here is the result of a many-to-many merge. The technical details of what happens are a bit complicated, but we can say, in a simplified way, that SAS matches lines side-to-side until one side runs out of the matching observations, then it repeats the last observation from the short side until the long side runs out of the matching value. (If you go back to the previous examples, you can see that they are special cases of this more general result.) There are very few situations where this behavior is desirable. Most merging is done with one-to-one or one-to-many relationships.

As a final comment, note that while there is a useful purpose for having two or more set statements, there is nothing similar for merge statements. You can put two or more merge statements in a data step, with or without a by statement, and not get an error message, but the resulting data values may be intermingled in "unexpected" ways.

Exercises
1. Refer to the data in Exercise #1 of Lesson 6. For each of the following, include a proc print to display the results. Use appropriate titles. This can all be done in one program.

Create a data set with only the three given variables. Name the variables x, y, and z. (This is the only time you will use cards.)
Create another data set, using a set statement, that takes the SAS data set in Part a as input, renames the variables length, width, and height during reading (on the way in), and calculates the volume and cost as in Lesson 6.
Do as in Part b, except this time rename the variables when the data set is written (on the way out, this does not mean in proc print).
Do as in Part b, except this time use obs and firstobs to bring in only the third and fourth observations from the original data set.
Using the data set created in Part b as input, create a new data set that contains only the volume and cost variables.

2. Refer to Exercise #2 of Lesson 5.

Begin with the same input statement as was used in Lesson 5, then create a new name variable of the form "Lastname, Firstname" and another of the form "City, ST zip#". Use an option to eliminate the original five variables used to create these new variables.
Create another data set where you use obs and firstobs in the infile statement to read the second and third lines of data only.

3. Download this data. Do not change the file or copy it into your editor. Look at it with a text editor, such as Notepad. There are two sections, with headings that say "1." and "2." (These lines are not to be considered observations).

Write two data steps, using this one file as the source in both cases, but using firstobs and obs to control the starting and ending line so that each section is read into its own data set. The data have a city name and state abbreviation. Read these as two variables, "City" and "State." Use a length statement to make the city variable long enough not to cut any of the names short and make the state abbreviation of length 2. Create a new variable that forms a single five-character abbreviation using the first three letters of the city and the two letters of the state abbreviation. Create another variable that concatenates the city and state with a comma and one space immediately following the city. It should look something like this:
Obs city state shortcity longcity
1 Bismarck ND BisND Bismarck, ND
Concatenate the two data sets and print the result. (Do not sort the data before this step.)
Next, interleave the two data sets. Remember they must be sorted first. Use "state" as the by variable. Print the results but use a data set option within proc print to show only the "longcity" variable and observation number.
Next, merge the two data sets using "state" as the matching variable and applying the rename option as needed (within this data step). Use an option in the data statement so that only the two original city variables and the state remain in the new data set. Print the result (with no data set options used in proc print this time).

4. Copy the SAS code below into the editor to start with. Assume that these data sets represent an inventory list that is being revised at each step. The prices change each time, but the "itemno" is revised between new1 and new2 only. Write a program that does the following, and print each of the data sets you create.

Merge new2 and new3 with itemno as the match key, and show old and new prices.
Merge new1 and new3 with name as the match key, including the old and new values of "itemno" and price in the result..

data new1;
input itemno name $ price;
cards;
325 PrintCrd 211
276 KeyPad 37
842 PnclHldr 8
422 PaprShrd 132
523 Basket 29
;
data new2;
input itemno name $ price;
cards;
333 PrintCrd 399
277 KeyPad 25
802 PnclHldr 12
417 PaprShrd 122
515 Basket 17
;
data new3;
input itemno name $ price;
cards;
333 PrintCrd 386
277 KeyPad 25
802 PnclHldr 11
417 PaprShrd 135
515 Basket 15
;

Lesson 6: Creating Variables

2012-09-02T11:41:00.002+05:30

Creating Variables with Assignment Statements
You can create variables that are not in the data that you are reading. In the following program, avgrowth is calculated from the other variables in the data. Second, dummy is assigned a constant value. Since the value assigned to it is a character string, indicated by the quotes around it, dummy will be a character variable of length 3, because that is the length of the first value assigned to it. Unless a length statement is used to set the length of a character variable before it is used, the length will be determined by the first value assigned to it. Numeric constants can also be assigned, simply by putting a number on the right side of the equal sign (no quotes).

Obviously, variables are created by the input statement, but they are also created if they are specified in a length, attrib, format, or informat statement (see below). They can also be created by array definitions (a later topic), or by assignment statements, such as those in the example above. An assignment statement is made up of a variable name, an equal sign, and an expression representing the value to be assigned to the variable. The variable can appear in its own assigned expression, such as x=x+1, or x=log(x). A very special form of assignment statement, called a sum statement, or an accumulator, is an exception to this syntax. In the example below, p and q are accumulators. Their values are incremented, starting from zero, by the amount specified, for each succeeding observation. The accumulator p+1, below, is essentially the same as p=p+1, except that it is initialized to zero, which does not automatically happen if you use p=p+1. (See also the retain statement.)

The arithmetic operations and mathematical functions used in assignment statements for numeric values are quite intuitive. The syntax is similar to that used for formulas on a graphing calculator or spreadsheet. The arithmetic operations are "+" (add), "-" (subtract or negative), "*" (multiply), and "/" (divide). Exponents are given with a double asterisk, such as "3**2" (three to the second power). Parentheses are used in the usual manner for controlling order of operations. Many functions are available, and their names can often be guessed because of their similarity to standard mathematical notation. All functions have at least one argument enclosed in parentheses. Some examples are sqrt(x) for square root of x (where x can be a number, variable name, or other expression that evaluates to a non-negative number), log(x) for natural log, and exp(x) for the exponential function ("e to the x"). There are also some constants, such as pi, given by the function constant(pi). For more detailed information about functions, see the SAS Documentation under "Base SAS/SAS Language Reference: Dictionary/Dictionary of Language Elements/Functions and CALL Routines." (Note: Some of the documented functions may not work in The Learning Edition.) Here are a few more examples:

Since dates are numbers, you can do simple things like subtract two dates to find the number of days between them, without any problem. However, for more complicated tasks, SAS has quite a few date-related functions. For example day(x) returns the day of the month, month(x) returns the month number for a date, and qtr(x) returns the quarter number. If you have to do any serious computations with dates, check the SAS documentation for available tools. Remember, SAS also has date-time values, and functions to go along with them, as well.

For character variables, there is an operation called concatenation, indicated by "||" (two vertical bars), that puts two character strings together. There are many, many functions for character variables. We will just look at a few: substr(source, position, length) which extracts a substring, trim(source) which eliminates trailing blanks, length(source) which calculates the length of the value excluding trailing blanks, and upcase(source) which changes all the letters to upper case.
In the program below, a length statement has been used for the city variable, to allow up to 15 letters. Note that this method would not work for city names that have more than one word, like "New York City." The st (state) variable has been given an informat for two characters, but a colon modifier is used so that the pointer will move on to the beginning of the zip code. Zip codes should always be character variables, otherwise those that start with zero will be shortened.

The first assigned variable, addr1, is created by simply concatenating all three variables. Note the (possibly undesirable) result, with the "extra" spaces between city and state, and the lack of spaces between state and zip code. The spaces are there because the variable length is, in fact, 15, and the unused positions are filled with spaces. Concatenation uses the whole variable, including spaces.
In addr2 we have removed the trailing spaces from city by using a trim function. Now there are no spaces between any of the combined variables.
In addr3, we have included punctuation and spaces between the variables. Notice that the concatenation operation works with constant expressions enclosed in quotes, as well as variables. Spaces are preserved just as written between the quotes, including the one space after the comma and the two spaces in front of the zip code.
The upcase function is demonstrated in addr4, which converts addr3 to all uppercase characters. Following that, the substring function is used to create a four-letter abbreviation, by extracting the first two letters of city and combining them with the state code. Note the order of the three arguments, first the source variable, then the starting position, then the number of characters to extract.
The last assignment statement shows how we can combine various functions to perform a specialized task. The idea here was to find the middle character of the city variable, defined to be the actual middle character for odd lengths and the letter immediately prior to the middle for even lengths. The substring function is used to extract the character, but the starting position must be calculated. The length function divided by two would be almost right, as it works fine for even lengths, but for odd lengths gives a half, like 4.5 for "Brookings." Since the middle character is the next higher whole number, we can use the ceiling function, one of several rounding functions available, this being the one that always rounds any decimal value up to the next integer.
Length, informat, and attrib statements
An alternative to specifying informats in the input statement is to use an informat statement. The informat statement has the same syntax as the format statement. It doesn't do anything that can't be done in the input statement, but it might be convenient to keep things organized, as in this example:

Numeric variables have a default length of 8 bytes in SAS. As we have seen, there is also a default length of 8 for character variables, if they are read using a $ informat, or if an informat is used, the length depends on n in "$n.". In a later section, we will see that if character variables are created using data step programming statements, they get their lengths from the first value assigned to them. The length statement can be used to override the default lengths for both character and numeric variables.
It's not often we want to change the length of a numeric variable. Sometimes space can be saved when the values are integers. The allowed lengths are from 3 to 8 for PC SAS. A length of 3 will accommodate accurate integer values from -8192 to 8192. A length of 4 works to slightly over 2 million. It is not recommended to use shortened numeric values when fractions (decimals) are involved.

In the above example, you can see that the length statement has syntax similar to the format or informat statements. However, the "dot" is not required. Here it has been left out for the numeric length and included for the character length, just for an example. The dollar sign, however, is required for character variables. The length statement must occur before the first use of the variable in the program, or it will not have any effect.
Another way to use the length statement is shown below. This example sets the default numeric length to 3. Unless you specify other lengths, all numeric variables in this data set will have length 3. (This only works for numeric variables.) The character variables will have length 8.

Another way to do this is with the attrib statement, which is more complicated and allows you to set the lengths, formats, informats, and labels all in one command:

Exercises:
For each of the following exercises, copy and paste the data given in the problem into the SAS editor. Write a data step to read the data and create the new variables described, then print the results using proc print, using appropriate titles.
1. These numbers represent dimensions of cardboard boxes, length, width, and height, in inches.

Calculate the volume of each box in cubic feet.
Calculate the amount of cardboard needed to make each box in square feet, assuming that the top and bottom flaps meet in the middle (this results in a double layer of cardboard for both top and bottom).
Suppose the cost of cardboard is $.05 per square foot, and there is a fixed cost of $.25 for manufacturing each box regardless of size. Calculate the cost of manufacturing each box.
Calculate the cost per cubic foot of volume.

2. This problem will provide a little practice in writing complicated formulas in SAS, paying attention to order of operations. Use the data below, with variables a, b, and c, and apply the following formulas to create two new variables called root and trunk. The first observation's results are -1 and 2.094, respectively.
,

3. Read the following data into three variables, making sure to get complete names. Use the character functions and operators to extract initials from the following names so that they look like "J.F.K." Then create an abbreviation for each name that looks like "J-n F-d K-y".

John Fitzgerald Kennedy
Martha Helena Goetz
Frederich Anthony Sailer
Albert Blake Codwell

Lesson 5: Input Styles

2012-09-02T11:40:00.003+05:30

It's time to dig a little deeper into the technical details of data reading. Before we do that, it is important to make clear what we mean by "reading" and "writing" in a data step. "Reading" is the process whereby SAS interprets raw data from a file or an instream cards section of the program, or when it accesses an existing data set. Thus, "reading' means SAS is bringing data values into computer memory to process in the data step. "Writing" is the process of saving the finished data to a SAS data set file on a hard drive (or other computer storage device). It is NOT the same as "printing." which is a term by which we usually mean "use proc print to display text in the Output Window."
Imagine that you are a computer and are instructed to read a file. What do you actually do?
Well, as a human, how do you read a book? First you have to open it. You find the starting place, and you begin reading, which at the most fundamental level means you read a character, interpret it, and move on to the next one, and repeat. Upon reaching the end of a word, you interpret the word, and move on to the next one. Upon reaching the end of a line, you move down a line and go back to the left and read the first character, and so on, until you reach the end of the book, at which point you close it and stop. Well, something like that, anyway. For us, so much happens automatically, we don't have to think about it. But, a computer doesn't think at all. It merely follows a sequence of instructions, and this sequence, in some ways, is similar to processes we humans follow when reading a book.
When SAS opens a file to read it, it creates two pointers, which are nothing more than numbers for keeping track of position in the file. One pointer is a position in a line of text (column), the other is the line number in the file. (We are assuming a standard text file here. SAS can also read binary files, but that is another subject.) The pointers are initially at column 1, line 1. As SAS reads data, the pointer moves along the line (not literally, of course, the number just changes). SAS needs to know when to begin reading a value and when to stop. What is obvious to us is not necessarily obvious to a computer. Consider the following line:
12 33 42 51 24
Do you see five numbers? How about this:
1233425124
If I told you this was a string of five two-digit numbers, you would know immediately how to interpret it. We are now going to consider what must be done to tell SAS how to interpret lines of data in ways somewhat analogous to how a person would interpret them.
SAS has four input styles. It is easiest to learn about them one at a time, but they can actually be used together (mixed input) on the same file in almost any order. The input styles are: list, column,formatted, and named input.
List input is perhaps the most straightforward. The data values are simply given in a "list," one after the other, with a delimiter between them. The delimiter is often just a space (that's the default), but may be a comma, tab, or other character. List input, in the simplest case, can be recognized if all you see in the input statement is variable names and dollar signs following the character variables. Typically, the data will not be aligned in columns.
To make our example easier to follow, the data is shown in a "cards" section, but we will discuss it as though it were really an external file. Some differences involved in actually using an external file will be dealt with later. Notice that the data values are separated by a single space and are not aligned in columns. The input statement contains only variable names and one dollar sign.

When SAS processes the input statement, it creates, in memory, an "input vector," which is temporary storage for all the variables in one observation. At this point, the attributes of the variables (length, character vs. numeric) are fixed. As the data step goes through its commands, it fills up the fields of the input vector, and when it gets to the end, it outputs one observation to the data set. If there is more to do, it goes back and starts over, first clearing the input vector, then filling it up again. One pass like this is known as a data step iteration.
The default length for character variables is eight characters, so in our example, that is the length of the "name" variable. Age and height are numeric variables, also taking up eight bytes of memory, but that has no bearing on the number of characters to be read. As reading begins, the pointers are set to line 1, column 1. SAS is going to read up to eight characters into the variable "name." However, in the list input style, if first checks to see if the current character is a space (or other blank character). If so, it advances to the next, and keeps going until it comes to a non-blank character. Then it starts reading characters into the input vector. When it comes to another blank, it stops. If the data value has more than eight characters, SAS will read the first eight and save them, but will then continue advancing the pointer until a space is encountered, then stop. (Longer character variables can be specified using the "colon modifier," ":$w." as has been shown in a previous section. The colon causes SAS to read in list style even when there is an informat present. There is also an "ampersand modifier" which allows use of a character informat and reads imbedded spaces. Multiple spaces then signal the end of the field.)
The second variable, "age," is a number. With list input, SAS can only read numbers in "standard" format, which essentially means there can be only numerals, decimals, and minus signs present. SAS again advances the pointer to the first non-blank character and begins reading the number until it encounters a space. The number of columns read is immaterial this time, as SAS will simply store the number with as much precision as it can, regardless of how many numerals were given. When it reaches a space, SAS saves the number to the input vector and stops. The third variable, "height," is read the same way, except that we are now at the end of a line. Upon reaching the end of the line, SAS saves the value, moves the column pointer back to 1, and advances the line pointer to the next number. As it has come to the end of the input statement as well, it considers the observation complete and writes the contents of the input vector to the output data set. It then clears the input vector and starts over, repeating until the end of the file is reached.
Missing values for character variables require special care with list input, since spaces are interpreted as delimiters and cannot then represent missing values. Missing values may have to be coded using a word or symbol (e.g., "missing"). Options that change the delimiter (discussed later) can also solve this problem. Numeric missing values are represented by a decimal point (period). If values are missing at the end of a line (without a placeholder of some kind), the infile option missover can be used to set the remaining variables to missing and go on to the next line. If this is not done, SAS will try to read the variables from the next line.
Column input requires the data to be arranged in aligned columns. The key element of column input is that you give a range of columns after each variable name, or after the dollar sign of a character variable, in the form of start-end. Informats cannot be used in the input statement with column input. (They can be specified in a separate informat statement, introduced in the next lesson.) There is no need to worry about the column pointer in this case, as SAS changes it according to the ranges specified. The ranges need not be in order. They can even overlap or be re-read.

The next example illustrates some of the advantages of column input. Notice that the character variable will read whatever is in the associated columns and is automatically set to the length specified by the range of columns. Even spaces and special characters are correctly read and stored. Missing numeric values need not be coded with a period, as spaces will be correctly interpreted as missing.

One of the best features of column input is that no delimiters are required. Many mainframe programs produce this kind of file, which has no extra spaces or delimiters. This can greatly reduce the size of a file. As long as the column positions are known, there is no difficulty with reading this data in SAS.

Formatted input relies on informats and pointer controls to determine where and what to read into each variable. In the example below, the @n syntax gives the starting column for each variable. It repositions the column pointer to that column. The "name" variable has a default length of eight. The numeric variables are read until a space is encountered. It is important to note that the syntax here is the @n comes in front of the variable name, and the informat comes in its usual position after the variable name.

Variables need not be in left-to-right order. Informats may be used as needed.

Even though I have shown the @n for each variable here, it is not really necessary in all cases. The initial "@1" is not required, as the pointer starts out in column 1. With formatted input, the line pointer will end up at the next character past the field that was just read. IF this is the start of the next variable, you are ready to go and do not need to reposition the pointer. The syntax "+n" may be used to advance the pointer a specified number of columns. Just as with column input, delimiters are not necessary when using formatted input.

Because formatted input and column input cause SAS to read a specified number of columns, a problem occurs if the end of the line varies, as in the example of the dates given below. When the data are instream, SAS does not have a problem. But if the file is external, a line that is too short will cause an error. The truncover option in the infile statement will cause SAS to treat short lines as if there were spaces in the file to fill out the remainder of the field. If there is no data at all for the field, the observation will be set to missing. The syntax is demonstrated here with instream data, but is only necessary for external files.

It is often helpful with formatted input, if there are many variables, to line them up vertically in the input statement, with the @'s all in front and the informats after. I have not shown an example, but with a large number of variables, this makes it much easier to prevent and correct mistakes.
The log below is the result of trying to read this same data from an external file without the truncover option. Observe that SAS is looking for the "bday" variable at the beginning of line 2, and since what is actually there is a name variable, it declares the data to be invalid. The reason for this is that the "bday" given in line 1 is only 7 characters in length. Since there are not enough characters, SAS goes to the next line to look for the variable. After failing to read "bday," the end of the input statement is reached, so SAS tries to move the next line to start a new input cycle, but finding the end of the file, it quits and writes only one observation to the data set.

Including the truncover option in the infile statement fixes this problem.

Named input is used when each variable is identified in the data with a variable name and the equals sign. This input style is not very common. While named input can be mixed with the other styles, it must be last on the line. You cannot change back to another style.

However, the idea demonstrated here is very useful. In some data sets, it is difficult to identify where the variables are in the line. If they are "signaled" by some identifiable text, we can use that text to determine the position of the pointer and use formatted input. In the example below, we have given a character string in quotes with the @ sign, where we had the column number in previous examples. SAS scans from the current column until it matches the text in quotes after the @ sign. Note that a trailing space was included in the quotes in this example. An alternative would be to leave out the space and increase the field width to 3. In any case, you want to make sure the pointer ends up in the right place, which will be right after the text in quotes, and the field width matches the location of the value to be read. In cases like this, a lot of effort is required to determine what consistent properties of the data source can be reliably used. Careful study of the file and testing of various scenarios is required, or the result may be misread data, quite possibly with no warning of the errors.

If the variable values are not in a consistent order in the data, we can deal with that too. By using "@1" to reset the pointer back to the beginning of the line, we can make sure nothing is missed:

To finish this off, here is an example of mixed input styles. All four styles, list, column, formatted, and named, are demonstrated in one input statement.

Exercises:
For each problem below, write a SAS program that creates a data set using instream data. Copy and paste the given data segments into the SAS editor. This is important in order to keep the data in the same format as presented. DO NOT adjust the data, such as by adding spaces or aligning columns. Include a proc print step in the program, and turn in the editor, output, and log files. Use appropriate titles and formats, if necessary, in your output.
1. The variables are Name, Age, Height, Sex, and JoinDate. Assume that no values will be longer than those included here, and use the shortest possible length for the character variables. Use list input (with colon modifiers where needed).

John 21 70 M 2/14/97
Jo 18 62 F 3/27/99
Mark 32 68 M 6/22/98
Linda 25 65 F 12/14/97
Carey 27 59 F 8/20/98

2. The variables and the columns they are found in are LastName (1-15), FirstName (16-30), Address (31-55), City (56-65), State (66-67), and Zip (68-72). Assume that character variables may fill the entire field width. Use column input.

Johnson        Michael        121 1st St S             Brookings SD57006
Big Hammer     Beatrice       45031 271st Ave S        Moorhead  MN56560
Helms-Marquart Charlotte      302 N Mason-Dixon Ave    Somewhere DC01221
Cutler         George         Rural Route 2            Zap       ND58563

3. In this problem, the same variables are used as in the previous problem, but additional variables are included, namely the Social Security Number, Ownership Status, and Move-in Date. You can see where these new variables are added. The field widths of the variables that were in the previous problem are unchanged. Use formatted input to read this data, but change the order of reading to First Name, Last Name, Social Security Number, Ownership Status, Move-in Date, Address, City, State, and Zip. Use at least one example of the "+n" syntax to move the pointer.

503118596Johnson        Michael        Own 121 1st St S             01051974Brookings SD57006
471559684Big Hammer     Beatrice       Rent45031 271st Ave S        10221987Moorhead  MN56560
362995874Helms-Marquart Charlotte      Own 302 N Mason-Dixon Ave    07091991Somewhere DC01221
474843859Cutler         George         RentRural Route 2            12161996Zap       ND58563

Lesson 4: Numeric Formats and Informats

2012-09-02T11:39:00.001+05:30

SAS stores all data with only two variable types, character and numeric. We have seen that character variables can have different lengths. In contrast, numeric variables (including integers and dates) are almost always stored in 8-byte floating-point form. These numbers have a precision of about 16 significant digits. Some other languages refer to this as a "real" data type (which is not mathematically correct, of course). Therefore, we do not have to be concerned about how numbers will be stored. We do, however, have to think about how to read and write them.
Let's begin with a simple example. Here we see a data set with three numbers. There are no complications in reading these numbers; the variable x in the input statement is a numeric variable by default (no informat). Observe that in the output, the first two observations were written in the same form they appeared in the data, but the third was not. Because it is such a large number, SAS defaulted to printing this number in scientific notation. The "E18" is interpreted as "times 10 to the 18th power."

The appearance of observation 3 in the output can be changed by adding a format statement to proc print, as shown below. The actual format code is "19.". The period or decimal point is part of the code and is standard syntax for all formats and informats. Character formats and informats start with "$". In most formats and informats there is a number right before the period that indicates the field width. For numeric variables only, a number after the period indicates the width of the decimal portion of the number.
Notice that 19 digits are now displayed, however, the last two are not the same as the original data. There has been some rounding error.

Commas can be included in the output. Note that the field width had to be increased to accommodate the commas.

Or perhaps you want dollars:

Let's turn to reading numbers in various formats. First, we should note that we cannot read numbers that are not in "standard format" without an informat, a code that tells SAS how to interpret the number it is reading. See what happens in this example:

The commaw. (dollarw. is the same) informat reads numbers with commas, as well as dollar signs and some other imbedded symbols. The w stands for the field width, but be sure to count the commas (and dollar signs) when determining the number of columns needed. Also, make use of the colon modifier just as with character informats, if the field widths vary. (If you are working with other currencies or European style numbers, check the documentation for alternative informats.)

Handling decimal places correctly can sometimes be tricky. Here we see a basic example with no informat. In addition, no format has been specified in proc print, so SAS chooses a format that it "thinks" is "best." Note that the third observation is rounded, but this is only because of the printing format that was used, and does not mean the number is rounded off in the data set. If you add a format statement with a 9.4 format to the proc print step, all the original digits will be displayed.

Here is an example that is incorrect. Numeric formats and informats can specify a number of decimal places by putting a number after the period. The informat below, 4.2, is saying that SAS should read a field of width 4 with two decimal places.

One problem is that the decimal is part of the field and needs to be counted, which caused the second and third observations to be cut short. We should have 5 instead of 4 for the field width.. Secondly, when a width for the decimal portion of the number is specified in an informat, it means that those decimal places are to be assumed whenever no decimal point appears in the number. It does not over-ride an existing decimal point. The first observation is thus interpreted as 11.22, that is, assuming that the last two digits should be in the decimal portion. This may or may not be correct, so great care must be taken when using this method. Normally, it would only be used when the data is known to be recorded with an implied decimal. Usually such data are not mixed (with and without decimals). The most common situation in which mixing might occur is when a variable is a percent or proportion, and has been recorded inconsistently, using both notations. In that case, you might want 22 and .22 to mean the same thing. A 3.2 format would accomplish the correct result.
Here the field width is corrected, the decimal is left off of the informat, and a format is included in proc print to display all the decimals.

Formats can be permanently stored with the data set. If this is done, the formats are then available to any proc that can use them, without writing another format statement. The program shown below uses the "5." informat, but also stores the "9.4" format in the data set. There is no need for another format statement in proc print. However, if you want to use a format other than the one stored with the data, you can still specify it in proc print (perhaps "format x 7.2;"). It should also be mentioned here that SAS syntax allows specifying a format for several variables at once. For example, "format x y z 7.2;" would apply the 7.2 format to all three variables, x, y, and z. Or, you can use "format x 7.2 y z 5.;" which will apply the 7.2 format to x and the 5. format to y and z.

While this covers the most frequently needed informats for numbers, there are many other special cases. Check the SAS documentation (under Base SAS, Language Reference: Dictionary) for other formats and informats.
Date Formats and Informats
Since SAS has only two data types, you may wonder what we do with dates. While it is possible to store dates in character form, doing so would make calculations with dates very difficult. Dates are stored as numbers, precisely, the number of days since (or before) January 1, 1960, which is "day zero."

You cannot read a date without an informat, except perhaps in the rare event that it is already coded as the number of days since 1/1/1960. Dates can be written in many ways, and SAS can read almost any of them, with the right instructions. In the example above, the dates are given in the most common American format, month/day/year. The informat uses the codes mm for month, dd for day, and yy for year. In some other countries, dates are written in the form day/month/year, so in SAS we simply switch the order accordingly, to "ddmmyyw. Once again, w stands for the width of the field that is being read, including the delimiters. SAS does not require a specific delimiter when interpreting the date, so it does not matter if it says 1/1/1960 or 1-1-1960 or 1.1.1960. The width is usually 10 to accommodate two digits for month, two for day, and four for year, plus two delimiters. However, it could be 8 if only two year digits are used, and it could be 6 or 8 if no delimiters are used (010160 or 01011960). SAS will interpret these variations correctly as long as they are not ambiguous (1160 for January 1, 1960 would not work), as in this example:

Of course, we don't want our printout to give dates like "0" or "16604," since they are not very meaningful to human readers! Therefore, we should include a nice format to make it readable.

There are many formats to choose from. See the SAS documentation for more. Here are some more examples. In the program below, the dates appear in the data in three different formats. The first one is like those discussed above, the second is what SAS considers a "standard" date, and the third is a Julian date (used in many businesses--it's the year followed by the number of the day in the year). Three proc print steps follow, to demonstrate the dates with no format, and with six different formats. As with character and numeric formats, date formats can also be stored with the data set.

Note that SAS also has informats and formats for time values and date-time combination values. If you have need of these, or want to explore the many other possibilities, check out the SAS documentation.
Interpreting Two-digit Years
In the years leading up to 2000, the government and businesses became very concerned about the "Y2K" problem. Many programs stored years using two digits, because most business software did not need to deal with dates outside of the twentieth century. In 2000, this all changed. SAS never had a "Y2K" problem for storing dates, since a date is just the number of days before or after January 1, 1960. However, there can still be a problem when reading dates with two-digit years from a file or instream data. SAS interprets two-digit years as belonging in a specific 100-year interval. The first year of this interval is called the Year Cut Off, and the SAS system option "YearCutOff=n" is used to set it in an options statement. The default value of YearCutOff is set by the administrator when SAS is installed, typically 1920.

Exercises
1. Copy the raw data below into a SAS program. a) Write a data step to read these data into three variables: Invoice, Amount, and Quantity. Using proc print, display the data so that all the Amount values are formatted like the Amount value in the first observation of the raw data. b) Then, revise the data step so that a format for Amount is stored with the data set, and show the results in proc print, without using any format statement in proc print. Use appropriate titles that identify which part of the exercise the output comes from.

12244 $1,499.99 144
32189 $20,000 1
92314 49.28 3

2. Copy the data below into a SAS program. Write a data step to read them into a SAS data set. The variables are capitol, state, capitol population, and state population. Store labels with the data set. Print the data with proc print, displaying labels, using appropriate formats and a title.

Bismarck ND 56,344 633,837
Pierre SD 13,939 764,309
Helena MT 26,718 917,621
Madison WI 218,432 5,472,299

3. Download this file. The data contain the names of some of the past presidents of the United States together with their birth and death dates. The data are aligned in columns, as shown in the example below (the longest name). Save the file to your computer and use an infile statement to read the data from the file into a SAS data set. Read the entire name into one variable, using a character variable length of 23. Store formats for the dates with the data set. Write three proc print steps that result in three different sets of date formats. Use appropriate titles.

Lesson 3: Appearance of Output, Infile, Labels and Informats

2012-09-02T11:37:00.000+05:30

Keeping Up Appearances
Suppose your output doesn't fit on the page the way you like when you print it or paste it into a word processor. An options statement can be used to adjust the number of lines and columns used in the page formatting. In the example below, "ps" stands for "pagesize" (you can also spell it out if you like). This is the number of lines on a page. Next, "ls" stands for "linesize" (you can spell this out too), which is the width of a line in characters. If you don't want the date and time displayed, you can include "nodate," and if you'd like to reset the starting page number, "pageno=n" will do that, where you replace "n" with the number you want. If page number is not reset, the page numbers keep incrementing in the output window, even if you clear it. There are many more options available (see the help or manuals).

Reading from a File
Now, back to reading data. Our example data set is small, and easy enough to type in. If the data set is large, it may not be convenient to type everything into the program. In this case, the data may be saved in a text file outside of SAS. Let's say we had the same data saved in a file called F:\sample.txt.  The following program would then have almost the same effect as the previous one (can you tell what will be different?):

(Since the library isn't specified, this data will be saved in work.)
There are some details to take note of here. It may seem that the infile statement replaces the "cards" section, but that is not what really happens. The infile statement comes before the input statement, whereas the "cards" section comes after the input statement.  (In fact, "cards" must always be placed last in the data step.) When you include a "cards" statement, SAS automatically assumes there is a default infile statement that says "infile cards;" before the input statement. In other words, SAS treats the "cards" section just like an external file. This is confirmed by the fact that it does not appear in the program statements copied to the log. You can explicitly include the infile cards statement, especially if you need some of the optional commands available with infile. This will be discussed further in a future lesson.
There is also an import wizard available from the File Menu.  It will load Excel and other popular file types too. (One caveat for Excel imports: You must look under the "options" button in the wizard, where there is a check box to indicate whether the first line contains data or variable names.) In Enterprise Guide, this can be accomplished by going to the "Insert" menu and choosing "data."
Labels for Variables
SAS allows variable names to be 32 characters long. You can have upper and lower case letters, numbers, and underscores, but cannot start with a number. Programming statements do not distinguish between upper and lower case, but the cases are remembered for use in output. This flexibility takes care of most variable naming needs. However, there are times when even more flexibility is desired. Perhaps you want true spaces (not underscores) between words, or special characters that are not allowed. Or maybe you'd like to use a short name like "LEye" in your program, but want the output to say "Left Eye Acuity." For these situations, SAS allows us to assign labels to variables. Labels can be up to 256 characters long and may include almost any text symbols. Labels are assigned in the data step and are stored with the data set. Many SAS procedures, like proc print, can use the labels in producing output. In the example below, note the syntax of the label statement in the data step: The statement begins with the keyword label, followed by a variable name, equal sign, and the label in quote marks. More labels may be assigned in the same statement. They are listed one after the other separated by spaces (no commas). To use the labels in proc print, the option label is added to the proc print statement. The example shows the results both without and with the label option.

Character Informats
So far we've discussed reading fairly straight-forward data consisting of numbers or short words. We will now explore more complex data types.
Consider this example:

No errors in the log....

Why isn't "Amphitheater" complete? The default length for character variables is eight. SAS has only read eight characters from the data even when more characters are present. We need to tell SAS to make the x variable hold more characters. Try this:

The "$12." expression in the input statement is called an "informat." Think of it as an "input format" that tells SAS what to expect the data to look like. The dollar sign signifies that it is a character variable, and the 12 is the length of the field to be read, and also the length of the resulting variable. All informats have a period in them. This is part of the syntax that SAS uses to recognize an informat.
Let's look at four more examples to demonstrate the behavior of informats. These examples will use two character variables. In the first example, we show what happens with only dollar signs to indicate that they are character variables. Of course, the values are now cut off at eight characters, but otherwise the data are read correctly:

Now suppose we attempt to fix the length problem by putting in informats. Then, SAS reads the full 12 characters for x, regardless of whether or not there are spaces included:

To fix this, we need SAS to treat a space as a delimiter just as it does when a dollar sign is used alone. The "colon modifier" placed in front of the informat will give this result. In fact, the dollar sign alone is an abbreviation for ":$8.".

The character informat can also be used to create variables shorter than eight characters. For large data sets, this can result in considerable space savings. For example, the data set might contain a variable that is a one-character code (such as M or F for male or female). Using an informat of $1. would then be appropriate, and would save seven bytes of storage for every observation.
Running out of Line
An additional problem occurs when using these techniques to read from an external file. A character informat at the end of a line causes SAS to try to read all of the characters for the width of the field specified by the informat. If the line is shorter than that, errors will be reported in the log and the data will not be read correctly. One solution is to add the option "truncover" in the infile statement after the file path. The meaning of "truncover" is something like "keep reading over the whole field even if the line is truncated." (This problem does not occur with instream data.) A colon modifier with the informat can often solve this problem, too.
There is a related option, "missover" that can also be used when there are not enough variable values at the end of the line and you want the remaining ones set to missing in the SAS data set. Without "missover", SAS would go to the next line and try to continue reading the input variables for which it did not find values. The two options behave almost identically. The difference is that missover will set short values to missing when an informat (no colon) is used, while truncover will not. Truncover also does the same thing when more than one value is missing at the end of a line.

Exercises
From now on, include titles in all your output that give your name, the lesson number, and problem number. Unless otherwise directed, do not change data sets, and turn in your editor, log, and output.
1. Download the file at this link. It contains four variables, FirstName, LastName, Age, and Score. Write a SAS program to read this data from the external file and print it to the output window. Save the data set in a library that you specify (not work). Experiment with title and options statements to change the appearance of your output.
2. Copy the data below into the SAS editor and write a data step to read it, followed by a proc step to print it (to the output window). Make sure the printout matches the original data. The variables are first and last name, sex, and age. Include labels in your data set and output. Also include a two-line title and suppress the printing of the time and date on each page.

Andy Stewart M 47
Martha Gustafson F 55
Marissa Maneschevitz F 32
John Fitzgerald M 28
Jacqueline Martin F 33

3. Download the file at this link. Similar to a previous exercise, it contains four variables, Age, Score, LastName, and FirstName. Examine the data file carefully, then write a SAS program to read this data from the external file and print it to the output window. Include an appropriate title.

Lesson 2: Data Sets and Libraries

2012-09-02T11:35:00.003+05:30

Data Sets

SAS stores data in “SAS data sets,” using its own internal database format. If you are familiar with any database software (Oracle, Sybase, Dbase, MS Access, etc.), you will find that data sets correspond to tables in a database program. The rows are called observations (database "records"), and the columns are called variables (database "fields"). In the example data set below, x, y, z, and w are variables, while 1, 2, 3, and 4 are observation numbers. It is also becoming more common to use the database terms with SAS, so it is good to be aware of both terminologies. Rows=Observations=Records. Columns=Variables=Fields.

However, data sets contain more than just variables and observations. Such things as how values are to be printed, labels to use instead of variable names, and sorting and indexing information can also be included.

As you learn about SAS, you will see that SAS gives you a great deal of control over almost any aspect of your work that you might think of. However, greater control is obtained by using more complex program statements. So, SAS has many "default" settings that save you from extra work and headaches as long as you are satisfied with what is specified by the default. Therefore, many standard actions can be accomplished by very short SAS commands. When there is need for more control, additional commands are available. The first of these "defaults" that we will encounter concerns where data sets are stored.

Libraries

SAS stores data sets in libraries. (They are really just computer directories or folders, but the term comes from the mainframe language.) There is a default library called “work.” This is where the data will be placed if you don't specify another location. However, work is a temporary library, that is, when SAS is closed, all data sets in work are deleted. However, if you want a data set to be saved permanently, such as in your “My Documents” folder or anywhere else you wish, you can tell SAS to designate a permanent library using a libname statement. The libname statement will look something like this:

There are three parts to this command. The first part is the keyword "libname" which tells SAS you want to define a new library. The second part, "myownlib" is the name that SAS will use to refer to this library. This is called the libref. You can supply any name you like here, as long as it meets the guidelines for allowed names, which are: you can use letters, numbers, and underscores, but can't start with a number. A libref can only be eight characters long, though SAS variable names can be up to 32 characters. The third part of the statement is the pathname (DOS style) showing the actual location of the folder or directory you want to use. It is enclosed in quotes (single or double). On some Windows systems, 'Desktop' and 'My Documents' can be used and will automatically be assigned to the correct path. 'A:' usually works to assign the floppy drive, but only if there is a disk in the drive (applies to any removable volume). Note: The libname statement does not create a folder. It essentially creates a shortcut or alias to an existing folder. We call the library "permanent" because the data is not deleted when SAS closes, but the libref itself will normally have to be recreated in future SAS sessions.

The illustration below shows the SAS Explorer pane (from the left side of the SAS window, note the tab at the bottom) displaying the currently defined libraries. Some of these libraries are standard in SAS. The one called "Rao" has been created with a libname statement. Note that "Work" is explicitly listed.

If you double-click the "Work" file drawer, the data sets in "Work" become visible. The spreadsheet icon in the example below represents a data set named "One." If you double-click on "One" it will open in a "Viewtable," a spreadsheet-like view.

The viewtable has two modes, "Edit" and "Browse." In browse mode, you cannot change the data. To switch modes, go to the "Edit" menu and select the mode you want. A new data set can be created by selecting "Table Editor" under the "Tools" menu.

(Note: In order to go back to previous windows in the explorer pane, you press the folder with the up arrow on it. But this will disappear if the "Explorer" is not the active window. Click on the "Explorer" window to bring it back.)

(Note: There is also another "Explorer" under the "View" menu. This opens a window much like a Windows Explorer.)

When you create a SAS data set, you give it a name, such as "One" in the example above. Names can contain letters, numbers, and underscores, but cannot start with a number. They can be up to 32 characters long. You can refer to a data set in the work directory by its name alone, because that is the default location. But data sets are actually identified by “two-level names,” where the library is given first, followed by a dot, then the dataset name. In other words, the form is libref.datasetname. Since work is the default library, datasetname alone is equivalent to work.datasetname. In order to store a dataset permanently, specify a two-level name, with a first level being a defined libname other than work.

In rare cases, you may want to change the default library to something other than work. To do this, use the special libref "user" (libname user 'C:\folder1\myfolder';). This allows you to use a one-level name with a permanent library that you specify. It does not change which libraries are permanent and temporary. To create temporary data sets when the default library has been changed, use a two-level name with "work" in the first position.

There is also a way to export data in some common file formats. See "File-->Export Data."

In Enterprise Guide, the datasets appear in the project tree under the code that created them. They will be saved when you save your project. (But when you run code you may get a choice of whether or not to replace the existing data. This may affect what is saved in the project.)

Getting Data Into SAS

Most of the time, when you begin working on a project in SAS, your data will not be in a SAS data set. In order for SAS to perform analysis tasks, the data will be need to be brought into a SAS data set. Because data may come in so many different forms, SAS is very flexible and provides a variety of ways to do this. We will keep our first examples simple, but be assured that SAS can handle very complex data reading tasks!

The simplest way to get data into a SAS data set is using “instream data.” This means the data is included “in the stream” of the programming statements that will load it. Here is an example. An explanation of the program follows.

The first two lines are comments. A comment is simply text inserted into computer code that the programming language will ignore. Comments are often used to explain what is happening in the program (for others or for future reference). Sometimes they are used to temporarily disable some statements in the program. Sometimes they are used to "beautify" or enhance the readability of the program. In SAS, there are two ways to write comments. A statement that begins with an asterisk and ends with a semicolon is a comment. This type of comment will only work for one statement at a time. If a larger section of a program is to be commented, that is, multiple statements in one group, you can use "/*" to begin the comment and "*/" to close it. Even semicolons are ignored by this syntax.

The third line contains a libname definition. The library will be called “mysaslib” and the actual folder location on your computer is given in the quote marks.

The fourth line begins with the keyword "data," which tells SAS this is the beginning of a data step. We can see by the two-level name that the dataset will be called “myfirst” and will be stored in the “mysaslib” library.

The fifth line, the input statement, tells SAS what variables to put into the data set. Each variable name may need to be followed by a code that tells SAS what kind of variable it is and how to read it. These codes are called informats. However, there is a default for this, called "standard numeric," which is just an ordinary number in decimal form, with no commas. Since "age" fits this description, we do not have to include an informat for it. On the other hand, "name" is a character variable. The "$" tells SAS to read "name" as character variable eight characters long. Character variables have no numeric value, and can contain letters, numbers, and most other symbols. They are also known as "strings."

The “cards” statement tells SAS that the list of data to read is coming next ("datalines" and "lines" may be used as synonyms for "cards"). The data are organized in a straightforward way. Each observation is on one line and the variable values are separated by spaces. This is called “list input.” A semicolon on a line by itself indicates the end of the data. (The data are not program statements, so there are no semicolons in the data list.)

In addition to comments, we can use indenting to make our programs more readable. For example, the statements under a data or proc statement can be indented to make the the steps look like an outline. Data given in cards should be placed along the margin, though.

Next, SAS encounters a proc statement, and will therefore compile and execute the data step before going on. The dataset “myfirst” is now created and populated with three observations.

SAS continues by compiling the proc step, which consists of only the “proc print” statement. Without any other commands specified, this will cause the default action of printing the most recently created data set, which, of course, is “myfirst.” Print does NOT mean "print to the printer." Proc print produces a formatted "printout" of the data set in the output window. You can save or print (really) this output using File Menu commands. The result looks like this:

In case you do not want to use the default (last created) data set, or just want to your program to be more obvious to the reader, you can specify the data set that proc print will use this way:

Using Titles

SAS provides several ways to modify the appearance of the output it produces. Notice that in our example the heading "The SAS System" together with the time, date, and page number appear at the top of the page. "The SAS System" is the default page title. You can supply your own titles by using title statements, as shown here:

You can have multiple lines of titles. Just add more title statements with higher numbers. Title statements are global; they don't belong to a particular proc and are in effect until changed or deleted. Redefining a title deletes all previously defined titles of that number or higher. To delete a title without replacing it, just include a blank title statement, like "title3;" . This will delete the old title3, as well as title4 or any other higher-numbered titles.

Producing HTML (web page) output

Both PC SAS and Enterprise Guide can produce HTML or text output. Enterprise Guide displays HTML by default:

Pretty, isn't it? To get HTML in PC SAS, you can go to "Tools-->Options-->Preferences," click the "Results" tab, then check "Create HTML."

<<Previous|Contents|Next>>

Exercises

Submit one Word document with all answers either typed in or copied in.

1. Indicate which of the following are valid names for variables and librefs (two questions).

sales
SALES
Sales
Sales.12
Sales.Month.12
12MonthSales
Month12Sales
More_Sales
More&More
Moore_and_Moore
Month12
_Month12_

2. If a database has a table with 500 records and 14 fields, how many observations and variables would a SAS dataset containing the same information have?

3. If a spreadsheet had 5 columns and 4 rows, how many observations and variables would a SAS dataset containing the same information have?

4. Looking at the screen print below, answer the following questions:

Is this a temporary or permanent data set?
How many observations are there?
How many variables are there?
How many records are there?
How many fields are there?
How many rows are there?
How many columns are there?

5. Copy the data below into the SAS editor (use copy and paste) and write a data step to read it, followed by a proc step to print it (to the output window). Make sure the printout matches the original data. The variables are Name, Age, and Grade. Age and Grade are to be read as numeric variables. Allow the data to be saved to the work directory. (Submit Program, Log, and Output.)

Marissa 13 7
Andy 7 1
Martha 9 3
John 10 4
Larry 11 6

6. Copy the following data into the SAS editor and write a data step to read it into a data set. Print the results in html format. The variables are Field, Fertilizer, and Variety. Submit the Program, Log, and the html output instead of the normal output.

1 A Magnus
2 B Arbin
3 A Carver
4 B Visser
5 A Turnip
6 B Danun

7. Create a libref for a folder on your hard drive and another for a floppy disk. (If you don't have a floppy disk, you may use a pen drive). Modify the program in problem 5 so that the data set is saved in each location. Use the explorer window and the viewtable to verify that it is actually there. (Submit your program and log for this problem.)

8. Submit only the program statements (editor) for this problem. Note that to "reference a data set" means to tell a proc, like proc print, which data set to use.

Write a libname statement that assigns the name "SaleData" to a library that corresponds to folder on the C drive with the same name. Then show how you would reference a data set called "January" in that folder.
Write a libname statement that makes the folder in part a the default library and show how you would reference the data set "January" in that folder. Show how you would now reference a temporary dataset called "February".

SAS Windows

2012-09-02T11:16:00.002+05:30

SAS Windows
PC SAS is a Windows GUI for running SAS.  When you open the program, you will notice three windows (probably overlapping) called “Editor,” “Log,” and “Output.”  An example appears below. The windows have been arranged so you can see them all.

The editor window is used to write programs.  Text output will appear in the output window, and the log window will contain error messages and other program execution information.  The typical process is to type a program in the editor, then submit it (running man icon) and look at your log and output results. After a program has been submitted, it remains in the editor, so you can make modifications and submit it again.
You can save your programs and open previously saved programs from the file menu. However, the "Save" command will apply to the active (top) window. You can save editor, log, or output files, accordingly. An extension of .sas, .log, or .lst (respectively) will be added automatically unless you supply some other extension. (Using .txt may be helpful if you intend to open the file with Notepad or a word processor, but most of the time it is best to stick with SAS's defaults.) There is one little catch you should remember: In order to open a saved program, an editor window must be active when you select "Open" from the file menu. If you have closed your editor window, you must first open a new one by selecting "Enhanced Editor" from the "View" menu, then proceed to the "File-->Open" dialog..
If you have font problems (incorrect characters) when you open an output file in a word processor, try changing the font to "SAS Monospace." This should work if you are on a computer with SAS installed. If SAS is not installed, you may not be able to get all of the characters correct, but any monospace font, like Courier, will straighten out most of the formatting.
Take a look at the program statements in the editor window. Notice that each line ends with a semicolon . SAS uses semicolons to define the end of a statement. It doesn't matter how the text is arranged, whether there are extra spaces, indentions, extra lines, multiple statements on a line, or statements split across lines. Such formatting can, and should, be used to enhance readability for humans, but to SAS all that matters is where the semicolons are.
Enterprise Guide is a new environment for running SAS. Although the same programs work and produce similar results, there are some differences in the appearance and behavior of the interface. If you purchase the "SAS Learning Edition," this is the interface that will be presented after it is installed. An example appears below. In Enterprise Guide, your work is organized into projects, which appear in a collapsible tree structure on the left. The three windows mentioned above do not open automatically. In order to type in a program, you open a code window which replaces the editor. Output windows open as needed when programs run, but not necessarily automatically. Output, log, and code windows (also datasets) can be opened by double-clicking icons in the project tree. The contents do not accumulate in the log and output windows as they do in PC SAS. When you submit a program, you have the choice of overwriting previous output or starting a new node in the project tree. This keeps your results more organized. Note, the "running man" icon that is used for "submit" in the old version is replaced by a sheet of paper with a down-arrow beside it.
You can use the regular interface described under "PC SAS" with Learning Edition, but you have to find the sas.exe file in the program files directory. Make a shortcut to this file and place it on your desktop to use for starting SAS.

Help
When you need more information about making SAS do what you want, there are several sources you can access. The first is the "Help" facility installed on your computer and found at the right end of the menu bar. Unfortunately, because SAS is a huge and powerful product, the help can be a challenge to navigate. The appearance and content of your help menu may vary depending on the version of SAS you are working with. The examples here use version 9.1.3. Under "Help," select "SAS Help and Documentation." Then you should see a window like this:

Click on the plus sign by SAS Products and the tree opens like this:

There is an important lesson right here in looking at this list in help. SAS is not just one program. It is a system of interconnected modules ("products"). In some ways it is like Microsoft Office, which has a number of components like Word, Excel, PowerPoint, etc. The list you see under "SAS Products" is not necessarily all of them, and you do not necessarily have all those listed available to you. In this course, we will only be dealing with a few of them, and most of the time, we will be in "Base SAS." Click the plus sign by "Base SAS" and you will see:

Again we have a long list of choices. The challenge is to learn where to look for the information you need, because there is simply so much that it can easily cause "information overload." As you begin learning, the most helpful sources of information will be under "SAS Command Reference," "SAS Procedures," or "SAS Language Dictionary." Spend some time looking around in "Help" and familiarizing yourself with what is there. Notice that there are also index and search facilities. Unfortunately, these often return too many "hits" from modules other than those you are interested in. Thus, there is no substitute for learning to navigate the help tree!
SAS also provides SAS OnlineDoc 9.1.3 for the Web which is similar to the help but may be more up-to-date. In fact, you can download it in PDF form and print whatever you want. The Online version has a search facility which allows you to restrict your search to a particular module or procedure. In some cases this can be extremely helpful for avoiding unwanted hits.
Program Organization
A statement in SAS is sort of like a complete sentence (although the analogy won't extend as far as having a subject and verb) or a single command. Every statement must end with a semicolon, which signals the end of a command. Inside a statement you will find such things as keywords , options , and user-supplied names . SAS is pretty flexible in its ability to interpret words within a statement. For example, you can separate words with spaces, tabs, or returns--any white space will be treated the same way. You can split statements across multiple lines or put multiple statements on one line. We will try to develop a style that is easy to read and follow by using indentation and comments. SAS is also forgiving, in that it tries to figure out things that might be mistakes. For example, you can put two statements together without a space, because as long as a semicolon is there, SAS can tell where one ends and the next begins.
SAS is designed for data analysis, so programs are organized into “ steps ” that correspond roughly to steps you go through in analyzing data.  However, these steps are not just a matter of programming style. They are blocks of code that SAS treats as a whole. Some information is passed from one step to the next, but you should think of steps as independent units.
There are data steps and proc steps .  The main purpose of data steps is to create data sets.  Proc steps may perform analysis tasks or other actions. Every data step begins with the keyword "data" and every proc step begins with the keyword "proc." (How logical is that?) A " run " statement can signal the end of a step (we will deal with exceptions later) and triggers execution of statements preceding it. A step always ends when another statement that begins with "data" or "proc" is encountered, signaling a new step. Most of the time there must be a "run" statement at the end of a program or the last step will not be executed. Some procs also require a " quit " statement in order to stop them completely.
Some commands are called " global statements " because they are not really part of a step. Some examples are "options," "title," and "libname" statements, which will be described later. The effects of these commands typically hold across many steps.
We should understand the flow of events after a program is submitted. In most cases, SAS first reads all the commands in a step, checks them for errors, then executes the instructions before going on to the next step. If errors are found, SAS writes error messages and warnings to the log. If there are serious errors, SAS will not execute the statements in the step. If another step follows, SAS will go on and try to run the next step. This may produce unexpected results if a later step depends on output from a previous step that had errors. So, errors do not always cause SAS to stop reading and executing code. This is why it is important to ALWAYS CHECK THE LOG . You may get output that looks fine, but was produced in spite of errors that caused the results to be wrong!
A step could be just one line of code, but it could also be many lines.  The program shown below has four steps. Each begins with a keyword, either "data" or "proc," and ends with a run statement (even though it is redundant to place a "run" before another data or proc step, it turns out to be useful in some cases). Don't worry about the meaning of the other statements right now, but study the structure of the steps. Note how the editor separates the steps with horizontal lines and adds color codes to various elements of syntax.

Incidentally, SAS has two editors. The one that opens by default in PC SAS is the "Enhanced Editor." We may explore uses of the other editor later, but for now we'll stick to this one. If you ever need to open another editor window (such as if you have closed one, or you want to have two programs showing at once), choose "Enhanced Editor" rather than "Program Editor" in the "View" menu.

<<Contents|Next>>

Exercises:

The following may be copied into a word processing document, which may be edited to answer the questions and then submitted. There is no need to run SAS programs for these exercises.

1. How many steps are there in the following program? Mark the beginning and end of each step and label it as a data or proc step.

data one;
do x=1 to 1000;
y=int(ranuni(0)*6+1);
output;
end;
run;
proc freq;
tables y;
data two;
set one;
z=7-y;
run;
proc freq;
tables z;
run;

2. Suppose the program above was modified so that an error occurred in the second step. What would probably happen when SAS tried to process the remaining steps? (Be sure you have #1 right!)

3. Find three errors in the following program, based on the information in this lesson. (Assume there are no statements split across multiple lines.)

data thirsty;
infile "c:\drinkexp.txt"
input subject brand rating;
procprint;run;
data two;
set one;

A Simple Example

2012-09-02T11:04:00.002+05:30

A Simple Example

Before getting started on the technical details of SAS programming, we'll look at a simple example.
When you open SAS, you will see something similar to the picture below. The three windows on the right, Log, Output, and Editor, will most likely be overlapping. Here they have been arranged so you can see them all. Below these windows there is a task bar with buttons that allows easy switching between windows. The log contains a record of what SAS does, together with error messages and other information. At this point there is already some information in the Log relating to the startup process. On the left, you see a pane called Explorer. Notice there are tabs at the bottom. This pane can be switched between Explorer and Results.

Now suppose we have some data on course grades and percent attendance, as follows:
89 90
98 95
76 80
64 55
85 100
93 95
88 95
79 65
72 85
Let's analyze this data.
First, we have to get the data into SAS. Here's a way to do it:

This SAS program will create a dataset called "grades" with two variables called "grade" and "attend." There are nine observations. Type this program into the editor, then submit it by clicking the "running man" icon in the toolbar. The log will show some notes about the creation of the dataset.

This is the only result you can immediately see from running this program. It doesn't produce any output, it just creates a dataset. It is important to check the log when running a program like this, or you may not know if it has run correctly.
The existence of the dataset can also be verified by looking at the explorer pane on the right. Double-click the file-cabinet icon called Libraries, then the file-drawer icon called Work. You will see a spreadsheet-like icon called "Grades." You can also double-click this icon to open a spreadsheet view of the data.

Now that we have data in SAS, what can we do with it? Lots of things, of course! But this is a simple example. We will demonstrate two of the most commonly used procs (procedures) in SAS. The first is proc print. This will produce formatted output with headings, page numbers, page breaks, and so forth, suitable for printing. It doesn't actually send the output to the printer, but displays it in the output window. The second is proc plot, which is used for producing simple scatterplots of two variables. The commands for these procedures are shown below, together with the commands that create the dataset.

The results of proc print and proc plot will be shown in the output window, and will look something like this (examples here are modified to reduce the size):

That's the end of our simple example. Now we're ready to begin in earnest!

What is SAS? Who is SAS?

2012-09-02T10:52:00.000+05:30

What is SAS? Who is SAS?
SAS is produced by the SAS Institute in Cary, NC. It is the most powerful and comprehensive statistics software available. We should avoid calling SAS a "program," since we write "programs" in SAS. But it is also not appropriate to refer to SAS as a "language" like C++, Fortran, etc. SAS actually contains several computer languages within it. Even "application" doesn't seem to fully describe SAS, so maybe we should just use the term SAS gives itself at the top of its output, "The SAS System."
In 1976 the SAS Institute came out with its first software, a mainframe-based statistical analysis software package. Since then, SAS has enjoyed phenomenal growth. Its software is available for all the major platforms, and has grown beyond statistics to a variety of data management and business applications. To read more about SAS, see their website at www.sas.com. A history timeline is given here.
SAS is also a community. Users groups (SUGI, NDSUG, RRVSUG) provide opportunities to interact with other SAS enthusiasts, hold conferences and publish articles about SAS programming techniques. There is even an annual SAS ballot, in which users can vote for the changes and enhancements they would like to see SAS work on.

Starting With Sas

2012-09-02T10:49:00.001+05:30

SAS Tutorial
Contents
Chapter 0: Introduction
Goals
What is SAS? Who is SAS?
A Simple Example
Homework Guidelines
--------------SAS Programming I---------------
Chapter 1: Elementary Data Step Techniques
Lesson 1:  Introduction to PC SAS
Lesson 2:  Data Sets and Libraries
Lesson 3:  Appearance, Infile, Labels and Informats
Lesson 4:  Numeric Formats and Informats
Lesson 5:  Input styles
Lesson 6:  Creating Variables
Lesson 7:  Data Set Options, Set and Merge
Chapter 2: Common SAS Procedures
Lesson 8:  Proc Print and Proc Sort, with Introduction to ODS
Lesson 9:  Proc Rank, Proc Contents, and Proc Format
Lesson 10:  Proc Univariate and More About ODS
Lesson 11:  Proc Means and Proc Freq
Lesson 12:  Proc Chart, Proc Plot, and Proc Corr
Lesson 13:  Proc Reg
Lesson 14:  Proc Transpose and Proc Report
Chapter 3: Advanced Data Step Techniques
Lesson 15:  Tabs and Other Delimiters
Lesson 16:  Multiple Lines, Multiple Observations
Lesson 17:  Generating Random Data
Lesson 18:  Using Arrays to Program With Variables
Lesson 19:  Project Yahtzee Simulation
Lesson 20: Data Null
Chapter 4: Advanced Programming
Lesson 21:  SQL
Lesson 22:  Macro
Lesson 23:  Introduction to SAS Graph
Chapter 5: Menu Driven Interfaces
Lesson 24:  Analyst & Insight
-------------------SAS Programming II--------------------
Video Introduction
Chapter 6: IML
Lesson 25:  Introduction to IML
Lesson 26:  Data Sets and Subscripts
Lesson 27:  Headers, Do Loops, and Sampling
Lesson 28:  SAS Data Sets and Matrices
Lesson 29:  Modules
Chapter 7: Simulations
Lesson 30:  First Simulation
Lesson 31:  Simulating Power and Significance
Lesson 32:  Power and Regression
Lesson 33:  A Binomial Problem
Lesson 34:  Bootstrap for Model Selection Frequencies
Lesson 35: Bootstrap II
Lesson 36:  Bootstrap III
Lesson 37:  Bootstrap IV
Chapter 8: ODS
Lesson 38:  Creating Excel files and traffic lighting
Lesson 39:  Ods Graphics in Proc Reg
Lesson 40:  Ods Document and Proc Document
Chapter 9: SAS Graph
Lesson 41:  Review of SAS Proc Gplot
Lesson 42:  Proc Gplot and Proc Gchart
Lesson 43:  Proc G3D and Proc Contour
Lesson 44:  Proc G3D and Proc Contour