Merge pull request #28 from Merck/27-update-internal-variables-to-make-it-in-snake-case

update internal variables to follow snake case

Author: nanxstats

NAMESPACE

@@ -23,5 +23,15 @@ import(foreach)
 import(mvtnorm)
 import(survival)
 import(tibble)
-import(tidyr)
+importFrom(dplyr,"%>%")
+importFrom(dplyr,arrange)
+importFrom(dplyr,filter)
+importFrom(dplyr,group_by)
+importFrom(dplyr,last)
+importFrom(dplyr,mutate)
+importFrom(dplyr,select)
+importFrom(dplyr,ungroup)
+importFrom(tibble,as_tibble)
+importFrom(tibble,tibble)
+importFrom(tidyr,expand)
 useDynLib(simtrial, .registration = TRUE)

R/MBdelayed.R

@@ -1,12 +1,12 @@
 #' Simulated survival dataset with delayed treatment effect
-#' 
+#'
 #' Magirr and Burman (2019) considered several scenarios for their modestly weighted logrank test.
 #' One of these had a delayed treatment effect with a hazard ratio of 1 for 6 months followed by a hazard ratio of 1/2
 #' thereafter.
-#' The scenario enrolled 200 patients uniformly over 12 months and 
-#' cut data for analysis 36 months after enrollment was opened. 
+#' The scenario enrolled 200 patients uniformly over 12 months and
+#' cut data for analysis 36 months after enrollment was opened.
 #' This dataset was generated by the `simtrial::simPWSurv()` function under the above scenario.
-#' 
+#'
 #' @format A tibble with 200 rows and xx columns
 #' \describe{
 #' \item{tte}{time to event}
@@ -17,38 +17,38 @@
 #' library(survival)
 #' library(mvtnorm)
 #' fit <- survfit(Surv(tte, event) ~ Treatment, data = MBdelayed)
-#' 
+#'
 #' # Plot survival
-#' plot(fit, lty=1:2) 
+#' plot(fit, lty=1:2)
 #' legend("topright", legend = c("Control", "Experimental"), lty = 1:2)
-#' 
+#'
 #' # Set up time, event, number of event dataset for testing
 #' # with arbitrary weights
 #' ten <- MBdelayed %>% tensurv(txval = "Experimental")
 #' head(ten)
-#' 
+#'
 #' # MaxCombo with logrank, FH(0,1), FH(1,1)
 #' ten %>% tenFHcorr(rg=tibble(rho=c(0, 0, 1), gamma=c(0, 1, 1))) %>%
 #'         pMaxCombo()
-#' 
+#'
 #' # Magirr-Burman modestly down-weighted rank test with 6 month delay
 #' # First, add weights
 #' ten <- ten %>% wMB(6)
 #' head(ten)
-#' 
+#'
 #' # Now compute test based on these weights
-#' ten %>% summarise(S = sum(OminusE*wMB),
-#'                   V = sum(Var*wMB^2),
+#' ten %>% summarise(S = sum(o_minus_e*wMB),
+#'                   V = sum(var_o_minus_e*wMB^2),
 #'                   Z = S/sqrt(V)) %>%
 #'         mutate(p=pnorm(Z))
-#' 
+#'
 #' # Create 0 weights for first 6 months
 #' ten <- ten %>% mutate(w6 = 1 * (tte >= 6))
-#' ten %>% summarise(S = sum(OminusE*w6),
-#'                   V = sum(Var*w6^2),
-#'                   Z = S/sqrt(V)) %>% 
+#' ten %>% summarise(S = sum(o_minus_e*w6),
+#'                   V = sum(var_o_minus_e*w6^2),
+#'                   Z = S/sqrt(V)) %>%
 #'         mutate(p=pnorm(Z))
-#'         
+#'
 #' # Generate another dataset
 #' ds <- simPWSurv(n = 200,
 #'                 enrollRates = tibble(rate = 200 / 12, duration = 12),
@@ -64,10 +64,10 @@
 #'        )
 #' # Cut data at 24 months after final enrollment
 #' MBdelayed2 <- ds %>% cutData(max(ds$enrollTime) + 24)
-#' 
-#' @references 
-#' Magirr, Dominic, and Carl‐Fredrik Burman. 
-#' "Modestly weighted logrank tests." 
+#'
+#' @references
+#' Magirr, Dominic, and Carl‐Fredrik Burman.
+#' "Modestly weighted logrank tests."
 #' \emph{Statistics in Medicine} 38.20 (2019): 3782-3790.
-#' 
+#'
 "MBdelayed"

R/cutData.R

@@ -15,28 +15,33 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#' @import tibble
-#' @import dplyr
+#' @importFrom  dplyr filter mutate select %>%
 NULL
 
 #' Cut a Dataset for Analysis at a Specified Date
 #'
 #' @param x a time-to-event dataset, e.g., generated by \code{simPWSurv}
 #' @param cutDate date relative to start of randomization (\code{cte} from input dataset)
 #' at which dataset is to be cut off for analysis
+#'
 #' @return A dataset ready for survival analysis
+#'
 #' @examples
-#' # Use default enrollment and event rates and cut at calendar time 5 after start
-#' # of randomization
+#' # Use default enrollment and event rates and
+#' # cut at calendar time 5 after start of randomization
 #' library(dplyr)
-#' simPWSurv(n=20) %>% cutData(5)
+#' simPWSurv(n = 20) %>% cutData(5)
+#'
 #' @export
-cutData <- function(x,cutDate){
-  return(x %>%
-           filter(enrollTime <= cutDate) %>%
-           mutate(tte=pmin(cte,cutDate)-enrollTime,
-                  event=fail*(cte<=cutDate)) %>%
-           select(tte,event,Stratum,Treatment)
-  )
+#'
+cutData <- function(x, cutDate){
+
+  ans <- x %>%
+    filter(enrollTime <= cutDate) %>%
+    mutate(tte = pmin(cte, cutDate) - enrollTime,
+           event = fail * (cte <= cutDate)) %>%
+    select(tte, event, Stratum, Treatment)
+
+  return(ans)
 }
 

R/cutDataAtCount.R

@@ -26,15 +26,17 @@
 #' @examples
 #' library(tidyr)
 #' # Use default enrollment and event rates at cut at 100 events
-#' x <- simPWSurv(n=200) %>% cutDataAtCount(100)
-#' table(x$event,x$Treatment)
+#' x <- simPWSurv(n = 200) %>% cutDataAtCount(100)
+#' table(x$event, x$Treatment)
 #'
 #' @return a \code{tibble} ready for survival analysis, including culumns time to event (`tte`),
 #' `event`, the `stratum` and the `treatment.`
 #'
 #' @export
 
-cutDataAtCount <- function(x,count){
-  ctecut <- getCutDateForCount(x,count)
-  return(cutData(x,ctecut))
+cutDataAtCount <- function(x, count){
+  cut_date <- getCutDateForCount(x, count)
+  ans <- x %>% cutData(cutDate = cut_date)
+
+  return(ans)
 }

R/fixedBlockRand.R

@@ -23,25 +23,33 @@
 #'
 #' @param n sample size to be randomized
 #' @param block Vector of treatments to be included in each block
+#'
 #' @return A treatment group sequence (vector) of length `n` with treatments from `block` permuted within
 #' each block having block size equal to the length of `block`
+#'
 #' @examples
 #' library(dplyr)
+#'
+#' # example 1
 #' # 2:1 randomization with block size 3, treatments "A" and "B"
-#' tibble(x=1:10) %>% mutate(Treatment=fixedBlockRand(block=c("A","B","B")))
+#' tibble(x = 1:10) %>% mutate(Treatment = fixedBlockRand(block = c("A", "B", "B")))
+#'
+#' # example 2
 #' # Stratified randomization
-#' tibble(Stratum=c(rep("A",10),rep("B",10))) %>%
-#' group_by(Stratum) %>%
-#' mutate(Treatment=fixedBlockRand())
+#' tibble(Stratum = c(rep("A", 10), rep("B", 10))) %>%
+#'   group_by(Stratum) %>%
+#'   mutate(Treatment = fixedBlockRand())
+#'
 #' @export
-fixedBlockRand <- function(n=10, block=c(0,0,1,1)){
+fixedBlockRand <- function(n = 10, block = c(0, 0, 1, 1)){
+
   length_block <- length(block)
-  nblock <- ceiling(n/length_block)
-  ntot <- nblock * length_block
-  tx <- NULL
-  u <- NULL
-  tx <- rep(block, each = nblock)
-  u <- rep(1:nblock, length_block)
-  u <- u + stats::runif(ntot)
-  return((tx[order(u)])[1:n])
+  n_block <- ceiling(n / length_block)
+  n_total <- n_block * length_block
+
+  block_to_sample <- rep(block, each = n_block)
+  sample_order <- rep(1:n_block, length_block)
+  sample_order <- sample_order + stats::runif(n_total)
+
+  return((block_to_sample[order(sample_order)])[1:n])
 }

R/getCutDateForCount.R

@@ -15,8 +15,7 @@
 #  You should have received a copy of the GNU General Public License
 #  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-#' @import tibble
-#' @import dplyr
+#' @importFrom dplyr ungroup select mutate filter arrange last
 NULL
 #' Get Date at Which an Event Count is Reached
 #'
@@ -25,36 +24,43 @@ NULL
 #'
 #' @examples
 #' library(dplyr)
+#' library(tibble)
+#'
 #' # Use default enrollment and calendar cut date for 50 events in Positive stratum
-#' x <- simPWSurv(n=200,
-#'                strata = tibble::tibble(Stratum=c("Positive","Negative"), p = c(.5, .5)),
-#'                failRates = tibble::tibble(Stratum = rep(c("Positive","Negative"),2),
-#'                                           period = rep(1, 4),
-#'                                           Treatment = c(rep("Control", 2),
-#'                                                         rep("Experimental", 2)),
-#'                                           duration = rep(1, 4),
-#'                                           rate = log(2) / c(6, 9, 9, 12)
-#'                                           ),
-#'                dropoutRates = tibble::tibble(Stratum = rep(c("Positive","Negative"),2),
-#'                                              period = rep(1, 4),
-#'                                              Treatment = c(rep("Control", 2),
-#'                                                            rep("Experimental", 2)),
-#'                                              duration = rep(1, 4),
-#'                                              rate = rep(.001, 4)
-#'                                             )
-#'               )
-#' d <- getCutDateForCount(filter(x,Stratum=="Positive"),count=50)
-#' y <- cutData(x,cutDate=d)
-#' table(y$Stratum,y$event)
+#' x <- simPWSurv(
+#'   n = 200,
+#'   strata = tibble(Stratum = c("Positive", "Negative"),
+#'                   p = c(.5, .5)),
+#'   failRates = tibble(Stratum = rep(c("Positive","Negative"), 2),
+#'                      period = rep(1, 4),
+#'                      Treatment = c(rep("Control", 2), rep("Experimental", 2)),
+#'                      duration = rep(1, 4),
+#'                      rate = log(2) / c(6, 9, 9, 12)),
+#'   dropoutRates = tibble(Stratum = rep(c("Positive", "Negative"),2),
+#'                         period = rep(1, 4),
+#'                         Treatment = c(rep("Control", 2), rep("Experimental", 2)),
+#'                         duration = rep(1, 4),
+#'                         rate = rep(.001, 4)))
+#'
+#' d <- getCutDateForCount(x %>% filter(Stratum == "Positive"), count = 50)
+#'
+#' y <- cutData(x, cutDate = d)
+#' table(y$Stratum, y$event)
 #'
 #' @return The a numeric value with the \code{cte} from the input dataset at which the targeted event count
 #' is reached, or if the final event count is never reached, the final \code{cte} at which an event occurs.
 #'
 #' @export
 
-getCutDateForCount <- function(x,count){
-  y <- ungroup(x) %>% select(cte,fail) %>% filter(fail==1) %>% select(cte) %>% arrange(cte) %>%
-         mutate(eventCount=row_number()) %>%
-         subset(eventCount<=count)
+getCutDateForCount <- function(x, count){
+  y <- x %>%
+    ungroup() %>%
+    select(cte, fail) %>%
+    filter(fail == 1) %>%
+    select(cte) %>%
+    arrange(cte) %>%
+    mutate(eventCount = row_number()) %>%
+    subset(eventCount <= count)
+
   return(last(y$cte))
 }

R/pMaxCombo.R

@@ -32,24 +32,46 @@ NULL
 #' @param dummyvar a dummy input that allows \code{group_map()} to be used to
 #' compute p-values for multiple simulations.
 #' @param algorithm This is passed directly to the \code{algorithm} argument in the \code{mvtnorm::pmvnorm()}
+#'
 #' @return A numeric p-value
+#'
 #' @examples
 #' library(tidyr)
-#' x <- simfix(nsim=1,timingType=5,rg=tibble::tibble(rho=c(0,0,1),gamma=c(0,1,1)))
+#' library(tibble)
+#' library(dplyr)
+#'
+#' # example 1
+#' x <- simfix(nsim = 1,
+#'             timingType = 5,
+#'             rg = tibble(rho = c(0, 0, 1),
+#'                         gamma = c(0, 1, 1)))
 #' head(x)
 #' pMaxCombo(x)
+#'
+#' # example 2
 #' # Only use cuts for events, events + min follow-up
-#' xx <- simfix(nsim=100,timingType=5,rg=tibble::tibble(rho=c(0,0,1),gamma=c(0,1,1)))
+#' xx <- simfix(nsim = 100,
+#'              timingType = 5,
+#'              rg = tibble(rho = c(0, 0, 1),
+#'                          gamma = c(0, 1, 1)))
 #' head(xx)
 #' # MaxCombo power estimate for cutoff at max of targeted events, minimum follow-up
-#' p <- unlist(xx %>%  dplyr::group_by(Sim) %>% dplyr::group_map(pMaxCombo))
-#' mean(p<.025)
+#' p <- xx %>% group_by(Sim) %>% group_map(pMaxCombo) %>% unlist()
+#' mean(p < .025)
+#'
 #' @export
-pMaxCombo <- function(Z,dummyvar, algorithm=GenzBretz(maxpts=50000,abseps=0.00001)){
-  MaxCombo <- as.numeric(min(Z$Z))
-  # correlation matrix
-  corr <- data.matrix(Z %>% select(starts_with("V")))
-  as.numeric(1-mvtnorm::pmvnorm(lower=rep(MaxCombo,nrow(Z)),
-                                corr=corr,
-                                algorithm=algorithm)[1])
+#'
+pMaxCombo <- function(Z,
+                      dummyvar,
+                      algorithm = GenzBretz(maxpts = 50000, abseps = 0.00001)){
+
+  ans <- (1 - mvtnorm::pmvnorm(lower = rep(Z$Z %>% min() %>% as.numeric(),
+                                           nrow(Z)),
+                               corr = Z %>%
+                                        select(starts_with("V")) %>%
+                                        data.matrix(),
+                               algorithm = algorithm)[1]
+          ) %>% as.numeric()
+
+  return(ans)
 }