Introduction

This vignette shows how to use the function getDataset() as an utility function to process adjusted means and estimated standard deviations from raw data, how to convert the raw data into an rpact dataset, and finally how to use this information for the analysis at interim and the final stage. Essentially, this is through the use of the CRAN package emmeans that allows the extraction of least squares means from a specified model which is an ANCOVA model in this vignette.

Contents

System: rpact 4.5.0.9315, R version 4.6.1 (2026-06-24), platform: x86_64-pc-linux-gnu

To cite R in publications use:

R Core Team (2026). R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria. doi:10.32614/R.manuals https://doi.org/10.32614/R.manuals. https://www.R-project.org/.

To cite package ‘rpact’ in publications use:

Wassmer G, Pahlke F (2026). rpact: Confirmatory Adaptive Clinical Trial Design and Analysis. R package version 4.5.0.9315. doi:10.32614/CRAN.package.rpact

Wassmer G, Brannath W (2025). Group Sequential and Confirmatory Adaptive Designs in Clinical Trials, 2nd edition. Springer, Cham, Switzerland. ISBN 978-3-031-89668-2. doi:10.1007/978-3-031-89669-9 https://doi.org/10.1007/978-3-031-89669-9.

Define the type of design to be used for the analysis

First, load the rpact package

library(rpact)
packageVersion("rpact")

[1] '4.5.0.9315'

In this vignette, we want to illustrate a design where at interim stages we are able to perform data-driven sample size adaptations. For this purpose, we use the inverse normal combination test for combining the -values from the stages of the trial. This type of design ensures that the Type I error rate is controlled.

We want to use a three stage design with O`Brien and Fleming boundaries and additionally want to consider futility bounds -0.5 and 0.5 for the test statistics at the first and the second stage, respectively. Accordingly,

# Example of an inverse normal combination test:
designIN <- getDesignInverseNormal(
    futilityBounds = c(-0.5, 0.5)
)

defines the design to be used for this purpose. By default, this is a design with three stages, equally spaced information rates and one-sided . The critical values can be displayed on the -value or the -value scale:

designIN |> plot(type = 1)

designIN |> plot(type = 3)

Note that we are using non-binding futility bounds that do not affect the boundaries for the rejection of the null hypothesis. They do however have an effect on the calculation of the conditional power at interim stages.

Creating the design with the function getDesignInverseNormal() fixes how the data are analysed. By default, the unweighted inverse normal combination test is used, i.e., the stage results are combined through the use on the inverse normal combination test statistics

for the second and the third (final) stage of the trial, respectively.

Entering the data

In rpact, the way of using data for adaptive analysis is through summary statistics that summarize the data from the separate stages. Generally, the function getDataset() is used and depending on which summary statistics are entered, rpact knows the type of endpoint and the number of treatment groups. For testing means in a two-treatment parallel group design, means1, means2, stDevs1, stDevs2, n1, and n2 must be defined as vectors with length number of the observed interim stages.

As an example, assume that the following results in the control and the experimental treatment arm were obtained for the first and the second stage of the trial.

First stage:

Second stage:

Here, sample size, mean and standard deviation were obtained separately from the stages. Enter these results as follows to obtain a dataset object in rpact:

datasetExample <- getDataset(
    means1 = c(112.3, 113.1),
    means2 = c(98.1, 99.3),
    stDevs1 = c(44.4, 42.9),
    stDevs2 = c(46.7, 41.1),
    n1 = c(34, 31),
    n2 = c(37, 33)
)

The object datasetExample also contains the cumulative results which were calculated from the separate stage results:

You might alternatively enter the cumulative results by specifying
cumulativeMeans1, cumulativeMeans2, cumulativeStDevs1, cumulativeStDevs2, cumulativeN1, and cumulativeN2 (note that you can also use the prefix cum instead of cumulative for this):

getDataset(
    cumulativeMeans1 = c(112.3, 112.68),
    cumulativeMeans2 = c(98.1, 98.67),
    cumulativeStDevs1 = c(44.4, 43.35),
    cumulativeStDevs2 = c(46.7, 43.84),
    cumulativeN1 = c(34, 65),
    cumulativeN2 = c(37, 70)
)

Analysis results

To apply the specified design to the provided data set, we can use the function getAnalysisResults(). Accordingly, this function requires the arguments design and dataInput. In our case,

results <- getAnalysisResults(
    design = designIN,
    dataInput = datasetExample,
    stage = 2
)

does the job, and the output is

Displayed as summary:

results |> summary()

Note that explicitly specifying the argument stage = 2 is not necessary in this case as it would also be automatically obtained from the data set. However, one may wish to specify stage = 1 in order to obtain the first-stage results only.

The inverse normal combination test statistic at the second stage is calculated to be 1.837, which is smaller than 2.454. Hence, the null hypothesis cannot be rejected, which is also reflected in the repeated -value = 0.0785 larger than and the lower bound of the repeated confidence interval (= -4.803) being smaller than 0 (i.e., the RCI contains the null hypothesis value).

Reassessing the sample size for the last stage

A calculation of the conditional power is performed if the argument nPlanned is specified to getAnalysisResults(). nPlanned contains the (stage-wise) sample sizes of the remaining stages for both treatment groups and is a vector with one observation per remaining stage. For example, if we specify nPlanned = 60, the conditional power is calculated for a total of 60 patients in the 2 treatment groups for the final stage with equal allocation between the treatment groups (the latter can be changed with allocationRatioPlanned which is 1 by default).

results <- getAnalysisResults(
    design = designIN,
    datasetExample,
    stage = 2,
    nPlanned = 60
)

yields the following output:

The conditional power of 0.645 is not very large and so a sample size increase might be appropriate. This conditional power calculation, however, is performed with the observed effect and observed standard deviation and so it might be reasonable to take a look at the effect size and its variability. This is graphically illustrated by the plot of the conditional power and the likelihood function over a range of alternative values. E.g., specify thetaRange = c(0,30) and obtain the graph below.

results |> plot(thetaRange = c(0, 30))

NULL

You can also specify an alternative effect and standard deviation (e.g., thetaH1 = 15, assumedStDev = 35) for which the conditional power should be calculated, and graph the results. Here, the functions getConditionalPower() and getStageResults() are used, but the same result can be obtained when specifying thetaH1 = 15, assumedStDev = 35 in getAnalysisResults().

stageResults <- getStageResults(
    design = designIN,
    dataInput = datasetExample
)

stageResults |>
    getConditionalPower(
        nPlanned = 60,
        thetaH1 = 15,
        assumedStDev = 35
    )

stageResults |>
    plot(
        nPlanned = 60,
        thetaRange = c(0, 30),
        assumedStDev = 35
    )

Overall, using a slightly smaller standard deviation than observed, the conditional power calculated with the originally planned sample size seems to be reasonably high.

Final analysis

Assume now that it was decided to continue with the originally planned sample size ( = 60 per stage) and the final stage shows the results:

Final stage:

We obtain the test results for the final stage and show it as a summary output as follows:

datasetExample <- getDataset(
    means1 = c(112.3, 113.1, 111.3),
    means2 = c(98.1, 99.3, 100.1),
    stDevs1 = c(44.4, 42.9, 41.4),
    stDevs2 = c(46.7, 41.1, 39.5),
    n1 = c(34, 31, 32),
    n2 = c(37, 33, 31)
)

designIN |>
    getAnalysisResults(
        dataInput = datasetExample
    ) |>
    summary()

Calculation of final confidence interval performed for kMax = 3 (for kMax > 2, it is theoretically shown that it is valid only if no sample size change was performed)

The warning indicates that the calculation of the final CI can be critical if sample size changes were performed. This is not the case here, and so the confidence interval that is based on the stagewise ordering given by (0.621, 24.519) is a valid inference tool. Together with the RCI at stage 3 (0.768, 25.31) it corresponds to the test decision of rejecting the null hypothesis. The test decision is also reflected in both the final -value and repeated -value being smaller than .

References

1. Gernot Wassmer and Werner Brannath, Group Sequential and Confirmatory Adaptive Designs in Clinical Trials, Springer 2016, ISBN 978-3319325606

System: rpact 4.5.0.9315, R version 4.6.1 (2026-06-24), platform: x86_64-pc-linux-gnu

To cite R in publications use:

R Core Team (2026). R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria. doi:10.32614/R.manuals https://doi.org/10.32614/R.manuals. https://www.R-project.org/.

To cite package ‘rpact’ in publications use:

Wassmer G, Pahlke F (2026). rpact: Confirmatory Adaptive Clinical Trial Design and Analysis. R package version 4.5.0.9315. doi:10.32614/CRAN.package.rpact

Wassmer G, Brannath W (2025). Group Sequential and Confirmatory Adaptive Designs in Clinical Trials, 2nd edition. Springer, Cham, Switzerland. ISBN 978-3-031-89668-2. doi:10.1007/978-3-031-89669-9 https://doi.org/10.1007/978-3-031-89669-9.

Introduction

This vignette provides examples of how to analyse a trial with multiple arms and a binary endpoint. It shows how to calculate the conditional power at a given stage and how to select/deselect treatment arms. For designs with multiple arms, rpact enables the analysis using the closed combination testing principle. For a description of the methodology please refer to Part III of the book “Group Sequential and Confirmatory Adaptive Designs in Clinical Trials” (Wassmer and Brannath, 2016).

Suppose the trial was conducted as a multi-arm multi-stage trial with three active treatments arms and a control arm when the trial started. In the interim stages, it should be possible to de-select treatment arms if their treatment effect is likely too small to show significance - assuming reasonable sample size - at the end of the trial. This should hold true even if a certain sample size increase was taken into account. For this vignette, the considered endpoint is a failure (i.e., binary) and it is intended to test each active arm against a common control. This is to test the hypotheses in the many-to-one comparisons setting. That is, it is intended to show that the failure rate is smaller in active arms as compared to control and so the power is directed towards negative values of .

Create the design

First, load the rpact package

library(rpact)
packageVersion("rpact") # version should be version 3.0 or later

[1] '4.5.0.9315'

In rpact, we first have to select the combination test with the corresponding stopping boundaries to be used in the closed testing procedure. We choose a design with critical values within the Wang & Tsiatis -class of boundaries with . Planning two interim stages and a final stage, assuming equally sized stages, the design is defined through

designIN <- getDesignInverseNormal(
    kMax = 3, 
    alpha = 0.025,
    typeOfDesign = "WT", 
    deltaWT = 0.25
) 
designIN |> summary()

This definition fixes the weights in the combination test which are the same over the three stages. This is a reasonable choice although the amount of information seems to be not the same over the stages (see Wassmer, 2010).

Analysis

dataRates <- getDataset(
    events1      =  7,
    events2      =  8,
    events3      = 14,
    events4      = 18,
    sampleSizes1 = 42,
    sampleSizes2 = 39,
    sampleSizes3 = 38,
    sampleSizes4 = 41
)

getAnalysisResults(
    design = designIN, 
    dataInput = dataRates,
    directionUpper = FALSE
) |> 
    summary()

results |> plot(type = 2)

options("rpact.summary.output.size" = "small")
getAnalysisResults(
    design = designIN, 
    dataInput = dataRates,
    directionUpper = FALSE, 
    nPlanned = c(80, 80)
) |> 
    summary()

results <- getAnalysisResults(
    design = designIN, 
    dataInput = dataRates,
    directionUpper = FALSE, 
    nPlanned = c(80, 80),
    piTreatments = c(0.17, 0.2, 0.37),
    piControl = 0.44
) 
results |> summary()

results |> plot(
    type = 1, 
    piTreatmentRange = c(0, 0.5), 
    legendPosition = 3)

NULL

dataRates <- getDataset(
    events1 = c(7, 9),
    events2 = c(8, 13),
    events3 = c(14, NA),
    events4 = c(18, 19),
    sampleSizes1 = c(42, 37),
    sampleSizes2 = c(39, 41),
    sampleSizes3 = c(38, NA),
    sampleSizes4 = c(41, 42)
)

options("rpact.summary.output.size" = "small") # small, medium, large
results <- getAnalysisResults(
    design = designIN, 
    dataInput = dataRates,
    directionUpper = FALSE, 
    nPlanned = 40
) 
results |> summary()

NULL

results <- getAnalysisResults(
    design = designIN, 
    dataInput = dataRates,
    directionUpper = FALSE, 
    nPlanned = 40,
    piTreatments = 0.2
)
round(100 * results$conditionalPower[2, 3], 1)

dataRates <- getDataset(
    events1 = c(7, 9, NA),
    events2 = c(8, 13, 7),
    events3 = c(14, NA, NA),
    events4 = c(18, 19, 11),
    sampleSizes1 = c(42, 37, NA),
    sampleSizes2 = c(39, 41, 18),
    sampleSizes3 = c(38, NA, NA),
    sampleSizes4 = c(41, 42, 19)
)

results <- getAnalysisResults(
    design = designIN, 
    dataInput = dataRates,
    directionUpper = FALSE
) 
results |> summary()

Closing remarks

This example describes a range of design modifications, namely selecting treatments arms and performing sample size recalculation for both stages. It is important to recognize that neither the type of adaptation nor the adaptation rule was pre-specified. Despite this, the closed combination test provides control of the experimentwise error rate in the strong sense. To utilize the whole repertoire of possible adaptations, one might also use the conditional rejection probability (i) values in order to completely redefine the design, which includes, for example, to change the number of remaining stages, to change the type of intersection test, or even to add a treatment arm.

Note that in multi-arm designs no final analysis -values, confidence intervals, and median unbiased treatment effect estimates are calculated. This is in contrast to the single hypothesis adaptive designs where, using the stage-wise ordering of the sample space, at the final stage such calculations were done with rpact (for example, see the vignette Analysis of a group sequential trial with a survival endpoint).

System: rpact 4.5.0.9315, R version 4.6.1 (2026-06-24), platform: x86_64-pc-linux-gnu

To cite R in publications use:

R Core Team (2026). R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria. doi:10.32614/R.manuals https://doi.org/10.32614/R.manuals. https://www.R-project.org/.

To cite package ‘rpact’ in publications use:

Wassmer G, Pahlke F (2026). rpact: Confirmatory Adaptive Clinical Trial Design and Analysis. R package version 4.5.0.9315. doi:10.32614/CRAN.package.rpact

Wassmer G, Brannath W (2025). Group Sequential and Confirmatory Adaptive Designs in Clinical Trials, 2nd edition. Springer, Cham, Switzerland. ISBN 978-3-031-89668-2. doi:10.1007/978-3-031-89669-9 https://doi.org/10.1007/978-3-031-89669-9.

Introduction

This tutorial provides two examples:

• The first example illustrates how to get inference (point estimate, confidence interval, and -value) which respect the group sequential design after rejecting the null hypothesis at the interim or final analysis.
• The second example illustrates tools which are relevant for monitoring interim results of an ongoing trial: repeated confidence intervals and conditional power.

For a general introduction to “Inference in group sequential designs”, please refer to the book “Group Sequential and Confirmatory Adaptive Designs in Clinical Trials” by Gernot Wassmer & Werner Brannath.

This tutorial only covers survival endpoints. Code for other endpoints is similar but the dataset needs to be provided in a different format (see ?getDataset for details).

Inference for the Gallium trial which was stopped at an interim analysis

For details about the Gallium trial, we refer to the primary study publication: Marcus et al, N Engl J Med 2017; 377:1331-1344.

library(rpact)
packageVersion("rpact") 

[1] '4.5.0.9315'

# FutilityBounds = c(0,-6) are on the Z-scale; a value of Z = 0 implies futility
# if the interim estimate is "in the wrong direction" (i.e., HR >= 1 here),
# a value of Z = -6 is essentially the same as Z = -Inf and implies no futility
# boundary for the second interim as per the Gallium design
design <- getDesignGroupSequential(
    informationRates = c(113, 245, 370) / 370,
    typeOfDesign = "asOF", sided = 1, alpha = 0.025,
    futilityBounds = c(0, -6), bindingFutility = FALSE
)

# overallLogRanks: One-sided logrank statistic or Z-score ( = log(HR)/SE) from Cox regression
results <- getDataSet(
    overallEvents = c(113, 245),
    overallLogRanks = c(-1.86, -3.225),
    overallAllocationRatio = c(1, 1)
)

results <- getDataSet(
    cumulativeEvents = c(113, 245),
    cumulativeLogRanks = c(-1.86, -3.225),
    cumulativeAllocationRatio = c(1, 1)
)

adj_result <- getAnalysisResults(
    design = design,
    dataInput = results,
    directionUpper = FALSE
)
adj_result

adj_result |> summary()

Example: Monitoring an ongoing trial

Monitoring ongoing trials is also possible with the function getAnalysisResults() introduced above. Repeated confidence intervals which provide valid (but conservative) inference at any stage of an ongoing or stopped group sequential trial can be obtained using the same code as introduced in the previous example. Conditional power calculations require additional specification of the following arguments:

• The assumed true hazard ratio thetaH1.
• The planned number of additional events for future interim stages (nPlanned).
• The planned allocation ratio allocationRatioPlanned for future interim stages (default is 1).

We illustrate these capabilities by introducing hypothetical interim results for the Gallium trial.

Assume the same design as for the Gallium trial introduced above and the following interim results:

Hypothetical results from standard inference at the futility interim analysis after 113 events:

• Stratified HR 0.69 (95% CI 0.47 to 1.01). Trial would continue.
• log(HR) = log(0.69) with standard error 0.20.
• Corresponding Z-score: log(0.69)/0.20 = -1.86.

Hypothetical results from standard inference at the efficacy interim analysis after 245 events:

• Stratified HR 0.80 (95% CI 0.62 to 1.03). Trial would continue.
• log(HR) = log(0.80) with standard error 0.13.
• Corresponding Z-score: log(0.80)/0.13 = -1.716.

Calculation of repeated confidence intervals and conditional power:

# 1) Specify results so far using function getDataset() as before
results <- getDataset(
    cumulativeEvents = c(113, 245),
    cumulativeLogRanks = c(-1.86, -1.716),
    cumulativeAllocationRatio = c(1, 1)
)

# 2) Calculate repeated confidence intervals and conditional power using
# the function getAnalysisResults() as before
# Additional arguments for the conditional power calculation are
# - nPlanned: additional events from second interim until final analysis
#   (370-245 for this trial)
# - thetaH1: True hazard ratio governing future stages
#   (set to 0.74 here as per the original protocol assumptions)
interim_results <- getAnalysisResults(
    design = design,
    dataInput = results,
    directionUpper = FALSE,
    nPlanned = 370 - 245, thetaH1 = 0.74
)
interim_results |> summary()

As per the output above, the recommended action after the second interim analysis of this hypothetical trial would be to continue the trial, a repeated confidence interval for the hazard ratio is (0.582 to 1.108), and the conditional power to reach significance at the final analysis under protocol assumptions is 0.745. Final estimates and -values are still missing as the trial has not stopped yet.

To obtain a plot of the conditional power over a range of alternatives you might call the rpact plot() function and specify the range for theta with thetaRange. This produces the conditional power curve together with the likelihood function over the specified range:

interim_results |> plot(thetaRange = c(0.6, 1))

NULL

Note that nPlanned (the maximum number of remaining events) is extracted from interim_results and can optionally be changed.

If one only wants to calculate the conditional power, then it is computationally more efficient to call the functions getStageResults() and getConditionalPower() instead. The code below illustrates this by plotting the conditional power curve depending on the true treatment effect. The dashed vertical lines in the plot correspond to the protocol hazard ratio of 0.74 and the observed interim hazard ratio of 0.8.

# get stage results so far
stageResults <- getStageResults(design, results, directionUpper = FALSE)

# calculate condition power for true HR ranging from 0.6 to 1
hr <- seq(0.6, 1, by = 0.01)

cpower <- rep(NA, length(hr))
for (i in 1:length(hr)) {
    cpower[i] <- getConditionalPower(stageResults,
        nPlanned = 370 - 245,
        thetaH1 = hr[i]
    )$conditionalPower[3]
}

# Alternatively, use the Vectorize() function for doing this:
cpowerVec <- Vectorize(function(x) {
    getConditionalPower(stageResults,
        nPlanned = 370 - 245,
        thetaH1 = x
    )$conditionalPower[3]
})
cpower <- cpowerVec(hr)

# Plot results
plot(hr, cpower,
    type = "l", xlab = "True hazard ratio",
    ylab = "Conditional power",
    lwd = 2, ylim = c(0, 1), axes = FALSE,
    main = "Conditional power after second interim analysis"
)
axis(1, at = seq(0.6, 1, by = 0.025))
axis(2, at = seq(0, 1, by = 0.1))
abline(v = seq(0.6, 1, by = 0.05), h = seq(0, 1, by = 0.1), col = gray(0.9))
abline(v = c(0.74, 0.8), lty = 2)

System: rpact 4.5.0.9315, R version 4.6.1 (2026-06-24), platform: x86_64-pc-linux-gnu

To cite R in publications use:

R Core Team (2026). R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria. doi:10.32614/R.manuals https://doi.org/10.32614/R.manuals. https://www.R-project.org/.

To cite package ‘rpact’ in publications use:

Wassmer G, Pahlke F (2026). rpact: Confirmatory Adaptive Clinical Trial Design and Analysis. R package version 4.5.0.9315. doi:10.32614/CRAN.package.rpact

Wassmer G, Brannath W (2025). Group Sequential and Confirmatory Adaptive Designs in Clinical Trials, 2nd edition. Springer, Cham, Switzerland. ISBN 978-3-031-89668-2. doi:10.1007/978-3-031-89669-9 https://doi.org/10.1007/978-3-031-89669-9.

Getting started with RPACT Cloud

The best graphical user interface for rpact is available at rpact.cloud. Upon loading the app, you will see the “Design” box where you can click on “Create new design”.

The new design will be started, and opens with a new window. The default setting is for a fixed sample design, which means that there is only one look at the data (1 (fixed sample)). In other words, the default setting is not for a sequential design, but a traditional fixed design where the data is analyzed once.

Using the drop-down menu for the “Maximum number of stages” you can increase the number of looks in the design (you can select a maximum of up to 6 looks).

The rpact package focuses on Confirmatory Adaptive Clinical Trial Design and Analysis. In clinical trials, researchers mostly test directional predictions, and thus the default setting is to perform a one-sided test. Outside of clinical trials, it might be less common to design studies testing a directional prediction, but it is often a good idea. In clinical trials, it is common to use a significance level (or Type I error rate) for one-sided tests, as it is deemed preferable in regulatory settings to set the Type I error rate for one-sided tests at half the conventional Type I error used in two-sided tests. In other fields, such as psychology, researchers typically use a significance level, regardless of whether they perform a one-sided or two-sided test. A default Type II error rate (or power of ) is common in many fields, and is thus the default setting for the Type II error rate in RPACT Cloud.

Remember that you always need to justify your error rates – the defaults are most often not optimal choices in any real-life design (and it might be especially useful to choose a higher power, if possible).

Type I error rate control in sequential designs

We can explore a group sequential design by using the drop-down menu and select, say, 2 stages. The option to choose a design appears below in a new drop-down menu (“Inverse Normal”, “Group Sequential”, and “Fisher’s combination test”), which by default is set to an inverse normal design. Let’s select the group sequential design – this is the type of design we will focus on in this step by step tutorial. The other options are relevant for adaptive designs, which we will not discuss here.

Once a design with more than one stage has been specified, a new drop-down menu which asks you to specify the “Type of design” appears below the “Type II error rate” field. This allows you to choose how you want to control the level across looks. By default, the choice is an O’Brien-Fleming design. Set the “Type of Design” option to “Pocock (P)”. Note there is also a Pocock type -spending (asP) option – we will use that later.

Because most people in social sciences will probably have more experience with two-sided tests at an , we will choose a two-sided test and an for demonstration purposes by altering the respective input fields. The input window should now look like the example below:

Have a look on the “Plot” widget on the right-hand side of the app. The default plot shows the cumulative Type I error rate across the stages. By clicking on the little gear or settings icon on the top right corner in the plot widget, you can change the type of plot. Let’s select “Plot type” to be “Boundaries [1]”.

The critical score at each look is presented, as is a reference line at and . These reference lines are the critical value for a two-sided test with a single look (i.e., a fixed design) with an of 5%. We see that the boundaries on the scale are further away from 0 for the two-stage case compared to the fixed design. This means we need to observe a more extreme score at an analysis to reject . Furthermore, we see that the critical boundaries are constant across both looks. This is exactly the goal of the Pocock correction: At each look, the same proportion of the overall level is spent, where this proportion is calculated in such a way that the overall level is controlled at the pre-specified number (here, 5%). It is conceptually very similar to the Bonferroni correction. We can reproduce the design and the plot in R using the following code:

getDesignGroupSequential(
    kMax = 2,
    typeOfDesign = "P",
    alpha = 0.05,
    sided = 2
) |>
    plot(type = 1)

In the drop-down menu in the “Design” widget on the left again, we can easily change the type of design from “Pocock (P)” to “O’Brien-Fleming (OF)” to see the effect of using different corrections for the critical values across looks in the plot. We see in the plot below that the O’Brien-Fleming correction has a different goal.

The critical value at the first look is very high (which also means the level for this look is very low), but the critical value at the final look is extremely close to the unadjusted critical value of 1.96 (or the level of 0.05). In the code, this change is equally easily achieved by replacing typeOfDesign = "P" with typeOfDesign = "OF":

getDesignGroupSequential(
    kMax = 2,
    typeOfDesign = "OF",
    alpha = 0.05,
    sided = 2
) |>
    plot(type = 1)

To more clearly illustrate the differences between design types, we can plot the corrections for different types of designs for each of 3 looks (2 interim looks and one final look) in the same plot in R. The plot below shows the Pocock, O’Brien-Fleming, Haybittle-Peto, and Wang-Tsiatis correction with . We see that researchers can choose different approaches to spend their -level across looks. Researchers can choose to spend their conservatively (keeping most of the for the last look), or more liberally (spending more at the earlier looks, which increases the probability of stopping early for many true effect sizes). The comparison of multiple design types is facilitated by the rpact function getDesignSet().

# Comparison corrections
d1 <- getDesignGroupSequential(
    typeOfDesign = "OF",
    sided = 2,
    alpha = 0.05
)
d2 <- getDesignGroupSequential(
    typeOfDesign = "P",
    sided = 2,
    alpha = 0.05
)
d3 <- getDesignGroupSequential(
    typeOfDesign = "WT",
    deltaWT = 0.25,
    sided = 2,
    alpha = 0.05
)
d4 <- getDesignGroupSequential(
    typeOfDesign = "HP",
    sided = 2,
    alpha = 0.05
)

getDesignSet(
    designs = c(d1, d2, d3, d4),
    variedParameters = "typeOfDesign"
) |>
    plot(type = 1, legendPosition = 5)

Because the statistical power of a test depends on the level (and the effect size and the sample size), this means that at the final look the statistical power of an O’Brien-Fleming or Haybittle-Peto design is very similar to the statistical power for a fixed design with only one look. If the is lowered, the sample size of a study needs to be increased to maintain the same statistical power at the last look. Therefore, the Pocock correction requires a remarkably larger increase in the maximum sample size than the O’Brien-Fleming or Haybittle-Peto correction. We will discuss these issues in more detail when we consider sample size planning below.

If you head to the “Reporting” tab, you can download an easily readable summary of the main results. Here, you can also see the level you would use for each look at the data (e.g., , and for a O’Brien-Fleming type design with 2 looks): In the table, the row is called “Stage levels (two-sided)”.

Corrected levels can be computed to many digits, but this quickly reaches a level of precision that is meaningless in real life. The observed type I error rate for all tests you will do in your lifetime is not noticeably different if you set the level at 0.0194, 0.019, or 0.02 (see the concept of significant digits). Even as we calculate and use thresholds up to many digits in sequential tests, the messiness of most research makes these levels have false precision. Keep this in mind when interpreting your data.

Note that the RPACT Cloud usefully shows the R code required to reproduce the output in both the “Reporting” and “Design Interim Stages” tabs.

getDesignGroupSequential(
    kMax = 2,
    alpha = 0.05,
    sided = 2
) |>
    summary()

Alpha spending functions

An important contribution to the sequential testing literature was made by Lan and DeMets (1983) who proposed the -spending function approach. In the figure below, the O’Brien-Fleming-like and Pocock-like -spending functions are plotted against the discrete O’Brien-Fleming and Pocock boundaries. We can see that the two approaches are not identical, but very comparable. The main benefit of these spending functions is that the error rate of the study can be controlled, while neither the number nor the timing of the looks needs to be specified in advance. This makes -spending approaches much more flexible. When using an -spending function, it is important that the decision to perform an interim analysis is not based on collected data, as this can still increase the Type I error rate.

d1 <- getDesignGroupSequential(
    typeOfDesign = "P",
    kMax = 5
)
d2 <- getDesignGroupSequential(
    typeOfDesign = "asP",
    kMax = 5
)
d3 <- getDesignGroupSequential(
    typeOfDesign = "OF",
    kMax = 5
)
d4 <- getDesignGroupSequential(
    typeOfDesign = "asOF",
    kMax = 5
)

getDesignSet(
    designs = c(d1, d2, d3, d4),
    variedParameters = "typeOfDesign"
) |>
    plot(type = 1)

Updating boundaries during a study

Although -spending functions control the Type I error rate even when there are deviations from the pre-planned number of looks, or their timing, this does require recalculating the boundaries used in the statistical test based on the amount of information that has been observed. Let us assume a researcher designs a study with three equally spaced looks at the data (two interim looks, one final look), using a Pocock-type spending function, where results will be analyzed in a two-sided t-test with an overall desired Type I error rate of 0.05, and a desired power of 0.9 for a Cohen’s d of 0.5. An a-priori power analysis (which we will explain later in this tutorial) shows that we achieve the desired power in our sequential design if we plan to look after 65.4, 130.9, and 196.3 total observations. Since we cannot collect partial participants, we should round these numbers up, and because we have 2 independent groups, we will collect 66 observations for look 1 (33 in each condition), 132 at the second look (66 in each condition) and 198 at the third look (99 in each condition).

getDesignGroupSequential(
    kMax = 3,
    typeOfDesign = "asP",
    sided = 2,
    alpha = 0.05,
    beta = 0.1
) |>
    getSampleSizeMeans(
        groups = 2,
        alternative = 0.5,
        stDev = 1
    ) |>
    summary()

Now imagine that due to logistical issues, we do not manage to analyze the data until we have collected data from 76 observations (38 in each condition) instead of the planned 66 observations. So our first look at the data does not occur at 33.3% of planned sample, but at 76/198 = 38.4% of the planned sample. We can recalculate the level we should use for each look at the data, based on the current look, and planned future looks. Instead of using the -levels 0.0226, 0.0217, and 0.0217 at the three respective looks (as indicated above in the summary of the originally planned design), we can adjust the information rates in RPACT Cloud:

The updated -levels are 0.0253 for the current look, 0.0204 for the second look, and 0.0216 for the final look. To compute updated bounds in R directly, we can use the code:

getDesignGroupSequential(
    typeOfDesign = "asP",
    informationRates = c(76 / 198, 2 / 3, 1),
    alpha = 0.05,
    sided = 2
) |>
    summary()

It is also possible to correct the -level if the final look at the data changes, for example because you are not able to collect the intended sample size, or because due to unforeseen circumstances you collect more data than planned. If this happens, we can no longer use the -spending function we chose, and instead have to provide a user-defined -spending function by updating the timing and -spending function to reflect the data collection as it actually occurred up to the final look.

Assuming the second look in our earlier example occurred as originally planned, but the last look occurred at 206 participants instead of 198 we can compute an updated -level for the last look. Given the current total sample size, we need to recompute the -levels for the earlier looks, which now occurred at 72/206 = 0.369, 132/206 = 0.641, and for the last look at 206/206 = 1.

Because the first and second look occurred with the adjusted -levels we computed after the first adjustment (-levels of 0.0253 and 0.0382) we can look at the “Cumulative alpha spent” row and see how much of our Type I error rate we spent so far (0.0253 and 0.0382). We also know we want to spend the remainder of our Type I error rate at the last look, for a total of 0.05.

Our actual -spending function is no longer captured by the Pocock spending function after collecting more data than planned, but instead, we have a user defined spending function. We can enter both the updated information rates and the final -spending function directly in RPACT Cloud by selecting the “User defined alpha spending (asUser)” option as “Type of design”:

The output shows the computed -level for this final look is 0.0208 instead of 0.0216. The difference is very small in this specific case, but might be larger depending on the situation. This example shows the flexibility of group sequential designs when -spending functions are used. We can also perform these calculations in R directly:

getDesignGroupSequential(
    typeOfDesign = "asUser",
    informationRates = c(72 / 206, 132 / 206, 1),
    alpha = 0.05,
    sided = 2,
    userAlphaSpending = c(0.0253, 0.0382, 0.05)
) |>
    summary()

Power analysis for group sequential designs

To illustrate an analysis of the sample size/power, we will once again start with the default settings of RPACT Cloud which is for a fixed design with one look. Click on the “Plan a Trial” tab to choose how you want to specify the desired endpoint in this study. We will assume we plan to perform a test, and therefore, that our endpoint is based on the means we observe.

In the “Planning” area, you can specify if you want to calculate the required sample size (to achieve a desired power) or compute the expected power (based on a chosen sample size). For now, we will calculate the sample size required to reach a power of 80%, which is the default value in rpact. By default, the calculation will be for a two-group (independent) test.

The same number of individuals are collected in each group (allocation ratio = 1). It is possible to choose to use a normal approximation (which some software programs use) but the default settings where the calculations are based on the distribution, will be (ever so slightly) more accurate.

The effect under the null hypothesis is 0 by default, the default effect under the alternative is 0.2, and the default standard deviation is 1. This means that by default the power analysis is for a standardized effect size of Cohen’s d = 0.2/1 = 0.2. That is a small effect. In this example, we will assume a researcher is interested in detecting a somewhat more substantial effect size, a mean difference of 0.5. This can be specified by changing the effect under the alternative to 0.5. Note that it is possible to compute the sample size or power for multiple values by selecting a value larger than 1 in the “# values” drop-down menu (but we will calculate power for a single alternative for now).

We can also directly perform these calculations in R. Here, for a fixed sample size design, the significance level and sided = 2 can directly be used within the getSampleSizeMeans() function:

getSampleSizeMeans(
    alpha = 0.05,
    sided = 2,
    alternative = 0.5
) |>
    summary()

These calculations show that for a fixed design, we should collect 128 participants (64 in each condition) to achieve 80% power for a Cohen’s d of 0.5 (or a mean difference of 0.5 with an expected population standard deviation of 1) at a two-sided significance level of 5%.

This result is similar to what can be computed in power analysis software for non-sequential designs, such as G*power.

Sample sizes and power across looks

We will now look at power in a sequential design. Change the slider for the number of looks (kMax) in the “Design” tab to 3. Furthermore, change the Type II error rate to 0.1 (a default of 0.2 is, regardless of what Cohen thought, really a bit large). By default, rpact assumes we will look at the data at equally spaced intervals – after 33%, 67%, and 100% of the data is collected. The default design is an O’Brien-Fleming design, with a one-sided test. Set the effect under the alternative hypothesis in the “Trial Settings” tab to 0.5. We can compute the sample size we would need for a group sequential design to achieve the desired error rates for a specified alternative using the getSampleSizeMeans() function in R.

seq_design_OF <- getDesignGroupSequential(
    kMax = 3,
    typeOfDesign = "OF",
    sided = 1,
    alpha = 0.05,
    beta = 0.1
)

# Compute the sample size we need
power_res_OF <- seq_design_OF |>
    getSampleSizeMeans(
        groups = 2,
        alternative = 0.5,
        stDev = 1,
        allocationRatioPlanned = 1,
        normalApproximation = FALSE
    )

power_res_OF |> summary()

The same output is available in RPACT Cloud under the “Sample Size” tab.

This output shows that at the first look, with a very strict -level of 0.0015, we will have almost no power. Even if there is a true effect of d = 0.5, in only 10.55% of the studies we run will we be able to stop after 33% of the data has been collected (as we see in the row “Overall power” or “Cumulative Power”). One might wonder whether it would even be worth looking at the data at this time point (the answer might very well be ‘no’, and it is not necessary to design equally spaced looks). At the second look, overall power is 62.95%, which gives us a reasonable chance to stop if there is an effect, at the the final look it should be 90%, as this is what we designed the study to achieve. We can also print the full results (instead of just a summary), or select “Details” in RPACT Cloud:

power_res_OF

We see that the maximum number of subjects we would need to collect is 141.8, or rounded up, 142. The expected number of subjects under (when there is no true effect) is 140.9 - we will almost always collect data up to the third look, unless we make a Type I error and stop at the first two looks.

The expected number of subjects under (i.e., d = 0.5) is 107.1. If there is a true effect of d = 0.5, we will stop early in some studies, and therefore the average expected sample size is lower than the maximum.

We can plot the results across a range of possible effect sizes:

sample_res_plot <- seq_design_OF |>
    getPowerMeans(
        groups = 2,
        alternative = seq(0, 1, 0.01),
        stDev = 1,
        allocationRatioPlanned = 1,
        maxNumberOfSubjects = 142, # rounded up
        normalApproximation = FALSE
    )

# code for plot (not run, we show an annotated version of this plot)
# plot(sample_res_plot, type = 6, legendPosition = 6)

To create this plot in RPACT Cloud, you need to specify the design, in the endpoint tab select “Means”, and in the trial settings select “Power” as the calculation target, two groups, and for the number of values, select 20 from the drop-down menu. Specify the lower (i.e., 0) and upper (i.e., 1) value of the mean difference (given the standard deviation of 1, these values will also be Cohen’s d effect sizes). The maximum number of subjects is set to 142 (based on the power analysis we performed above). Go to the “Plot” tab and select the “Expacted Sample Size [6]” plot.

You see that depending on the true effect size there is a decent probability of stopping early (green line) compared to at the final look (red line). Furthermore, the larger the effect size, the lower the Average sample size will be (blue line).

Without sequential analyses, we would collect 142 participants (the maximum sample size specified). But when the true effect size is large, we have a high probability to stop early, and the sample size that one needs to collect will on average (in the long run of doing many sequential designs) be lower.

After this general introduction to the benefits of group sequential designs to efficiently design well powered studies, we will look at more concrete examples of how to perform an a-priori power analysis for sequential designs.

A-priori power analysis in sequential designs

When designing a study where the goal is to test whether a specific effect can be statistically rejected, researchers often want to make sure their sample size is large enough to have sufficient power for an effect size of interest. This is done by performing an a-priori power analysis. Given a specified effect size, -level, and desired power, an a-priori power analysis will indicate the number of observations that should be collected.

An informative study has a high probability of correctly concluding an effect is present when it is present, and absent when it is absent. An a-priori power analysis is used to choose a sample size to achieve desired Type I and Type II error rates, in the long run, given assumptions about the null and alternative model.

We will assume that we want to design a study that can detect a difference of 0.5, with an assumed standard deviation in the population of 1, which means the expected effect is a Cohen’s d of 0.5. If we plan to analyze our hypothesis in a one-sided test (given our directional prediction), set the overall -level to 0.05, and want to achieve a Type II error probability of 0.1 (or a power of 0.9). Finally, we believe it is feasible to perform 2 interim analyses, and one final analysis (e.g., collect the data across three weeks, and we are willing to stop the data collection after any Friday). How many observations would we need?

The decision depends on the final factor we need to decide in a sequential design: the -spending function. We can choose an -spending function as we design our experiment, and compare different choices of a spending function. We will start by examining the sample size we need to collect if we choose an O’Brien-Fleming -spending function.

On the “Endpoint” drop-down menu of RPACT Cloud, we specify means. It is easy to plot power across a range of effect sizes in rpact, by selecting multiple values from the drop-down menu (i.e., 5). We set 0.3 and 0.7 as the lower and upper value, and keep the standard deviation at 1, so that we get the sample sizes for the range of Cohen’s d 0.3 to 0.7.

Sometimes you might have a clearly defined effect size to test against – such as a theoretically predicted effect size, or a smallest practically relevant effect size. Other times, you might primarily know the sample size you can achieve to collect, and you want to perform a sensitivity analysis, where you examine which effect size you can detect with a desired power, given a certain sample size. Plotting power across a range of effect sizes is typically useful. Even if you know which effect size you expect, you might want to look at what would be the consequences of the true effect size being slightly different than expected.

IN the “Plot” tab and from the drop-down menu select “Expected Sample size [6]”. You will see a plot like the one below, created with the R package. From the results (in the row “Maximum number of subjects”), we see that if the true effect size is indeed d = 0.5, we would need to collect at most 141 participants (the result differs very slightly from the power analysis reported above, as we use the O’Brien-Fleming alpha spending function, and not the O’Brien-Fleming correction). In the two rows below, we see that this is based on 71 (rounded up) participants in each condition, so in practice, we would actually collect a total of 142 participants due to upward rounding within each condition.

getDesignGroupSequential(
    typeOfDesign = "asOF",
    alpha = 0.05,
    beta = 0.1
) |>
    getSampleSizeMeans(
        alternative = c(0.3, 0.4, 0.5, 0.6, 0.7)
    ) |>
    summary() |>
    plot(type = 5, legendPosition = 4)

This maximum is only slightly higher than if we had used a fixed design. For a fixed design (which you can examine by moving the slider for the maximum number of stages back to 1), we would need to collect 69.2 participants, or 138.4 in total, while for a sequential design, the maximum sample size per condition is 70.5.

The difference between a fixed design and a sequential design can be calculated by looking at the “Inflation factor”. We can find the inflation factor for the sequential design in the summary title which is 1.0187. In other words, the maximum sample size increased to 69.2 x 1.0187 = 70.5 per condition. The inflation is essentially caused by the reduction in the -level at the final look, and differs between designs (e.g., for a Pocock type alpha spending function, the inflation factor for the current design is larger, namely 1.1595).

However, the maximum sample size is not the expected sample size for this design, because of the possibility that we can stop data collection at an earlier look in the sequential design. In the long run, if d = 0.5, and we use an O’Brien-Fleming -spending function, and ignoring upward rounding because we can only collect a complete number of observations, we will sometimes collect 47 participants and stop after the first look (see the row “Number of subjects, alt. = 0.5”), sometimes 94 and stop after the second look, and sometimes 141 and stop after the last look.

As we see in the row “Exit probability for efficacy (under H1)”, we can stop early 6.75% of the time after look 1, 54.02% after look two, and in the remaining cases we will stop 1 - (0.0675 + 0.5402) = 39.23% of the time at the last look.

This means that, assuming there is a true effect of d = 0.5, the expected sample size on average is the probability of stopping at each look, multiplied by the number of observations we collect at each look, so 0.0675 * 47.0 + 0.5402 * 94.0 + ((1 - (0.0675 + 0.5402)) * 141.0) = 109.3, which matches the row “Expected number of subjects under H1, alt. = 0.5” (again, assuming the alternative hypothesis of d = 0.5 is correct). So, in any single study we might need to collect slightly more data than in a fixed design, but on average we will need to collect fewer observations in a sequential design, namely 109.3, instead of 138.4 in a fixed design (assuming the alternative hypothesis is true).

For a Pocock -spending function the maximum sample size is larger (you can check by changing the spending function). The reason is that the -level at the final look is lower for a Pocock spending function than for the O’Brien-Fleming spending function, and the sample size required to achieve a desired power is thus higher. However, because the -level at the first look is higher, there is a higher probability of stopping early, and therefore the expected sample size is lower for a Pocock spending function (97.7 compared to 109.3). It is up to the researcher to choose a spending function, and weigh how desirable it would be to stop early, given some risk in any single study of increasing the sample size at the final look. For these specific design parameters, the Pocock -spending function might be more efficient on average, but also more risky in any single study.

Stopping for futility

So far, the sequential design would only stop at an interim analysis if we can reject . It is also possible to stop for futility, for example, based on a -spending function. We can directly compare the previous design with a design where we allow stopping for futility. Just as we are willing to distribute our Type I error rate across interim analyses, we can distribute our Type II error rate across looks, and decide to stop for futility when we can reject the presence of an effect at least as large as 0.5, even if we may then be making a Type II error.

If there actually is no effect, such designs are more efficient. One can choose in advance to stop data collection when the presence of the effect the study was designed to detect can be rejected (i.e., binding -spending), but it is typically recommended to allow the possibility to continue data collection (i.e., non-binding -spending). Adding futility bounds based on -spending functions reduces power, and increases the required sample size to reach a desired power, but this is on average compensated by the fact that studies stop earlier due to futility, which can make designs more efficient.

When an -spending function is chosen in RPACT Cloud, a new drop-drown menu appears that allows users to choose a beta-spending function. In the R package, we simply add typeBetaSpending = "bsOF" to the specification of the design. You do not need to choose the same spending approach for and as is done in this example.

getDesignGroupSequential(
    typeOfDesign = "asOF",
    alpha = 0.05,
    beta = 0.1,
    typeBetaSpending = "bsOF"
) |>
    getSampleSizeMeans(alternative = 0.5) |>
    summary()

We see that with a -spending function, the Expected number of subjects under has increased from 109.3 to 111.0. The maximum number of subjects has increased from 141 to 148.2. So, if the alternative hypothesis is true, stopping for futility comes at a cost. However, it is possible that is true.

At the last look in our sequential design, which we designed to have 90% power, we are willing to act as if is true with a 10% error rate. We can reverse the null and alternative hypothesis, and view the same decision process as an equivalence test. In this view, we test whether we can reject the presence of a meaningful effect. For example, if our smallest effect size of interest is a mean difference of 0.5, and we observe a mean difference that is surprisingly far away from 0.5, we can reject the presence of an effect that is large enough to care about. In essence, in such an equivalence test, the Type II error of the original null hypothesis significance test has now become the Type I error rate. Because we have designed our null hypothesis significance test to have 90% power for a mean difference of 0.5, 10% of the time we would incorrectly decide to act as if an effect of at least 0.5 is absent. This is statistically comparable to performing an equivalence test with an -level of 10%, and decide to act as if we can reject the presence of an effect at least as large as 0.5, which should also happen 10% of the time, in the long run.

If we can reject the presence of a meaningful effect, whenever is true, at an earlier look, we would save resources when is true. We see that, in the previous example which did not allow for futility stopping, the expected number of subjects under was 140.2. In other words, when is true, we would continue to the last look most of the time (unless we made a Type 1 error at look 1 or 2). With a -spending function, the expected number of subjects under has decreased substantially, to 99.6 (= 0.1921 * 49.4 + 0.5998 98.8 + (1 - 0.1921 - 0.5998)148.2, or see the print output). The choice of whether you want to use a -spending function depends on the goals of your study. If you believe there is a decent probability is true, and you would like to efficiently conclude this from the data, the use of a -spending approach might be worth considering.

Reporting the results of a sequential analysis

A challenge when wanting to interpret the observed effect size is that whenever a study is stopped early when rejecting , there is a risk that we stopped because, due to random variation, we happened to observe a large effect size at the time of the interim analysis. This means that the observed effect size at these interim analyses over-estimates the true effect.

A similar issue is at play when reporting -values and confidence intervals. When a sequential design is used, the distribution of a -value that does not account for the sequential nature of the design is no longer uniform when is true. A -value is the probability of observing a result at least as extreme as the result that was observed, given that is true. It is no longer straightforward to determine what ‘at least as extreme’ means in a sequential design (Cook, 2002). It is possible to compute adjusted effect size estimates, confidence intervals, and -values in rpact. This currently cannot be done in the rpact cloud.

Imagine we have performed a study planned to have at most 3 equally spaced looks at the data, where we perform a two-sided test with an of 0.05, and we use a Pocock type -spending function, and we observe mean differences between the two conditions of , 95% CI , , at stage 1, , 95% CI , , at stage 2, and , 95% CI , , at the last look. Based on a Pocock-like -spending function with three equally spaced looks the -level at each look for a two-sided test is 0.02264, 0.02174, and 0.02168. We can thus reject after look 3. But we would also like to report an effect size, and adjusted -values and confidence intervals.

The first step is to create a dataset with the results at each look, consisting of the sample sizes, means, and standard deviations. Note that these are the sample sizes, means, and standard deviations only based on the data at each stage. In other words, we compute the means and standard deviations of later looks by excluding the data in earlier looks, so every mean and standard deviation in this example is based on 33 observations in each condition.

data_means <- getDataset(
    n1 = c(33, 33, 33),
    n2 = c(33, 33, 33),
    means1 = c(0.6067868, 0.2795294, 0.7132186),
    means2 = c(0.01976029, 0.08212538, 0.08982903),
    stDevs1 = c(1.135266, 1.35426, 1.013671),
    stDevs2 = c(1.068052, 0.9610714, 1.225192)
)
data_means |> summary()

We then take our design:

seq_design <- getDesignGroupSequential(
    kMax = 3,
    typeOfDesign = "asP",
    sided = 2,
    alpha = 0.05,
    beta = 0.1
)

and compute the results based on the data we entered:

res <- seq_design |>
    getAnalysisResults(
        equalVariances = FALSE,
        dataInput = data_means
    )

We can then print a summary of the results:

res |> summary()

The results show that the action after look 1 and 2 was to continue data collection, and that we could reject at the third look. The unadjusted mean difference is provided in the row “Cumulative effect size” and at the final look this was 0.469. The adjusted mean difference is provided in the row “Median unbiased estimate” and is lower, and the adjusted confidence interval is in the row “Final confidence interval”, giving the result 0.403, 95% CI [0.022, 0.743].

The unadjusted -values for a one-sided tests are reported in the row “Overall p-value”. The actual -values for our two-sided test would be twice as large, so 0.0342596, 0.0495679, 0.0038994. The adjusted -value at the final look is provided in the row “Final p-value” and it is 0.03928.

Conditional power analysis

The probability of finding a significant result, given the data that have been observed up to an interim analysis, is called conditional power. This approach can be useful in adaptive designs - designs where the final sample size is updated based on an early look at the data. In blinded sample size recalculation, no effect size is calculated at an earlier look, but other aspects of the design, such as the standard deviation, are updated. In an unblinded sample size recalculation, the effect size estimate at an early look is used to determine the final sample size.

Let us imagine that we perform a sequential design using a Pocock - and -spending function:

seq_design <- getDesignGroupSequential(
    sided = 1,
    alpha = 0.05,
    beta = 0.1,
    typeOfDesign = "asP",
    typeBetaSpending = "bsP",
    bindingFutility = FALSE
)

We perform an a-priori power analysis based on a smallest effect size of interest of d = 0.38, which yields a maximum number of subjects of 330.

seq_design |>
    getSampleSizeMeans(
        groups = 2,
        alternative = 0.38,
        stDev = 1,
        allocationRatioPlanned = 1,
        normalApproximation = FALSE
    ) |>
    summary()

We first looked at the data after we collected 110 observations. At this time, we observed a mean difference of 0.1. Let us say we assume the population standard deviation is 1, and that we are willing to collect 330 observations in total, as this gave us 90% power for the effect we wanted to detect, a mean difference of 0.38. Given the effect size we observed, which is smaller than our smallest effect size of interest, what is the probability we will find a significant effect if we continue? We create a dataset:

data_means <- getDataset(
    n1 = c(55),
    n2 = c(55),
    means1 = c(0.1), # for directional test, means 1 > means 2
    means2 = c(0),
    stDevs1 = c(1),
    stDevs2 = c(1)
)

and calculate the results to be used in the getConditionalPower() function:

stage_res <- seq_design |>
    getStageResults(
        equalVariances = TRUE,
        dataInput = data_means
    )

We can now perform a conditional power analysis based on the data we have observed so far. An important question is which effect size should be entered. Irrespective of the effect size we expected when designing the study, we have observed an effect of d = 0.1, and the smallest effect size of interest was a d = 0.38. We can compute the power under the assumption that the true effect size is d = 0.1 and d = 0.38:

# Compute conditional power after the first look
stage_res |>
    getConditionalPower(
        nPlanned = c(110, 110), # The sample size planned for the subsequent stages.
        thetaH1 = 0.1, # alternative effect
        assumedStDev = 1 # standard deviation
    )

If the true effect size is 0.1, the power is 0.09 at the final look. Under this assumption, there is little use in continuing the data collection. Under the assumption that the smallest effect size of interest would be true:

# Compute conditional power after the first look
stage_res |>
    getConditionalPower(
        nPlanned = c(110, 110), # The sample size planned for the subsequent stages.
        thetaH1 = 0.38, # alternative effect
        assumedStDev = 1 # standard deviation
    ) |>
    print()

Under the assumption that the smallest effect size of interest exists, there is a reasonable probability of still observing a significant result at the last look (71.26%).

Preregistration and downloading a report

Because of the flexibility in choosing the number of looks, and the -spending function, it is important to preregister your statistical analysis plan. Preregistration allows other researchers to evaluate the severity of a test – how likely were you to find an effect if it is there, and how likely were you to not find an effect if there was no effect. Flexibility in the data analysis increases the Type 1 error rate, or the probability of finding an effect if there actually isn’t any effect (i.e., a false positive), and preregistering your sequential analysis plan can reveal to future readers that you severely tested your prediction.

The use of sequential analyses gives researchers more flexibility. To make sure this flexibility is not abused, the planned experimental design should be preregistered. The easiest way to do this is by either adding the rpact R code, or when the RPACT Cloud is used, to use the export function and store the planned design as a PDF, R Markdown, or R file.

Introduction

In rpact, sample size calculation for a group sequential trial proceeds by following the same two steps regardless of whether the endpoint is a continuous, binary, or a time-to-event endpoint:

1. Define the (abstract) group sequential boundaries of the design using the function getDesignGroupSequential().
2. Calculate sample size for the endpoint of interest by feeding the abstract boundaries from step 1 into specific functions for the endpoint of interest. This step uses functions such as getSampleSizeMeans() (for continuous endpoints), getSampleSizeRates() (for binary endpoints), and getSampleSizeSurvival() (for survival endpoints).

The mathematical rationale for this two-step approach is that all group sequential trials, regardless of the chosen endpoint type, rely on the fact that the -scores at different interim stages follow the same “canonical joint multivariate distribution” (at least asymptotically).

This document covers the more abstract first step, step 2 is not covered in this document but it is covered in the separate endpoint-specific R Markdown files for continuous, binary, and time-to-event endpoints. Of note, step 1 can be omitted for trials without interim analyses.

These examples are not intended to replace the official rpact documentation and help pages but rather to supplement them.

In general, rpact supports both one-sided and two-sided group sequential designs. If futility boundaries are specified, however, only one-sided tests are permitted. For simplicity, it is often preferred to use one-sided tests for group sequential designs (typically, with ).

First, load the rpact package

library(rpact)
packageVersion("rpact") 

[1] '4.5.0.9315'

Designs with efficacy interim analyses

design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "asOF"
)

design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "OF"
)

design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "P"
)

# Quadratic Kim & DeMets alpha-spending
design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "asKD", 
    gammaA = 2
)

# Example: User-defined alpha-spending function which is very conservative at
# first interim (spend alpha = 0.001), conservative at second (spend an additional
# alpha = 0.01, i.e., total cumulative alpha spent is 0.011 up to second interim),
# and spends the remaining alpha at the final analysis (i.e., cumulative
# alpha = 0.025)
design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025,
    informationRates = c(0.33, 0.67, 1),
    typeOfDesign = "asUser",
    userAlphaSpending = c(0.001, 0.01 + 0.001, 0.025)
)
# $stageLevels below extract local significance levels across interim analyses.
# Note that the local significance level is exactly 0.001 at the first
# interim, but slightly >0.01 at the second interim because the design
# exploits correlations between interim analyses.
design$stageLevels

[1] 0.00100000 0.01052883 0.02004781

Designs with efficacy and futility interim analyses

# Example: non-binding futility boundary at each interim in case
# estimated treatment effect is null or goes in "the wrong direction"
design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "asOF",
    futilityBounds = c(0, 0), 
    bindingFutility = FALSE
)

# Example: beta-spending function approach with O'Brien & Fleming alpha-spending
# function and Pocock beta-spending function
design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025, 
    beta = 0.1,
    typeOfDesign = "asOF",
    typeBetaSpending = "bsP"
)

# Example: beta-spending function approach with O'Brien & Fleming boundaries for
# rejecting the null and Pocock boundaries for rejecting H1
design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025, 
    beta = 0.1,
    typeOfDesign = "PT",
    deltaPT1 = 0, 
    deltaPT0 = 0.5
)

Designs with futility interim analyses only

Designs which only use interim analyses for potential futility stopping can be implemented by using a user-defined -spending function which spends all of the Type I error at the final analysis. Note that such designs do not allow stopping for efficacy regardless how persuasive the effect is.

# Example: non-binding futility boundary using an O'Brien & Fleming type
# beta spending function. No early stopping for efficacy (i.e., all alpha
# is spent at the final analysis).
design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025, beta = 0.2,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "asUser",
    userAlphaSpending = c(0, 0, 0.025), 
    typeBetaSpending = "bsOF",
    bindingFutility = FALSE
)

Changed type of design to 'noEarlyEfficacy'

As indicated by the note, you can alternatively specify typeOfDesign = "noEarlyEfficacy" which is a shortcut for typeOfDesign = "asUser" and userAlphaSpending = c(0, 0, 0.025).

Interpreting, accessing and printing rpact boundary objects

We use the design with an O’Brien & Fleming -spending function and prespecified futility bounds:

design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025, 
    beta = 0.2,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "asOF",
    futilityBounds = c(0, 0), 
    bindingFutility = FALSE
)

design

design |> names()

 [1] "kMax"                   "alpha"                  "stages"                
 [4] "informationRates"       "userAlphaSpending"      "criticalValues"        
 [7] "stageLevels"            "alphaSpent"             "bindingFutility"       
[10] "directionUpper"         "tolerance"              "typeOfDesign"          
[13] "beta"                   "deltaWT"                "deltaPT1"              
[16] "deltaPT0"               "futilityBounds"         "gammaA"                
[19] "gammaB"                 "optimizationCriterion"  "sided"                 
[22] "betaSpent"              "typeBetaSpending"       "userBetaSpending"      
[25] "efficacyStops"          "futilityStops"          "power"                 
[28] "twoSidedPower"          "constantBoundsHP"       "betaAdjustment"        
[31] "delayedInformation"     "decisionCriticalValues" "reversalProbabilities" 

design |> summary()

designChar <- design |> getDesignCharacteristics()
designChar

designChar |> names()

 [1] "nFixed"                 "shift"                  "inflationFactor"       
 [4] "stages"                 "information"            "power"                 
 [7] "rejectionProbabilities" "futilityProbabilities"  "averageSampleNumber1"  
[10] "averageSampleNumber01"  "averageSampleNumber0"  

# theta = 0 for calculations under H0
getPowerAndAverageSampleNumber(design,
    theta = c(0), 
    nMax = designChar$shift
)

# theta = 1 for calculations under alternative H1
getPowerAndAverageSampleNumber(design,
    theta = 1, 
    nMax = designChar$shift
)

Plotting rpact boundary objects

We use again the design with an O’Brien & Fleming -spending function and prespecified futility bounds:

design <- getDesignGroupSequential(
    sided = 1, 
    alpha = 0.025, 
    beta = 0.2,
    informationRates = c(0.33, 0.67, 1), 
    typeOfDesign = "asOF",
    futilityBounds = c(0, 0), 
    bindingFutility = FALSE
)

Boundaries can be plotted using the plot (or plot.TrialDesign) function which produces a ggplot2 object.

The most relevant plots for (abstract) boundaries without easily interpretable treatment effect are boundary plots on -scale (type = 1) or -value-scale (type = 3) as well as plots of the -spending function (type = 4). Conveniently, argument showSource = TRUE also provides the source data for the plot. For examples of all available plots, see the R Markdown document How to create admirable plots with rpact.

design |> plot(type = 1, showSource = TRUE)

Source data of the plot (type 1):
  x-axis: <environment>$informationRates
  y-axes:
    y1: c(<environment>$futilityBounds, <environment>$criticalValues[length(<environment>$criticalValues)])
    y2: <environment>$criticalValues
Simple plot command examples:
  plot(<environment>$informationRates, c(<environment>$futilityBounds, <environment>$criticalValues[length(<environment>$criticalValues)]), type = "l")
  plot(<environment>$informationRates, <environment>$criticalValues, type = "l")

design |> plot(type = 3, showSource = TRUE)

Source data of the plot (type 3):
  x-axis: <environment>$informationRates
  y-axis: <environment>$stageLevels
Simple plot command example:
  plot(<environment>$informationRates, <environment>$stageLevels, type = "l")

design |> plot(type = 4, showSource = TRUE)

Source data of the plot (type 4):
  x-axis: <environment>$informationRates
  y-axis: <environment>$alphaSpent
Simple plot command example:
  plot(<environment>$informationRates, <environment>$alphaSpent, type = "l")

Decision regions for two-sided tests with futility bounds are displayed accordingly:

design <- getDesignGroupSequential(
    sided = 2, 
    alpha = 0.05, 
    beta = 0.2,
    informationRates = c(0.33, 0.67, 1),
    typeOfDesign = "asOF",
    typeBetaSpending = "bsP",
    bindingFutility = FALSE
)
design |> plot(type = 1)

Comparison of multiple designs

Multiple designs can be combined into a design set (getDesignSet()) and their properties plotted jointly:

# O'Brien & Fleming, 3 equally spaced stages
d1 <- getDesignGroupSequential(
  typeOfDesign = "OF", 
  kMax = 3
)
# Pocock
d2 <- getDesignGroupSequential(
  typeOfDesign = "P", 
  kMax = 3
)
designSet <- getDesignSet(
  designs = c(d1, d2), 
  variedParameters = "typeOfDesign"
)

designSet |> plot(type = 1)

Even simpler, in rpact 3.0, you can also use plot(d1, d2).

System: rpact 4.5.0.9315, R version 4.6.1 (2026-06-24), platform: x86_64-pc-linux-gnu

To cite R in publications use:

R Core Team (2026). R: A Language and Environment for Statistical Computing. R Foundation for Statistical Computing, Vienna, Austria. doi:10.32614/R.manuals https://doi.org/10.32614/R.manuals. https://www.R-project.org/.

To cite package ‘rpact’ in publications use:

Wassmer G, Pahlke F (2026). rpact: Confirmatory Adaptive Clinical Trial Design and Analysis. R package version 4.5.0.9315. doi:10.32614/CRAN.package.rpact

Wassmer G, Brannath W (2025). Group Sequential and Confirmatory Adaptive Designs in Clinical Trials, 2nd edition. Springer, Cham, Switzerland. ISBN 978-3-031-89668-2. doi:10.1007/978-3-031-89669-9 https://doi.org/10.1007/978-3-031-89669-9.

Introduction

In rpact version 3.3, the group sequential methodology from Hampson and Jennison (2013) is implemented. As traditional group sequential designs are characterized specifically by the underlying boundary sets, one main task was to write a function returning the decision critical values according to the calculation rules in Hampson and Jennison (2013). The function returning the respective critical values has been validated, particularly via simulation towards Type I error rate control in various settings (for an example see below). Subsequently, functions characterizing a delayed response group sequential test in terms of power, maximum sample size and expected sample size have been written. These functions were integrated in the rpact functions getDesignGroupSequential(), getDesignCharacteristics(), and the corresponding getSampleSize...() and getPower...() functions.

Methodology

The classical group sequential methodology works on the assumptions of having no treatment response delay, i.e., it is assumed that enrolled subjects are observed upon recruitment or at least shortly after. In many practical situations, this assumption does not hold true. Instead, it might be that there is a latency between the timing of recruitment and the actual measurement of a primary endpoint. That is, at interim there is some information in pipeline.

One method to handle this pipeline information was proposed by Hampson & Jennison (2013) and is called delayed response group sequential design. Assume that, in a -stage trial, given we will proceed to the trial end, we will observe an information sequence , and the corresponding -statistics . As we now have information in pipeline, define as the information available after awaiting the delay after having observed . Let be the vector of -statistics that are calculated based upon the information levels . Given boundary sets , and , a -stage delayed response group sequential design has the following structure:

That is, at each of the interim analyses, there is information outstanding. If does not fall within , the conclusion is to stop the trial neither for efficacy nor for futility (as it would be in a traditional group sequential design), but to irreversibly stop the recruitment. Afterwards, the outstanding data is awaited such that after awaiting the delayed information fraction of time, information is available and a new -statistic can be calculated. This statistic is then used to test the actual hypothesis of interest using a decision critical value . The heuristic idea is that the recruitment is stopped only if one is “confident about the subsequent decision”. This means that if the recruitment has been stopped for , it should be likely to obtain a subsequent rejection. In contrast, if the recruitment is stopped for , obtaining a subsequent rejection should be rather unlikely (but still possible).

The main difference to a group sequential design is that due to the delayed information, each interim potentially consists of two analyses: a recruitment stop analysis and, if indicated, a subsequent decision analysis. Hampson & Jennison (2013) propose to define the boundary sets and as error-spending boundaries determined using -spending and -spending functions in the one-sided testing setting with binding futility boundaries. In rpact, this methodology is extended to (one-sided) testing situations where (binding or non-binding) futility boundaries are available. According to Hampson & Jennison (2013), the boundaries with are chosen such that “reversal probabilities” are balanced. More precisely, is chosen as the (unique) solution of:

and for , is the (unique) solution of:

It can easily be shown that this constraint yields critical values that ensure Type I error rate control. We call this approach the reverse probabilities approach.

The values , , are determined via a root-search. Having determined all applicable boundaries, the rejection probability of the procedure given a treatment effect is:

i.e., the probability to firstly stop the recruitment, followed by a rejection at any of the stages. Setting , this expression gives the Type I error rate. These values are calculated also for and specified maximum sample size (in the prototype case of testing against with ).

As for the group sequential designs, the inflation factor, , of a delayed response design is the maximum sample size, , to achieve power for testing against (in the prototype case) relative to the fixed sample size, :

Let denote the number of subjects observed at the -th recruitment stop analysis and the number of subjects recruited at the subsequent -th decision analysis. Given , it holds that

The expected sample size, , of a delayed response design is:

with . As for the maximum sample size, this is provided relative to the sample size in a fixed sample design, i.e., as the expected reduction in sample size.

Examples

We illustrate the calculation of decision critical values and design characteristics using the described approach for a three-stage group sequential design with Kim & DeMets - and -spending functions with .

First, load the rpact package

library(rpact)
packageVersion("rpact") # version should be version 3.3 or later

[1] '4.5.0.9315'

gsdWithDelay <- getDesignGroupSequential(
    kMax = 3,
    alpha = 0.025,
    beta = 0.2,
    typeOfDesign = "asKD",
    gammaA = 2,
    gammaB = 2,
    typeBetaSpending = "bsKD",
    informationRates = c(0.3, 0.7, 1),
    delayedInformation = c(0.16, 0.2),
    bindingFutility = TRUE
)

gsdWithDelay

gsdWithDelay |> getDesignCharacteristics()

gsdWithDelay |> summary()

rpact:::getSimulatedRejectionsDelayedResponse(gsdWithDelay, iterations = 10^6)

$simulatedAlpha
[1] 0.024733

$delta
[1] 0

$iterations
[1] 1000000

$seed
[1] -945806944

$confidenceIntervall
[1] 0.02442859 0.02503741

$alphaWithin95ConfidenceIntervall
[1] TRUE

$time
Time difference of 4.870353 secs

gsdWithoutDelay <- getDesignGroupSequential(
    kMax = 3,
    alpha = 0.025,
    beta = 0.2,
    typeOfDesign = "asKD",
    gammaA = 2,
    gammaB = 2,
    typeBetaSpending = "bsKD",
    informationRates = c(0.3, 0.7, 1),
    bindingFutility = TRUE
)
gsdWithoutDelay |> 
  summary()

# use calculated sample size for the prototype case
nMax <- getDesignCharacteristics(gsdWithDelay)$shift 
deltaRange <- seq(-0.2, 1.5, 0.05)
ASN <- getPowerMeans(gsdWithDelay,
    groups = 1, normalApproximation = TRUE, alternative = deltaRange,
    maxNumberOfSubjects = nMax
)$expectedNumberOfSubjects
dat <- data.frame(delta = deltaRange, ASN = ASN, delay = "delay")
ASN <- getPowerMeans(gsdWithoutDelay,
    groups = 1, normalApproximation = TRUE, alternative = deltaRange,
    maxNumberOfSubjects = nMax
)$expectedNumberOfSubjects
dat <- rbind(dat, data.frame(delta = deltaRange, ASN = ASN, delay = "no delay"))

library(ggplot2)
myTheme <- theme(
    axis.title.x = element_text(size = 14),
    axis.text.x = element_text(size = 14),
    axis.title.y = element_text(size = 14),
    axis.text.y = element_text(size = 14)
)

ggplot(data = dat, aes(x = delta, y = ASN, group = delay, linetype = factor(delay))) +
    geom_line(size = 0.8) +
    ylim(0, ceiling(nMax)) +
    myTheme +
    theme_classic() +
    xlab("alternative") +
    ylab("Expected number of subjects") +
    geom_hline(size = 1, yintercept = nMax, linetype = "dotted") +
    geom_vline(size = 0.6, xintercept = 0, linetype = "dotted") +
    geom_vline(size = 0.6, xintercept = 0.5, linetype = "dotted") +
    geom_vline(size = 0.6, xintercept = 1, linetype = "dotted") +
    labs(linetype = "") +
    annotate(geom = "text", x = 0, y = nMax - 0.3, label = "fixed sample size", size = 4)

reject <- c(
    getPowerMeans(gsdWithDelay,
        groups = 1, normalApproximation = TRUE, alternative = deltaRange,
        maxNumberOfSubjects = nMax
    )$overallReject,
    getPowerMeans(gsdWithoutDelay,
        groups = 1, normalApproximation = TRUE, alternative = deltaRange,
        maxNumberOfSubjects = nMax
    )$overallReject
)
dat$reject <- reject

ggplot(data = dat, aes(x = delta, y = reject, group = delay, linetype = factor(delay))) +
    geom_line(size = 0.8) +
    ylim(0, 1) +
    myTheme +
    theme_classic() +
    xlab("alternative") +
    ylab("rejection probability") +
    geom_hline(size = 1, yintercept = 1 - gsdWithDelay$beta, linetype = "dotted") +
    geom_vline(size = 0.6, xintercept = 0, linetype = "dotted") +
    geom_vline(size = 0.6, xintercept = 0.5, linetype = "dotted") +
    geom_vline(size = 0.6, xintercept = 1, linetype = "dotted") +
    labs(linetype = "")

gsdTwoStagesWithDelay <- getDesignGroupSequential(
    kMax = 2,
    alpha = 0.025,
    beta = 0.2,
    typeOfDesign = "asOF",
    typeBetaSpending = "bsOF",
    informationRates = c(0.3, 1),
    delayedInformation = 5 / 24,
    bindingFutility = TRUE
)
results <- getPowerMeans(
    design = gsdTwoStagesWithDelay,
    groups = 2,
    normalApproximation = TRUE,
    alternative = 0.3,
    stDev = 1,
    maxNumberOfSubjects = 350
)

# expected number of subjects table 5.2
round(results$expectedNumberOfSubjects / 2, 3)

[1] 172.6

# expected trial duration table 5.2
round(results$earlyStop * 17.2 + (1 - results$earlyStop) * 29, 3)

[1] 28.671

# power table 5.2
round(results$overallReject, 3)

[1] 0.798

gsdTwoStagesWithoutDelay <- getDesignGroupSequential(
    kMax = 2,
    alpha = 0.025,
    beta = 0.2,
    typeOfDesign = "asOF",
    typeBetaSpending = "bsOF",
    informationRates = c(0.3 + 5 / 24, 1),
    bindingFutility = FALSE
)

results <- getPowerMeans(
    design = gsdTwoStagesWithoutDelay,
    groups = 2,
    normalApproximation = TRUE,
    alternative = 0.3,
    stDev = 1,
    maxNumberOfSubjects = 350
)

# expected number of subjects table 5.2
round(results$expectedNumberOfSubjects / 2, 3)

[1] 153.053

# expected trial duration table 5.2
round(results$earlyStop * 17.2 + (1 - results$earlyStop) * 34, 3)

[1] 29.715

# power table 5.2
round(results$overallReject, 3)

[1] 0.779

gsdWithDelay |> plot()

An alternative approach

The approach described so far uses the identity of reversal probabilities to derive the decision boundaries. An alternative approach is to demand two conditions for rejecting the null at a given stage of the trial and spend a specified amount of significance at this stage. This definition is independent of the specification of futility boundaries but can be used with these as well. We show how the (new) rpact function getGroupSequentialProbabilities() can handle this situation.

###   Derive decision boundaries for delayed response alpha spending approach
alpha <- 0.025
gammaA <- 1.345
tolerance <- 1E-6
#     Specify use function
spend <- function(x, size, gamma) {
    return(size * x^gamma)
}

infRates <- c(28, 54, 96) / 96
kMax <- length(infRates)
delay <- rep(16, kMax - 1) / 96
u <- rep(NA, kMax)
c <- rep(qnorm(1 - alpha), kMax - 1)

for (k in (1:kMax)) {
    if (k < kMax) {
        infRatesPlusDelay <- c(infRates[1:k], infRates[k] + delay[k])
    } else {
        infRatesPlusDelay <- infRates
    }
    u[k] <- uniroot(
        function(x) {
            if (k == 1) {
                d <- matrix(c(
                    x, c[k],
                    Inf, Inf
                ), nrow = 2, byrow = TRUE)
            } else if (k < kMax) {
                d <- matrix(c(
                    rep(-Inf, k - 1), x, c[k],
                    u[1:(k - 1)], Inf, Inf
                ), nrow = 2, byrow = TRUE)
            } else {
                d <- matrix(c(
                    rep(-Inf, k - 1), x,
                    u[1:(k - 1)], Inf
                ), nrow = 2, byrow = TRUE)
            }
            probs <- getGroupSequentialProbabilities(d, infRatesPlusDelay)
            if (k == 1) {
                probs[2, k + 1] - probs[1, k + 1] - spend(infRates[k], alpha, gammaA)
            } else if (k < kMax) {
                probs[2, k + 1] - probs[1, k + 1] - (spend(infRates[k], alpha, gammaA) -
                    spend(infRates[k - 1], alpha, gammaA))
            } else {
                probs[2, k] - probs[1, k] - (spend(infRates[k], alpha, gammaA) -
                    spend(infRates[k - 1], alpha, gammaA))
            }
        },
        lower = -8, upper = 8
    )$root
}
round(u, 5)