Abbreviated code

Abbreviated code follows a subset of Fortran language syntax within an NM-TRAN control stream. A block of abbreviated code begins with control record $PRED, $PK, $ERROR, $DES, $AES, $AESINITIAL, $TOL, $MIX, or $INFN, and ends with either another record (that begins with "$"), or the end of the control stream. The code blocks are case-insensitive (NM72).

Comments

Semicolon character ; marks the beginning of comments so that the rest of the line is ignored.

Line continuation

Character & at the end of a line indicates continuation to the next line.

Types

Reals

User-defined real variables do not require declaration. Using a non-reserved (see "Reserved variables" below) word automatically declares it a (double precision) real variable. For example, TVCL below is recoganized as a real variable.

1
2


  $PK
  TVCL=THETA(1)

Integers

Integers variables are declared by (see $ABBREVIATED DECLARE for details)

1

  $ABBR DECLARE INTEGER variable_name

A special index integer declared by

1

  $ABBR DECLARE DOWHILE variable_name

must be used for indices of DOWHILE loops. See "Index" section below.

Real vectors

One-dimensional real vector can be defined using

1

$ABBR VECTOR variable_name (dimension)

Assignment

A user-defined variable can have a name of length 1-20 (length limit defined by constant SD in SIZES), consisting of letters (A-Z), numerals (0-9), understore (_), and beginning with a letter. It cannot be one of the reserved variable names or keywords (see "Reserved variables" below).

A user-defined variable A is given value B through assignment state A=B. The right-hand (RHS) quantity B can be an expression of:

previously defined quantities (see $ABBREVIATED);
constants ¹, e.g. 1, 1.1, 3E+1, 3E1, 3E01, 3E-1 3E-01, 3D+1, 3D1, 3D01, 3D-1, 3D-01;
THETA, OMEGA, and SIGMA elements, e.g. THETA(1), OMEGA(1,3), OMEGA(2,2) (equivalently OMEGA(2), for diagonal elements);
data items defined from the $INPUT record;
ETA, EPS, and ERR, elements, assummed with mean 0 and covariance matrix specifed by OMEGA and SIGMA;
operators: + , - , * , / , and ** (exponentiate);
parentheses ();
Fortran functions: LOG (natural log), LOG10, EXP, SQRT, SIN, COS, ABS, TAN, ASIN, ACOS, ATAN, INT, MIN, MAX, MOD;
NONMEM function: PHI (cumulative distribution function);
NONMEM function: GAMLN (logarithm of the gamma function) ²;
NONMEM function: RANDMT and RANDMTU that return a random variables (See Introduction to NONMEM 7 for details).

Variables assigned with ETA, EPS, or ERR expressions are random variables, so are the quantities defined in terms of them. If a fortran function includes random variable arguments, NONMEM automatically computes the partial derivatives of these variables with respective to ETA, EPS, and ERR. However, special cases require attention:

The partial derivative of ABS(X) at X=0 is mathematically undefined. NONMEM defines it as dX/dETA (similar for EPS, and ERR). Similarly, NONMEM does not compute partial derivatives for functions that return discontinuous values, such INT, MOD, MIN, and MAX. If using them outside of a simulation block such that the function value affects the objective function value (OFV) may lead to erroneous estimation. If they are needed in the computations of DADT in $DES, then the funcions should be used instead in the PK routine, and model event time (see also Model Time examples).
The cumulative distribution function PHI may accept a random variable argument, but NONMEM does not compute partial derivatives for it.
NONMEM computes derivatives only when they are needed, thus not in simulation block, initialization block, finalization block, or PRED_IGNORE_DATA block (see Code blocks below.)

In addition to user-defined variables, left-hand quantities A can also be:

VECTRA(n), VECTRB(n), VECTRC(n): they become elements of pre-defined vectors VECTRA, VECTRB, VECTRC. If an variable VECTRA (same for VECTRB, VECTRC, etc) is used without an index, it referrs to a different scalar variable. An index must be an integer constant, or a character string that is replaced by an integer constant using the $ABBR REPLACE feature. Whereas once it is defined, a vector element may be used as a right-hand quantity – in the same way as any previously defined variable – the vector itself may be used only as an argument to an abbreviated function. (See VECTORS and ABBREVIATED FUNCTIONS, below.)
Certain special variables: RPTO, RPTON and PRDFL - with the repetition feature (See Repetition Variables); SKIP_ (but only in a finalization block) - with superproblems or subproblems (See SKIP).
COM() elements. (COM is a storage array in module NMPRD4. Even if assigned with a random variables, NONMEM does not compute derivatives of COM() elements with respect to the base random variables).

In simulation blocks, initialization blocks, finalization blocks, a label from $INPUT record can be on the left in an assignment statement.

Loop (DO-WHILE)

DO-WHILE may be used in all blocks of abbreviated code (NM73):

1
2
3
4
5
6


 $ABBR DECLARE DOWHILE ILOOP $PK
 ILOOP=1
 DOWHILE (condition)
  .. statements ..
 ILOOP=ILOOP+1
 ENDDO

When it is used in data-anlytic code, DOWHILE must be used with a looping counter defined with $ABBR DECLARE DOWHILE, as the ILOOP in the example.

DOWHILE blocks may be nested.
DOWHILE blocks may not include IF/THEN/ENDIF blocks. Only single-statement IF statements are permitted.
Index variables may be used within the block. These are variables that have been declared arrays using the $ABBR statement, or indexed reserved variables such as THETA. Indices may be integer expressions using declared integer variables and integer values, e.g.
1 2 3 4 5 6 7 8 9

$ABBR DECLARE X(10) $ABBR DECLARE DOWHILE ILOOP ... $PK ILOOP=1 DOWHILE (condition) X(ILOOP)=THETA(ILOOP+1) ILOOP=ILOOP+1 ENDDO
A DOWHILE loop may compute recursive random variables. These are variables that are modified recursively in a dowhile block and which have eta derivatives. For example,
1 2 3 4 5 6 7

TERM=THETA(1)*EXP(ETA(1)) SUM=0 ILOOP=1 DO WHILE(ILOOP<=IMAX) SUM=SUM+TERM ILOOP=ILOOP+1 ENDDO
The DOWHILE recursive variable must be initialized to a non-random variable outside the loop and must appear on both sides of the equal sign only once within the DOWHILE loop: V= … V …

The syntax is limited, for example the following are not permitted:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


  ILOOP=1
  DO WHILE(ILOOP<=IMAX)
  IF (ILOOP == 1) SUM=0  ; initialization within the loop
  SUM=SUM+TERM
  ILOOP=ILOOP+1
  ENDDO

  ILOOP=1
  DO WHILE(ILOOP<=IMAX)
  IF (ILOOP == 1) THEN
  SUM=0                  ; initialization within the loop
  ELSE                   ; else statement
  SUM=SUM+TERM
  ENDIF
  ILOOP=ILOOP+1
  ENDDO

The looping variable ILOOP may also be set and tested and incremented with different integers than shown.

Several examples are present in the examples directory:

Auto-correlation ("examples/ar1mod")
Auto-correlation with Simulation ("exmaples/ar1newsim").
Dose Superposition ("examples/sumdosetn")
Summing elements of THETA ("examples/superid3_6")

The non-FORTRAN syntax DO WHILE(DATA) is permitted in $PRED initialization and finalization blocks, and in the $INFN record. (See Initialization-Finalization block).

Conditional

The IF Conditional statements can be paired with ELSE/ELSEIF/ENDIF or used in one line.

1
2
3
4
5
6
7
8
9


    IF (condition) THEN
       abbreviated code ...
    ELSEIF (condition) THEN
       abbreviated code ...
    ELSE
       abbreviated code ...
    ENDIF

    IF (condition) assignment statement

See below for a restriction on ELSEIF.

Conditions may include the operators .EQ., .NE., .LE., .GE., .LT., .GT., .AND., and .OR.. The arthmetic operators may be coded as =, /, <=, >=, <, and >, respectively. They may include expressions that can be used as right-hand quantities with assignment statements. They may not include parentheses except in such expressions.

1
2
3
4
5


  ;! Valid:
  IF (Q.EQ.(R+C)/D) ...

  ;!Invalid
  IF (Q.EQ.R.AND.(C.GT.D.OR.E.EQ.F)) ...

With $PRED, $PK, and $ERROR records, a condition may test the ICALL argument. However, if the test is IF (ICALL.EQ.2), then ELSE may not be used. Special rules apply. For more detail, see SPECIAL STATEMENTS (below), and help entries for these records.

A condition may also test certain variables defined in modules (See variables in NONMEM modules, NONMEM modules).

Abbreviated code in a particular THEN or ELSE clause may not contain multiple definitions of the same random variable. The code below is invalid:

1
2
3
4


  IF (condition) THEN
  X=...an expression involving a random variable
  X= ....
  ENDIF

Random variables cannot be defined within nested conditionals, i.e., within a conditional structure beginning with an IF and containing another IF. The use of ELSEIF … THEN implies a nested conditional.

A special rule applies when random variables are defined via conditional statements. If a random variable is multiply defined within a series of IF … THEN structures, but all conditions are false, then the value of the random variable is set to zero. If an ELSE appears, then not all conditions are false. Consider two cases in which the following statements are the only ones defining TVK and K, respectively:

1

  IF (WT.GT.0) TVK=THETA(1)*WT

If the condition is false, the non-random variable TVK retains the value set with the previous data record.

1

  IF (WT.GT.0) K=THETA(1)*WT*EXP(ETA(1))

If the condition is false, the value of the random variable K is set to zero. NM-TRAN prints a warning message when it detects such code.

In $PK, $ERROR, and $PRED records, recursion code may be used in an explicit manner, as in this example:

1
2
3
4
5


  IF (WT.GT.0) THEN
    K=THETA(1)*WT*EXP(ETA(1))
  ELSE
    K=K
  ENDIF

If the condition is false, K retains its value set with the previous data record. Recursion code can be used in $PRED, $PK, and $ERROR records for other purposes as well. The following two fragments of code illustrate how one can use abbreviated code to implement recursive kinetics in $PRED. The first example works with a single bolus dose and the second example works with single or multiple bolus doses. Similar code can be used in $PK and $ERROR.

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


  K=THETA(1)*EXP(ETA(1))
  IF (TIME.EQ.0) THEN
    OLDA=AMT
    T=TIME
  ENDIF
  A=OLDA*EXP(-K*(TIME-T))
  OLDA=A
  T=TIME

  K=THETA(1)*EXP(ETA(1))
  IF (TIME.EQ.0) THEN
    A=AMT
    T=TIME
  ELSE
    A=A*EXP(-K*(TIME-T))+AMT
  ENDIF
  T=TIME

The above forms of recursion work for recursion from one data record to the next ("inter-record" recursion). It is also possible to use recursion in a do-while loop ("intra-record", or "do-while" recursion).

Example of a DO-WHILE recursive loop using a random variable:

1
2
3
4
5
6


  TERM=THETA(1)*EXP(ETA(1))
  SUM=0
  DO WHILE(condition)
  SUM=SUM+TERM
  ...
  ENDDO

A product loop such as

1

  PROD=PROD*TERM

is also possible, as are other ways the dowhile recursive variable can be used, so long as the variable appears on both sides of the equal sign within the DOWHILE loop: V= … V …

Functions

User-defined function FUNCx, with x being A, B, … etc. ³ can be used in abbreviated code as

1

A=FUNCA(X)  ;! similar for FUNCB, FUNCC, etc.

The X is the vector argument corresponding to the X argument in the Fortran definition (see below). The function should be defined with Fortran signature:

1
2
3
4


   FUNCTION FUNCA(X,X1,X2)
   DOUBLE PRECISION X,X1,X2,FUNCA
   DIMENSION X(9),X1(9),X2(9,9)    ! dimension must be 9.
   ...

X: input argument (can be a vector).
X1: X1(n) is the first-order partial derivative of the function with respect X(n). If the value of X(n) is not value of a random variable, X1(n) need not be set. If the argument X is a (scalar) expression, only X1(1) is needed.
X2: X2(n,m) is the second-partial derivative of the function with respect to the nth and mth elements of the argument. If the value of either X(n) or X(m) will not be a value of a random variable, X2(n,m) need not be set. Nor need any value of X2 be set if a test of MSEC=1 is false (see Partial Derivative Indicators). If the argument is a (scalar) expression, only X2(1,1) may be needed. If the argument is a vector and if the value of X2(n,m) is needed, then the value of X2(m,n) is needed as well, even though these two values will be identical.

The Fortran code for the functions should be placed in one or more files. Suppose there is one such file and its name is funcfile. It should be listed on the $SUBROUTINES record. It may contain more than one FUNCTION, e.g.,

1

 $SUBROUTINES ... OTHER=funcfile

If the reserved function names are used without but not define by $SUBR OTHER, NONMEM will emit error such as:

1

 FUNCA WAS CALLED, BUT NO CODE WAS SUPPLIED.

NONMEM provides reserved variable VECTRA, VECTRB, VECTRC, etc. to be used as the vector argument X, e.g.

1
2
3
4
5
6
7
8


  $PK
  ;#...
  VECTRA(1)=CL
  VECTRA(2)=V
  VECTRA(3)=Q
  VECTRA(4)=V2
  ;#...
  W=FUNCA(VECTRA)

Note that Vectors defined outside of $DES (or $AES) may not be used in the $DES (or $AES) block.

NONMEM v7.4+ provides a more flexible way to declare functions and vector arguments through $ABBR FUNCTION and $ABBR VECTOR (see $ABBREVIATED).

1

 $ABBR FUNCTION function_name(input_vector_name,dimension[,usage])

and define the corresponding Fortran function

1
2
3
4
5
6
7


 FUNCTION function_name(X,X1,X2,NDIM)
 USE SIZES, ONLY: DPSIZE,ISIZE
 INTEGER(KIND=ISIZE) :: NDIM
 REAL(KIND=DPSIZE), INTENT(IN)     :: X
 REAL(KIND=DPSIZE), INTENT(IN OUT) :: X1,X2
 REAL(KIND=DPSIZE):: function_name
 DIMENSION X(NDIM),X1(NDIM),X2(NDIM,NDIM)

The Function_name must be exactly as specified via $ABBR FUNCTION, and the same as defined in Fortran source file; the input_vector_name is the name corresponding to X in the Fortran definition that one can use in the abbreviated code; the dimension is passed as NDIM; usage is the maximum number of the function to be used in the abbreviated code (default to 999). For example, one can declare

1

  $ABBR FUNCTION BIVARIATE(VBI,5,3) ;# NDIM=5, usage=3

and use it as

1
2
3
4
5
6
7
8


$PK
;#...
  VBI(1)=RHO
  VBI(2)=5
  VBI(3)=6
  VBI(4)=1
  VBI(5)=1
  BV=BIVARIATE(VBI)

Alternatively, one can declare a vector with $ABBR VECTOR and use it in the functions. In this case, use "*" for the function argument, e.g.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


  $ABBR FUNCTION BIVARIATE(*,5)
  $ABBR FUNCTION BIVARIATEQ(*,10)
  $ABBR VECTOR VQI(15)
  ;#...
  $PK
    VQI(1)=RHO
    VQI(2)=MX
    BVAL=BIVARIATE(VQI)
    RVAL=BIVARIATEQ(VQI)
    VECTRA(1)=RHO
    VECTRA(2)=MX2
    YVAL=FUNCB(VECTRA)
    QVAL=BIVARIATEQ(VECTRA)

Note that VQI is shared by the two functions. As shown one can also use the old pattern.

Pseudo-assignment

Pseudo-assignment statements provide special instructions and must appear at the beginning of a control record. They may be enclosed in parentheses. Multiple pseudo-assignment statements enclosed by parentheses must be semicolon-separated. A common example (may be used in all records except $MIX) is

1

COMRES=-1

It specifies that all quantities defined in abbreviated code are to be stored locally instead of by default in the (global) MODULE NMPRD4. (Variables in MODULE NMPRD4 can be used for communication between various user-routines, and can be displayed in tables and scatterplots.)

Reserved variables

Entries for $PRED, $PK, $ERROR, $DES, $AES, $AESINITIAL, and $TOL describe the reserved variable names for these abbreviated codes. A reserved variable name cannot be used for user-defined variables unless the pseudo-assignment statement COMRES=-1 is used.

See a list of reserved variables in Module variables, and details in variables.

Index

Indices may be used with user-defined variables that are declared to be arrays using the $ABBR DECLARE record, and also with certain reserved variables:

1
2
3
4
5
6
7


  THETA,THETAFR,SETHET,THSIMP,SETHETR,THSIMPR
  OMEGA,OMEGAF,SEOMEG,OMSIMP
  SIGMA,SIGMAF,SESIGM,SGSIMP
  CNTID,IIDX
  CDEN_
  A, A_0                       ! when used in a WRITE or PRINT statement
  ETA, EPS, ERR                ! when used in a WRITE OR PRINT statement

Where an index is permitted or necessary, it may be an integer expression. An integer expression is an integer constant, a declared integer variable that has appeared on the left (i.e., has been given a value), a constant defined in SIZES, an expression involving integer constants and integer variables and arithmetic operators +, -, , /, *. It may also be a character string that is replaced by an integer expression using the $ABBR REPLACE feature. The number of indices must be equal to the number of dimensions. If there are two indices, either or both may be constants or expressions. If a indexed variable may be used on the left side, then the index may also be an integer expression. E.g.,

1
2
3
4
5


   $ABBR DECLARE INTEGER IND
    ...
   $PK
    IND=1
    X=THETA(IND+1)

With reserved random variables such as ETA(n) EPS(n) ERR(n) A(n) A_0(n) integer expressions may be used only if they are listed in in WRITE or PRINT statements. Otherwise n must be an integer constant, or a character string that is replaced by an integer constant using the $ABBR REPLACE feature.

Probability density functions

A series of built in probability density functions are available with NONMEM 7.4.2. For a given probability density there is also a cumulative distribution function (densitycdf), and random number generating function (density_rng).

They are described in INTRODUCTION TO NONMEM 7.4.2 Section I.26.

The density and densityCDF functions have arguments that are compatible with the FUNC system, in which function provides derivatives (XD), and second derivatives (XDD) (see I.65.Expanded Syntax and Capacity for User-Defined Functions (FUNCA) (NM74)). Thus, even random (eta associated) variables may serve as arguments to the parameters of the density functions. The source code of these densities are in ..\source\DISTRIB.f90, DISTRIBCDF.f90, and DISTRIBRNG.f90. Note that multi-variate densities do not have a corresponding CDF routine.

Examples of their use are in the ..\examples\densities directory.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


 BERNOULLI
 BERNOULLILOGIT
 BINOMIAL
 BINOMIALLOGIT
 BETABINOMIAL
 HYPERGEOMETRIC
 CATEGORICAL
 CATEGORICALLOGIT
 ORDEREDLOGISTIC
 NEGBINOMIAL
 NEGBINOMIAL2
 NEGBINOMIAL2LOG
 POISSON
 POISSONLOG
 MULTINOMIAL
 NORMAL
 EXPMODNORMAL
 SKEWNORMAL
 STUDENTT
 DOUBLEEXPONENTIAL
 LOGISTIC
 GUMBEL
 LOGNORMAL
 CHISQUARE
 INVCHISQUARE
 SCALEDINVCHISQUARE
 EXPONENTIAL
 GAMMA
 INVGAMMA
 WEIBULL
 FRECHET
 RAYLEIGH
 PARETO
 PARETO2
 BETA
 DIRICHLET
 VON MISES

Calling protocol: CALLFL

1

 CALLFL=n

In $PK abbreviated code: control when PREDPP calls the PK routine.
In $ERROR abbreviated code: control when PREDPP calls the ERROR routine.
In $AESINITIAL abbreviated code: when the TIME data item is not used, it controls when PREDPP calls the ADVAN9, ADVAN15, or ADVAN17 routine.

The use of CALLFL in each of the three abbreviated codes is independent of its use in the others. The pseudo-assignment statement may be enclosed in parentheses. The pseudo-assignment statement may take these forms:

CALLFL=-2: call the PK subroutine with every event record, with additional and lagged doses, and at modeled event times. It does not affect ERROR, ADVAN9, ADVAN15, or ADVAN17 routines.

The following messages will appear in the NONMEM output report:

1
2
3
4
5


PK SUBROUTINE CALLED WITH EVERY EVENT RECORD
PK SUBROUTINE CALLED AT NONEVENT (ADDITIONAL AND LAGGED) DOSE TIMES
or
PK SUBROUTINE CALLED AT NONEVENT (ADDITIONAL AND LAGGED) DOSE TIMES
AND AT MODEL TIMES

CALLFL=-1 (default): call the subroutine with every event record.

Correspondingly messages will appear in the NONMEM output:

1
2
3
4
5
6
7
8


PK SUBROUTINE CALLED WITH EVERY EVENT RECORD
PK SUBROUTINE NOT CALLED AT NONEVENT (ADDITIONAL OR LAGGED) DOSE TIMES

ERROR SUBROUTINE CALLED WITH EVERY EVENT RECORD

ADVAN9 CALLED WITH EVERY EVENT RECORD
ADVAN15 CALLED WITH EVERY EVENT RECORD
ADVAN17 CALLED WITH EVERY EVENT RECORD

CALLFL=0
- For the PK subroutine: If the data are population data, call the subroutine with the first event record of each individual record; if the data are single-subject data, call the subroutine with the first event record of the data set. In addition, call the subroutine with with every event record where the event time differs from the previous event time.
  
  The following messages will appear in the NONMEM output report:
  1 2
  
  PK SUBROUTINE CALLED ONLY WITH NEW INDIVIDUAL OR NEW TIME PK SUBROUTINE NOT CALLED AT NONEVENT (ADDITIONAL DOSE OR LAGGED) DOSE TIMES.
- For the ERROR subroutine: When the Simulation Step is being implemented, call the subroutine with every event record. Otherwise, call the subroutine only with observation event records.
  
  The following messages will appear in the NONMEM output report:
  1 2
  
  DURING SIMULATION, ERROR SUBROUTINE CALLED WITH EVERY EVENT RECORD OTHERWISE, ERROR SUBROUTINE CALLED ONLY WITH OBSERVATION EVENTS
- not applicable to the ADVAN9, ADVAN15, or ADVAN17 routine.
With CALLFL=0, The CALL data item may be used to request calls with additional event records.

CALLFL=1:

For the PK and ADVAN9, ADVAN15, or ADVAN17 subroutines: If the data are population data, call the subroutine with the first event record of each individual record; if the data are single-subject data, call the subroutine with the first event record of the data set.

The following messages appear in the NONMEM output report:

1
2
3
4
5
6


PK SUBROUTINE CALLED ONCE PER INDIVIDUAL RECORD
PK SUBROUTINE NOT CALLED AT NONEVENT (ADDITIONAL DOSE OR LAGGED) DOSE TIMES

ADVAN9 CALLED ONCE PER INDIVIDUAL RECORD.
ADVAN15 CALLED ONCE PER INDIVIDUAL RECORD.
ADVAN17 CALLED ONCE PER INDIVIDUAL RECORD.

For the ERROR subroutine: When the Simulation Step is being implemented, call the subroutine with every event record. Otherwise, if the data are population data, call the subroutine with the first event record of each individual record; if the data are single-subject data, call the subroutine with the first event record of the data set.

The following messages appear in the NONMEM output report:
1 2

DURING SIMULATION, ERROR SUBROUTINE CALLED WITH EVERY EVENT RECORD OTHERWISE, ERROR SUBROUTINE CALLED ONCE PER INDIVIDUAL RECORD

With CALLFL=1, The CALL data item may be used to request calls with additional event records.

In a block of abbreviated code, the CALLFL=n pseudo-assignment statement must precede all the other abbreviated code (except for verbatim code or other pseudo-assignment statements). The pseudo-assignment statement may not be used conditionally. CALLFL may not be used as a variable elsewhere in the abbreviated code.

Note that if the $ERROR record consists of only one of these four statements:

1
2
3
4


   Y=F+ERR(1)
   Y=F*(1+ERR(1))
   Y=F+F*ERR(1)
   Y=F*EXP(ERR(1))

NM-TRAN will automatically limit calls to ERROR to once-per-problem (unless the Simulation Step is being implemented, in which case. calls are made with every event record). In effect, this amounts to yet another way to control when it is that calls may occur to the ERROR routine, but one which may not be explicitly specified in $ERROR via the use of CALLFL.

With the last three models above (proportional and exponential), NM-TRAN will also request PREDPP to output the message:

1

  ERROR IN LOG Y IS MODELED

This does not mean that a model is fit to Log Y data.

A calling protocol phrase may be used within parentheses instead of a pseudo-assignment statement CALLFL. For example

1
2
3


 $PK (ONCE PER INDIVIDUAL RECORD)
 $ERROR (ONCE PER INDIVIDUAL RECORD)
 $AESINITIAL (ONCE PER INDIVIDUAL RECORD)

A calling protocol phrase can be used instead of the CALLFL pseudo-statement in $PK, $ERROR, and $AESINITIAL abbreviated codes. The phrase must be enclosed in parentheses. Either upper or lower case may be used. In an abbreviated code, the line of code containing the phrase must precede all the other abbreviated code (except for verbatim code or other pseudo-assignment statements), and it may be the same line that marks the beginning of the code, as in the above usage examples. Pseudo-statements defining COMRES may be coded within the same parentheses, separated by a semicolon ";". No abbreviated code may follow ")" on the same line as the ")".

Phrases equivalent to CALLFL=-2 for the $PK record:

1
2


(NON-EVENT)
(ADDITIONAL OR LAGGED)