### PARAMETERS Statement

`PARAMETERS | PARMS` parameters <<=> numbers  |  (numbers)> <<,> parameters <<=> numbers  |  (numbers)> …> ;

The PARAMETERS statement defines parameters that are useful in the modeling. You can specify more than one PARAMETERS statement.

The three main uses of the PARAMETERS statement are as follows:

• Define independent parameters that are not specified in your model. In some modeling situations, it is more convenient (practically or conceptually) to define the model parameters as functions of these independent parameters. PROC CALIS computes the estimates and their standard errors for these independent parameters.

• Define dependent parameters of interest. These dependent parameters are then defined as functions of the model parameters in the SAS programming statements. PROC CALIS computes the estimates and their standard errors for these dependent parameters.

• Provide initial values for the free parameters in the model if they have not been specified in the model specification statements.

For example, the following statements illustrate the three main uses of the PARAMETERS statement:

```proc calis;
path
V1    <===  V2    = b1,
V1    <===  V3    = b2,
V2    <===  V4    = b3 (0.9),
V3    <===  V5    = b4;
parameters  a1 (0.1)  a2 (0.2)  b3 (0.3)  b4 (0.4) b5;
b1  =  -a1 / a2;
b2  =  1 / a2;
b5  =  b3 - b4;
run;
```

In the PARAMETERS statement, you specify five parameters that take different roles in the modeling. Parameters `a1` and `a2` are independent parameters that are not specified in the PATH statement, which specifies four paths with four parameters for the path coefficients `b1`, `b2`, `b3`, and `b4`. The two SAS programming statements immediately after the PARAMETERS statement define parameters `b1` and `b2` as functions of parameters `a1` and `a2`. Because `a1` and `a2` appear only on the right side of the programming statements, they are independent parameters of the model. In addition, `b1` and `b2` are dependent parameters because they appear on the left side of the first two programming statements. Independent parameters `a1` and `a2` are provided with initial values 0.1 and 0.2, respectively, in the PARAMETERS statement. Because the initial values these two independent parameters are used, dependent parameters `b1` and `b2` are also initialized with values –0.5 and 5, respectively.

Parameters `b3` and `b4` appear in both the PATH and PARAMETERS statements. Because these two parameters are already specified in the PATH statement, their initial values might have been defined in the model. For example, parameter `b3` in the PATH statement has an initial value of 0.9. This initial value is not replaced by the initial value of 0.3 specified in the PARAMETERS statement. However, because you do not specify an initial value for parameter `b4` in the PATH statement, the initial value of 0.4 specified in the PARAMETERS statement is used. In general, the initial values that are specified in the PARAMETERS statement do not replace the initial values that have already been specified for the same parameters in the model.

Parameter `b5` in the PARAMETERS statement is a dependent parameter, which is defined as the difference between the model parameters `b3` and `b4` in the last SAS programming statement. No initial value for this dependent parameter is provided (nor is it needed). By definition, dependent parameters are functions of other parameters, so their initial values are computed. In this example, parameter `b5` takes an initial value of 0.5, the difference between the initial values of `b3` and `b4`.

It is not necessary to provide initial values for the parameters in the PARAMETERS statement. For the independent parameters without initial values specified, PROC CALIS generates the initial values from the START= value in the PROC CALIS statement. The default START= value is 0.5. If you specify the RANDOM= option in the PROC CALIS statement, random numbers are generated for the initial values of the independent parameters. For the dependent parameters, PROC CALIS computes the initial values by using the SAS programming statements.

In general, the number of parameters and the number of initial values do not have to match. When you specify fewer initial values than parameter names, PROC CALIS either generates or computes the initial values. When you specify more values than parameter names, the extra values are ignored.

For example, consider the following statements:

```parameters  c1 c2 c3 c4 (0.2 0.3 0.4);
parameters  d1 d2 d3 d4 (0.1 0.2 0.3 0.4 0.5);
run;
```

The first PARAMETERS statement has a shorter initial value list than the parameter list. The initial values 0.2, 0.3, and 0.4 are assigned to `c2`, `c3`, and `c4`, respectively. PROC CALIS generates the initial value for `c1`. The second PARAMETERS statement has a longer initial value list than the parameter list. The initial values 0.1, 0.2, 0.3, and 0.4 are assigned to `d1`, `d2`, `d3`, and `d4`, respectively. The extra initial value 0.5 is ignored.

When the lengths of the parameter list and the initial value list match, you can use an equal sign between the lists freely without affecting the assignments of the initial values. For example, each of the following PARAMETERS statements assigns the initial values `alpha`=0.5 and `beta`=–0.5:

```parameters  alfa   0.5  beta   -0.5;
parameters  alfa = 0.5  beta = -0.5;
parameters  alfa   (0.5) beta   (-0.5);
parameters  alfa = (0.5) beta = (-0.5);
parameters  alfa beta   0.5 -0.5;
parameters  alfa beta = 0.5 -0.5;
parameters  alfa beta   (0.5 -0.5);
parameters  alfa beta = (0.5 -0.5);
```

However, when the parameter list is longer than the initial value list, the equal sign affects the assignments of the initial values. For example, the following statement assigns the initial values to the last three parameters, `c2`, `c3`, and `c4`:

```parameters  c1 c2 c3 c4 (0.2 0.3 0.4);
```

But with an equal sign between the lists, the following statement assigns the initial values to the first three parameters, `c1`, `c2`, and `c3`:

```parameters  c1 c2 c3 c4 = (0.2 0.3 0.4);
```

To make initial value assignments less ambiguous, you can use commas to separate parameter lists. For example, the following statement clearly assigns the initial values to `c2`, `c3`, and `c4`:

```parameters  c1, c2 c3 c4 (0.2 0.3 0.4);
```

This specification is equivalent to the same specification without the comma. But the specification is certainly less ambiguous with the comma.

Proper grouping of the parameter and initial value lists with the use of commas helps make the specification in the PARAMETERS statement clear. For example, consider the following specification:

```parameters  c1 c2 c3 c4 = (0.1 0.2 0.3) c5 c6 (0.6);
```

Initial values 0.1, 0.2, 0.3, and 0.6 are assigned to parameters `c1`, `c2`, `c3`, and `c6`, respectively. Initial values for other parameters are either generated or computed by PROC CALIS. A much better practice is to use the following equivalent specification:

```parameters  c1 c2 c3 (0.1 0.2 0.3), c4 c5, c6 (0.6);
```

Matching the number of parameters and the number of initial values (if provided) in entries separated by commas in the PARAMETERS statement is highly recommended. It reduces ambiguities and makes your code more interpretable.

It is important to notice that PROC CALIS does not have better alternatives to generate initial values (such as those for setting the initial values of the model parameters) for the independent parameters specified in the PARAMETERS statement other than using either the START= value or random values generated by using the RANDOM= option. These ad hoc initial values are arbitrary and might not always lead to converged solutions. Therefore, you should try to provide good initial values for those independent parameters that are defined only in the PARAMETERS statement.

Do not confuse the PARAMETERS statement with the VAR statement. While you specify the parameters of the model in the PARAMETERS statement, you specify analysis variables in the VAR statement. See the for more details.

Caution: The OUTMODEL= and OUTRAM= data sets do not contain any information about the PARAMETERS statement or the SAS programming statements.