The Analytic Method

The analytical functions estimate power from a closed-form expression, so they are useful for rapid scenario exploration. The process is:

1. One-Time Estimation: The function first analyzes the provided reference data to estimate two key parameters:
   • The treatment effect size (e.g., the difference in RMST or the log-RMST ratio).
   • The asymptotic variance of that effect estimator, which measures its uncertainty.
2. Power Formula: It then plugs these fixed estimates into a standard power formula. For a given total sample size N, the power is calculated as: \[ \text{Power} = \Phi\left( \frac{|\beta_{\text{effect}}|}{\sigma_N} - z_{1-\alpha/2} \right) \] where:
   • \(\Phi\) is the cumulative distribution function (CDF) of the standard normal distribution.
   • \(\beta_{\text{effect}}\) is the treatment effect.
   • \(\sigma_N = \frac{\sigma_1}{\sqrt{N}}\) is the standard error of the effect for the target sample size N, which is scaled from the reference data’s variance.
   • \(z_{1-\alpha/2}\) is the critical value from the standard normal distribution (e.g., 1.96 for an alpha of 0.05).

The Bootstrap Method

The bootstrap functions estimate power empirically and therefore require more computation. The process is:

1. Resample: The function simulates a “future trial” of a given sample_size by resampling with replacement from the reference data.
2. Fit Model: On this new bootstrap sample, it performs the full analysis (e.g., calculating weights or pseudo-observations and fitting the specified model).
3. Get P-Value: It extracts the p-value for the treatment effect from the fitted model.
4. Repeat: This process is repeated thousands of times (n_sim).
5. Calculate Power: The final estimated power is the proportion of simulations where the p-value was less than the significance level alpha. \[ \text{Power} = \frac{\text{Number of simulations with } p < \alpha}{n_{\text{sim}}} \]

The Sample Size Search Algorithm

rmst.ss() uses an iterative search algorithm to find the N required to achieve a target_power:

1. Start: The search begins with a sample size of n_start.
2. Calculate Power: It calculates the power for the current_n using either the analytic formula or a full bootstrap simulation.
3. Check Condition:
   • If calculated_power >= target_power, the search succeeds and returns current_n.
   • If not, it increments the sample size (current_n = current_n + n_step) and repeats the process.
4. Stopping Rules: The search terminates if the sample size exceeds max_n or, for bootstrap methods, if the power fails to improve for a set number of patience steps.

The Unified Interface

RMSTpowerBoost exposes all models through two top-level functions that use a familiar Surv()-based formula interface:

Key arguments that control model selection:

The underlying model-specific functions remain exported for direct use when needed.

Selecting an Appropriate Model

Model choice depends on the study design and the assumptions you are willing to make. The table below summarizes typical settings for each approach:

Theory and Model

Based on the methods of (Tian et al. 2014), these functions model the conditional RMST as a linear function of covariates: \[\mathbb{E}[\min(T_i, L) | Z_i] = \beta_0 + \beta_{\text{effect}} \text{Treatment}_i + \beta_2 \text{Covariate}_{i}\] In this model, the expected RMST up to a pre-specified time L for subject i is modeled as a linear combination of their treatment arm and other variables \(Z_i\).

To handle right-censoring, the method uses Inverse Probability of Censoring Weighting (IPCW). This is achieved through the following steps:

1. A survival curve for the censoring distribution is estimated using the Kaplan-Meier method (where “failure” is being censored).
2. For each subject who experienced the primary event, a weight is calculated. This weight is the inverse of the probability of not being censored up to their event time.
3. A standard weighted linear model (lm()) is then fitted using these weights. The model only includes subjects who experienced the event.

Analytical Methods

The analytical functions use a formula based on the asymptotic variance of the regression coefficients to calculate power or sample size, making them fast to evaluate.

Scenario: We use the veteran dataset to estimate power for a trial comparing standard vs. test chemotherapy (trt), adjusting for the Karnofsky performance score (karno).

power_results_vet <- vignette_cache("veteran_power_calc", {
rmst.power(
  Surv(time, status) ~ karno,
  data         = vet,
  arm          = "arm",
  sample_sizes = c(100, 150, 200, 250),
  L            = 270
)
})

ss_results_vet <- vignette_cache("veteran_ss_calc", {
rmst.ss(
  Surv(time, status) ~ karno,
  data         = vet,
  arm          = "arm",
  target_power = 0.40,
  L            = 365,
  n_start = 1000, n_step = 250, max_n = 5000
)
})

Bootstrap Methods

Passing type = "boot" to rmst.power() or rmst.ss() switches to a simulation-based approach. This method repeatedly resamples from the reference data, fits the model on each sample, and calculates power as the proportion of simulations where the treatment effect is significant. It relies less on closed-form large-sample approximations at the cost of greater computation time.

power_boot_vet <- vignette_cache("linear_boot_example", {
rmst.power(
  Surv(time, status) ~ karno,
  data         = vet,
  arm          = "arm",
  sample_sizes = c(150, 200, 250),
  L            = 365,
  type         = "boot",
  n_sim        = 50
)
})

ss_boot_vet <- vignette_cache("linear_boot_ss_example", {
rmst.ss(
  Surv(time, status) ~ karno,
  data         = vet,
  arm          = "arm",
  target_power = 0.5,
  L            = 180,
  type         = "boot",
  n_sim        = 100,
  patience     = 5
)
})

Theory and Model

The semiparametric additive model for RMST, as developed by (Zhang and Schaubel 2024), is defined as: \[\mu_{ij} = \mu_{0j} + \beta'Z_i\] This model assumes that the effect of the covariates \(Z_i\) (which includes the treatment arm) is additive and constant across all strata \(j\). Each stratum has its own baseline RMST, denoted by \(\mu_{0j}\).

The common treatment effect, \(\beta\), is estimated with a stratum-centering approach applied to IPCW-weighted data. This avoids direct estimation of the many \(\mu_{0j}\) parameters.

Analytical Methods

ss_results_colon <- vignette_cache("colon_ss_calc", {
rmst.ss(
  Surv(time, status) ~ 1,
  data         = colon_death,
  arm          = "arm",
  strata       = "strata",
  strata_type  = "additive",
  target_power = 0.60,
  L            = 1825,
  n_start = 100, n_step = 100, max_n = 10000
)
})

power_results_colon <- vignette_cache("additive_power_calc", {
rmst.power(
  Surv(time, status) ~ 1,
  data         = colon_death,
  arm          = "arm",
  strata       = "strata",
  strata_type  = "additive",
  sample_sizes = c(1000, 3000, 5000),
  L            = 1825
)
})

Theory and Model

The multiplicative model, based on the work of (Wang et al. 2019), is defined as: \[\mu_{ij} = \mu_{0j} \exp(\beta'Z_i)\] In this model, the covariates \(Z_i\) have a multiplicative effect on the baseline stratum-specific RMST, \(\mu_{0j}\). This structure is equivalent to a linear model on the log-RMST.

Formal estimation of \(\beta\) requires an iterative solver. This package instead fits a weighted log-linear model (lm(log(Y_rmst) ~ ...)) to approximate the log-RMST ratio and its variance.

Analytical Methods

power_ms_analytical <- vignette_cache("ms_power_analytical_example", {
rmst.power(
  Surv(time, status) ~ 1,
  data         = colon_death,
  arm          = "arm",
  strata       = "strata",
  strata_type  = "multiplicative",
  sample_sizes = c(300, 400, 500),
  L            = 1825
)
})

ms_ss_results_colon <- vignette_cache("ms_ss_analytical_example", {
rmst.ss(
  Surv(time, status) ~ 1,
  data         = colon_death,
  arm          = "arm",
  strata       = "strata",
  strata_type  = "multiplicative",
  target_power = 0.6,
  L            = 1825
)
})

Bootstrap Methods

The bootstrap approach provides a simulation-based analysis for the multiplicative model. Pass type = "boot" together with strata_type = "multiplicative".

power_ms_boot <- vignette_cache("ms_power_boot_example", {
rmst.power(
  Surv(time, status) ~ 1,
  data           = colon_death,
  arm            = "arm",
  strata         = "strata",
  strata_type    = "multiplicative",
  sample_sizes   = c(100, 300, 500),
  L              = 1825,
  type           = "boot",
  n_sim          = 30,
  parallel.cores = 1
)
})

ss_ms_boot <- vignette_cache("ms_ss_boot_example", {
rmst.ss(
  Surv(time, status) ~ 1,
  data           = colon_death,
  arm            = "arm",
  strata         = "strata",
  strata_type    = "multiplicative",
  target_power   = 0.75,
  L              = 1825,
  type           = "boot",
  n_sim          = 30,
  n_start        = 100,
  n_step         = 50,
  patience       = 4,
  parallel.cores = 1
)
})

Theory and Model

These functions use a bootstrap simulation approach combined with a GAM. The method involves two main steps:

1. Jackknife Pseudo-Observations: The time-to-event outcome is first converted into jackknife pseudo-observations for the RMST. This technique (Andersen et al. 2004; Parner and Andersen 2010) creates a continuous, uncensored variable that represents each subject’s contribution to the RMST. This makes the outcome suitable for use in a standard regression framework.

2. GAM Fitting: A GAM is then fitted to these pseudo-observations. The model has the form: \[\mathbb{E}[\text{pseudo}_i] = \beta_0 + \beta_{\text{effect}} \cdot \text{Treatment}_i + \sum_{k=1}^{q} f_k(\text{Covariate}_{ik})\] Here, \(f_k()\) are the non-linear smooth functions (splines) that the GAM estimates from the data.

Bootstrap Methods

Wrap smooth covariates in s() in the formula — this automatically routes to the GAM bootstrap engine regardless of the type argument.

power_gam <- vignette_cache("gbsg_power_calc", {
rmst.power(
  Surv(rfstime, status) ~ s(pgr),
  data           = gbsg_prepared,
  arm            = "arm",
  sample_sizes   = c(50, 200, 400),
  L              = 2825,
  n_sim          = 50,
  parallel.cores = 1
)
})

print(power_gam$results_plot)

ss_gam <- vignette_cache("gbsg_ss_calc", {
rmst.ss(
  Surv(rfstime, status) ~ s(pgr),
  data           = gbsg_prepared,
  arm            = "arm",
  target_power   = 0.95,
  L              = 182,
  n_sim          = 50,
  patience       = 5,
  parallel.cores = 1
)
})