Package 'nlmixr2est'

The fitted model object from which to retrieve the simulation model.

nlmixr2 fit without WRES/CWRES

Boolean indicating if the focei objective function is added. If not the foce objective function is added.

Boolean indicating if the original fit object should be updated. By default this is true.

Environment that should be checked for object to update. By default this is the global environment.

nlmixr2 fit object

Boolean indicating if original object should be updated. By default this is TRUE.

'tableControl()' list of options

Other ignored parameters.

Environment that should be checked for object to update. By default this is the global environment.

nlmixr2 family of objects

Update the object (default FALSE)

Saved data from

Internal theta/eta parameters

a 'tableControl()' list of options

Character Vector of items to keep

Character Vector of items to drop or NULL

Environment to search for updating

Fit object

Fit object

The number of points used to approximate the objective function via a quadratic approximation. The value of npt must be in the interval [n+2,(n+1)(n+2)/2] where n is the number of parameters in 'par'. Choices that exceed 2*n+1 are not recommended. If not defined, it will be set to min(n * 2, n+2).

'rhobeg' and 'rhoend' must be set to the initial and final values of a trust region radius, so both must be positive with '0 < rhoend < rhobeg'. Typically 'rhobeg' should be about one tenth of the greatest expected change to a variable. If the user does not provide a value, this will be set to 'min(0.95, 0.2 * max(abs(par)))'. Note also that smallest difference 'abs(upper-lower)' should be greater than or equal to 'rhobeg*2'. If this is not the case then 'rhobeg' will be adjusted.

The smallest value of the trust region radius that is allowed. If not defined, then 1e-6 times the value set for 'rhobeg' will be used.

The value of 'iprint' should be set to an integer value in '0, 1, 2, 3, ...', which controls the amount of printing. Specifically, there is no output if 'iprint=0' and there is output only at the start and the return if 'iprint=1'. Otherwise, each new value of 'rho' is printed, with the best vector of variables so far and the corresponding value of the objective function. Further, each new value of the objective function with its variables are output if 'iprint=3'. If 'iprint > 3', the objective function value and corresponding variables are output every 'iprint' evaluations. Default value is '0'.

The maximum allowed number of function evaluations. If this is exceeded, the method will terminate.

return the bobyqa output instead of the nlmixr2 fit

The number of bad ODE solves before reducing the atol/rtol for the rest of the problem.

Maximum number of times to reduce the ODE tolerances and try to resolve the system if there was a bad ODE solve.

The ODE recalculation factor when ODE solving goes bad, this is the factor the rtol/atol is reduced

Boolean indicating if focei can use ASCII color codes

Number of columns to printout before wrapping parameter estimates/gradient

Integer representing when the outer step is printed. When this is 0 or do not print the iterations. 1 is print every function evaluation (default), 5 is print every 5 evaluations.

This is the type of parameter normalization/scaling used to get the scaled initial values for nlmixr2. These are used with scaleType of.

With the exception of rescale2, these come from Feature Scaling. The rescale2 The rescaling is the same type described in the OptdesX software manual.

In general, all all scaling formula can be described by:

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

Where

The other data normalization approaches follow the following formula

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

• rescale2 This scales all parameters from (-1 to 1). The relative differences between the parameters are preserved with this approach and the constants are:

  $C_{1}$

  = (max(all unscaled values)+min(all unscaled values))/2

  $C_{2}$

  = (max(all unscaled values) - min(all unscaled values))/2

• rescale or min-max normalization. This rescales all parameters from (0 to 1). As in the rescale2 the relative differences are preserved. In this approach:

  $C_{1}$

  = min(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• mean or mean normalization. This rescales to center the parameters around the mean but the parameters are from 0 to 1. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• std or standardization. This standardizes by the mean and standard deviation. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = sd(all unscaled values)

• len or unit length scaling. This scales the parameters to the unit length. For this approach we use the Euclidean length, that is:

  $C_{1}$

  = 0

  $C_{2}$

  =

  $\sqrt(v_1^2 + v_2^2 + \cdots + v_n^2)$

• constant which does not perform data normalization. That is

  $C_{1}$

  = 0

  $C_{2}$

  = 1

The scaling scheme for nlmixr2. The supported types are:

• nlmixr2 In this approach the scaling is performed by the following equation:

  $v_{scaled}$

  = (

  $v_{current} - v_{init}$

  )*scaleC[i] + scaleTo

  The scaleTo parameter is specified by the normType, and the scales are specified by scaleC.

• norm This approach uses the simple scaling provided by the normType argument.

• mult This approach does not use the data normalization provided by normType, but rather uses multiplicative scaling to a constant provided by the scaleTo argument.

  In this case:

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

• multAdd This approach changes the scaling based on the parameter being specified. If a parameter is defined in an exponential block (ie exp(theta)), then it is scaled on a linearly, that is:

  $v_{scaled}$

  = (

  $v_{current}-v_{init}$

  ) + scaleTo

  Otherwise the parameter is scaled multiplicatively.

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

Maximum value of the scaleC to prevent overflow.

Minimum value of the scaleC to prevent underflow.

The scaling constant used with scaleType=nlmixr2. When not specified, it is based on the type of parameter that is estimated. The idea is to keep the derivatives similar on a log scale to have similar gradient sizes. Hence parameters like log(exp(theta)) would have a scaling factor of 1 and log(theta) would have a scaling factor of ini_value (to scale by 1/value; ie d/dt(log(ini_value)) = 1/ini_value or scaleC=ini_value)

• For parameters in an exponential (ie exp(theta)) or parameters specifying powers, boxCox or yeoJohnson transformations , this is 1.

• For additive, proportional, lognormal error structures, these are given by 0.5*abs(initial_estimate)

• Factorials are scaled by abs(1/digamma(initial_estimate+1))

• parameters in a log scale (ie log(theta)) are transformed by log(abs(initial_estimate))*abs(initial_estimate)

These parameter scaling coefficients are chose to try to keep similar slopes among parameters. That is they all follow the slopes approximately on a log-scale.

While these are chosen in a logical manner, they may not always apply. You can specify each parameters scaling factor by this parameter if you wish.

Scale the initial parameter estimate to this value. By default this is 1. When zero or below, no scaling is performed.

'rxode2' ODE solving options during fitting, created with 'rxControl()'

Optimize the rxode2 expression to speed up calculation. By default this is turned on.

Is a boolean indicating if the model should change multiplication to high precision multiplication and sums to high precision sums using the PreciseSums package. By default this is FALSE.

boolean, substitute fixed population values as literals and re-adjust ui and parameter estimates after optimization; Default is 'TRUE'.

specifies the type of additive plus proportional errors, the one where standard deviations add (combined1) or the type where the variances add (combined2).

The combined1 error type can be described by the following equation:

$y = f + (a + b\times f^c) \times \varepsilon$

The combined2 error model can be described by the following equation:

$y = f + \sqrt{a^2 + b^2\times f^{2\times c}} \times \varepsilon$

Where:

- y represents the observed value

- f represents the predicted value

- a is the additive standard deviation

- b is the proportional/power standard deviation

- c is the power exponent (in the proportional case c=1)

This boolean is to determine if the foceiFit will calculate tables. By default this is TRUE

Should the object have compressed items

Method for calculating covariance. In this discussion, R is the Hessian matrix of the objective function. The S matrix is the sum of individual gradient cross-product (evaluated at the individual empirical Bayes estimates).

• "r,s" Uses the sandwich matrix to calculate the covariance, that is: solve(R) %*% S %*% solve(R)

• "r" Uses the Hessian matrix to calculate the covariance as 2 %*% solve(R)

• "s" Uses the cross-product matrix to calculate the covariance as 4 %*% solve(S)

• "" Does not calculate the covariance step.

is a boolean to indicate if the objective function should be adjusted to be closer to NONMEM's default objective function. By default this is TRUE

Confidence level for some tables. By default this is 0.95 or 95% confidence.

Optimization significant digits. This controls:

• The tolerance of the inner and outer optimization is 10^-sigdig

• The tolerance of the ODE solvers is 0.5*10^(-sigdig-2); For the sensitivity equations and steady-state solutions the default is 0.5*10^(-sigdig-1.5) (sensitivity changes only applicable for liblsoda)

• The tolerance of the boundary check is 5 * 10 ^ (-sigdig + 1)

Significant digits in the final output table. If not specified, then it matches the significant digits in the 'sigdig' optimization algorithm. If 'sigdig' is NULL, use 3.

Ignored parameters

data to transform

Cox-box lambda parameter

Matrix to be Factorized.

Tolerance; Algorithm suggests (.Machine$double.eps) ^ (1 / 3), default

Optimization significant digits. This controls:

• The tolerance of the inner and outer optimization is 10^-sigdig

• The tolerance of the ODE solvers is 0.5*10^(-sigdig-2); For the sensitivity equations and steady-state solutions the default is 0.5*10^(-sigdig-1.5) (sensitivity changes only applicable for liblsoda)

• The tolerance of the boundary check is 5 * 10 ^ (-sigdig + 1)

Ignored parameters

Precision of estimate for n1qn1 optimization.

Number of iterations for n1qn1 optimization.

Maximum number of L-BFGS-B optimization for outer problem.

Number of function evaluations for n1qn1 optimization.

Integer representing when the outer step is printed. When this is 0 or do not print the iterations. 1 is print every function evaluation (default), 5 is print every 5 evaluations.

Number of columns to printout before wrapping parameter estimates/gradient

Scale the initial parameter estimate to this value. By default this is 1. When zero or below, no scaling is performed.

Scale the initial objective function to this value. By default this is 0 (meaning do not scale)

This is the type of parameter normalization/scaling used to get the scaled initial values for nlmixr2. These are used with scaleType of.

With the exception of rescale2, these come from Feature Scaling. The rescale2 The rescaling is the same type described in the OptdesX software manual.

In general, all all scaling formula can be described by:

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

Where

The other data normalization approaches follow the following formula

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

• rescale2 This scales all parameters from (-1 to 1). The relative differences between the parameters are preserved with this approach and the constants are:

  $C_{1}$

  = (max(all unscaled values)+min(all unscaled values))/2

  $C_{2}$

  = (max(all unscaled values) - min(all unscaled values))/2

• rescale or min-max normalization. This rescales all parameters from (0 to 1). As in the rescale2 the relative differences are preserved. In this approach:

  $C_{1}$

  = min(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• mean or mean normalization. This rescales to center the parameters around the mean but the parameters are from 0 to 1. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• std or standardization. This standardizes by the mean and standard deviation. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = sd(all unscaled values)

• len or unit length scaling. This scales the parameters to the unit length. For this approach we use the Euclidean length, that is:

  $C_{1}$

  = 0

  $C_{2}$

  =

  $\sqrt(v_1^2 + v_2^2 + \cdots + v_n^2)$

• constant which does not perform data normalization. That is

  $C_{1}$

  = 0

  $C_{2}$

  = 1

The scaling scheme for nlmixr2. The supported types are:

• nlmixr2 In this approach the scaling is performed by the following equation:

  $v_{scaled}$

  = (

  $v_{current} - v_{init}$

  )*scaleC[i] + scaleTo

  The scaleTo parameter is specified by the normType, and the scales are specified by scaleC.

• norm This approach uses the simple scaling provided by the normType argument.

• mult This approach does not use the data normalization provided by normType, but rather uses multiplicative scaling to a constant provided by the scaleTo argument.

  In this case:

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

• multAdd This approach changes the scaling based on the parameter being specified. If a parameter is defined in an exponential block (ie exp(theta)), then it is scaled on a linearly, that is:

  $v_{scaled}$

  = (

  $v_{current}-v_{init}$

  ) + scaleTo

  Otherwise the parameter is scaled multiplicatively.

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

Maximum value of the scaleC to prevent overflow.

Minimum value of the scaleC to prevent underflow.

The scaling constant used with scaleType=nlmixr2. When not specified, it is based on the type of parameter that is estimated. The idea is to keep the derivatives similar on a log scale to have similar gradient sizes. Hence parameters like log(exp(theta)) would have a scaling factor of 1 and log(theta) would have a scaling factor of ini_value (to scale by 1/value; ie d/dt(log(ini_value)) = 1/ini_value or scaleC=ini_value)

• For parameters in an exponential (ie exp(theta)) or parameters specifying powers, boxCox or yeoJohnson transformations , this is 1.

• For additive, proportional, lognormal error structures, these are given by 0.5*abs(initial_estimate)

• Factorials are scaled by abs(1/digamma(initial_estimate+1))

• parameters in a log scale (ie log(theta)) are transformed by log(abs(initial_estimate))*abs(initial_estimate)

These parameter scaling coefficients are chose to try to keep similar slopes among parameters. That is they all follow the slopes approximately on a log-scale.

While these are chosen in a logical manner, they may not always apply. You can specify each parameters scaling factor by this parameter if you wish.

Number to adjust the scaling factor by if the initial gradient is zero.

Forward difference tolerances, which is a vector of relative difference and absolute difference. The central/forward difference step size h is calculated as:

h = abs(x)*derivEps[1] + derivEps[2]

indicates the method for calculating derivatives of the outer problem. Currently supports "switch", "central" and "forward" difference methods. Switch starts with forward differences. This will switch to central differences when abs(delta(OFV)) <= derivSwitchTol and switch back to forward differences when abs(delta(OFV)) > derivSwitchTol.

The tolerance to switch forward to central differences.

indicates the method for calculating the derivatives while calculating the covariance components (Hessian and S).

Method for calculating covariance. In this discussion, R is the Hessian matrix of the objective function. The S matrix is the sum of individual gradient cross-product (evaluated at the individual empirical Bayes estimates).

• "r,s" Uses the sandwich matrix to calculate the covariance, that is: solve(R) %*% S %*% solve(R)

• "r" Uses the Hessian matrix to calculate the covariance as 2 %*% solve(R)

• "s" Uses the cross-product matrix to calculate the covariance as 4 %*% solve(S)

• "" Does not calculate the covariance step.

is a double value representing the epsilon for the Hessian calculation. This is used for the R matrix calculation.

is a double value representing the epsilon for the Hessian calculation when doing focei generalized log-likelihood estimation. This is used for the R matrix calculation.

The hessian type for when calculating the individual hessian by numeric differences (in generalized log-likelihood estimation). The options are "central", and "forward". The central differences is what R's 'optimHess()' uses and is the default for this method. (Though the "forward" is faster and still reasonable for most cases). The Shi21 cannot be changed for the Gill83 algorithm with the optimHess in a generalized likelihood problem.

The hessian type for when calculating the individual hessian by numeric differences (in generalized log-likelihood estimation). The options are "central", and "forward". The central differences is what R's 'optimHess()' uses. While this takes longer in optimization, it is more accurate, so for calculating the covariance and final likelihood, the central differences are used. This also uses the modified Shi21 method

Event gradient type for dosing events; Can be "central" or "forward"

Central difference tolerances. This is a numeric vector of relative difference and absolute difference. The central/forward difference step size h is calculated as:

h = abs(x)*derivEps[1] + derivEps[2]

An integer giving the number of BFGS updates retained in the "L-BFGS-B" method, It defaults to 7.

is a double precision variable.

On entry pgtol >= 0 is specified by the user. The iteration will stop when:

max(\| proj g_i \| i = 1, ..., n) <= lbfgsPgtol

where pg_i is the ith component of the projected gradient.

On exit pgtol is unchanged. This defaults to zero, when the check is suppressed.

Controls the convergence of the "L-BFGS-B" method. Convergence occurs when the reduction in the objective is within this factor of the machine tolerance. Default is 1e10, which gives a tolerance of about 2e-6, approximately 4 sigdigs. You can check your exact tolerance by multiplying this value by .Machine$double.eps

A boolean indicating if eigenvectors are calculated to include a condition number calculation.

Boolean indicating if posthoc parameters are added to the table output.

This is the transformation used on the diagonal of the chol(solve(omega)). This matrix and values are the parameters estimated in FOCEi. The possibilities are:

• sqrt Estimates the sqrt of the diagonal elements of chol(solve(omega)). This is the default method.

• log Estimates the log of the diagonal elements of chol(solve(omega))

• identity Estimates the diagonal elements without any transformations

Is a boolean indicating if the model should change multiplication to high precision multiplication and sums to high precision sums using the PreciseSums package. By default this is FALSE.

Optimize the rxode2 expression to speed up calculation. By default this is turned on.

boolean, substitute fixed population values as literals and re-adjust ui and parameter estimates after optimization; Default is 'TRUE'.

Confidence level for some tables. By default this is 0.95 or 95% confidence.

Boolean indicating if focei can use ASCII color codes

Tolerance for boundary issues.

This boolean is to determine if the foceiFit will calculate tables. By default this is TRUE

Boolean to indicate if you should abort the FOCEi evaluation if it runs into troubles. (default TRUE)

Boolean indicate FOCEi should be used (TRUE) instead of FOCE (FALSE)

tolerance for Generalized Cholesky Decomposition. Defaults to suggested (.Machine$double.eps)^(1/3)

Tolerance to accept a Generalized Cholesky Decomposition for a R or S matrix.

represents the p-value for reseting the individual ETA to 0 during optimization (instead of the saved value). The two test statistics used in the z-test are either chol(omega^-1) %*% eta or eta/sd(allEtas). A p-value of 0 indicates the ETAs never reset. A p-value of 1 indicates the ETAs always reset.

represents the p-value for reseting the population mu-referenced THETA parameters based on ETA drift during optimization, and resetting the optimization. A p-value of 0 indicates the THETAs never reset. A p-value of 1 indicates the THETAs always reset and is not allowed. The theta reset is checked at the beginning and when nearing a local minima. The percent change in objective function where a theta reset check is initiated is controlled in resetThetaCheckPer.

represents the p-value for reseting the population mu-referenced THETA parameters based on ETA drift during optimization, and resetting the optimization one final time.

This represents the upper bound of the diagonal omega matrix. The upper bound is given by diag(omega)*diagOmegaBoundUpper. If diagOmegaBoundUpper is 1, there is no upper bound on Omega.

This represents the lower bound of the diagonal omega matrix. The lower bound is given by diag(omega)/diagOmegaBoundUpper. If diagOmegaBoundLower is 1, there is no lower bound on Omega.

Boolean indicating if the generalized Cholesky should be used while optimizing.

Boolean indicating if the generalized Cholesky should be used while calculating the Covariance Matrix.

is a boolean indicating if this is a FO approximation routine.

If the R matrix is non-positive definite and cannot be corrected to be non-positive definite try estimating the Hessian on the unscaled parameter space.

optimization method for the outer problem

optimization method for the inner problem (not implemented yet.)

Beginning change in parameters for bobyqa algorithm (trust region). By default this is 0.2 or 20 parameters when the parameters are scaled to 1. rhobeg and rhoend must be set to the initial and final values of a trust region radius, so both must be positive with 0 < rhoend < rhobeg. Typically rhobeg should be about one tenth of the greatest expected change to a variable. Note also that smallest difference abs(upper-lower) should be greater than or equal to rhobeg*2. If this is not the case then rhobeg will be adjusted. (bobyqa)

The smallest value of the trust region radius that is allowed. If not defined, then 10^(-sigdig-1) will be used. (bobyqa)

The number of points used to approximate the objective function via a quadratic approximation for bobyqa. The value of npt must be in the interval [n+2,(n+1)(n+2)/2] where n is the number of parameters in par. Choices that exceed 2*n+1 are not recommended. If not defined, it will be set to 2*n + 1. (bobyqa)

Relative tolerance before nlminb stops (nlmimb).

X tolerance for nlmixr2 optimizer

Number of maximum evaluations of the objective function (nlmimb)

Maximum number of iterations allowed (nlmimb)

Absolute tolerance for nlmixr2 optimizer (BFGS)

tolerance for nlmixr2 (BFGS)

is a boolean representing if the individual Hessian is reset when ETAs are reset using the option resetEtaP.

Trim state amounts/concentrations to this value.

The maximum number of steps for the optimization of the forward-difference step size. When not zero, use this instead of Gill differences.

The maximum number of steps for the optimization of the individual Hessian matrices in the generalized likelihood problem. When 0, un-optimized finite differences are used.

The maximum number of steps for the optimization of the individual Hessian matrices in the generalized likelihood problem for the covariance step. When 0, un-optimized finite differences are used.

The maximum number of steps for the optimization of the forward difference step size when using dosing events (lag time, modeled duration/rate and bioavailability)

The total number of possible steps to determine the optimal forward/central difference step size per parameter (by the Gill 1983 method). If 0, no optimal step size is determined. Otherwise this is the optimal step size determined.

When looking for the optimal forward difference step size, this is This is the step size to increase the initial estimate by. So each iteration the new step size = (prior step size)*gillStep

The gillFtol is the gradient error tolerance that is acceptable before issuing a warning/error about the gradient estimates.

The relative tolerance used for Gill 1983 determination of optimal step size.

The total number of possible steps to determine the optimal forward/central difference step size per parameter (by the Gill 1983 method) during the covariance step. If 0, no optimal step size is determined. Otherwise this is the optimal step size determined.

The total number of possible steps to determine the optimal forward/central difference step per parameter when using the generalized focei log-likelihood method (by the Gill 1986 method). If 0, no optimal step size is determined. Otherwise this is the optimal step size is determined

Same as above but during generalized focei log-likelihood

When looking for the optimal forward difference step size, this is This is the step size to increase the initial estimate by. So each iteration during the covariance step is equal to the new step size = (prior step size)*gillStepCov

The gillFtol is the gradient error tolerance that is acceptable before issuing a warning/error about the gradient estimates during the covariance step.

Same as above but applied during generalized log-likelihood estimation.

A parameter to normalize gradient step size by the parameter value during the calculation of the R matrix

A parameter to normalize gradient step size by the parameter value during the calculation of the R matrix if you are using generalized log-likelihood Hessian matrix.

A parameter to normalize gradient step size by the parameter value during the calculation of the S matrix

A parameter to normalize gradient step size by the parameter value during the calculation of the S matrix if you are using the generalized log-likelihood.

Use the Gill calculated optimal Forward difference step size for the instead of the central difference step size during the central difference gradient calculation.

Use the Gill calculated optimal Forward difference step size for the instead of the central difference step size during the central differences for optimization.

The covSmall is the small number to compare covariance numbers before rejecting an estimate of the covariance as the final estimate (when comparing sandwich vs R/S matrix estimates of the covariance). This number controls how small the variance is before the covariance matrix is rejected.

In nlmixr2, the objective function matches NONMEM's objective function, which removes a 2*pi constant from the likelihood calculation. If this is TRUE, the likelihood function is adjusted by this 2*pi factor. When adjusted this number more closely matches the likelihood approximations of nlme, and SAS approximations. Regardless of if this is turned on or off the objective function matches NONMEM's objective function.

The parameter to adjust the gradient to if the |gradient| is very large.

Maximum number of times to reduce the ODE tolerances and try to resolve the system if there was a bad ODE solve.

The ODE recalculation factor when ODE solving goes bad, this is the factor the rtol/atol is reduced

A small number that represents the value where |grad| < gradCalcCentralSmall where forward differences switch to central differences.

A large number that represents the value where |grad| > gradCalcCentralLarge where forward differences switch to central differences.

By default initial ETA estimates start at zero; Sometimes this doesn't optimize appropriately. If this value is non-zero, when the n1qn1 optimization didn't perform appropriately, reset the Hessian, and nudge the ETA up by this value; If the ETA still doesn't move, nudge the ETA down by this value. By default this value is qnorm(1-0.05/2)*1/sqrt(3), the first of the Gauss Quadrature numbers times by the 0.95% normal region. If this is not successful try the second eta nudge number (below). If +-etaNudge2 is not successful, then assign to zero and do not optimize any longer

This is the second eta nudge. By default it is qnorm(1-0.05/2)*sqrt(3/5), which is the n=3 quadrature point (excluding zero) times by the 0.95% normal region

If FOCEi doesn't fit with the current parameter estimates, randomly sample new parameter estimates and restart the problem. This is similar to 'PsN' resampling.

an object specifying if and how the random number generator should be initialized

represents objective function % percentage below which resetThetaP is checked.

Eta matrix for initial estimates or final estimates of the ETAs.

If the tolerances were reduced when calculating the initial Gill differences, the Gill difference is repeated up to a maximum number of times defined by this parameter.

The number of bad ODE solves before reducing the atol/rtol for the rest of the problem.

This is the time for a single objective function evaluation (in seconds) to start progress bars on gradient evaluations

specifies the type of additive plus proportional errors, the one where standard deviations add (combined1) or the type where the variances add (combined2).

The combined1 error type can be described by the following equation:

$y = f + (a + b\times f^c) \times \varepsilon$

The combined2 error model can be described by the following equation:

$y = f + \sqrt{a^2 + b^2\times f^{2\times c}} \times \varepsilon$

Where:

- y represents the observed value

- f represents the predicted value

- a is the additive standard deviation

- b is the proportional/power standard deviation

- c is the power exponent (in the proportional case c=1)

The objective function adjustment when the ODE system cannot be solved. It is based on each individual bad solve.

Should the object have compressed items

'rxode2' ODE solving options during fitting, created with 'rxControl()'

Significant digits in the final output table. If not specified, then it matches the significant digits in the 'sigdig' optimization algorithm. If 'sigdig' is NULL, use 3.

Fallback to the finite differences if the sensitivity equations do not solve.

A percentage representing the number of failed parameter gradients for each individual (which are replaced with the overall gradient for the parameter) out of the total number of gradients parameters (ie 'ntheta*nsub') before the S matrix is considered to be a bad matrix.

A factor for multiplying the estimate by when the lower estimate is zero and the error is known to represent a standard deviation of a parameter (like add.sd, prop.sd, pow.sd, lnorm.sd, etc). When zero, no factor is applied. If your initial estimate is 0.15 and your lower bound is zero, then the lower bound would be assumed to be 0.00015.

boolean, when 'TRUE' if the first gradient is zero, reset the zero gradient to 'sqrt(.Machine$double.eps)' to get past the bad initial estimate, otherwise error (and possibly reset), when 'FALSE' error when the first gradient is zero. When 'NA' on the last reset, have the zero gradient ignored, otherwise error and look for another value. Default is 'TRUE'

boolean, when 'TRUE' if a gradient is zero, reset the zero gradient to 'sqrt(.Machine$double.eps)' to get past the bad estimate while running. Otherwise error (and possibly reset). Default is 'TRUE'

boolean, when 'TRUE' if a gradient is zero, the reset will change the method to the gradient free bobyqa method. When 'NA', the zero gradient will change to bobyqa only when the first gradient is zero. Default is 'TRUE'

nlmixr control object

Estimation routine

If positive, tracing information on the progress of the optimization is produced. Higher values may produce more tracing information: for method "L-BFGS-B" there are six levels of tracing. (To understand exactly what these do see the source code: higher levels give more detail.)

controls the convergence of the "L-BFGS-B" method. Convergence occurs when the reduction in the objective is within this factor of the machine tolerance. Default is 1e7, that is a tolerance of about 1e-8.

helps control the convergence of the "L-BFGS-B" method. It is a tolerance on the projected gradient in the current search direction. This defaults to zero, when the check is suppressed.

helps control the convergence of the "L-BFGS-B" method. It is an absolute tolerance difference in x values. This defaults to zero, when the check is suppressed.

helps control the convergence of the "L-BFGS-B" method. It is an relative tolerance difference in x values. This defaults to zero, when the check is suppressed.

is an integer giving the number of BFGS updates retained in the "L-BFGS-B" method, It defaults to 5.

maximum number of iterations.

return the lbfgsb3c output instead of the nlmixr2 fit

The number of bad ODE solves before reducing the atol/rtol for the rest of the problem.

Maximum number of times to reduce the ODE tolerances and try to resolve the system if there was a bad ODE solve.

The ODE recalculation factor when ODE solving goes bad, this is the factor the rtol/atol is reduced

Boolean indicating if focei can use ASCII color codes

Number of columns to printout before wrapping parameter estimates/gradient

Integer representing when the outer step is printed. When this is 0 or do not print the iterations. 1 is print every function evaluation (default), 5 is print every 5 evaluations.

This is the type of parameter normalization/scaling used to get the scaled initial values for nlmixr2. These are used with scaleType of.

With the exception of rescale2, these come from Feature Scaling. The rescale2 The rescaling is the same type described in the OptdesX software manual.

In general, all all scaling formula can be described by:

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

Where

The other data normalization approaches follow the following formula

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

• rescale2 This scales all parameters from (-1 to 1). The relative differences between the parameters are preserved with this approach and the constants are:

  $C_{1}$

  = (max(all unscaled values)+min(all unscaled values))/2

  $C_{2}$

  = (max(all unscaled values) - min(all unscaled values))/2

• rescale or min-max normalization. This rescales all parameters from (0 to 1). As in the rescale2 the relative differences are preserved. In this approach:

  $C_{1}$

  = min(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• mean or mean normalization. This rescales to center the parameters around the mean but the parameters are from 0 to 1. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• std or standardization. This standardizes by the mean and standard deviation. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = sd(all unscaled values)

• len or unit length scaling. This scales the parameters to the unit length. For this approach we use the Euclidean length, that is:

  $C_{1}$

  = 0

  $C_{2}$

  =

  $\sqrt(v_1^2 + v_2^2 + \cdots + v_n^2)$

• constant which does not perform data normalization. That is

  $C_{1}$

  = 0

  $C_{2}$

  = 1

The scaling scheme for nlmixr2. The supported types are:

• nlmixr2 In this approach the scaling is performed by the following equation:

  $v_{scaled}$

  = (

  $v_{current} - v_{init}$

  )*scaleC[i] + scaleTo

  The scaleTo parameter is specified by the normType, and the scales are specified by scaleC.

• norm This approach uses the simple scaling provided by the normType argument.

• mult This approach does not use the data normalization provided by normType, but rather uses multiplicative scaling to a constant provided by the scaleTo argument.

  In this case:

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

• multAdd This approach changes the scaling based on the parameter being specified. If a parameter is defined in an exponential block (ie exp(theta)), then it is scaled on a linearly, that is:

  $v_{scaled}$

  = (

  $v_{current}-v_{init}$

  ) + scaleTo

  Otherwise the parameter is scaled multiplicatively.

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

Maximum value of the scaleC to prevent overflow.

Minimum value of the scaleC to prevent underflow.

The scaling constant used with scaleType=nlmixr2. When not specified, it is based on the type of parameter that is estimated. The idea is to keep the derivatives similar on a log scale to have similar gradient sizes. Hence parameters like log(exp(theta)) would have a scaling factor of 1 and log(theta) would have a scaling factor of ini_value (to scale by 1/value; ie d/dt(log(ini_value)) = 1/ini_value or scaleC=ini_value)

• For parameters in an exponential (ie exp(theta)) or parameters specifying powers, boxCox or yeoJohnson transformations , this is 1.

• For additive, proportional, lognormal error structures, these are given by 0.5*abs(initial_estimate)

• Factorials are scaled by abs(1/digamma(initial_estimate+1))

• parameters in a log scale (ie log(theta)) are transformed by log(abs(initial_estimate))*abs(initial_estimate)

These parameter scaling coefficients are chose to try to keep similar slopes among parameters. That is they all follow the slopes approximately on a log-scale.

While these are chosen in a logical manner, they may not always apply. You can specify each parameters scaling factor by this parameter if you wish.

Scale the initial parameter estimate to this value. By default this is 1. When zero or below, no scaling is performed.

this is the factor that the gradient is scaled to before optimizing. This only works with scaleType="nlmixr2".

'rxode2' ODE solving options during fitting, created with 'rxControl()'

Optimize the rxode2 expression to speed up calculation. By default this is turned on.

Is a boolean indicating if the model should change multiplication to high precision multiplication and sums to high precision sums using the PreciseSums package. By default this is FALSE.

boolean, substitute fixed population values as literals and re-adjust ui and parameter estimates after optimization; Default is 'TRUE'.

specifies the type of additive plus proportional errors, the one where standard deviations add (combined1) or the type where the variances add (combined2).

The combined1 error type can be described by the following equation:

$y = f + (a + b\times f^c) \times \varepsilon$

The combined2 error model can be described by the following equation:

$y = f + \sqrt{a^2 + b^2\times f^{2\times c}} \times \varepsilon$

Where:

- y represents the observed value

- f represents the predicted value

- a is the additive standard deviation

- b is the proportional/power standard deviation

- c is the power exponent (in the proportional case c=1)

This boolean is to determine if the foceiFit will calculate tables. By default this is TRUE

Should the object have compressed items

Method for calculating covariance. In this discussion, R is the Hessian matrix of the objective function. The S matrix is the sum of individual gradient cross-product (evaluated at the individual empirical Bayes estimates).

• "r,s" Uses the sandwich matrix to calculate the covariance, that is: solve(R) %*% S %*% solve(R)

• "r" Uses the Hessian matrix to calculate the covariance as 2 %*% solve(R)

• "s" Uses the cross-product matrix to calculate the covariance as 4 %*% solve(S)

• "" Does not calculate the covariance step.

is a boolean to indicate if the objective function should be adjusted to be closer to NONMEM's default objective function. By default this is TRUE

Confidence level for some tables. By default this is 0.95 or 95% confidence.

Optimization significant digits. This controls:

• The tolerance of the inner and outer optimization is 10^-sigdig

• The tolerance of the ODE solvers is 0.5*10^(-sigdig-2); For the sensitivity equations and steady-state solutions the default is 0.5*10^(-sigdig-1.5) (sensitivity changes only applicable for liblsoda)

• The tolerance of the boundary check is 5 * 10 ^ (-sigdig + 1)

Significant digits in the final output table. If not specified, then it matches the significant digits in the 'sigdig' optimization algorithm. If 'sigdig' is NULL, use 3.

Ignored parameters

Precision of estimate for n1qn1 optimization.

Number of iterations

Number of function evaluations

Verbosity of messages.

Boolean to control if the function value and parameter estimates are echoed every time a function is called.

return the n1qn1 output instead of the nlmixr2 fit

The number of bad ODE solves before reducing the atol/rtol for the rest of the problem.

Maximum number of times to reduce the ODE tolerances and try to resolve the system if there was a bad ODE solve.

The ODE recalculation factor when ODE solving goes bad, this is the factor the rtol/atol is reduced

Boolean indicating if focei can use ASCII color codes

Number of columns to printout before wrapping parameter estimates/gradient

Integer representing when the outer step is printed. When this is 0 or do not print the iterations. 1 is print every function evaluation (default), 5 is print every 5 evaluations.

This is the type of parameter normalization/scaling used to get the scaled initial values for nlmixr2. These are used with scaleType of.

With the exception of rescale2, these come from Feature Scaling. The rescale2 The rescaling is the same type described in the OptdesX software manual.

In general, all all scaling formula can be described by:

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

Where

The other data normalization approaches follow the following formula

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

• rescale2 This scales all parameters from (-1 to 1). The relative differences between the parameters are preserved with this approach and the constants are:

  $C_{1}$

  = (max(all unscaled values)+min(all unscaled values))/2

  $C_{2}$

  = (max(all unscaled values) - min(all unscaled values))/2

• rescale or min-max normalization. This rescales all parameters from (0 to 1). As in the rescale2 the relative differences are preserved. In this approach:

  $C_{1}$

  = min(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• mean or mean normalization. This rescales to center the parameters around the mean but the parameters are from 0 to 1. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• std or standardization. This standardizes by the mean and standard deviation. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = sd(all unscaled values)

• len or unit length scaling. This scales the parameters to the unit length. For this approach we use the Euclidean length, that is:

  $C_{1}$

  = 0

  $C_{2}$

  =

  $\sqrt(v_1^2 + v_2^2 + \cdots + v_n^2)$

• constant which does not perform data normalization. That is

  $C_{1}$

  = 0

  $C_{2}$

  = 1

The scaling scheme for nlmixr2. The supported types are:

• nlmixr2 In this approach the scaling is performed by the following equation:

  $v_{scaled}$

  = (

  $v_{current} - v_{init}$

  )*scaleC[i] + scaleTo

  The scaleTo parameter is specified by the normType, and the scales are specified by scaleC.

• norm This approach uses the simple scaling provided by the normType argument.

• mult This approach does not use the data normalization provided by normType, but rather uses multiplicative scaling to a constant provided by the scaleTo argument.

  In this case:

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

• multAdd This approach changes the scaling based on the parameter being specified. If a parameter is defined in an exponential block (ie exp(theta)), then it is scaled on a linearly, that is:

  $v_{scaled}$

  = (

  $v_{current}-v_{init}$

  ) + scaleTo

  Otherwise the parameter is scaled multiplicatively.

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

Maximum value of the scaleC to prevent overflow.

Minimum value of the scaleC to prevent underflow.

The scaling constant used with scaleType=nlmixr2. When not specified, it is based on the type of parameter that is estimated. The idea is to keep the derivatives similar on a log scale to have similar gradient sizes. Hence parameters like log(exp(theta)) would have a scaling factor of 1 and log(theta) would have a scaling factor of ini_value (to scale by 1/value; ie d/dt(log(ini_value)) = 1/ini_value or scaleC=ini_value)

• For parameters in an exponential (ie exp(theta)) or parameters specifying powers, boxCox or yeoJohnson transformations , this is 1.

• For additive, proportional, lognormal error structures, these are given by 0.5*abs(initial_estimate)

• Factorials are scaled by abs(1/digamma(initial_estimate+1))

• parameters in a log scale (ie log(theta)) are transformed by log(abs(initial_estimate))*abs(initial_estimate)

These parameter scaling coefficients are chose to try to keep similar slopes among parameters. That is they all follow the slopes approximately on a log-scale.

While these are chosen in a logical manner, they may not always apply. You can specify each parameters scaling factor by this parameter if you wish.

Scale the initial parameter estimate to this value. By default this is 1. When zero or below, no scaling is performed.

this is the factor that the gradient is scaled to before optimizing. This only works with scaleType="nlmixr2".

'rxode2' ODE solving options during fitting, created with 'rxControl()'

Optimize the rxode2 expression to speed up calculation. By default this is turned on.

Is a boolean indicating if the model should change multiplication to high precision multiplication and sums to high precision sums using the PreciseSums package. By default this is FALSE.

boolean, substitute fixed population values as literals and re-adjust ui and parameter estimates after optimization; Default is 'TRUE'.

specifies the type of additive plus proportional errors, the one where standard deviations add (combined1) or the type where the variances add (combined2).

The combined1 error type can be described by the following equation:

$y = f + (a + b\times f^c) \times \varepsilon$

The combined2 error model can be described by the following equation:

$y = f + \sqrt{a^2 + b^2\times f^{2\times c}} \times \varepsilon$

Where:

- y represents the observed value

- f represents the predicted value

- a is the additive standard deviation

- b is the proportional/power standard deviation

- c is the power exponent (in the proportional case c=1)

This boolean is to determine if the foceiFit will calculate tables. By default this is TRUE

Should the object have compressed items

Method for calculating covariance. In this discussion, R is the Hessian matrix of the objective function. The S matrix is the sum of individual gradient cross-product (evaluated at the individual empirical Bayes estimates).

• "r,s" Uses the sandwich matrix to calculate the covariance, that is: solve(R) %*% S %*% solve(R)

• "r" Uses the Hessian matrix to calculate the covariance as 2 %*% solve(R)

• "s" Uses the cross-product matrix to calculate the covariance as 4 %*% solve(S)

• "" Does not calculate the covariance step.

is a boolean to indicate if the objective function should be adjusted to be closer to NONMEM's default objective function. By default this is TRUE

Confidence level for some tables. By default this is 0.95 or 95% confidence.

Optimization significant digits. This controls:

• The tolerance of the inner and outer optimization is 10^-sigdig

• The tolerance of the ODE solvers is 0.5*10^(-sigdig-2); For the sensitivity equations and steady-state solutions the default is 0.5*10^(-sigdig-1.5) (sensitivity changes only applicable for liblsoda)

• The tolerance of the boundary check is 5 * 10 ^ (-sigdig + 1)

Significant digits in the final output table. If not specified, then it matches the significant digits in the 'sigdig' optimization algorithm. If 'sigdig' is NULL, use 3.

Ignored parameters

The number of points used to approximate the objective function via a quadratic approximation for bobyqa. The value of npt must be in the interval [n+2,(n+1)(n+2)/2] where n is the number of parameters in par. Choices that exceed 2*n+1 are not recommended. If not defined, it will be set to 2*n + 1. (bobyqa)

Beginning change in parameters for bobyqa algorithm (trust region). By default this is 0.2 or 20 parameters when the parameters are scaled to 1. rhobeg and rhoend must be set to the initial and final values of a trust region radius, so both must be positive with 0 < rhoend < rhobeg. Typically rhobeg should be about one tenth of the greatest expected change to a variable. Note also that smallest difference abs(upper-lower) should be greater than or equal to rhobeg*2. If this is not the case then rhobeg will be adjusted. (bobyqa)

The smallest value of the trust region radius that is allowed. If not defined, then 10^(-sigdig-1) will be used. (bobyqa)

The value of 'iprint' should be set to an integer value in '0, 1, 2, 3, ...', which controls the amount of printing. Specifically, there is no output if 'iprint=0' and there is output only at the start and the return if 'iprint=1'. Otherwise, each new value of 'rho' is printed, with the best vector of variables so far and the corresponding value of the objective function. Further, each new value of the objective function with its variables are output if 'iprint=3'. If 'iprint > 3', the objective function value and corresponding variables are output every 'iprint' evaluations. Default value is '0'.

The maximum allowed number of function evaluations. If this is exceeded, the method will terminate.

return the newuoa output instead of the nlmixr2 fit

The number of bad ODE solves before reducing the atol/rtol for the rest of the problem.

Maximum number of times to reduce the ODE tolerances and try to resolve the system if there was a bad ODE solve.

The ODE recalculation factor when ODE solving goes bad, this is the factor the rtol/atol is reduced

Boolean indicating if focei can use ASCII color codes

Number of columns to printout before wrapping parameter estimates/gradient

Integer representing when the outer step is printed. When this is 0 or do not print the iterations. 1 is print every function evaluation (default), 5 is print every 5 evaluations.

This is the type of parameter normalization/scaling used to get the scaled initial values for nlmixr2. These are used with scaleType of.

With the exception of rescale2, these come from Feature Scaling. The rescale2 The rescaling is the same type described in the OptdesX software manual.

In general, all all scaling formula can be described by:

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

Where

The other data normalization approaches follow the following formula

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

• rescale2 This scales all parameters from (-1 to 1). The relative differences between the parameters are preserved with this approach and the constants are:

  $C_{1}$

  = (max(all unscaled values)+min(all unscaled values))/2

  $C_{2}$

  = (max(all unscaled values) - min(all unscaled values))/2

• rescale or min-max normalization. This rescales all parameters from (0 to 1). As in the rescale2 the relative differences are preserved. In this approach:

  $C_{1}$

  = min(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• mean or mean normalization. This rescales to center the parameters around the mean but the parameters are from 0 to 1. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• std or standardization. This standardizes by the mean and standard deviation. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = sd(all unscaled values)

• len or unit length scaling. This scales the parameters to the unit length. For this approach we use the Euclidean length, that is:

  $C_{1}$

  = 0

  $C_{2}$

  =

  $\sqrt(v_1^2 + v_2^2 + \cdots + v_n^2)$

• constant which does not perform data normalization. That is

  $C_{1}$

  = 0

  $C_{2}$

  = 1

The scaling scheme for nlmixr2. The supported types are:

• nlmixr2 In this approach the scaling is performed by the following equation:

  $v_{scaled}$

  = (

  $v_{current} - v_{init}$

  )*scaleC[i] + scaleTo

  The scaleTo parameter is specified by the normType, and the scales are specified by scaleC.

• norm This approach uses the simple scaling provided by the normType argument.

• mult This approach does not use the data normalization provided by normType, but rather uses multiplicative scaling to a constant provided by the scaleTo argument.

  In this case:

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

• multAdd This approach changes the scaling based on the parameter being specified. If a parameter is defined in an exponential block (ie exp(theta)), then it is scaled on a linearly, that is:

  $v_{scaled}$

  = (

  $v_{current}-v_{init}$

  ) + scaleTo

  Otherwise the parameter is scaled multiplicatively.

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

Maximum value of the scaleC to prevent overflow.

Minimum value of the scaleC to prevent underflow.

The scaling constant used with scaleType=nlmixr2. When not specified, it is based on the type of parameter that is estimated. The idea is to keep the derivatives similar on a log scale to have similar gradient sizes. Hence parameters like log(exp(theta)) would have a scaling factor of 1 and log(theta) would have a scaling factor of ini_value (to scale by 1/value; ie d/dt(log(ini_value)) = 1/ini_value or scaleC=ini_value)

• For parameters in an exponential (ie exp(theta)) or parameters specifying powers, boxCox or yeoJohnson transformations , this is 1.

• For additive, proportional, lognormal error structures, these are given by 0.5*abs(initial_estimate)

• Factorials are scaled by abs(1/digamma(initial_estimate+1))

• parameters in a log scale (ie log(theta)) are transformed by log(abs(initial_estimate))*abs(initial_estimate)

These parameter scaling coefficients are chose to try to keep similar slopes among parameters. That is they all follow the slopes approximately on a log-scale.

While these are chosen in a logical manner, they may not always apply. You can specify each parameters scaling factor by this parameter if you wish.

Scale the initial parameter estimate to this value. By default this is 1. When zero or below, no scaling is performed.

'rxode2' ODE solving options during fitting, created with 'rxControl()'

Optimize the rxode2 expression to speed up calculation. By default this is turned on.

Is a boolean indicating if the model should change multiplication to high precision multiplication and sums to high precision sums using the PreciseSums package. By default this is FALSE.

boolean, substitute fixed population values as literals and re-adjust ui and parameter estimates after optimization; Default is 'TRUE'.

specifies the type of additive plus proportional errors, the one where standard deviations add (combined1) or the type where the variances add (combined2).

The combined1 error type can be described by the following equation:

$y = f + (a + b\times f^c) \times \varepsilon$

The combined2 error model can be described by the following equation:

$y = f + \sqrt{a^2 + b^2\times f^{2\times c}} \times \varepsilon$

Where:

- y represents the observed value

- f represents the predicted value

- a is the additive standard deviation

- b is the proportional/power standard deviation

- c is the power exponent (in the proportional case c=1)

This boolean is to determine if the foceiFit will calculate tables. By default this is TRUE

Should the object have compressed items

Method for calculating covariance. In this discussion, R is the Hessian matrix of the objective function. The S matrix is the sum of individual gradient cross-product (evaluated at the individual empirical Bayes estimates).

• "r,s" Uses the sandwich matrix to calculate the covariance, that is: solve(R) %*% S %*% solve(R)

• "r" Uses the Hessian matrix to calculate the covariance as 2 %*% solve(R)

• "s" Uses the cross-product matrix to calculate the covariance as 4 %*% solve(S)

• "" Does not calculate the covariance step.

is a boolean to indicate if the objective function should be adjusted to be closer to NONMEM's default objective function. By default this is TRUE

Confidence level for some tables. By default this is 0.95 or 95% confidence.

Optimization significant digits. This controls:

• The tolerance of the inner and outer optimization is 10^-sigdig

• The tolerance of the ODE solvers is 0.5*10^(-sigdig-2); For the sensitivity equations and steady-state solutions the default is 0.5*10^(-sigdig-1.5) (sensitivity changes only applicable for liblsoda)

• The tolerance of the boundary check is 5 * 10 ^ (-sigdig + 1)

Significant digits in the final output table. If not specified, then it matches the significant digits in the 'sigdig' optimization algorithm. If 'sigdig' is NULL, use 3.

Ignored parameters

an estimate of the size of each parameter at the minimum.

an estimate of the size of f at the minimum.

this argument determines the level of printing which is done during the minimization process. The default value of 0 means that no printing occurs, a value of 1 means that initial and final details are printed and a value of 2 means that full tracing information is printed.

the number of significant digits in the function f.

a positive scalar giving the tolerance at which the scaled gradient is considered close enough to zero to terminate the algorithm. The scaled gradient is a measure of the relative change in f in each direction p[i] divided by the relative change in p[i].

a positive scalar which gives the maximum allowable scaled step length. stepmax is used to prevent steps which would cause the optimization function to overflow, to prevent the algorithm from leaving the area of interest in parameter space, or to detect divergence in the algorithm. stepmax would be chosen small enough to prevent the first two of these occurrences, but should be larger than any anticipated reasonable step.

A positive scalar providing the minimum allowable relative step length.

a positive integer specifying the maximum number of iterations to be performed before the program is terminated.

a logical scalar specifying whether the analytic gradients and Hessians, if they are supplied, should be checked against numerical derivatives at the initial parameter values. This can help detect incorrectly formulated gradients or Hessians.

is a logical that allows a return of the 'nlm' object

tells if ‘nlm' will use nlmixr2’s analytical gradients when available (finite differences will be used for event-related parameters like parameters controlling lag time, duration/rate of infusion, and modeled bioavailability). This can be:

- '"hessian"' which will use the analytical gradients to create a Hessian with finite differences.

- '"gradient"' which will use the gradient and let 'nlm' calculate the finite difference hessian

- '"fun"' where nlm will calculate both the finite difference gradient and the finite difference Hessian

When using nlmixr2's finite differences, the "ideal" step size for either central or forward differences are optimized for with the Shi2021 method which may give more accurate derivatives

The number of bad ODE solves before reducing the atol/rtol for the rest of the problem.

Maximum number of times to reduce the ODE tolerances and try to resolve the system if there was a bad ODE solve.

The ODE recalculation factor when ODE solving goes bad, this is the factor the rtol/atol is reduced

Event gradient type for dosing events; Can be "central" or "forward"

This represents the epsilon when optimizing the ideal step size for numeric differentiation using the Shi2021 method

The maximum number of steps for the optimization of the forward difference step size when using dosing events (lag time, modeled duration/rate and bioavailability)

The hessian type for when calculating the individual hessian by numeric differences (in generalized log-likelihood estimation). The options are "central", and "forward". The central differences is what R's 'optimHess()' uses and is the default for this method. (Though the "forward" is faster and still reasonable for most cases). The Shi21 cannot be changed for the Gill83 algorithm with the optimHess in a generalized likelihood problem.

This represents the epsilon when optimizing the Hessian step size using the Shi2021 method.

Maximum number of times to optimize the best step size for the hessian calculation

Boolean indicating if focei can use ASCII color codes

Number of columns to printout before wrapping parameter estimates/gradient

Integer representing when the outer step is printed. When this is 0 or do not print the iterations. 1 is print every function evaluation (default), 5 is print every 5 evaluations.

This is the type of parameter normalization/scaling used to get the scaled initial values for nlmixr2. These are used with scaleType of.

With the exception of rescale2, these come from Feature Scaling. The rescale2 The rescaling is the same type described in the OptdesX software manual.

In general, all all scaling formula can be described by:

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

Where

The other data normalization approaches follow the following formula

$v_{scaled}$

= (

$v_{unscaled}-C_{1}$

)/

$C_{2}$

• rescale2 This scales all parameters from (-1 to 1). The relative differences between the parameters are preserved with this approach and the constants are:

  $C_{1}$

  = (max(all unscaled values)+min(all unscaled values))/2

  $C_{2}$

  = (max(all unscaled values) - min(all unscaled values))/2

• rescale or min-max normalization. This rescales all parameters from (0 to 1). As in the rescale2 the relative differences are preserved. In this approach:

  $C_{1}$

  = min(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• mean or mean normalization. This rescales to center the parameters around the mean but the parameters are from 0 to 1. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = max(all unscaled values) - min(all unscaled values)

• std or standardization. This standardizes by the mean and standard deviation. In this approach:

  $C_{1}$

  = mean(all unscaled values)

  $C_{2}$

  = sd(all unscaled values)

• len or unit length scaling. This scales the parameters to the unit length. For this approach we use the Euclidean length, that is:

  $C_{1}$

  = 0

  $C_{2}$

  =

  $\sqrt(v_1^2 + v_2^2 + \cdots + v_n^2)$

• constant which does not perform data normalization. That is

  $C_{1}$

  = 0

  $C_{2}$

  = 1

The scaling scheme for nlmixr2. The supported types are:

• nlmixr2 In this approach the scaling is performed by the following equation:

  $v_{scaled}$

  = (

  $v_{current} - v_{init}$

  )*scaleC[i] + scaleTo

  The scaleTo parameter is specified by the normType, and the scales are specified by scaleC.

• norm This approach uses the simple scaling provided by the normType argument.

• mult This approach does not use the data normalization provided by normType, but rather uses multiplicative scaling to a constant provided by the scaleTo argument.

  In this case:

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

• multAdd This approach changes the scaling based on the parameter being specified. If a parameter is defined in an exponential block (ie exp(theta)), then it is scaled on a linearly, that is:

  $v_{scaled}$

  = (

  $v_{current}-v_{init}$

  ) + scaleTo

  Otherwise the parameter is scaled multiplicatively.

  $v_{scaled}$

  =

  $v_{current}$

  /

  $v_{init}$

  *scaleTo

Maximum value of the scaleC to prevent overflow.

Minimum value of the scaleC to prevent underflow.

The scaling constant used with scaleType=nlmixr2. When not specified, it is based on the type of parameter that is estimated. The idea is to keep the derivatives similar on a log scale to have similar gradient sizes. Hence parameters like log(exp(theta)) would have a scaling factor of 1 and log(theta) would have a scaling factor of ini_value (to scale by 1/value; ie d/dt(log(ini_value)) = 1/ini_value or scaleC=ini_value)

• For parameters in an exponential (ie exp(theta)) or parameters specifying powers, boxCox or yeoJohnson transformations , this is 1.

• For additive, proportional, lognormal error structures, these are given by 0.5*abs(initial_estimate)

• Factorials are scaled by abs(1/digamma(initial_estimate+1))

• parameters in a log scale (ie log(theta)) are transformed by log(abs(initial_estimate))*abs(initial_estimate)

These parameter scaling coefficients are chose to try to keep similar slopes among parameters. That is they all follow the slopes approximately on a log-scale.

While these are chosen in a logical manner, they may not always apply. You can specify each parameters scaling factor by this parameter if you wish.

Scale the initial parameter estimate to this value. By default this is 1. When zero or below, no scaling is performed.

this is the factor that the gradient is scaled to before optimizing. This only works with scaleType="nlmixr2".

'rxode2' ODE solving options during fitting, created with 'rxControl()'

Optimize the rxode2 expression to speed up calculation. By default this is turned on.

Is a boolean indicating if the model should change multiplication to high precision multiplication and sums to high precision sums using the PreciseSums package. By default this is FALSE.

boolean, substitute fixed population values as literals and re-adjust ui and parameter estimates after optimization; Default is 'TRUE'.

specifies the type of additive plus proportional errors, the one where standard deviations add (combined1) or the type where the variances add (combined2).

The combined1 error type can be described by the following equation:

$y = f + (a + b\times f^c) \times \varepsilon$

The combined2 error model can be described by the following equation:

$y = f + \sqrt{a^2 + b^2\times f^{2\times c}} \times \varepsilon$

Where:

- y represents the observed value

- f represents the predicted value

- a is the additive standard deviation

- b is the proportional/power standard deviation

- c is the power exponent (in the proportional case c=1)

This boolean is to determine if the foceiFit will calculate tables. By default this is TRUE

Should the object have compressed items

allows selection of "r", which uses nlmixr2's 'nlmixr2Hess()' for the hessian calculation or "nlm" which uses the hessian from 'stats::nlm(.., hessian=TRUE)'. When using ‘nlmixr2’s‘ hessian for optimization or 'nlmixr2’s' gradient for solving this defaults to "nlm" since 'stats::optimHess()' assumes an accurate gradient and is faster than 'nlmixr2Hess'

is a boolean to indicate if the objective function should be adjusted to be closer to NONMEM's default objective function. By default this is TRUE

Confidence level for some tables. By default this is 0.95 or 95% confidence.