Nothing
## |
## | rpact: Confirmatory Adaptive Clinical Trial Design and Analysis
## | This file is part of the rpact R package.
## |
## | RPACT — Statistical Tools for Drug Development
## |
## | Authors: Gernot Wassmer, PhD, and Friedrich Pahlke, PhD
## | SPDX-FileCopyrightText: RPACT GmbH, Germany <info@rpact.com>
## | SPDX-License-Identifier: LGPL-3.0-only
## |
## | Licensed under the GNU Lesser General Public License, version 3.
## | License text: https://www.gnu.org/licenses/lgpl-3.0.html
## |
## | Package documentation: https://www.rpact.org
## | Resources and customer portal: https://connect.rpact.app
## | Consulting and services: https://www.rpact.com
## | Contact: info@rpact.com
## |
#' @include f_core_utilities.R
#' @include f_core_assertions.R
NULL
.createSummaryHypothesisText <- function(object, summaryFactory) {
if (!inherits(object, "AnalysisResults") && !inherits(object, "TrialDesignPlan") &&
!inherits(object, "SimulationResults")) {
stopIllegalArgument("'object' must be an instance of class ",
"'AnalysisResults', 'TrialDesignPlan' ",
"or 'SimulationResults' (is ", .getClassName(object, quote = TRUE), ")",
functionName = ".createSummaryHypothesisText",
parameter = "object",
value = .getClassName(object)
)
}
design <- object[[".design"]]
if (is.null(design)) {
stopRuntimeIssue("'.design' must be defined in specified ", .getClassName(object),
functionName = ".createSummaryHypothesisText",
parameter = ".design"
)
}
settings <- .getSummaryObjectSettings(object)
sided <- ifelse(settings$multiArmEnabled || settings$enrichmentEnabled, 1, design$sided)
directionUpper <- object[["directionUpper"]]
if (is.null(directionUpper) || length(directionUpper) != 1 || is.na(directionUpper)) {
directionUpper <- TRUE
}
comparisonH0 <- " = "
comparisonH1 <- NA_character_
if (inherits(object, "AnalysisResults") && !is.null(directionUpper)) {
comparisonH1 <- ifelse(sided == 2, " != ", ifelse(!isFALSE(directionUpper), " > ", " < "))
}
if (!is.null(object[["thetaH0"]])) {
thetaH0 <- object$thetaH0
} else {
thetaH0 <- ifelse(settings$survivalEnabled, 1, 0)
}
treatmentArmIndex <- ifelse(settings$groups > 1, "(i)", "(treatment)")
controlArmIndex <- ifelse(settings$groups > 1, "(i)", "(control)")
if (settings$multiArmEnabled || settings$enrichmentEnabled) {
if ((settings$survivalEnabled) && (settings$multiArmEnabled)) {
treatmentArmIndex <- "(i)"
controlArmIndex <- ""
} else if ((settings$survivalEnabled) && (settings$enrichmentEnabled)) {
treatmentArmIndex <- ""
controlArmIndex <- ""
} else if (settings$groups == 1) {
treatmentArmIndex <- "(treatment)"
controlArmIndex <- "(control)"
} else {
if (settings$enrichmentEnabled) {
treatmentArmIndex <- "(treatment)"
} else {
treatmentArmIndex <- "(i)"
}
controlArmIndex <- "(control)"
}
} else {
if (settings$groups == 1 || settings$survivalEnabled) {
treatmentArmIndex <- ""
controlArmIndex <- ""
} else {
treatmentArmIndex <- "(1)"
controlArmIndex <- "(2)"
}
}
value <- "?"
if (settings$generalEnabled) {
value <- "theta"
} else if (settings$meansEnabled) {
value <- "mu"
} else if (settings$ratesEnabled) {
value <- "pi"
} else if (settings$survivalEnabled) {
value <- "hazard ratio"
} else if (settings$countDataEnabled) {
value <- "lambda"
}
calcSep <- ifelse(settings$ratioEnabled || settings$countDataEnabled, " / ", " - ")
hypothesis <- ""
if (!settings$survivalEnabled && (settings$multiArmEnabled ||
settings$enrichmentEnabled || settings$groups == 2)) {
hypothesis <- paste0(
hypothesis, "H0: ", value, treatmentArmIndex,
calcSep, value, controlArmIndex, comparisonH0, thetaH0
)
if (!is.na(comparisonH1)) {
hypothesis <- paste0(hypothesis, " against ")
hypothesis <- paste0(
hypothesis, "H1: ", value, treatmentArmIndex,
calcSep, value, controlArmIndex, comparisonH1, thetaH0
)
}
} else {
hypothesis <- paste0(hypothesis, "H0: ", value, treatmentArmIndex, comparisonH0, thetaH0)
if (!is.na(comparisonH1)) {
hypothesis <- paste0(hypothesis, " against ")
hypothesis <- paste0(hypothesis, "H1: ", value, treatmentArmIndex, comparisonH1, thetaH0)
}
}
hypothesis <- .concatenateSummaryText(
hypothesis,
.createSummaryHypothesisPowerDirectionText(object, sided, directionUpper)
)
return(hypothesis)
}
.createSummaryHypothesisPowerDirectionText <- function(object, sided, directionUpper) {
if (sided == 2 || is.null(directionUpper) || all(is.na(directionUpper))) {
return("")
}
directionUpper <- unique(directionUpper)
if (length(directionUpper) != 1) {
return("")
}
if (inherits(object, "AnalysisResults")) {
return("")
}
if (.isTrialDesignPlan(object) && !object$.isPowerObject()) {
return("")
}
if (directionUpper) {
return("power directed towards larger values")
} else {
return("power directed towards smaller values")
}
}
.createSummary <- function(
object,
digits = NA_integer_,
output = c("all", "title", "overview", "body")) {
output <- match.arg(output)
markdown <- attr(object, "markdown")
if (is.null(markdown) || length(markdown) == 0 || !is.logical(markdown)) {
markdown <- FALSE
}
if (inherits(object, "TrialDesignCharacteristics")) {
return(.createSummaryDesignPlan(object,
digits = digits,
output = output,
markdown = markdown
))
}
if (.isTrialDesign(object) || .isTrialDesignPlan(object) || inherits(object, "SimulationResults")) {
return(.createSummaryDesignPlan(object,
digits = digits,
output = output,
markdown = markdown
))
}
if (inherits(object, "AnalysisResults")) {
return(.createSummaryAnalysisResults(object,
digits = digits, output = output, markdown = markdown
))
}
if (inherits(object, "PerformanceScore")) {
return(.createSummaryPerformanceScore(object,
digits = digits, output = output, markdown = markdown
))
}
stopRuntimeIssue("function 'summary' not ", "implemented yet for class ", .getClassName(object),
functionName = ".createSummary",
parameter = "summary"
)
}
.createSummaryPerformanceScore <- function(
object,
...,
digits = NA_integer_,
output = c("all", "title", "overview", "body"),
markdown = FALSE) {
.createSummaryDesignPlan(object$.simulationResults,
digits = digits,
output = output,
performanceScore = object,
markdown = markdown
)
}
#'
#' Main function for creating a summary of an analysis result
#'
#' @noRd
#'
.createSummaryAnalysisResults <- function(
object,
...,
digits = NA_integer_,
output = c("all", "title", "overview", "body"),
markdown = FALSE) {
output <- match.arg(output)
if (!inherits(object, "AnalysisResults")) {
stopIllegalArgument("'object' must be a valid analysis result object (is class ", .getClassName(object),
")",
functionName = ".createSummaryAnalysisResults",
parameter = "object", value = object
)
}
digitSettings <- .getSummaryDigits(digits)
outputSize <- .getEnvironmentVariable(
"RPACT_SUMMARY_OUTPUT_SIZE",
"rpact.summary.output.size",
default = C_SUMMARY_OUTPUT_SIZE_DEFAULT,
type = "character"
)
intervalFormat <- .getEnvironmentVariable(
"RPACT_SUMMARY_INTERVALFORMAT",
"rpact.summary.intervalFormat",
default = "[%s; %s]",
type = "character"
)
.assertIsValidSummaryIntervalFormat(intervalFormat)
multiArmEnabled <- .isMultiArmAnalysisResults(object)
enrichmentEnabled <- .isEnrichmentAnalysisResults(object)
multiHypothesesEnabled <- .isMultiHypothesesAnalysisResults(object)
analysisResults <- object
design <- analysisResults$.design
stageResults <- analysisResults$.stageResults
dataInput <- analysisResults$.dataInput
closedTestResults <- NULL
conditionalPowerResults <- NULL
if (multiHypothesesEnabled) {
closedTestResults <- analysisResults$.closedTestResults
if (length(analysisResults$nPlanned) > 0 && !all(is.na(analysisResults$nPlanned))) {
conditionalPowerResults <- analysisResults$.conditionalPowerResults
}
}
summaryFactory <- SummaryFactory$new(
object = object,
intervalFormat = intervalFormat,
output = output,
markdown = markdown
)
.addDesignInformationToSummary(design, object, summaryFactory,
output = output, digits = digits
)
summaryFactory$addParameter(stageResults,
parameterName = "effectSizes",
parameterCaption = ifelse(stageResults$isDatasetRates() &&
dataInput$getNumberOfGroups() == 1,
"Cumulative treatment rate", "Cumulative effect size"
),
roundDigits = digitSettings$digitsGeneral
)
if (stageResults$isDatasetGeneral()) {
summaryFactory$addParameter(stageResults,
parameterName = "overallStandardErrors",
parameterCaption = "Cumulative standard error",
roundDigits = digitSettings$digitsGeneral
)
} else if (stageResults$isDatasetMeans()) {
parameterCaption <- ifelse(stageResults$isOneSampleDataset(),
"Cumulative standard deviation", "Cumulative (pooled) standard deviation"
)
parameterName <- ifelse(inherits(stageResults, "StageResultsMultiArmMeans") &&
!inherits(stageResults, "StageResultsEnrichmentMeans"),
"overallPooledStDevs", "overallStDevs"
)
summaryFactory$addParameter(stageResults,
parameterName = parameterName,
parameterCaption = parameterCaption,
roundDigits = digitSettings$digitsGeneral,
enforceFirstCase = (parameterName == "overallPooledStDevs")
)
} else if (stageResults$isDatasetRates()) {
if (outputSize != "small" && dataInput$getNumberOfGroups() > 1) {
treatmentRateParamName <- "overallPi1"
controlRateParamName <- "overallPi2"
enforceFirstCase <- TRUE
if (.isEnrichmentStageResults(stageResults)) {
treatmentRateParamName <- "overallPisTreatment"
controlRateParamName <- "overallPisControl"
enforceFirstCase <- FALSE
} else if (.isMultiArmStageResults(stageResults)) {
treatmentRateParamName <- "overallPiTreatments"
controlRateParamName <- "overallPiControl"
}
summaryFactory$addParameter(stageResults,
parameterName = treatmentRateParamName,
parameterCaption = "Cumulative treatment rate",
roundDigits = digitSettings$digitsGeneral
)
summaryFactory$addParameter(stageResults,
parameterName = controlRateParamName,
parameterCaption = "Cumulative control rate",
roundDigits = digitSettings$digitsGeneral,
enforceFirstCase = enforceFirstCase
)
}
}
if (.isTrialDesignGroupSequential(design)) {
summaryFactory$addParameter(stageResults,
parameterName = "overallTestStatistics",
parameterCaption = "Overall test statistic",
roundDigits = ifelse(digitSettings$digitsProbabilities > 1,
digitSettings$digitsProbabilities - 1,
digitSettings$digitsProbabilities
),
smoothedZeroFormat = TRUE
)
summaryFactory$addParameter(stageResults,
parameterName = ifelse(multiHypothesesEnabled,
"separatePValues", "overallPValues"
),
parameterCaption = "Overall p-value",
roundDigits = digitSettings$digitsProbabilities
)
} else {
summaryFactory$addParameter(stageResults,
parameterName = "testStatistics",
parameterCaption = "Stage-wise test statistic",
roundDigits = ifelse(digitSettings$digitsProbabilities > 1,
digitSettings$digitsProbabilities - 1,
digitSettings$digitsProbabilities
),
smoothedZeroFormat = TRUE
)
summaryFactory$addParameter(stageResults,
parameterName = ifelse(multiHypothesesEnabled, "separatePValues", "pValues"),
parameterCaption = "Stage-wise p-value",
roundDigits = digitSettings$digitsProbabilities
)
}
if (!is.null(closedTestResults)) {
if (outputSize == "large") {
if (.isTrialDesignConditionalDunnett(design)) {
summaryFactory$addParameter(closedTestResults,
parameterName = "conditionalErrorRate",
parameterCaption = "Conditional error rate",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
summaryFactory$addParameter(closedTestResults,
parameterName = "secondStagePValues",
parameterCaption = "Second stage p-value",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
} else {
summaryFactory$addParameter(closedTestResults,
parameterName = "adjustedStageWisePValues",
parameterCaption = "Adjusted stage-wise p-value",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
summaryFactory$addParameter(closedTestResults,
parameterName = "overallAdjustedTestStatistics",
parameterCaption = "Overall adjusted test statistic",
roundDigits = digitSettings$digitsProbabilities -
ifelse(.isTrialDesignFisher(design) || digitSettings$digitsProbabilities <= 1, 0, 1),
smoothedZeroFormat = !.isTrialDesignFisher(design)
)
}
} else if (outputSize == "medium") {
legendEntry <- .addLegendEntry("treatmentArms")
gMax <- stageResults$getGMax()
if (.isTrialDesignConditionalDunnett(design)) {
summaryFactory$addParameter(closedTestResults,
parameterName = "adjustedStageWisePValues",
values = closedTestResults$conditionalErrorRate[1, ],
parameterCaption = paste0(
"Conditional error rate (",
paste0(1:gMax, collapse = ", "), ")"
), roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE,
legendEntry = legendEntry
)
summaryFactory$addParameter(closedTestResults,
parameterName = "overallAdjustedTestStatistics",
values = closedTestResults$secondStagePValues[1, ],
parameterCaption = paste0(
"Second stage p-value (",
paste0(1:gMax, collapse = ", "), ")"
),
roundDigits = digitSettings$digitsProbabilities +
ifelse(.isTrialDesignFisher(design), 1, 0),
smoothedZeroFormat = !.isTrialDesignFisher(design),
legendEntry = legendEntry
)
} else {
summaryFactory$addParameter(closedTestResults,
parameterName = "adjustedStageWisePValues",
values = closedTestResults$adjustedStageWisePValues[1, ],
parameterCaption = paste0(
"Adjusted stage-wise p-value (",
paste0(1:gMax, collapse = ", "), ")"
), roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE, legendEntry = legendEntry
)
summaryFactory$addParameter(closedTestResults,
parameterName = "overallAdjustedTestStatistics",
values = closedTestResults$overallAdjustedTestStatistics[1, ],
parameterCaption = paste0(
"Overall adjusted test statistic (",
paste0(1:gMax, collapse = ", "), ")"
),
roundDigits = digitSettings$digitsProbabilities -
ifelse(.isTrialDesignFisher(design) ||
digitSettings$digitsProbabilities <= 1, 0, 1),
smoothedZeroFormat = !.isTrialDesignFisher(design),
legendEntry = legendEntry
)
}
}
}
if (multiHypothesesEnabled) {
summaryFactory$addParameter(closedTestResults,
parameterName = "rejected",
parameterCaption = "Test action: reject",
roundDigits = digitSettings$digitsGeneral
)
} else {
if (.isTrialDesignFisher(design)) {
summaryFactory$addParameter(stageResults,
parameterName = "combFisher",
parameterCaption = "Fisher combination",
roundDigits = 0
)
} else if (.isTrialDesignInverseNormal(design)) {
summaryFactory$addParameter(stageResults,
parameterName = "combInverseNormal",
parameterCaption = "Inverse normal combination",
roundDigits = ifelse(digitSettings$digitsProbabilities > 1,
digitSettings$digitsProbabilities - 1,
digitSettings$digitsProbabilities
),
smoothedZeroFormat = TRUE
)
}
summaryFactory$addParameter(analysisResults,
parameterName = "testActions",
parameterCaption = "Test action",
roundDigits = digitSettings$digitsGeneral
)
}
if (design$kMax > 1 && !.isTrialDesignConditionalDunnett(design)) {
summaryFactory$addParameter(analysisResults,
parameterName = "conditionalRejectionProbabilities",
parameterCaption = "Conditional rejection probability",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (design$kMax > 1) {
if (!is.null(conditionalPowerResults)) {
summaryFactory$addParameter(conditionalPowerResults,
parameterName = "nPlanned",
parameterCaption = "Planned sample size",
roundDigits = -1
)
} else if (analysisResults$isApplicableParameter("nPlanned")) {
summaryFactory$addParameter(analysisResults,
parameterName = "nPlanned",
parameterCaption = "Planned sample size",
roundDigits = -1
)
}
}
if (design$kMax > 1) {
if (!is.null(conditionalPowerResults)) {
summaryFactory$addParameter(conditionalPowerResults,
parameterName = "conditionalPower",
parameterCaption = "Conditional power",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
} else if (!multiHypothesesEnabled &&
analysisResults$isApplicableParameter("nPlanned")) {
parameterName <- "conditionalPower"
if (!is.null(analysisResults[["conditionalPowerSimulated"]]) &&
length(analysisResults[["conditionalPowerSimulated"]]) > 0) {
parameterName <- "conditionalPowerSimulated"
}
summaryFactory$addParameter(analysisResults,
parameterName = parameterName,
parameterCaption = "Conditional power",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
}
ciLevel <- round((1 - design$alpha * (3 - design$sided)) * 100, 2)
if (.isTrialDesignConditionalDunnett(design)) {
parameterCaptionRepeatedPValues <- "Overall p-value"
parameterCaptionRepeatedCI <- paste0(ciLevel, "% overall confidence interval")
} else {
parameterCaptionRepeatedPValues <- ifelse(design$kMax == 1,
ifelse(design$sided == 1, "One-sided p-value", "Two-sided p-value"),
"Repeated p-value"
)
parameterCaptionRepeatedCI <- paste0(
ciLevel, "% ",
ifelse(design$kMax == 1, "confidence interval", "repeated confidence interval")
)
}
summaryFactory$addParameter(analysisResults,
parameterName = c(
"repeatedConfidenceIntervalLowerBounds",
"repeatedConfidenceIntervalUpperBounds"
),
parameterCaption = parameterCaptionRepeatedCI,
roundDigits = digitSettings$digitsGeneral
)
summaryFactory$addParameter(analysisResults,
parameterName = "repeatedPValues",
parameterCaption = parameterCaptionRepeatedPValues,
roundDigits = digitSettings$digitsProbabilities,
formatRepeatedPValues = TRUE
)
if (!multiHypothesesEnabled && !is.null(analysisResults[["finalStage"]]) &&
!all(is.na(analysisResults$finalStage))) {
summaryFactory$addParameter(analysisResults,
parameterName = "finalPValues",
parameterCaption = "Final p-value",
roundDigits = digitSettings$digitsProbabilities
)
summaryFactory$addParameter(analysisResults,
parameterName = c(
"finalConfidenceIntervalLowerBounds",
"finalConfidenceIntervalUpperBounds"
),
parameterCaption = "Final confidence interval",
roundDigits = digitSettings$digitsGeneral
)
summaryFactory$addParameter(analysisResults,
parameterName = "medianUnbiasedEstimates",
parameterCaption = "Median unbiased estimate",
roundDigits = digitSettings$digitsGeneral
)
}
return(summaryFactory)
}
#'
#' Main function for creating a summary of a design or design plan
#'
#' @noRd
#'
.createSummaryDesignPlan <- function(
object,
digits = NA_integer_,
output = c("all", "title", "overview", "body"),
performanceScore = NULL,
markdown = FALSE) {
output <- match.arg(output)
designPlan <- NULL
if (.isTrialDesignPlan(object) || inherits(object, "SimulationResults")) {
design <- object$.design
designPlan <- object
} else if (inherits(object, "TrialDesignCharacteristics")) {
design <- object$.design
} else if (.isTrialDesign(object)) {
design <- object
} else {
stopIllegalArgument("'object' must be a valid design, design plan, ", "or simulation result object (is class ",
.getClassName(object), ")",
functionName = ".createSummaryDesignPlan",
parameter = "object", value = object
)
}
digitSettings <- .getSummaryDigits(digits)
outputSize <- .getEnvironmentVariable(
"RPACT_SUMMARY_OUTPUT_SIZE",
"rpact.summary.output.size",
default = C_SUMMARY_OUTPUT_SIZE_DEFAULT,
type = "character"
)
intervalFormat <- .getEnvironmentVariable(
"RPACT_SUMMARY_INTERVALFORMAT",
"rpact.summary.intervalFormat",
default = "[%s; %s]",
type = "character"
)
.assertIsValidSummaryIntervalFormat(intervalFormat)
summaryFactory <- SummaryFactory$new(
object = object,
intervalFormat = intervalFormat,
output = output,
markdown = markdown
)
if (output %in% c("all", "title", "overview")) {
.addDesignInformationToSummary(design, designPlan,
summaryFactory,
output = output, digits = digits
)
}
if (!(output %in% c("all", "body"))) {
return(summaryFactory)
}
multiArmEnabled <- FALSE
enrichmentEnabled <- FALSE
baseEnabled <- FALSE
planningEnabled <- FALSE
simulationEnabled <- FALSE
survivalEnabled <- FALSE
survivalPatientWiseEnabled <- FALSE
countDataEnabled <- FALSE
if (!is.null(designPlan)) {
multiArmEnabled <- grepl("MultiArm", .getClassName(designPlan))
enrichmentEnabled <- grepl("Enrichment", .getClassName(designPlan))
baseEnabled <- grepl(
"(TrialDesignPlan|SimulationResults)(Means|Rates|Survival|CountData)",
.getClassName(designPlan)
)
planningEnabled <- .isTrialDesignPlan(designPlan)
simulationEnabled <- .isSimulationResults(designPlan)
survivalEnabled <- grepl("Survival", .getClassName(designPlan))
countDataEnabled <- grepl("CountData", .getClassName(designPlan))
survivalPatientWiseEnabled <- simulationEnabled && survivalEnabled &&
(baseEnabled ||
identical(designPlan$simulationType, "patientWise") ||
identical(designPlan$simulationType, "patientWiseBasic"))
}
if (planningEnabled) {
legendEntry <- .addLegendEntry("treatmentEffectScale")
if (!is.null(designPlan[["criticalValuesEffectScale"]]) &&
ncol(designPlan$criticalValuesEffectScale) > 0 &&
!all(is.na(designPlan$criticalValuesEffectScale))) {
summaryFactory$addParameter(designPlan,
parameterName = "criticalValuesEffectScale",
parameterCaption = ifelse(.isDelayedInformationEnabled(design = design),
"Upper bounds of continuation (t)", "Efficacy boundary (t)"
),
roundDigits = digitSettings$digitsGeneral,
legendEntry = legendEntry
)
} else if (!is.null(designPlan[["criticalValuesEffectScaleUpper"]]) &&
ncol(designPlan$criticalValuesEffectScaleUpper) > 0) {
summaryFactory$addParameter(designPlan,
parameterName = "criticalValuesEffectScaleLower",
parameterCaption = "Lower efficacy boundary (t)",
roundDigits = digitSettings$digitsGeneral,
legendEntry = legendEntry
)
summaryFactory$addParameter(designPlan,
parameterName = "criticalValuesEffectScaleUpper",
parameterCaption = "Upper efficacy boundary (t)",
roundDigits = digitSettings$digitsGeneral,
legendEntry = legendEntry
)
}
if (!is.null(designPlan[["futilityBoundsEffectScale"]]) &&
ncol(designPlan$futilityBoundsEffectScale) > 0 &&
!all(is.na(designPlan$futilityBoundsEffectScale))) {
summaryFactory$addParameter(designPlan,
parameterName = "futilityBoundsEffectScale",
parameterCaption = ifelse(.isDelayedInformationEnabled(design = design),
"Lower bounds of continuation (t)", "Futility boundary (t)"
),
roundDigits = digitSettings$digitsGeneral,
legendEntry = legendEntry
)
} else if (!is.null(designPlan[["futilityBoundsEffectScaleUpper"]]) &&
ncol(designPlan$futilityBoundsEffectScaleUpper) > 0 &&
(any(!is.na(designPlan$futilityBoundsEffectScaleLower)) ||
any(!is.na(designPlan$futilityBoundsEffectScaleUpper)))) {
summaryFactory$addParameter(designPlan,
parameterName = "futilityBoundsEffectScaleLower",
parameterCaption = "Lower futility boundary (t)",
roundDigits = digitSettings$digitsGeneral,
legendEntry = legendEntry
)
summaryFactory$addParameter(designPlan,
parameterName = "futilityBoundsEffectScaleUpper",
parameterCaption = "Upper futility boundary (t)",
roundDigits = digitSettings$digitsGeneral,
legendEntry = legendEntry
)
}
}
if (design$.isDelayedResponseDesign()) {
summaryFactory$addParameter(design,
parameterName = "decisionCriticalValues",
parameterCaption = "Decision critical values",
roundDigits = digitSettings$digitsGeneral,
smoothedZeroFormat = TRUE
)
outputSize <- .getEnvironmentVariable(
"RPACT_SUMMARY_OUTPUT_SIZE",
"rpact.summary.output.size",
default = C_SUMMARY_OUTPUT_SIZE_DEFAULT,
type = "character"
)
if (outputSize == "large") {
summaryFactory$addParameter(design,
parameterName = "reversalProbabilities",
parameterCaption = "Reversal probabilities",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
}
designCharacteristics <- .getSummaryDesignCharacteristics(design, kMaxMin = 2)
if (is.null(designPlan)) {
return(.addDesignCharacteristicsToSummary(
designCharacteristics,
summaryFactory,
digits = digits
))
}
if (baseEnabled && countDataEnabled && !is.null(designPlan[["lambda1"]]) &&
designPlan$isGeneratedOrDerivedParameter("lambda1")) {
summaryFactory$addParameter(designPlan,
parameterName = "lambda1",
parameterCaption = "Lambda(1)",
roundDigits = digitSettings$digitsGeneral
)
}
if (baseEnabled && countDataEnabled && !is.null(designPlan[["lambda2"]]) &&
designPlan$isGeneratedOrDerivedParameter("lambda2")) {
summaryFactory$addParameter(designPlan,
parameterName = "lambda2",
parameterCaption = "Lambda(2)",
roundDigits = digitSettings$digitsGeneral
)
}
if (simulationEnabled && (multiArmEnabled || enrichmentEnabled)) {
summaryFactory$addParameter(designPlan,
parameterName = "rejectAtLeastOne",
parameterCaption = "Reject at least one",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE, transpose = TRUE,
lastStage = design$kMax
)
if (outputSize == "large" && multiArmEnabled) {
.addSimulationMultiArmArrayParameter(designPlan,
parameterName = "rejectedArmsPerStage",
parameterCaption = ifelse(design$kMax == 1,
"Rejected arms", "Rejected arms per stage"
),
summaryFactory,
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (outputSize == "large" && enrichmentEnabled) {
.addSimulationArrayToSummary(designPlan,
parameterName = "rejectedPopulationsPerStage",
parameterCaption = ifelse(design$kMax == 1,
"Rejected populations", "Rejected populations per stage"
),
summaryFactory,
digitsSampleSize = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (!(survivalEnabled && multiArmEnabled)) {
summaryFactory$addParameter(designPlan,
parameterName = "successPerStage",
parameterCaption = "Success per stage",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE,
transpose = TRUE
)
}
}
if (baseEnabled) {
parameterName <- "rejectPerStage"
if (design$kMax == 1) {
parameterName <- "overallReject"
}
if (any(!is.na(designPlan[[parameterName]]))) {
summaryFactory$addParameter(designPlan,
parameterName = parameterName,
parameterCaption = ifelse(design$kMax == 1, "Power", "Cumulative power"),
roundDigits = digitSettings$digitsProbabilities,
cumsumEnabled = TRUE,
smoothedZeroFormat = TRUE
)
}
}
if (simulationEnabled && (multiArmEnabled || enrichmentEnabled) && outputSize %in% c("medium", "large")) {
parameterNameSubjects <- ifelse(survivalEnabled || countDataEnabled,
"numberOfSubjects", "sampleSizes"
)
if (designPlan$isGeneratedParameter(parameterNameSubjects)) {
subjectsCaption <- ifelse(design$kMax > 1 && !survivalEnabled,
"Stage-wise number of subjects",
"Number of subjects"
)
summaryFactory$addParameter(designPlan,
parameterName = parameterNameSubjects,
parameterCaption = subjectsCaption,
roundDigits = digitSettings$digitsSampleSize,
validateParameterType = !countDataEnabled,
showNA = TRUE,
transpose = TRUE,
lastStage = NA_integer_
)
}
} else if (baseEnabled && outputSize %in% c("medium", "large")) {
parameterNameSubjects <- NULL
transpose <- FALSE
lastStage <- NA_integer_
if (simulationEnabled) {
parameterNameSubjects <- ifelse(survivalEnabled || countDataEnabled,
"numberOfSubjects", "sampleSizes"
)
} else {
if (design$kMax == 1 && (
designPlan$.isSampleSizeObject() ||
.isTrialDesignPlanMeans(designPlan) ||
.isTrialDesignPlanRates(designPlan) ||
countDataEnabled
)) {
parameterNameSubjects <- "nFixed"
} else if (countDataEnabled) {
parameterNameSubjects <- "numberOfSubjects"
} else if (design$kMax == 1 && designPlan$.isPowerObject()) {
parameterNameSubjects <- "expectedNumberOfSubjects"
transpose <- TRUE
lastStage <- design$kMax
} else {
parameterNameSubjects <- "numberOfSubjects"
}
}
if (designPlan$isGeneratedParameter(parameterNameSubjects)) {
subjectsCaption <- ifelse(design$kMax > 1 &&
simulationEnabled && !survivalEnabled,
"Stage-wise number of subjects",
"Number of subjects"
)
summaryFactory$addParameter(designPlan,
parameterName = parameterNameSubjects,
parameterCaption = subjectsCaption,
roundDigits = digitSettings$digitsSampleSize,
validateParameterType = !countDataEnabled,
showNA = TRUE,
transpose = transpose,
lastStage = lastStage
)
}
}
if (simulationEnabled && (multiArmEnabled || enrichmentEnabled || countDataEnabled)) {
if (!is.null(designPlan[["expectedNumberOfSubjects"]]) &&
designPlan$isGeneratedParameter("expectedNumberOfSubjects")) {
summaryFactory$addParameter(designPlan,
parameterName = "expectedNumberOfSubjects",
parameterCaption = "Expected number of subjects",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE,
lastStage = design$kMax
)
}
} else if (baseEnabled && design$kMax > 1) {
parameterName <- ifelse(inherits(designPlan, "TrialDesignPlan") &&
(designPlan$.isSampleSizeObject() || countDataEnabled),
"expectedNumberOfSubjectsH1",
"expectedNumberOfSubjects"
)
summaryFactory$addParameter(designPlan,
parameterName = parameterName,
parameterCaption = "Expected number of subjects",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE,
validateParameterType = !countDataEnabled,
lastStage = design$kMax
)
if (countDataEnabled &&
(is.null(designPlan[[parameterName]]) || all(is.na(designPlan[[parameterName]]))) &&
!is.null(designPlan[["maxNumberOfSubjects"]]) &&
designPlan$isGeneratedParameter("maxNumberOfSubjects")) {
summaryFactory$addParameter(designPlan,
parameterName = "maxNumberOfSubjects",
parameterCaption = "Maximum number of subjects",
roundDigits = digitSettings$digitsSampleSize
)
}
}
if (simulationEnabled && (multiArmEnabled || enrichmentEnabled) && outputSize %in% c("medium", "large")) {
parameterName <- NULL
parameterCaption <- NULL
if (survivalEnabled) {
if (enrichmentEnabled) {
if (!identical(designPlan$simulationType, "testStatisticBased")) {
if (!is.null(designPlan$populationEventsPerStage) &&
length(dim(designPlan$populationEventsPerStage)) > 2 &&
dim(designPlan$populationEventsPerStage)[3] > 1) {
parameterName <- "populationEventsPerStage"
parameterCaption <- "Number of events per population"
}
} else {
parameterName <- "singleEventsPerSubsetAndStage"
parameterCaption <- "Single number of events"
}
} else {
parameterName <- "cumulativeEventsPerStage"
parameterCaption <- "Cumulative number of events"
}
} else {
parameterName <- "sampleSizes"
parameterCaption <- "Stage-wise number of subjects"
}
if (!is.null(parameterName) && !is.null(parameterCaption)) {
.addSimulationArrayToSummary(
designPlan,
parameterName,
parameterCaption,
summaryFactory,
digitsSampleSize = digitSettings$digitsSampleSize,
smoothedZeroFormat = TRUE
)
}
}
if (baseEnabled && survivalEnabled && outputSize %in% c("medium", "large")) {
parameterNameEvents <- "cumulativeEventsPerStage"
if (!simulationEnabled) {
if (design$kMax == 1 && (
designPlan$.isSampleSizeObject() ||
.isTrialDesignPlanMeans(designPlan) ||
.isTrialDesignPlanRates(designPlan) ||
countDataEnabled
)) {
parameterNameEvents <- "eventsFixed"
} else if (design$kMax == 1 && designPlan$.isPowerObject()) {
parameterNameEvents <- "expectedNumberOfEvents"
}
}
summaryFactory$addParameter(designPlan,
parameterName = parameterNameEvents,
parameterCaption = ifelse(design$kMax == 1,
"Number of events",
"Cumulative number of events"
),
roundDigits = digitSettings$digitsSampleSize,
cumsumEnabled = FALSE
)
}
if (simulationEnabled && survivalEnabled && enrichmentEnabled &&
outputSize %in% c("medium", "large") &&
!is.null(designPlan$eventsNotAchieved)) {
.addSimulationArrayToSummary(
designPlan,
"eventsNotAchieved",
"Events not achieved",
summaryFactory,
digitsSampleSize = digitSettings$digitsSampleSize,
smoothedZeroFormat = TRUE
)
}
if (survivalEnabled && design$kMax > 1) {
# sample size survival: expectedEventsH1
# power survival: expectedNumberOfEvents
# simulation survival: expectedNumberOfEvents
parameterNameEventsH1 <- NA_character_
if (designPlan$isGeneratedParameter("expectedNumberOfEvents")) {
parameterNameEventsH1 <- "expectedNumberOfEvents"
} else if (designPlan$isGeneratedParameter("expectedEventsH1")) {
parameterNameEventsH1 <- "expectedEventsH1"
}
if (!is.na(parameterNameEventsH1)) {
summaryFactory$addParameter(designPlan,
parameterName = parameterNameEventsH1,
parameterCaption = "Expected number of events",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE,
lastStage = design$kMax
)
}
}
if (simulationEnabled && (multiArmEnabled || enrichmentEnabled)) {
if (multiArmEnabled && outputSize %in% c("medium", "large") && design$kMax > 1) {
.addSimulationMultiArmArrayParameter(
designPlan = designPlan,
parameterName = "selectedArms",
parameterCaption = "Selected arms",
summaryFactory = summaryFactory,
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (enrichmentEnabled && outputSize %in% c("medium", "large")) {
.addSimulationArrayToSummary(
designPlan = designPlan,
parameterName = "selectedPopulations",
parameterCaption = "Selected populations",
summaryFactory = summaryFactory,
digitsSampleSize = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (multiArmEnabled && outputSize %in% c("medium", "large") && design$kMax > 1) {
summaryFactory$addParameter(designPlan,
parameterName = "numberOfSelectedArms",
parameterCaption = "Number of selected active arms",
roundDigits = digitSettings$digitsGeneral,
transpose = TRUE
)
}
if (enrichmentEnabled && outputSize %in% c("medium", "large")) {
summaryFactory$addParameter(designPlan,
parameterName = "numberOfPopulations",
parameterCaption = "Number of populations",
roundDigits = digitSettings$digitsGeneral,
transpose = TRUE
)
}
}
if (baseEnabled && countDataEnabled && design$kMax > 1 && outputSize %in% c("medium", "large") &&
designPlan$.isSampleSizeObject()) {
if (outputSize == "large") {
summaryFactory$addParameter(designPlan,
parameterName = "informationOverStages",
parameterCaption = "Information over stages",
roundDigits = digitSettings$digitsSampleSize,
roundDigitsAsInformation = TRUE
)
summaryFactory$addParameter(designPlan,
parameterName = "expectedInformationH0",
parameterCaption = "Expected information under H0",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE,
roundDigitsAsInformation = TRUE,
lastStage = design$kMax
)
summaryFactory$addParameter(designPlan,
parameterName = "expectedInformationH01",
parameterCaption = "Expected information under H0/H1",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE,
roundDigitsAsInformation = TRUE,
lastStage = design$kMax
)
}
summaryFactory$addParameter(designPlan,
parameterName = "expectedInformationH1",
parameterCaption = "Expected information under H1",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE,
roundDigitsAsInformation = TRUE,
lastStage = design$kMax
)
}
if (baseEnabled && countDataEnabled && designPlan$.isSampleSizeObject() && design$kMax == 1) {
summaryFactory$addParameter(designPlan,
parameterName = "maxInformation",
parameterCaption = "Maximum information",
roundDigits = digitSettings$digitsSampleSize,
transpose = TRUE
)
}
if (baseEnabled && countDataEnabled && !is.null(designPlan[["calendarTime"]]) &&
designPlan$isGeneratedParameter("calendarTime")) {
summaryFactory$addParameter(designPlan,
parameterName = "calendarTime",
parameterCaption = "Calendar time",
roundDigits = digitSettings$digitsTime,
showNA = TRUE
)
}
if (outputSize == "large" && !is.null(designPlan[["analysisTime"]]) &&
designPlan$isGeneratedParameter("analysisTime")) {
summaryFactory$addParameter(designPlan,
parameterName = "analysisTime",
parameterCaption = "Analysis time",
roundDigits = digitSettings$digitsTime,
transpose = multiArmEnabled || enrichmentEnabled
)
}
if (baseEnabled && countDataEnabled && !is.null(designPlan[["studyTime"]]) &&
designPlan$isGeneratedParameter("studyTime")) {
summaryFactory$addParameter(designPlan,
parameterName = "studyTime",
parameterCaption = "Study time",
roundDigits = digitSettings$digitsTime
)
}
if (!is.null(designPlan[["studyDuration"]]) &&
designPlan$isGeneratedParameter("studyDuration")) {
summaryFactory$addParameter(designPlan,
parameterName = "studyDuration",
parameterCaption = "Expected study duration",
roundDigits = digitSettings$digitsTime,
smoothedZeroFormat = TRUE,
transpose = TRUE,
lastStage = design$kMax
)
}
if (simulationEnabled && (multiArmEnabled || enrichmentEnabled) && outputSize == "large" && design$kMax > 1) {
summaryFactory$addParameter(designPlan,
parameterName = "conditionalPowerAchieved",
parameterCaption = "Conditional power (achieved)",
roundDigits = digitSettings$digitsProbabilities,
transpose = TRUE
)
}
if (!is.null(designPlan[["allocationRatioPlanned"]]) &&
length(unique(designPlan$allocationRatioPlanned)) > 1) {
summaryFactory$addParameter(designPlan,
parameterName = "allocationRatioPlanned",
parameterCaption = "Optimum allocation ratio",
roundDigits = digitSettings$digitsGeneral
)
}
if (simulationEnabled &&
!grepl("SimulationResults(MultiArm|Enrichment|CountData)", .getClassName(designPlan))) {
summaryFactory$addParameter(designPlan,
parameterName = "conditionalPowerAchieved",
parameterCaption = "Conditional power (achieved)",
roundDigits = digitSettings$digitsProbabilities
)
}
probsH0 <- NULL
probsH1 <- NULL
if (planningEnabled && design$kMax > 1) {
if (!is.null(designCharacteristics) &&
.isTrialDesignInverseNormalOrGroupSequential(design) &&
length(designCharacteristics$shift) == 1 &&
!is.na(designCharacteristics$shift) &&
designCharacteristics$shift >= 1) {
probsH0 <- getPowerAndAverageSampleNumber(design, theta = 0, nMax = designCharacteristics$shift)
probsH1 <- getPowerAndAverageSampleNumber(design, theta = 1, nMax = designCharacteristics$shift)
}
if (!is.null(designPlan[["rejectPerStage"]])) {
probsH1 <- list(
earlyStop = designPlan$rejectPerStage[1:(design$kMax - 1), ] +
as.vector(designPlan$futilityPerStage),
rejectPerStage = designPlan$rejectPerStage,
futilityPerStage = designPlan$futilityPerStage
)
numberOfVariants <- 1
if (inherits(designPlan, "ParameterSet")) {
parameterNames <- designPlan$.getVisibleFieldNamesOrdered()
numberOfVariants <- .getMultidimensionalNumberOfVariants(designPlan, parameterNames)
}
if (numberOfVariants > 1 && is.matrix(probsH1$earlyStop) && ncol(probsH1$earlyStop) == 1) {
probsH1$earlyStop <- matrix(rep(probsH1$earlyStop, numberOfVariants), ncol = numberOfVariants)
probsH1$rejectPerStage <- matrix(rep(probsH1$rejectPerStage, numberOfVariants), ncol = numberOfVariants)
probsH1$futilityPerStage <- matrix(rep(probsH1$futilityPerStage, numberOfVariants), ncol = numberOfVariants)
}
}
}
if (design$kMax > 1 &&
outputSize %in% c("medium", "large") &&
!is.null(designPlan[["earlyStop"]])) {
summaryFactory$addParameter(
designPlan,
parameterName = "earlyStop",
parameterCaption = paste0(
"Stopping probability",
ifelse(survivalPatientWiseEnabled, " by stage", "")
), # under H1
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE,
transpose = !is(designPlan, "SimulationResultsSurvival"),
lastStage = design$kMax
)
}
if (planningEnabled && !is.null(probsH1)) {
if (design$kMax > 1) {
if (!is.null(probsH0)) {
probsH0$earlyStop <- matrix(
probsH0$earlyStop[1:(design$kMax - 1), 1],
ncol = 1
)
probsH0$rejectPerStage <- matrix(
probsH0$rejectPerStage[1:(design$kMax - 1), 1],
ncol = 1
)
}
if (is.matrix(probsH1$rejectPerStage)) {
if (design$kMax > 1 && designPlan$.isSampleSizeObject()) {
probsH1$rejectPerStage <- probsH1$rejectPerStage[1:(design$kMax - 1), 1]
} else {
probsH1$rejectPerStage <- matrix(
probsH1$rejectPerStage[1:(design$kMax - 1), ],
ncol = ncol(probsH1$rejectPerStage)
)
}
} else {
probsH1$rejectPerStage <- probsH1$rejectPerStage[1:(design$kMax - 1)]
}
if (.isTrialDesignWithValidFutilityBounds(design)) {
if (is.matrix(probsH1$earlyStop)) {
probsH1$earlyStop <- matrix(
probsH1$earlyStop[1:(design$kMax - 1), ],
ncol = ncol(probsH1$earlyStop)
)
} else {
probsH1$earlyStop <- probsH1$earlyStop[1:(design$kMax - 1)]
}
if (!is.null(probsH0)) {
summaryFactory$addParameter(
probsH0,
parameterName = "earlyStop",
parameterCaption = "Stopping probability by stage (under H0)",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
x <- designPlan
if (is.null(x)) {
x <- design
}
summaryFactory$addParameter(x,
parameterName = "earlyStop",
values = probsH1$earlyStop,
parameterCaption = "Stopping probability by stage",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (!is.null(probsH0)) {
summaryFactory$addParameter(probsH0,
parameterName = "rejectPerStage",
parameterCaption = "Efficacy stopping probability by stage (under H0)",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (designPlan$.isPowerObject()) {
summaryFactory$addParameter(designPlan,
parameterName = "rejectPerStage",
values = probsH1$rejectPerStage,
parameterCaption = "Efficacy stopping probability by stage",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
} else {
summaryFactory$addParameter(probsH1,
parameterName = "rejectPerStage",
parameterCaption = "Efficacy stopping probability by stage",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
if (.isTrialDesignWithValidFutilityBounds(design)) {
if (!is.null(probsH0)) {
summaryFactory$addParameter(probsH0,
parameterName = "futilityPerStage",
parameterCaption = "Futility stopping probability by stage (under H0)",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
futilityPerStage <- probsH1$futilityPerStage
if (designPlan$.isSampleSizeObject() && ncol(futilityPerStage) > 1) {
futilityPerStage <- futilityPerStage[, 1]
}
summaryFactory$addParameter(designPlan,
parameterName = "futilityPerStage",
values = futilityPerStage,
parameterCaption = "Futility stopping probability by stage",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
}
} else {
rejectPerStageValues <- NULL
rejectPerStageParameterSet <- designPlan
rejectPerStageParameterName <- "rejectPerStage"
rejectPerStageTranspose <- FALSE
if (simulationEnabled && survivalEnabled && design$kMax > 1) {
if (baseEnabled && !is.null(designPlan[["rejectPerStage"]])) {
rejectPerStageValues <- designPlan$rejectPerStage[seq_len(design$kMax - 1), , drop = FALSE]
} else if (multiArmEnabled && !is.null(designPlan[["successPerStage"]])) {
rejectPerStageValues <- designPlan$successPerStage[seq_len(design$kMax - 1), , drop = FALSE]
# For a single active arm, successPerStage is intentionally marked as
# not applicable in the result object although it is needed here as
# the trial-level efficacy stopping probability. Wrapping the object
# retains its varied-parameter metadata without applying that field's
# visibility setting.
rejectPerStageParameterSet <- list(parameterSet = designPlan)
rejectPerStageParameterName <- "successPerStage"
rejectPerStageTranspose <- TRUE
}
} else if (!is.null(probsH1) && !simulationEnabled) {
if (is.matrix(probsH1$rejectPerStage)) {
rejectPerStageValues <- matrix(
probsH1$rejectPerStage[1:(design$kMax - 1), ],
ncol = ncol(probsH1$rejectPerStage)
)
} else {
rejectPerStageValues <- probsH1$rejectPerStage[1:(design$kMax - 1)]
}
}
if (!is.null(rejectPerStageValues)) {
summaryFactory$addParameter(rejectPerStageParameterSet,
parameterName = rejectPerStageParameterName,
values = rejectPerStageValues,
parameterCaption = "Efficacy stopping probability by stage",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE,
transpose = rejectPerStageTranspose
)
}
if (.isTrialDesignWithValidFutilityBounds(design) &&
!is.null(designPlan[["futilityPerStage"]]) &&
!anyNA(designPlan[["futilityPerStage"]]) &&
any(designPlan$futilityPerStage != 0) &&
any(designPlan$futilityPerStage > 1e-08)) {
summaryFactory$addParameter(designPlan,
parameterName = "futilityPerStage",
parameterCaption = "Futility stopping probability by stage", # under H1
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE,
transpose = grepl("MultiArm|Enrichment", .getClassName(designPlan))
)
}
}
.addDropoutSummaryItems(designPlan, summaryFactory)
if (!is.null(performanceScore)) {
print(performanceScore)
summaryFactory$addParameter(performanceScore,
parameterName = "performanceScore",
parameterCaption = "Performance score",
roundDigits = digitSettings$digitsProbabilities,
smoothedZeroFormat = TRUE
)
}
return(summaryFactory)
}
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.