Statistical Consulting Seminars: Introduction to SPSS Statistical Computing Seminars
Introduction to SPSS Syntax
NOTE: This seminar was created using SPSS version 21. Some
of the syntax shown below may not work in earlier versions of SPSS.
Here is the link for downloading the syntax file associated with this seminar.
- The SPSS syntax shown in this seminar.
Introduction
The purpose of this seminar is to demonstrate the use of commands that are
useful for managing data in SPSS. Rather than going through each of the
commands in turn and discussing the options available, we are going to focus on
a series of short tasks. Some of these tasks may be similar to things that
you need to do in your work, and other tasks may seem unfamiliar.
Furthermore, we have tried to keep the tasks simple, perhaps too simple, so that
no more than a few commands are needed to accomplish each task. You should
think about different ways that these commands can be combined to do more
complex tasks.
Let’s start by reading in our example dataset. Notice
that this syntax will generate many errors in the output window, but the data
are read into SPSS correctly.
data list list / q1 to q5. begin data. 3 3 . . 2 2 2 -9 . 1 3 1 2 . 3 4 1 2 . -9 -8 1 3 . 2 -8 2 1 . -9 3 -9 4 . 2 4 4 2 . 3 1 1 1 . 1 2 -9 3 . 2 3 3 2 . 5 3 1 1 . 3 -9 4 4 . 2 . 2 4 . 1 2 3 1 . 4 end data. dataset name example_data. missing values q1 to q5 (-8 -9).
Counting the cases in the dataset (unique identifier)
You can create a variable that uniquely identifies each case in your data by
using the system variable $casenum. We also use the formats
command to format all of the variables in our dataset such that they have a
length of 5 and no decimal places. This is done just for esthetics.
compute id = $casenum. formats q1 to id (f5.0). exe. list.
q1 q2 q3 q4 q5 id
3 3 . . 2 1
2 2 -9 . 1 2
3 1 2 . 3 3
4 1 2 . -9 4
-8 1 3 . 2 5
-8 2 1 . -9 6
3 -9 4 . 2 7
4 4 2 . 3 8
1 1 1 . 1 9
2 -9 3 . 2 10
3 3 2 . 5 11
3 1 1 . 3 12
-9 4 4 . 2 13
. 2 4 . 1 14
2 3 1 . 4 15
Number of cases read: 15 Number of cases listed: 15
Another way to do this is to use the create command with the
csum (cumulative sum) function.
compute id1 = 1. create id1 = csum(id1). list.
q1 q2 q3 q4 q5 id id1
3 3 . . 2 1 1
2 2 -9 . 1 2 2
3 1 2 . 3 3 3
4 1 2 . -9 4 4
-8 1 3 . 2 5 5
-8 2 1 . -9 6 6
3 -9 4 . 2 7 7
4 4 2 . 3 8 8
1 1 1 . 1 9 9
2 -9 3 . 2 10 10
3 3 2 . 5 11 11
3 1 1 . 3 12 12
-9 4 4 . 2 13 13
. 2 4 . 1 14 14
2 3 1 . 4 15 15
Number of cases read: 15 Number of cases listed: 15
Taking a simple random sample
There are many reasons that you might want to take a simple random sample,
and there are several ways to do it. We will look at several ways to
accomplish this task.
In this example, we create a random variable (called ran_num) using
the uniform function. Next, we sort the cases in our dataset by
this random number.
set seed 156323669. compute ran_num = uniform(100) + 1. sort cases by ran_num. list id ran_num.
id ran_num
11 4.26
2 29.61
5 34.19
3 49.33
7 54.73
1 55.23
14 55.50
10 58.89
6 60.18
15 75.17
13 78.63
9 88.11
8 89.81
4 98.89
12 100.70
Number of cases read: 15 Number of cases listed: 15
We can now use one of three commands to keep the desired number of cases.
In this example, we will keep 6 cases. When we use the sample
command, we will need to explicitly set the seed before each call to the command
so that our results are reproducible.
temporary. select if $casenum le 6. list id ran_num.
id ran_num
11 4.26
2 29.61
5 34.19
3 49.33
7 54.73
1 55.23
Number of cases read: 6 Number of cases listed: 6
temporary. n of cases 6. list id ran_num.
id ran_num
11 4.26
2 29.61
5 34.19
3 49.33
7 54.73
1 55.23
Number of cases read: 6 Number of cases listed: 6
set seed 822916. temporary. sample .4. list id ran_num.
id ran_num
5 34.19
1 55.23
14 55.50
15 75.17
13 78.63
9 88.11
Number of cases read: 6 Number of cases listed: 6
set seed 822916. temporary. sample 6 from 15. list id ran_num.
id ran_num
5 34.19
1 55.23
14 55.50
15 75.17
13 78.63
9 88.11
Number of cases read: 6 Number of cases listed: 6
Notice the difference when you add an execute command before the
list command.
set seed 822916. temporary. sample 6 from 15. exe. list id ran_num.
id ran_num
11 4.26
2 29.61
5 34.19
3 49.33
7 54.73
1 55.23
14 55.50
10 58.89
6 60.18
15 75.17
13 78.63
9 88.11
8 89.81
4 98.89
12 100.70
Number of cases read: 15 Number of cases listed: 15
Creating a random identification variable
In this example, we will use the rv.normal function to create a
variable with random values. To use this function, you need to specify the
mean and standard deviation.
set seed 1856256. compute ran_num1 = rv.normal(100, 10). desc var = ran_num1.
sort cases by ran_num1. list id ran_num ran_num1.
id ran_num ran_num1
11 4.26 84.96
14 55.50 86.56
5 34.19 91.00
4 98.89 92.44
15 75.17 94.28
1 55.23 95.85
7 54.73 96.50
13 78.63 99.93
3 49.33 101.80
10 58.89 102.75
6 60.18 104.17
8 89.81 105.59
12 100.70 107.63
9 88.11 114.63
2 29.61 122.04
Number of cases read: 15 Number of cases listed: 15
Numbering groups consecutively
Sometimes you need to make a grouping variable, but you want to be sure that
the values are consecutive. To do this, you can use a scratch variable.
A scratch variable is a temporary variable that will not appear in your active
dataset. It exists only between procedures and is discarded when the new
procedure begins. The name of a scratch variable always starts with #, and
a scratch variable can be either string or numeric. Scratch variables
initialize to 0 for numeric variables and to a null string for string variables.
Also, they are not reinitialized for each case; rather, they keep their current
value when the next case is read. In this sense, they are equivalent to
using the leave command.
Let’s look at a simple example. We will make a new variable called x
that will be the group number (assuming that the values of a are sorted such
that a value of 1 for the variable a indicates a new group).
data list list / a. begin data. 1 2 3 1 2 3 4 1 2 3 4 5 6 1 2 1 2 3 end data. dataset name scratch. compute #x = #x + 1. if a ne 1 #x = lag(#x). compute x = #x. exe. list.
a x
1.00 1.00
2.00 1.00
3.00 1.00
1.00 2.00
2.00 2.00
3.00 2.00
4.00 2.00
1.00 3.00
2.00 3.00
3.00 3.00
4.00 3.00
5.00 3.00
6.00 3.00
1.00 4.00
2.00 4.00
1.00 5.00
2.00 5.00
3.00 5.00
Number of cases read: 18 Number of cases listed: 1
The equivalent syntax using the leave command is below. We will
discuss the leave command shortly.
if a ne lag(a) x1 = 0. compute x1 = x1 + x. leave x1. exe. list.
Creating an index number
We will start be reading in a new dataset. We will use this dataset
later in the presentation.
data list list / id famid * kidname (A5) birth age wt * sex (A1). begin data 1 1 Beth 1 9 60 f 2 1 Bob 2 6 40 m 3 1 Barb 3 3 20 f 4 2 Andy 1 8 80 m 5 2 Al 2 6 50 m 6 2 Ann 3 2 20 f 7 3 Pete 1 6 60 m 8 3 Pam 2 4 40 f 9 3 Phil 3 2 20 m end data. dataset name long_to_wide. list famid kidname age.
famid kidname age 1.00 Beth 9.00 1.00 Bob 6.00 1.00 Barb 3.00 2.00 Andy 8.00 2.00 Al 6.00 2.00 Ann 2.00 3.00 Pete 6.00 3.00 Pam 4.00 3.00 Phil 2.00 Number of cases read: 9 Number of cases listed: 9
compute index1 = 1. if famid = lag(famid) index1 = lag(index1) + 1. exe. list famid index1 kidname age.
famid index1 kidname age 1.00 1.00 Beth 9.00 1.00 2.00 Bob 6.00 1.00 3.00 Barb 3.00 2.00 1.00 Andy 8.00 2.00 2.00 Al 6.00 2.00 3.00 Ann 2.00 3.00 1.00 Pete 6.00 3.00 2.00 Pam 4.00 3.00 3.00 Phil 2.00 Number of cases read: 9 Number of cases listed: 9
Creating a flag variable for complete cases
Sometimes it is useful to know how many cases in your dataset have all valid
values, or, in other words, no missing values. You can create a flag
variable, which is a binary variable, that is coded 1 for cases that are
complete and 0 otherwise.
dataset activate example_data. compute comp_flag = 1. if missing(q1) or missing(q2) or missing(q3) comp_flag = 0. value labels comp_flag 0 "has at least one missing value" 1 "complete case" . exe. freq var = comp_flag.
list q1 q2 q3 comp_flag.
q1 q2 q3 comp_flag
3 3 2 1.00
. 2 4 .00
-8 1 3 .00
4 1 2 1.00
2 3 1 1.00
3 3 . .00
3 -9 4 .00
-9 4 4 .00
3 1 2 1.00
2 -9 3 .00
-8 2 1 .00
4 4 2 1.00
3 1 1 1.00
1 1 1 1.00
2 2 -9 .00
Number of cases read: 15 Number of cases listed: 15
Now we can find out how many valid and missing values each row in the dataset
has. We will use the nvalid and nmissing functions to create
these two new variables.
compute nvalid = nvalid(q1, q2, q3). compute nmissing = nmissing(q1, q2, q3). list q1 q2 q3 comp_flag nvalid nmissing.
q1 q2 q3 comp_flag nvalid nmissing
3 3 2 1.00 3.00 .00
. 2 4 .00 2.00 1.00
-8 1 3 .00 2.00 1.00
4 1 2 1.00 3.00 .00
2 3 1 1.00 3.00 .00
3 3 . .00 2.00 1.00
3 -9 4 .00 2.00 1.00
-9 4 4 .00 2.00 1.00
3 1 2 1.00 3.00 .00
2 -9 3 .00 2.00 1.00
-8 2 1 .00 2.00 1.00
4 4 2 1.00 3.00 .00
3 1 1 1.00 3.00 .00
1 1 1 1.00 3.00 .00
2 2 -9 .00 2.00 1.00
Number of cases read: 15 Number of cases listed: 15
Finding duplicate pairs
We will use the lag function to help us find duplicate pairs in our
dataset. Let’s assume that we have a group of people, and everyone is
asked to list one friend in the group. Your task is to find all of the
groups of friends, but you realize that if Person A picked Person B, and Person
B picked Person A, you would have the same pair of friends listed twice.
Our task is to find those duplicate pairs.
For this task, we will use an example dataset that has identification
variables that are in string format. We will then make numeric versions of
these variables. We will need both the string and numeric versions to
complete this task. Of course, you could just as easily start with numeric
variables and make string versions of them.
data list list / sid1 (A3) sid2 (A3). begin data. 110 210 514 856 210 110 210 111 693 246 end data. dataset name duplicates. recode sid1 (convert) into nid1. recode sid2 (convert) into nid2. string pairid (A6). if (nid1 lt nid2) pairid = concat(sid1, sid2). if (nid1 gt nid2) pairid = concat(sid2, sid1). sort cases by pairid. compute flag = 0. if pairid = lag(pairid) flag = 1. value labels flag 0 "not duplicate" 1 "duplicate". exe. list.
sid1 sid2 nid1 nid2 pairid flag 110 210 110.00 210.00 110210 .00 210 110 210.00 110.00 110210 1.00 210 111 210.00 111.00 111210 .00 693 246 693.00 246.00 246693 .00 514 856 514.00 856.00 514856 .00 Number of cases read: 5 Number of cases listed: 5
Comparing datasets
Sometimes you need to compare two datasets, such as when data have been
double-entered. We can use the compare datasets command to do this.
This command was introduced in SPSS version 21. Let’s enter two small
example datasets that have only one difference (in the first row). Note
that both datasets need to be sorted in ascending by variable listed on the
caseid subcommand. A new variable called casescompare will be
added to the active dataset. This new variable can have three values:
-1 means unmatched, 0 means matched and 1 means mismatch.
data list list / id var1 var2 var3. begin data 1 1 2 3 2 4 5 6 3 7 8 9 end data. dataset name filea. data list list / id var1 var2 var3. begin data 1 1 2 10 2 4 5 6 3 7 8 9 end data. dataset name fileb. dataset activate filea. compare datasets /compdataset fileb /variables = all /caseid id. freq var = casescompare.
In our next example, we will create two small datasets that have the same
data values but different variable labels.
data list list / id var1 var2 var3. begin data 1 1 2 3 2 4 5 6 3 7 8 9 end data. variable labels var1 "This is the first variable.". dataset name filec. data list list / id var1 var2 var3. begin data 1 1 2 3 2 4 5 6 3 7 8 9 end data. missing values var1 (99). dataset name filed. dataset activate filec. compare datasets /compdataset filed /variables = all /output varproperties = all /caseid id.
Updating datasets
Sometimes it is necessary to put updated values into a dataset. This
can be done with the update command. This command is not for adding
new variables or new cases (although you can add new cases with this command).
The dataset with the original data is called the master dataset, and the dataset
with the updated values is called the transaction dataset. Both the master
and the transaction datasets must be sorted on the key variable (or variables),
which are listed on the by subcommand. The values in the
transaction dataset will replace those in the master dataset.
data list list / id m1 m2 m3 m4 female. begin data 1 25 36 41 56 0 2 26 31 49 55 1 3 22 33 44 56 0 4 17 37 41 59 1 5 23 35 48 54 0 6 29 39 41 51 11 end data. dataset name master. data list list / id m1 m2 m3 m4 female. begin data 4 27 37 41 59 1 6 29 39 41 51 1 7 28 32 45 52 0 end data. dataset name new_updates. dataset activate master. update file = * /file = new_updates /by id. list.
id m1 m2 m3 m4 female 1.00 25.00 36.00 41.00 56.00 .00 2.00 26.00 31.00 49.00 55.00 1.00 3.00 22.00 33.00 44.00 56.00 .00 4.00 27.00 37.00 41.00 59.00 1.00 5.00 23.00 35.00 48.00 54.00 .00 6.00 29.00 39.00 41.00 51.00 1.00 7.00 28.00 32.00 45.00 52.00 .00 Number of cases read: 7 Number of cases listed: 7
Creating a level-2 variable
If you have nested data (or data in long form), you may want to create a
level-2 variable. This is a variable that is the mean (or average) of
values within each level 2 unit. Let’s look at an example dataset.
data list list / id score1. begin data. 1 6 1 2 1 4 2 2 2 2 2 5 3 4 3 5 3 6 4 1 4 2 4 3 end data. dataset name level2. list.
id score1 1.00 6.00 1.00 2.00 1.00 4.00 2.00 2.00 2.00 2.00 2.00 5.00 3.00 4.00 3.00 5.00 3.00 6.00 4.00 1.00 4.00 2.00 4.00 3.00 Number of cases read: 12 Number of cases listed: 12
Now we can use the aggregate command to create our new variable, which
we will call ave_score. First, we need to sort our data by the
variable by which we want to “break” the data. You can think of this as
the grouping variable. The variable (or variables) by which you sort the
data will be listed on the break subcommand. There are many
functions that we can use to create new variables; we are going to use the
mean function.
sort cases id. aggregate /break id /ave_score = mean(score1). list.
id score1 ave_score 1.00 6.00 4.00 1.00 2.00 4.00 1.00 4.00 4.00 2.00 2.00 3.00 2.00 2.00 3.00 2.00 5.00 3.00 3.00 4.00 5.00 3.00 5.00 5.00 3.00 6.00 5.00 4.00 1.00 2.00 4.00 2.00 2.00 4.00 3.00 2.00 Number of cases read: 12 Number of cases listed: 12
Collapsing across observations (aggregating data)
Let’s take a closer look at the aggregate command, as it can be very
useful. As we saw in the example above, we can add one (or more) variables
to the active dataset. We can also create a new dataset with the
aggregate command. In this example, we will create a new dataset
called new.sav. This dataset will have only 2 cases because the
variable that we use on the break subcommand, comp_flag, has only
2 values.
dataset activate example_data. sort cases by comp_flag. aggregate outfile 'd:datanew.sav' /break comp_flag /aveq1 = mean(q1). get file 'd:datanew.sav'. list.
comp_flag aveq1
.00 2.50
1.00 2.86
Number of cases read: 2 Number of cases listed: 2
Now let’s create multiple new variables in a single call to the aggregate
command, and let’s use some other functions to make these new variables.
We will put the new variables into the active dataset, rather than creating a
new dataset. Some options that are commonly used (but not needed) are
included. We will also include variable labels for each new variable.
Before the aggregate command, we will create a two new variables to use
on the break subcommand. This is done only so that we have a
variable with a few more categories (which may make for a more realistic
example).
dataset activate example_data. compute gender = 0. if (mod($casenum, 2) = 1) gender = 1. compute bvar = 1. if $casenum gt 5 bvar = 2. if $casenum gt 9 bvar = 3. if $casenum gt 12 bvar = 4. exe. sort cases by gender bvar. aggregate outfile = * mode = addvariables /break gender bvar /sdq1 "standard deviation of q1" = sd(q1) /sumq1 "sum of q1" = sum(q1) /missq3 "unweighted number of system missing for q3" = numiss(q3) /pinq5 "percent of cases between values 2 and 4 for q5" = pin(q5, 2, 4). list gender bvar q1 sdq1 sumq1 q3 missq3 q5 pinq5.
gender bvar q1 sdq1 sumq1 q3 missq3 q5 pinq5 .00 1.00 -8 . 3.00 3 0 2 100.0 .00 1.00 3 . 3.00 4 0 2 100.0 .00 2.00 2 .00 4.00 3 1 2 50.0 .00 2.00 2 .00 4.00 -9 1 1 50.0 .00 3.00 4 .71 7.00 2 0 -9 100.0 .00 3.00 3 .71 7.00 2 0 3 100.0 .00 4.00 3 . 3.00 1 0 3 100.0 1.00 1.00 . . 3.00 4 1 1 66.7 1.00 1.00 3 . 3.00 . 1 2 66.7 1.00 1.00 -9 . 3.00 4 1 2 66.7 1.00 2.00 -8 . 3.00 1 0 -9 .0 1.00 2.00 3 . 3.00 2 0 5 .0 1.00 3.00 2 . 2.00 1 0 4 100.0 1.00 4.00 4 2.12 5.00 2 0 3 50.0 1.00 4.00 1 2.12 5.00 1 0 1 50.0 Number of cases read: 15 Number of cases listed: 15
The leave command
The leave command “tells” SPSS to leave (or retain) the current value
of the variable as it is, rather than reinitializing it when SPSS reads a new
case. This command also sets the initial value of a case to 0 rather than
system missing (for numeric variables, of course). The leave
command cannot be used with scratch variables. The leave command is
often used to make running (or cumulative) totals and with vectors. We
will see some examples of the use of the leave command with vectors later
in this presentation. As we have already seen, the create command
can also be used to make a cumulative total variable. Because the leave
command does not read the active dataset, it is less resource intensive that the
create command. This may be important if your dataset has millions
of cases.
In the first example, we will make a variable called rtotal that is
the running total of the variable total.
Because we have two groups in our example dataset, our new variable will be the
running total within each group. In the second example, we will make two
new variables. The first variable will be called id, and it will
simply count the number of cases in our example dataset. The variable
cumtotal_leave will be the running total (not broken out by group).
data list list / group total. begin data 1 100 1 150 1 125 1 100 2 200 2 250 2 225 2 200 end data. dataset name leave_group. sort cases by group. if group ne lag(group) rtotal = 0. compute rtotal = rtotal + total. leave rtotal. exe. list.
group total rtotal
1.00 100.00 100.00
1.00 150.00 250.00
1.00 125.00 375.00
1.00 100.00 475.00
2.00 200.00 200.00
2.00 250.00 450.00
2.00 225.00 675.00
2.00 200.00 875.00
Number of cases read: 8 Number of cases listed: 8
if missing(lag(total)) id = 0. leave id. compute id = id + 1. if missing(lag(total)) cumtotal_leave = 0. leave cumtotal_leave. compute cumtotal_leave = cumtotal_leave + total. list.
group total rtotal id cumtotal_leave
1.00 100.00 100.00 1.00 100.00
1.00 150.00 250.00 2.00 250.00
1.00 125.00 375.00 3.00 375.00
1.00 100.00 475.00 4.00 475.00
2.00 200.00 200.00 5.00 675.00
2.00 250.00 450.00 6.00 925.00
2.00 225.00 675.00 7.00 1150.00
2.00 200.00 875.00 8.00 1350.00
Number of cases read: 8 Number of cases listed: 8
Review: Three ways to make a running (or cumulative) total
We have seen three ways that you can make a running total variable:
using the create command, using scratch variables, and using the leave
command. Let’s look at these methods side-by-side.
dataset activate leave_group. create method1 = csum(total). if missing(lag(total)) #method2 = 0. compute #method2 = #method2 + total. compute method2 = #method2. if missing(lag(total)) method3 = 0. leave method3. compute method3 = method3 + total. list method1 method2 method3.
method1 method2 method3 100.00 100.00 100.00 250.00 250.00 250.00 375.00 375.00 375.00 475.00 475.00 475.00 675.00 675.00 675.00 925.00 925.00 925.00 1150.00 1150.0 1150.0 1350.00 1350.0 1350.0 Number of cases read: 8 Number of cases listed: 8
Do repeat loops
Do repeat loops are very useful for accomplishing repetitive tasks.
In our first example, we are going to make dummy variables (also known as binary
or indicator variables) from a nominal variable. In this example, we will
make dummy variables from the categorical variable race. First, we
will show how this can be done with multiple compute commands.
Next, we show how this can be done with a do repeat loop. As you
can see, if you have many categories, the do repeat loop will save you
lots of typing (and the potential for silly mistakes).
data list free / race. begin data 1 2 3 4 5 6 . -9 end data. missing values race (-9). dataset name making_indicators. * make dummies, method 1 . compute race1=(race=1). compute race2=(race=2). compute race3=(race=3). compute race4=(race=4). compute race5=(race=5). compute race6=(race=6). list.
race race1 race2 race3 race4 race5 race6
1.00 1.00 .00 .00 .00 .00 .00
2.00 .00 1.00 .00 .00 .00 .00
3.00 .00 .00 1.00 .00 .00 .00
4.00 .00 .00 .00 1.00 .00 .00
5.00 .00 .00 .00 .00 1.00 .00
6.00 .00 .00 .00 .00 .00 1.00
. . . . . . .
-9.00 . . . . . .
Number of cases read: 8 Number of cases listed: 8
* make dummies, method 2 . do repeat a=v1 to v6 /b=1 to 6. compute a=(race=b). end repeat. list.
race race1 race2 race3 race4 race5 race6 v1 v2 v3 v4 v5 v6
1.00 1.00 .00 .00 .00 .00 .00 1.00 .00 .00 .00 .00 .00
2.00 .00 1.00 .00 .00 .00 .00 .00 1.00 .00 .00 .00 .00
3.00 .00 .00 1.00 .00 .00 .00 .00 .00 1.00 .00 .00 .00
4.00 .00 .00 .00 1.00 .00 .00 .00 .00 .00 1.00 .00 .00
5.00 .00 .00 .00 .00 1.00 .00 .00 .00 .00 .00 1.00 .00
6.00 .00 .00 .00 .00 .00 1.00 .00 .00 .00 .00 .00 1.00
. . . . . . . . . . . . .
-9.00 . . . . . . . . . . . .
Number of cases read: 8 Number of cases listed: 8
In our next example, we will recode user-defined missing values to system
missing values.
data list list / var1 var2 var3 var4. begin data 1 2 3 4 -99 -88 4 5 -77 -99 6 2 5 9 6 8 end data. dataset name missing. do repeat v = var1 to var4. *if v le -77 v = $sysmis. if any(v, -99, -88, -77) v = $sysmis. end repeat. exe. list.
var1 var2 var3 var4
1.00 2.00 3.00 4.00
. . 4.00 5.00
. . 6.00 2.00
5.00 9.00 6.00 8.00
Number of cases read: 4 Number of cases listed: 4
In the example below, the values shown on the do repeat command
replace the values in the dataset. The print option on the end
repeat command displays the commands in the log file.
data list list / var1 var3 id var2. begin data 3 3 3 3 2 2 2 2 end data. do repeat v=var1 to var2 /val = 1 3 5 7. compute v = val. end repeat print. exe. list.
var1 var3 id var2
1.00 3.00 5.00 7.00
1.00 3.00 5.00 7.00
Number of cases read: 2 Number of cases listed: 2
Do if loops
The do if-end if structure is often used for executing multiple
transformations, such as with the compute, recode or count
commands.
The else if command is optional, and it can be repeated as many times
as it is needed. The else command is optional, and it can be used
only once and must follow any else if commands. The end if
command must follow any else if and else commands. You can
have as many nested do if-end if structures as you like, as long your
computer has the memory to support it. Procedures (including graphing
commands) cannot be used in the do if-end if structure. However,
the do if-end if structure can be used to define complex data file
structures (for reading data into SPSS).
When working with do if loops, you need to think carefully about how
control is passed from one command to another. For full details of this,
please see the SPSS Command Syntax Reference Guide in the section on do if-end
if. Basically, control (or the ability to change the value of a variable)
is passed from one command to the next based on the evaluation of the present
command being true, false or missing. If the logical expression is true,
the commands following do if are executed up to the next else if,
else or end if command. Then control passes to the next
command following the end if command. If the expression is false,
control passes to the following else if command. This will continue
until one of the logical expressions is true. As before, the commands
following that logical expression will be executed, and then control will then
pass to the first command after the end if command. If none of the
expressions are true on the do if or any of the else if commands,
the commands following else will be executed. If there is no
else command, the case will not be changed. If all of the conditions
are mutually exclusive, the choice between if and do if is a
matter of preference.
Notice that these two methods of making variable gives different results.
In the do if loop, the first case evaluates as true, so control is not
passed to the else if command; rather, control is passed to the first
command after end if, which is exe. Hence, the value of 1 for the
first case of newvar2 never has a chance to switch to 2, even though the
value of var2 is 1.
data list free / var1 var2. begin data 1 1 2 1 end data. if (var1 = 1) newvar1 = 1. if (var2 = 1) newvar1 = 2. do if var1 = 1. compute newvar2 = 1. else if var2 = 1. compute newvar2 = 2. end if. exe. list.
var1 var2 newvar1 newvar2
1.00 1.00 2.00 1.00
2.00 1.00 2.00 2.00
Number of cases read: 2 Number of cases listed: 2
You will want to evaluate missing values first, often using the missing
function. This allows the expression to evaluate as either true or false.
If the missing function was used on the else if command, and it
evaluated as true, the compute command immediately following it would not
be executed, because control would have passed to end if.
data list free (",") /a.
begin data
1, , 1, ,
end data.
dataset name do_if_missing.
compute b = a.
do if missing(b).
compute b1 = 2.
else if b = 1.
compute b1 = 1.
end if.
exe.
list.
a b b1
1.00 1.00 1.00
. . 2.00
1.00 1.00 1.00
. . 2.00
Number of cases read: 4 Number of cases listed: 4
Vectors
A vector is a set of variables that can be referenced by an index number.
The set of variables may already exist in the active dataset, or they may be
created by the vector. The variables in a vector can be numeric or string,
temporary or permanent. The vector itself is temporary and ceases to exist
when the next procedure (or command that causes the dataset to be read) is
encountered. This is one place where extra exe. commands can cause
problems.
Both of the examples below are borrowed from Raynald Levesque’s SPSS
Programming and Data Management, Fourth Edition (pages 143-144). In our
first example, we read in an example dataset and then make two new variables,
called maxvalue and maxcount. Next, we use the vector
command to make a vector called vectorvar which contains the variables
first to fifth. We then loop backwards from 5 to 1 (by -1) to
populate the variable maxcount and to make the variable maxvar.
data list free /first second third fourth fifth. begin data 1 2 3 4 5 10 9 8 7 6 1 4 4 4 2 end data. dataset name vectors. compute maxvalue = max(first to fifth). compute maxcount = 0. list.
first second third fourth fifth maxvalue maxcount 1.00 2.00 3.00 4.00 5.00 5.00 .00 10.00 9.00 8.00 7.00 6.00 10.00 .00 1.00 4.00 4.00 4.00 2.00 4.00 .00 Number of cases read: 3 Number of cases listed: 3
vector vectorvar = first to fifth. loop #cnt = 5 to 1 by -1. do if maxvalue = vectorvar(#cnt). compute maxvar = #cnt. compute maxcount = maxcount+1. end if. end loop. exe. list.
first second third fourth fifth maxvalue maxcount maxvar 1.00 2.00 3.00 4.00 5.00 5.00 1.00 5.00 10.00 9.00 8.00 7.00 6.00 10.00 1.00 1.00 1.00 4.00 4.00 4.00 2.00 4.00 3.00 2.00 Number of cases read: 3 Number of cases listed: 3
In our second example, we create some new variables (containing random
values) using a vector. For this example, we must have an active dataset
to which we can add our new variables.
vector vec(4). loop #cnt = 1 to 4. compute vec(#cnt) = uniform(1). end loop. exe. list.
first second third fourth fifth maxvalue maxcount maxvar vec1 vec2 vec3 vec4 1.00 2.00 3.00 4.00 5.00 5.00 1.00 5.00 .14 .43 .61 .29 10.00 9.00 8.00 7.00 6.00 10.00 1.00 1.00 .16 .70 .35 .45 1.00 4.00 4.00 4.00 2.00 4.00 3.00 2.00 .05 .10 .14 .04 Number of cases read: 3 Number of cases listed: 3
Loops
Loops are used to do repeated transformations on the data until a specified
cutoff is reached. There are multiple ways to specify a cutoff. An
unconditional loop will run until it reaches the value specified by mxloops; the
default is 40. This value can be changed using the set mxloops
command. An indexing clause can be used to indicate the starting and
stopping points of the loops. You can also specify the step (the default
is 1). A third option to allow the loop to continue until a specified
condition has been met (similar to the idea of “do while”). You can use
end loop if to specify the ending condition, or you could use the break
command, which is unconditional. This means that the loop will end once
the break command is encountered.
As you might expect, you can nest one loop inside of another. If you do
this, you may want to indent your loops. You can use either + or – as the
character in the first column of the command to keep your syntax compatible with
batch mode processing.
You can also use loops to create a dataset. In the following example,
from pages 152-153 of the Levesque text, we create a casewise dataset from an
aggregated dataset. In the aggregated dataset, there are two females and
two males who are age 20; no one aged 21; one female and four males age 22, etc.
The xsave command is used to save each case to the dataset
tempdata.sav as it is written by the loop. The main difference between
the save command and the xsave command is that the save
command is executed by itself, where as xsave is not executed until data
are read for the next procedure. In this way, xsave reduces
processing time.
data list free / age female male. begin data 20 2 2 21 0 0 22 1 4 23 3 0 24 0 1 end data. dataset name loops. loop #cnt = 1 to sum(female, male). compute gender = (#cnt > female). xsave outfile "D:datatempdata.sav" /keep = age gender. end loop. exe. get file "D:datatempdata.sav". list.
age gender 20.00 .00 20.00 .00 20.00 1.00 20.00 1.00 22.00 .00 22.00 1.00 22.00 1.00 22.00 1.00 22.00 1.00 23.00 .00 23.00 .00 23.00 .00 24.00 1.00 Number of cases read: 13 Number of cases listed: 13
Reshaping data wide to long with the convenience command (varstocases)
In SPSS version 11, two convenience commands were introduced for reshaping
data. One command, varstocases, reshapes data from wide to long
format. The other command, called casestovars, reshapes data from
long to wide format. Of course, you could reshape data in SPSS prior to
version 11, but you had to do manually. In other words, you needed to use
multiple commands in a specific sequence to reshape your data. In this
section, we will show you both the convenience command and the manual method of
reshaping data. It is useful to know how to reshape data manually, because
you may encounter situations in which the convenience command does not meet your
needs. In other words, the manual way of reshaping your data is more
flexible than the convenience commands.
data list list / id trial1 trial2 trial3 female. begin data 1 16 14 15 0 2 17 19 12 1 3 16 15 19 1 4 17 18 19 0 5 11 12 17 0 6 14 19 18 1 end data. dataset name wide_data. varstocases /make trial from trial1 to trial3 /index = number /id = id1. list.
id1 id female number trial
1 1.00 .00 1 16.00
1 1.00 .00 2 14.00
1 1.00 .00 3 15.00
2 2.00 1.00 1 17.00
2 2.00 1.00 2 19.00
2 2.00 1.00 3 12.00
3 3.00 1.00 1 16.00
3 3.00 1.00 2 15.00
3 3.00 1.00 3 19.00
4 4.00 .00 1 17.00
4 4.00 .00 2 18.00
4 4.00 .00 3 19.00
5 5.00 .00 1 11.00
5 5.00 .00 2 12.00
5 5.00 .00 3 17.00
6 6.00 1.00 1 14.00
6 6.00 1.00 2 19.00
6 6.00 1.00 3 18.00
Number of cases read: 18 Number of cases listed: 18
Reshaping data wide to long manually (with vectors and loops)
vector Atrial = trial1 to trial3. loop number = 1 to 3. compute trial = Atrial(number). xsave outfile 'd:dataw2lm.sav' /drop trial1 trial2 trial3. end loop. execute. get file 'd:dataw2lm.sav'. list.
id female number trial 1.00 .00 1.00 16.00 1.00 .00 2.00 14.00 1.00 .00 3.00 15.00 2.00 1.00 1.00 17.00 2.00 1.00 2.00 19.00 2.00 1.00 3.00 12.00 3.00 1.00 1.00 16.00 3.00 1.00 2.00 15.00 3.00 1.00 3.00 19.00 4.00 .00 1.00 17.00 4.00 .00 2.00 18.00 4.00 .00 3.00 19.00 5.00 .00 1.00 11.00 5.00 .00 2.00 12.00 5.00 .00 3.00 17.00 6.00 1.00 1.00 14.00 6.00 1.00 2.00 19.00 6.00 1.00 3.00 18.00 Number of cases read: 18 Number of cases listed: 18
Reshaping data long to wide with the convenience command (casestovars)
casestovars /id = id /index = number. list.
id id1 female trial.1 trial.2 trial.3 1.00 1 .00 16.00 14.00 15.00 2.00 2 1.00 17.00 19.00 12.00 3.00 3 1.00 16.00 15.00 19.00 4.00 4 .00 17.00 18.00 19.00 5.00 5 .00 11.00 12.00 17.00 6.00 6 1.00 14.00 19.00 18.00 Number of cases read: 6 Number of cases listed: 6
Reshaping data wide to long manually (with vectors and the aggregate
command)
sort cases by id number. vector trial(3). compute trial(number) = trial. list id trial trial1 trial2 trial3. aggregate /break id /trial1 to trial3 = max(trial1 to trial3). delete variables trial1 to trial3. list.
id female number trial 1.00 .00 1.00 16.00 1.00 .00 2.00 14.00 1.00 .00 3.00 15.00 2.00 1.00 1.00 17.00 2.00 1.00 2.00 19.00 2.00 1.00 3.00 12.00 3.00 1.00 1.00 16.00 3.00 1.00 2.00 15.00 3.00 1.00 3.00 19.00 4.00 .00 1.00 17.00 4.00 .00 2.00 18.00 4.00 .00 3.00 19.00 5.00 .00 1.00 11.00 5.00 .00 2.00 12.00 5.00 .00 3.00 17.00 6.00 1.00 1.00 14.00 6.00 1.00 2.00 19.00 6.00 1.00 3.00 18.00 Number of cases read: 18 Number of cases listed: 18
Using matrix-end matrix (with OMS)
The example was taken from our SPSS Textbook Examples: Applied Survival
Analysis, Second Edition, Chapter 4 (table 7). Here is a brief description of the task:
We need to get the covariance matrix for the three estimated coefficients. SPSS
does not return the full covariance matrix. Instead, it gives a lower part
of the correlation matrix. We have to compute the full covariance matrix
based on this correlation matrix and the standard errors for the parameter
estimates. This is done making use of both OMS and the matrix language.
oms
/select tables
/if
subtypes = ['Correlation Matrix of Regression Coefficients']
/destination format = sav
outfile = 'd:dataasa2corr_table4_7.sav'.
oms
/select tables
/if
subtypes = ['Variables in the Equation']
/destination format = sav
outfile = 'd:dataasa2parms_table4_7.sav'.
coxreg foltime
/method = enter age2 age3 age4
/status folstatus(1)
/print = corr.
omsend.
matrix.
get corr /file="d:dataasa2corr_table4_7.sav"
/variables=age2 age3
/missing = 0.
compute d=nrow(corr).
compute a = make(d+1, d+1, 0).
loop i = 1 to d.
loop j = i+1 to d+1.
compute a(i, j) = corr(j-1, i).
compute a(j, i) = corr(j-1, i).
end loop.
end loop.
compute c = ident(d+1) + a.
get se /file="d:dataasa2parms_table4_7.sav"
/variables = se.
compute sigma=mdiag(se).
compute cov = sigma*c*sigma.
print cov.
end matrix.
COV
.2689919851 .1259938985 .1251235682
.1259938985 .1983542137 .1260336740
.1251235682 .1260336740 .1726740755
Using begin program-end program (with Python)
In the example below, we use Python to help us loop through two lists of
variables. SPSS will not allow you to loop through two lists of variables
simultaneously, as you may want to do if you have a list dependent variables and
a list of independent variables. This example was taken from our
SPSS FAQ:
How can I loop through two list of variables? and the full explanation for this
code can be found there.
begin program.
import spss, spssaux
spssaux.OpenDataFile('d:dataelemapi2.sav')
vdict=spssaux.VariableDict()
dlist=vdict.range(start="api00", end="ell")
ilist=vdict.range(start="grad_sch", end="enroll")
ddim = len(dlist)
idim = len(ilist)
if ddim != idim:
print "The two sequences of variables don't have the same length."
else:
for i in range(ddim):
mydvar = dlist[i]
myivar = ilist[i]
spss.Submit(r"""
regression /dependent %s
/method = enter %s.
""" %(mydvar, myivar))
end program.