Update app.R

app.R

@@ -1,3 +1,4 @@
+#
 # ============================================================
 #  app.R  |  Shiny App for Rerandomization with fastrerandomize
 # ============================================================
@@ -5,8 +6,10 @@
 # 2) They specify rerandomization parameters: n_treated, acceptance prob, etc.
 # 3) The app generates a set of accepted randomizations under rerandomization.
 # 4) The user can optionally upload or simulate outcomes (Y) and run a randomization test.
-# 5) The app displays distribution of the balance measure (e.g., Hotelling's T^2) and final p-value/fiducial interval.
-
+# 5) The app displays distribution of the balance measure (e.g., Hotelling's T^2) 
+#    and final p-value/fiducial interval, along with run-time comparisons between 
+#    fastrerandomize and base R methods.
+#
 # ----------------------------
 # Load required packages
 # ----------------------------
@@ -20,6 +23,125 @@ library(fastrerandomize)  # Our rerandomization package
 # install.packages("devtools")
 # devtools::install_github("cjerzak/fastrerandomize-software/fastrerandomize")
 
+# ---------------------------------------------------------
+# HELPER FUNCTIONS (BASE R)
+# ---------------------------------------------------------
+# 1) Compute Hotelling's T^2 in base R
+baseR_hotellingT2 <- function(X, W) {
+  # For a single assignment W:
+  # T^2 = (n0 * n1 / (n0 + n1)) * (xbar1 - xbar0)^T * S_inv * (xbar1 - xbar0)
+  n <- length(W)
+  n1 <- sum(W)
+  n0 <- n - n1
+  if (n1 == 0 || n0 == 0) return(NA_real_)  # invalid scenario
+  xbar_treat <- colMeans(X[W == 1, , drop = FALSE])
+  xbar_control <- colMeans(X[W == 0, , drop = FALSE])
+  diff_vec <- (xbar_treat - xbar_control)
+  
+  # covariance (pooled) – we just use cov(X)
+  S <- cov(X)
+  Sinv <- tryCatch(solve(S), error = function(e) NULL)
+  if (is.null(Sinv)) {
+    # fallback: diagonal approximation if solve fails
+    Sinv <- diag(1 / diag(S), ncol(S))
+  }
+  
+  out <- (n0 * n1 / (n0 + n1)) * c(t(diff_vec) %*% Sinv %*% diff_vec)
+  out
+}
+
+# 2) Generate randomizations in base R, filtering by acceptance probability 
+#    using T^2 and keep the best (lowest) fraction. 
+baseR_generate_randomizations <- function(n_units, n_treated, X, accept_prob, random_type,
+                                          max_draws, batch_size) {
+  
+  if (random_type == "exact") {
+    # -------------- EXACT RANDOMIZATIONS --------------
+    # All combinations
+    cidx <- combn(n_units, n_treated)
+    # Build assignment matrix
+    n_comb <- ncol(cidx)
+    assignment_mat <- matrix(0, nrow = n_comb, ncol = n_units)
+    for (i in seq_len(n_comb)) {
+      assignment_mat[i, cidx[, i]] <- 1
+    }
+    # Compute T^2 for each row
+    T2vals <- apply(assignment_mat, 1, function(w) baseR_hotellingT2(X, w))
+    # Drop any NA (in pathological cases)
+    keep_idx <- which(!is.na(T2vals))
+    assignment_mat <- assignment_mat[keep_idx, , drop = FALSE]
+    T2vals <- T2vals[keep_idx]
+    
+    # acceptance threshold
+    cutoff <- quantile(T2vals, probs = accept_prob)
+    keep_final <- (T2vals < cutoff)
+    assignment_mat_accepted <- assignment_mat[keep_final, , drop = FALSE]
+    T2vals_accepted <- T2vals[keep_final]
+    
+  } else {
+    # -------------- MONTE CARLO RANDOMIZATIONS --------------
+    # We'll sample max_draws permutations
+    # Start with a base assignment vector
+    base_assign <- c(rep(1, n_treated), rep(0, n_units - n_treated))
+    
+    # shuffle in R
+    # We'll store T2's in chunks to reduce memory overhead
+    batch_count <- ceiling(max_draws / batch_size)
+    all_assign <- list()
+    all_T2 <- numeric(0)
+    
+    cur_draw <- 0
+    for (b in seq_len(batch_count)) {
+      # how many draws in this batch
+      ndraws_here <- min(batch_size, max_draws - cur_draw)
+      cur_draw <- cur_draw + ndraws_here
+      
+      # sample permutations
+      perms <- matrix(nrow = ndraws_here, ncol = n_units)
+      for (j in seq_len(ndraws_here)) {
+        perms[j, ] <- sample(base_assign)
+      }
+      # T^2 for each
+      T2vals_batch <- apply(perms, 1, function(w) baseR_hotellingT2(X, w))
+      
+      # collect
+      all_assign[[b]] <- perms
+      all_T2 <- c(all_T2, T2vals_batch)
+    }
+    assignment_mat <- do.call(rbind, all_assign)
+    
+    # remove any NA
+    keep_idx <- which(!is.na(all_T2))
+    assignment_mat <- assignment_mat[keep_idx, , drop = FALSE]
+    all_T2 <- all_T2[keep_idx]
+    
+    # acceptance threshold
+    cutoff <- quantile(all_T2, probs = accept_prob)
+    keep_final <- (all_T2 < cutoff)
+    assignment_mat_accepted <- assignment_mat[keep_final, , drop = FALSE]
+    T2vals_accepted <- all_T2[keep_final]
+  }
+  
+  list(randomizations = assignment_mat_accepted, balance = T2vals_accepted)
+}
+
+# 3) Base R randomization test: difference in means
+baseR_randomization_test <- function(obsW, obsY, allW) {
+  # obs diff in means
+  n1 <- sum(obsW)
+  n0 <- length(obsW) - n1
+  obs_diff <- mean(obsY[obsW == 1]) - mean(obsY[obsW == 0])
+  
+  # for each candidate assignment, compute diff in means on obsY
+  diffs <- apply(allW, 1, function(w) {
+    mean(obsY[w == 1]) - mean(obsY[w == 0])
+  })
+  
+  # p-value = fraction whose absolute diff >= observed
+  pval <- mean(abs(diffs) >= abs(obs_diff))
+  list(p_value = pval, tau_obs = obs_diff)
+}
+
 # ---------------------------------------------------------
 # UI Section
 # ---------------------------------------------------------
@@ -80,8 +202,8 @@ ui <- dashboardPage(
               
               conditionalPanel(
                 condition = "input.data_source == 'simulate'",
-                numericInput("sim_n", "Number of units (rows)", value = 20, min = 2),
-                numericInput("sim_p", "Number of covariates (columns)", value = 3, min = 1),
+                numericInput("sim_n", "Number of units (rows)", value = 50, min = 2),
+                numericInput("sim_p", "Number of covariates (columns)", value = 10, min = 1),
                 actionButton("simulate_btn", "Simulate X")
               )
           ),
@@ -89,17 +211,6 @@ ui <- dashboardPage(
           box(width = 7, title = "Preview of Covariates (X)",
               status = "info", solidHeader = TRUE,
               DTOutput("covariates_table"))
-        ),
-        
-        # Performance info for data steps
-        fluidRow(
-          box(width = 12, title = "Performance Info for Data Steps", status = "warning", solidHeader = TRUE,
-              p("Time to upload X (CSV):"),
-              textOutput("time_data_upload"),
-              br(),
-              p("Time to simulate X:"),
-              textOutput("time_data_sim")
-          )
         )
       ),
       
@@ -122,7 +233,7 @@ ui <- dashboardPage(
                            value = 0.05, min = 0.0001, max = 1),
               conditionalPanel(
                 condition = "input.random_type == 'monte_carlo'",
-                numericInput("max_draws", "Max Draws (MC)", value = 1e4, min = 1e3),
+                numericInput("max_draws", "Max Draws (MC)", value = 1e5, min = 1e3),
                 numericInput("batch_size", "Batch Size (MC)", value = 1e3, min = 1e2)
               ),
               actionButton("generate_btn", "Generate Randomizations")
@@ -131,19 +242,14 @@ ui <- dashboardPage(
           box(width = 8, title = "Summary of Accepted Randomizations",
               status = "info", solidHeader = TRUE,
               fluidRow(
-                valueBoxOutput("n_accepted_box", width = 6),
-                valueBoxOutput("balance_min_box", width = 6)
+                valueBoxOutput("n_accepted_box", width = 4),
+                valueBoxOutput("balance_min_box", width = 4),
+                valueBoxOutput("fastrerand_time_box", width = 4),
+                valueBoxOutput("baseR_time_box", width = 4)
               ),
               br(),
               plotOutput("balance_hist", height = "250px")
           )
-        ),
-        
-        # Performance info for randomization generation
-        fluidRow(
-          box(width = 12, title = "Performance Info for Generation", status = "warning", solidHeader = TRUE,
-              textOutput("time_generate")
-          )
         )
       ),
       
@@ -182,27 +288,15 @@ ui <- dashboardPage(
           
           box(width = 8, title = "Test Results", status = "info", solidHeader = TRUE,
               fluidRow(
-                valueBoxOutput("pvalue_box", width = 6),
-                valueBoxOutput("tauobs_box", width = 6)
+                valueBoxOutput("pvalue_box", width = 4),
+                valueBoxOutput("tauobs_box", width = 4),
+                valueBoxOutput("fastrerand_test_time_box", width = 4),
+                valueBoxOutput("baseR_test_time_box", width = 4)
               ),
               uiOutput("fi_text"),
               br(),
               plotOutput("test_plot", height = "280px")
           )
-        ),
-        
-        # Performance info for randomization test
-        fluidRow(
-          box(width = 12, title = "Performance Info for Randomization Test", status = "warning", solidHeader = TRUE,
-              p("Time to upload Y (CSV):"),
-              textOutput("time_data_uploadY"),
-              br(),
-              p("Time to simulate Y:"),
-              textOutput("time_data_simY"),
-              br(),
-              p("Time to run randomization test:"),
-              textOutput("time_randtest")
-          )
         )
       )
       
@@ -215,31 +309,18 @@ ui <- dashboardPage(
 # ---------------------------------------------------------
 server <- function(input, output, session) {
   
-  # -- ReactiveVals to store performance times (seconds)
-  time_data_upload    <- reactiveVal(NA_real_)
-  time_data_sim       <- reactiveVal(NA_real_)
-  time_generate       <- reactiveVal(NA_real_)
-  time_data_uploadY   <- reactiveVal(NA_real_)
-  time_data_simY      <- reactiveVal(NA_real_)
-  time_randtest       <- reactiveVal(NA_real_)
-  
   # -------------------------------------------------------
   # 1. Covariate Data Handling
   # -------------------------------------------------------
   # We store the covariate matrix X in a reactiveVal for convenient reuse 
   X_data <- reactiveVal(NULL)
   
-  # Observe file input (upload) for X
+  # Observe file input or simulation for X
   observeEvent(input$file_covariates, {
     req(input$file_covariates)
     inFile <- input$file_covariates
-    
-    start_time <- Sys.time()
     df <- tryCatch(read.csv(inFile$datapath, header = TRUE),
                    error = function(e) NULL)
-    end_time <- Sys.time()
-    time_data_upload(as.numeric(difftime(end_time, start_time, units = "secs")))
-    
     if (!is.null(df)) {
       X_data(as.matrix(df))
     }
@@ -249,13 +330,8 @@ server <- function(input, output, session) {
   observeEvent(input$simulate_btn, {
     n <- input$sim_n
     p <- input$sim_p
-    
-    start_time <- Sys.time()
     # Basic simulation of N(0,1) data
     simX <- matrix(rnorm(n * p), nrow = n, ncol = p)
-    end_time <- Sys.time()
-    time_data_sim(as.numeric(difftime(end_time, start_time, units = "secs")))
-    
     X_data(simX)
   })
   
@@ -266,30 +342,17 @@ server <- function(input, output, session) {
               options = list(scrollX = TRUE, pageLength = 5))
   })
   
-  # --- Performance outputs for Data & Covariates
-  output$time_data_upload <- renderText({
-    t <- time_data_upload()
-    if (is.na(t)) {
-      "Not run yet."
-    } else {
-      paste0(round(t, 3), " seconds")
-    }
-  })
-  
-  output$time_data_sim <- renderText({
-    t <- time_data_sim()
-    if (is.na(t)) {
-      "Not run yet."
-    } else {
-      paste0(round(t, 3), " seconds")
-    }
-  })
-  
   # -------------------------------------------------------
   # 2. Generate Rerandomizations
   # -------------------------------------------------------
-  # We'll keep the accepted randomizations in a reactiveVal
+  # We'll keep the accepted randomizations from fastrerandomize in RerandResult
+  # and from base R in RerandResult_base.
   RerandResult <- reactiveVal(NULL)
+  RerandResult_base <- reactiveVal(NULL)
+  
+  # We also store their run times
+  fastrand_time <- reactiveVal(NULL)
+  baseR_time <- reactiveVal(NULL)
   
   observeEvent(input$generate_btn, {
     req(X_data())
@@ -298,37 +361,53 @@ server <- function(input, output, session) {
            "Number treated cannot exceed total units.")
     )
     
-    # withProgress to show progress bar in the UI
-    withProgress(message = "Computing randomizations...", value = 0, {
-      
-      # Measure time
-      start_time <- Sys.time()
-      
-      # We call generate_randomizations() from fastrerandomize
-      nunits <- nrow(X_data())
-      out <- tryCatch({
-        generate_randomizations(
-          n_units                  = nunits,
-          n_treated                = input$n_treated,
-          X                        = X_data(),
-          randomization_accept_prob= input$accept_prob,
-          randomization_type       = input$random_type,
-          max_draws                = if (input$random_type == "monte_carlo") input$max_draws else NULL,
-          batch_size               = if (input$random_type == "monte_carlo") input$batch_size else NULL,
-          verbose                  = FALSE
-        )
-      }, error = function(e) e)
-      
-      # End time
-      end_time <- Sys.time()
-      time_generate(as.numeric(difftime(end_time, start_time, units = "secs")))
-      
-      if (inherits(out, "error")) {
-        showNotification(paste("Error generating randomizations:", out$message), type = "error")
-        return(NULL)
-      }
+    # =========== 1) fastrerandomize generation timing ===========
+    t0_fast <- Sys.time()
+    out <- tryCatch({
+      generate_randomizations(
+        n_units                  = nrow(X_data()),
+        n_treated                = input$n_treated,
+        X                        = X_data(),
+        randomization_accept_prob= input$accept_prob,
+        randomization_type       = input$random_type,
+        max_draws                = if (input$random_type == "monte_carlo") input$max_draws else NULL,
+        batch_size               = if (input$random_type == "monte_carlo") input$batch_size else NULL,
+        verbose                  = FALSE
+      )
+    }, error = function(e) e)
+    t1_fast <- Sys.time()
+    
+    if (inherits(out, "error")) {
+      showNotification(paste("Error generating randomizations (fastrerandomize):", out$message), type = "error")
+      RerandResult(NULL)
+    } else {
       RerandResult(out)
-    })
+    }
+    fastrand_time(difftime(t1_fast, t0_fast, units = "secs"))
+    
+    # =========== 2) base R generation timing ===========
+    t0_base <- Sys.time()
+    out_base <- tryCatch({
+      baseR_generate_randomizations(
+        n_units    = nrow(X_data()),
+        n_treated  = input$n_treated,
+        X          = X_data(),
+        accept_prob= input$accept_prob,
+        random_type= input$random_type,
+        max_draws  = if (input$random_type == "monte_carlo") input$max_draws else NULL,
+        batch_size = if (input$random_type == "monte_carlo") input$batch_size else NULL
+      )
+    }, error = function(e) e)
+    t1_base <- Sys.time()
+    
+    if (inherits(out_base, "error")) {
+      showNotification(paste("Error generating randomizations (base R):", out_base$message), type = "error")
+      RerandResult_base(NULL)
+    } else {
+      RerandResult_base(out_base)
+    }
+    baseR_time(difftime(t1_base, t0_base, units = "secs"))
+    
   })
   
   # Summaries of accepted randomizations
@@ -352,7 +431,28 @@ server <- function(input, output, session) {
     }
   })
   
-  # Plot histogram of the balance measure
+  # Timings for generation: fastrerandomize and base R
+  output$fastrerand_time_box <- renderValueBox({
+    tm <- fastrand_time()
+    if (is.null(tm)) {
+      valueBox("---", "fastrerandomize generation time (secs)", icon = icon("clock"), color = "teal")
+    } else {
+      valueBox(round(as.numeric(tm), 3), "fastrerandomize generation time (secs)",
+               icon = icon("clock"), color = "teal")
+    }
+  })
+  
+  output$baseR_time_box <- renderValueBox({
+    tm <- baseR_time()
+    if (is.null(tm)) {
+      valueBox("---", "base R generation time (secs)", icon = icon("clock"), color = "lime")
+    } else {
+      valueBox(round(as.numeric(tm), 3), "base R generation time (secs)",
+               icon = icon("clock"), color = "lime")
+    }
+  })
+  
+  # Plot histogram of the balance measure (fastrerandomize result)
   output$balance_hist <- renderPlot({
     rr <- RerandResult()
     req(rr, rr$balance)
@@ -365,16 +465,6 @@ server <- function(input, output, session) {
       theme_minimal(base_size = 14)
   })
   
-  # --- Performance output for randomization generation
-  output$time_generate <- renderText({
-    t <- time_generate()
-    if (is.na(t)) {
-      "Not run yet."
-    } else {
-      paste0(round(t, 3), " seconds")
-    }
-  })
-  
   # -------------------------------------------------------
   # 3. Randomization Test
   # -------------------------------------------------------
@@ -385,11 +475,14 @@ server <- function(input, output, session) {
     req(RerandResult())
     rr <- RerandResult()
     
-    nunits <- ncol(rr$randomizations)  # #units is #cols in randomizations
-    
-    start_time <- Sys.time()
     # We'll just use the first accepted randomization as the "observed" assignment
+    if (is.null(rr$randomizations) || nrow(rr$randomizations) < 1) {
+      showNotification("No accepted randomizations found. Cannot simulate Y for the 'observed' assignment.", type = "error")
+      return(NULL)
+    }
+    
     obsW <- rr$randomizations[1, ]
+    nunits <- length(obsW)
     
     # Basic data generation: Y = X * beta + tau * W + noise
     Xval <- X_data()
@@ -401,9 +494,6 @@ server <- function(input, output, session) {
     beta <- rnorm(ncol(Xval), 0, 1)
     linear_part <- Xval %*% beta
     Ysim <- as.numeric(linear_part + obsW * input$true_tau + rnorm(nunits, 0, input$noise_sd))
-    end_time <- Sys.time()
-    
-    time_data_simY(as.numeric(difftime(end_time, start_time, units = "secs")))
     
     Y_data(Ysim)
   })
@@ -412,12 +502,7 @@ server <- function(input, output, session) {
   observeEvent(input$file_outcomes, {
     req(input$file_outcomes)
     inFile <- input$file_outcomes
-    
-    start_time <- Sys.time()
     dfy <- tryCatch(read.csv(inFile$datapath, header = FALSE), error=function(e) NULL)
-    end_time <- Sys.time()
-    time_data_uploadY(as.numeric(difftime(end_time, start_time, units = "secs")))
-    
     if (!is.null(dfy)) {
       if (ncol(dfy) > 1) {
         showNotification("Please provide a single-column CSV for Y.", type="error")
@@ -429,6 +514,11 @@ server <- function(input, output, session) {
   
   # The randomization test result:
   RandTestResult <- reactiveVal(NULL)
+  RandTestResult_base <- reactiveVal(NULL)
+  
+  # We'll store their times:
+  fastrand_test_time <- reactiveVal(NULL)
+  baseR_test_time <- reactiveVal(NULL)
   
   observeEvent(input$run_randtest_btn, {
     req(RerandResult())
@@ -439,44 +529,59 @@ server <- function(input, output, session) {
       return(NULL)
     }
     
-    withProgress(message = "Computing randomization test...", value = 0, {
-      
-      start_time <- Sys.time()
-      
-      obsW  <- rr$randomizations[1, ]
-      obsY  <- Y_data()
-      cands <- rr$randomizations
-      
-      # Check that Y has same length as a single W
-      if (length(obsY) != length(obsW)) {
-        showNotification("Dimension mismatch: Y must match number of units in the randomization.", 
-                         type = "error")
-        return(NULL)
-      }
-      
-      # Call the randomization_test function
-      outTest <- tryCatch({
-        randomization_test(
-          obsW      = obsW,
-          obsY      = obsY,
-          candidate_randomizations = cands,
-          findFI    = input$findFI
-        )
-      }, error=function(e) e)
-      
-      end_time <- Sys.time()
-      time_randtest(as.numeric(difftime(end_time, start_time, units = "secs")))
-      
-      if (inherits(outTest, "error")) {
-        showNotification(paste("Error in randomization_test:", outTest$message), type="error")
-        return(NULL)
-      }
-      
+    obsW  <- rr$randomizations[1, ]
+    obsY  <- Y_data()
+    
+    # =========== 1) fastrerandomize randomization_test timing ===========
+    t0_testfast <- Sys.time()
+    outTest <- tryCatch({
+      randomization_test(
+        obsW      = obsW,
+        obsY      = obsY,
+        candidate_randomizations = rr$randomizations,
+        findFI    = input$findFI
+      )
+    }, error=function(e) e)
+    t1_testfast <- Sys.time()
+    
+    if (inherits(outTest, "error")) {
+      showNotification(paste("Error in randomization_test (fastrerandomize):", outTest$message), type="error")
+      RandTestResult(NULL)
+    } else {
       RandTestResult(outTest)
-    })
+    }
+    fastrand_test_time(difftime(t1_testfast, t0_testfast, units = "secs"))
+    
+    # =========== 2) base R randomization test timing ===========
+    # We must also have the base R set of randomizations
+    req(RerandResult_base())
+    rr_base <- RerandResult_base()
+    if (is.null(rr_base$randomizations) || nrow(rr_base$randomizations) < 1) {
+      showNotification("No base R randomizations found. Cannot run base R test.", type = "error")
+      RandTestResult_base(NULL)
+      return(NULL)
+    }
+    
+    t0_testbase <- Sys.time()
+    outTestBase <- tryCatch({
+      baseR_randomization_test(
+        obsW    = obsW,
+        obsY    = obsY,
+        allW    = rr_base$randomizations
+      )
+    }, error = function(e) e)
+    t1_testbase <- Sys.time()
+    
+    if (inherits(outTestBase, "error")) {
+      showNotification(paste("Error in randomization_test (base R):", outTestBase$message), type="error")
+      RandTestResult_base(NULL)
+    } else {
+      RandTestResult_base(outTestBase)
+    }
+    baseR_test_time(difftime(t1_testbase, t0_testbase, units = "secs"))
   })
   
-  # Display p-value and observed tau
+  # Display p-value and observed tau (from the fastrerandomize test)
   output$pvalue_box <- renderValueBox({
     rt <- RandTestResult()
     if (is.null(rt)) {
@@ -495,6 +600,27 @@ server <- function(input, output, session) {
     }
   })
   
+  # Times for randomization test
+  output$fastrerand_test_time_box <- renderValueBox({
+    tm <- fastrand_test_time()
+    if (is.null(tm)) {
+      valueBox("---", "fastrerandomize test time (secs)", icon = icon("clock"), color = "teal")
+    } else {
+      valueBox(round(as.numeric(tm), 3), "fastrerandomize test time (secs)",
+               icon = icon("clock"), color = "teal")
+    }
+  })
+  
+  output$baseR_test_time_box <- renderValueBox({
+    tm <- baseR_test_time()
+    if (is.null(tm)) {
+      valueBox("---", "base R test time (secs)", icon = icon("clock"), color = "lime")
+    } else {
+      valueBox(round(as.numeric(tm), 3), "base R test time (secs)",
+               icon = icon("clock"), color = "lime")
+    }
+  })
+  
   # If we have a fiducial interval, display it
   output$fi_text <- renderUI({
     rt <- RandTestResult()
@@ -510,13 +636,18 @@ server <- function(input, output, session) {
     )
   })
   
-  # A simple plot for the randomization distribution 
-  # (no distribution stored by default, so just show the observed effect)
+  # A simple plot for the randomization distribution (for demonstration).
+  # In the minimal example, we do not store the entire distribution in 'randomization_test',
+  # so we simply show the observed effect with a placeholder.
   output$test_plot <- renderPlot({
     rt <- RandTestResult()
     if (is.null(rt)) {
+      # no test run yet
+      plot.new()
+      title("No test results yet.")
       return(NULL)
     }
+    # Just display the observed effect
     obs_val <- rt$tau_obs
     
     ggplot(data.frame(x = obs_val, y = 0), aes(x, y)) +
@@ -527,34 +658,6 @@ server <- function(input, output, session) {
       theme_minimal(base_size = 14) +
       geom_vline(xintercept = 0, linetype="dashed", color="gray40")
   })
-  
-  # --- Performance outputs for outcomes and randomization test
-  output$time_data_uploadY <- renderText({
-    t <- time_data_uploadY()
-    if (is.na(t)) {
-      "Not run yet."
-    } else {
-      paste0(round(t, 3), " seconds")
-    }
-  })
-  
-  output$time_data_simY <- renderText({
-    t <- time_data_simY()
-    if (is.na(t)) {
-      "Not run yet."
-    } else {
-      paste0(round(t, 3), " seconds")
-    }
-  })
-  
-  output$time_randtest <- renderText({
-    t <- time_randtest()
-    if (is.na(t)) {
-      "Not run yet."
-    } else {
-      paste0(round(t, 3), " seconds")
-    }
-  })
 }
 
 # ---------------------------------------------------------