efron.petrosian function

NPMLE computation with the first Efron-Petrosian algorithm

This function computes the NPMLE for the cumulative distribution function of X observed under one-sided (right or left) and two-sided (double) truncation. It provides simple bootstrap pointwise confidence limits too.

efron.petrosian(X, U = NA, V = NA, wt = NA, error = NA,
                 nmaxit = NA, boot = TRUE, B = NA, alpha = NA,
                         display.F = FALSE, display.S = FALSE)

Arguments

• X: Numeric vector with the values of the target variable.
• U: Numeric vector with the values of the left truncation variable. If there are no truncation values from the left, put U=NA.
• V: Numeric vector with the values of the right truncation variable. If there are no truncation values from the right, put V=NA.
• wt: Numeric vector of non-negative initial solution, with the same length as X. Default value is set to 1/n, being n the length of X.
• error: Numeric value. Maximum pointwise error when estimating the density associated to X (f) in two consecutive steps. If this is missing, it is $1e-06$.
• nmaxit: Numeric value. Maximum number of iterations. If this is missing, it is set to nmaxit =100 .
• boot: Logical. If TRUE (default), the simple bootstrap method is applied to lifetime distribution estimation. Pointwise confidence bands are provided.
• B: Numeric value. Number of bootstrap resamples . The default NA is equivalent to B =500 .
• alpha: Numeric value. (1-alpha) is the nominal coverage for the pointwise confidence intervals.
• display.F: Logical. Default is FALSE. If TRUE, the estimated cumulative distribution function associated to X, (F) is plotted.
• display.S: Logical. Default is FALSE. If TRUE, the estimated survival function associated to X, (S) is plotted.

Details

The NPMLE for the cumulative distribution function is computed by the first algorithm proposed in Efron and Petrosian (1999) . This is an iterative algorithm which converges to the NMPLE after a number of iterations. If the second (respectively third) argument is missing, computation of the Lynden-Bell estimator for right-truncated (respectively left-truncated) data is obtained. Note that individuals with NAs in the three first arguments will be automatically excluded.

Returns

A list containing the following values:

• time: The timepoint on the curve.

• n.event: The number of events that ocurred at time t.

• events: The total number of events.

• density: The estimated density values.

• cumulative.df: The estimated cumulative distribution values.

• truncation.probs: The probability of X falling into each truncation interval.

• S0: error reached in the algorithm.

• Survival: The estimated survival values.

• n.iterations: The number of iterations used by this algorithm.

• B: Number of bootstrap resamples computed.

• alpha: The nominal level used to construct the confidence intervals.

• upper.df: The estimated upper limits of the confidence intervals for F.

• lower.df: The estimated lower limits of the confidence intervals for F.

• upper.Sob: The estimated upper limits of the confidence intervals for S.

• lower.Sob: The estimated lower limits of the confidence intervals for S.

• sd.boot: The bootstrap standard deviation of F estimator.

• boot.repeat: The number of resamples done in each bootstrap call to ensure the existence and uniqueness of the bootstrap NPMLE.

References

Efron B and Petrosian V (1999) Nonparametric methods for doubly truncated data. Journal of the American Statistical Association 94 , 824-834.

Lynden-Bell D (1971) A method of allowing for known observational selection in small samples applied to 3CR quasars. Monograph National Royal Astronomical Society 155 , 95-118.

Xiao J and Hudgens MG (2020) On nonparametric maximum likelihood estimation with double truncation. Biometrika 106 , 989-996.

Author(s)

Carla Moreira, Jacobo de Uña-Álvarez and Rosa Crujeiras

See Also

lynden

Examples

##  Generating data which are doubly truncated

set.seed(4321)

n<-25
X<-runif(n,0,1)
U<-runif(n,0,0.5)
V<-runif(n,0.5,1)

for (i in 1:n){
        while (X[i]<U[i]|X[i]>V[i]){
        U[i]<-runif(1,0,0.5)
        X[i]<-runif(1,0,1)
        V[i]<-runif(1,0.5,1)
                                           }
                 }
efron.petrosian(X=X,U=U,V=V,boot=FALSE,display.F=TRUE,display.S=TRUE)